动态内存与智能指针 c/c++语言的一大特色是在于可以动态的进行内存管理，而这也是它的难点所在。程序出现问题，原因经常在动态内存管理这块，比如分配内存后没有及时释放，或者当前线程提前释放了其他线程也会使用的内存。而c++11中新增的智能指针能在一定程度上解决这些问题动态内存与智能指针在c++中动态内存的管理是通过一对运算符来完成的: new和delete ，new为对象分配空间并返回一个指向该对象的指针。delete 接受一个动态对象的指针，销毁对象并释放相关内存动态内存的管理十分困难，有时候会忘记释放内存，这种情况下会产生内存泄漏。有时在尚有指针引用内存的情况下我们就释放了它，在这种情况下就会产生引用非法内存的指针。为了更容易也更安全的使用动态内存，新的标准提供了两种智能指针类型来管理动态对象。shared_ptr 类类似于vector 智能指针也是模板。创建智能指针时，必须提供额外的信息——指针可以指向的类型。智能指针的用法与普通指针类似。解引用一个智能指针返回它指向的对象，箭头运算符可以返回对象中的成员shared_ptr<string> p = new string; if(nullptr != p && p->empty()) { *p = "hello world"; //字符串为空的时候，将一个新值赋予string }最安全的分配和使用动态内存的方法是调用一个名为 make_shared 的标准库函数。此函数在动态内存中分配一个对象并初始化它，返回此对象的 shared_ptr。shared_ptr<int> p3 = make_shared<int>(42); //初始化p3 指向一个值为42的int类型 shared_ptr<string> p4 = make_shared<string>(10, '9'); //p4指向一个值为 "9999999999" 的string shared_ptr<int> p5 = make_shared<int>(); //指向一个值初始化的int，即，值为0当shared_ptr 进行拷贝和赋值操作时，每个shared_ptr 都会记录有多少个其他的shared_ptr 指向相同的对象auto p = make_shared<int>(42); //此时p指向的对象只有一个引用值 auto q = p; //此时p指向的对象有两个引用者我们可以认为每一个shared_ptr 都有一个关联的计数器，通常称其为引用计数。无论何时我们拷贝一个shared_ptr，计数器都会递增。当我们给shared_ptr 赋一个新值或者shared_ptr 被销毁时，他所关联的计数器就会递减。当指向一个对象的最后一个shared_ptr 被销毁时，shared_ptr 类就会自动销毁此对象。shared_ptr 并不是万能的，也会出现内存泄漏的问题。这种情况一般出现在容器中。如果在容器中存放了shared_ptr ，然后重新排列了容器，从而不需要某些元素。在这种情况下应该确保使用earse删除某些不再需要的shared_ptr 元素直接管理内存相对与智能指针直接使用new 和 delete很容器出错。当内存耗尽时，new会失败，会抛出一个bad_alloc 异常。我们可以改变使用new的方式来阻止它抛出异常int *p1 = new int; //如果分配失败则会抛出异常 int *p2 = new (nothrow) int; //如果分配失败，new返回一个空指针我们称这种形式的new为定位new。定位new允许我们传递额外的参数给到new，在此例子中我们传递一个标准库中的nothrow 对象，告知它在内存不足的时候不要抛出异常。如果这种形式的new不能分配所需内存，它会返回一个空指针动态对象的生命周期一直到它被手动释放为止。这样就给使用者造成了一个额外的负担，调用者必须记得释放内存。使用new和delete 管理动态内存存在三个常见问题：忘记delete内存。造成内存泄漏问题使用已经释放掉的对象。通过在释放内存后将指针置为空，有时可以检出这种错误同一块内存多次释放坚持只使用智能指针就可以避免所有这些问题。对于一块内存只有在没有任何智能指针指向它的情况下，智能指针才会自动释放它shared_ptr 和 new 结合使用接受指针参数的智能指针构造函数是 explicit 的。因此，我们不能将一个内置指针隐式转化为智能指针,必须使用直接初始化的方式shared_ptr<int> p1 = new int(1024); //错误，这里需要将int* 隐式转化为shared_ptr<int> 类型 shared_ptr<int> p2(new int(1024)); //正确默认情况下一个用来初始化智能指针的普通指针必须指向使用new创建的动态内存(malloc 创建的需要自定义释放操作),因为智能指针默认采用delete来释放它所关联的对象。我们可以将智能指针绑定到一个指向其他类型的资源的指针上面，但是为了这样做，必须提供自己的操作来代替delete不要混合使用普通指针和智能指针。void process(shared_ptr<int> ptr) { // 进入到函数中时，ptr 所在的引用计数加1 } //函数结束时, ptr 所在对象的引用计数减 1 shared_ptr<int> p(new int(42)); //引用计数为1 process(p); //在函数内部，引用计数加1，变为2 //执行完成后，引用计数减1，变为1，此时对象不会被销毁 *p = 100; //可以进行赋值，此时对象还未被销毁 int* p1 = new int(42); process(shared_ptr<int>(p1)); //进入函数后，由于p1 自身不是智能指针，所以在函数结束之后，智能指针的计数为0，会销毁对应的对象 *p1 = 100; //错误，此时对象已被销毁 智能指针定义了一个get函数用来返回一个普通的指针，此函数是为了这样一种情况而设计的：我们需要像不能使用智能指针的代码传递一个内置指针，但这段代码中不能使用delete来销毁这个指针所指向的对象我们不能将get返回的指针再绑定到另一个智能指针上。智能指针和异常当发生异常时，普通的指针如果在异常发生之后进行delete操作，那么资源回收操作可能会被中断，而智能指针不会void f() { shared_ptr<int> sp(new int(24)); //即使后面发生异常，sp指针在函数结束时计数变为0，对象被释放 } void f() { int* p = new int(24); //这里发生异常的话，后面的delete 不会被执行，可能发生内存泄漏 delete p; }有些资源由于提供的是c函数级别的接口，因此需要手动进行释放，就会存在与动态内存一样的问题，忘记释放资源。这种情况我们也可以使用智能指针的技术来自动管理资源。例如我们的socket程序，在最后需要调用shutdown 和 closesocket来关闭void clear_socket(socket* sk) { shutdown(*sk); closesocket(*sk); } socket s = socket(AF_INET, SOCK_STREAM, IPPROTO_IP); shared_ptr<socket> ps(&s, clear_socket); //链接服务器 //程序推出后会自动调用clear_socket 来释放socket资源智能指针可以提供对动态分配的内存安全而有方便的管理，但是这建立在正确使用的前提下。为了方便的使用智能指针，我们必须坚持一些基本原则：不使用相同的内置指针初始化多个智能指针不delete get函数返回的指针不使用get初始化或者reset另一个指针指针如果使用get返回的指针，记住当最后一个对应的智能指针被销毁后，你的指针就变为无效了如果使用智能指针管理的资源不是new分配的，记住传递给它一个删除器unique_ptrunique_ptr 拥有它所指向的对象。某一个时刻只能有一个 unique_ptr 指向一个给定的对象。当unique_ptr 被销毁时，它所指向的对象也会被销毁unique_ptr 不支持拷贝操作，没有类似 make_shared 的操作。unique_ptr<string> p1(new string("hello world")); unique_ptr<string> p2(p1); //错误：unique_ptr 不支持拷贝 unique_ptr<string> p3; p3 = p1; //错误：unique_ptr 不支持赋值虽然不能拷贝和赋值unique_ptr ,但是可以调用release或者reset将指针的所有权从一个(非const)unique_ptr 转移给另一个unique_ptrreset 成员接受一个可选的指针参数，令unique_ptr 重新指向给定的指针。如果unique_ptr 不为空，它原来指向的对象被释放。release会切断unique_ptr 和它原来管理的对象间的联系。release返回的指针通常被用来初始化另一个智能指针或者给另一个智能指针赋值，如果我们不用另一个智能指针保存release返回的指针，则需要手工释放指针指向的资源p2.release(); //错误，p2指向的资源不会正常释放 auto p = p2.release(); delete p;不能拷贝unique_ptr 的规则又一个例外: 我们可以拷贝或者赋值一个将要被销毁的unique_ptr。最常见的例子是从函数返回一个unique_ptrunique_ptr<int> clone(int p){ return unique_ptr<int>(new int(p)); }还可以返回一个局部对象的拷贝:unique_ptr<int> clone(int p) { unique_ptr<int> ret(unique_ptr<int>(p)); return ret; }类似于shared_ptr， unique_ptr 默认情况下使用delete 释放它指向的对象。我们也可以重载一个unique_ptr 中默认的删除器。但是unique_ptr 管理删除器的方式与shared_ptr 不同。重载一个unique_ptr 中删除器会影响到unique_ptr 类型以及如何构造该类型的对象。与与重载关联容器的比较运算相似，我们必须在尖括号中unique_ptr 指向类型之后提供删除容器类型。在创建或者reset 一个这种unique_ptr 类型的对象时，必须提供一个指定类型的可调用对象weak_ptrweak_ptr 是一种不控制所指向对象生存期的智能指针，它指向由一个shared_ptr 管理的对象。将一个shared_ptr绑定到一个 weak_ptr。不会改变shared_ptr 的引用计数。一旦最后一个指向对象的shared_ptr 被销毁，对象就会被释放。即使有weak_ptr 指向对象，对象还是会被销毁由于对象可能不存在，所以不能直接使用weak_ptr 来访问对象，需要先调用lock函数，此函数检查weak_ptr 指向的对象是否仍然存在。如果存在，lock返回一个指向共享对象的shared_ptr。只要此shared_ptr 存在，它所指向的对象也会一直存在.if(shared_ptr<int> np = wp.lock()) { //在if中np 和wp 共享对象 }动态数组new 和数组标准库提供了一个可以管理new 分配的数组的unique_ptr 版本，为了用一个unique_ptr 管理动态数组，我们必须在对象类型后面跟一对方括号:unique_ptr<int[]> up(new int[10]); up.release(); //自动用delete[] 销毁其指针shared_ptr 不直接支持管理动态数组。如果希望使用shared_ptr 管理动态数组，必须提供自己定义的删除器:shared_ptr<int> sp(new int[10], [](int* p){delete[] p;}); sp.reset();shared_ptr 未定义下标运算符，因此我们通过shared_ptr 访问动态数组时需要使用get获取到内置指针，然后用它来访问数组元素** allocator 类当分配一块大内存时，我们通常计划在这块内存上按需求构造对象，这种情况下使用new分配时会立即执行对象的构造操作，会造成一定的开销string *const p = new string[n]; //构造n个空白的string delete[] p;上述代码在new 的同时已经调用了n次string 的构造函数。但是我们可能不需要n个string对象，少量的即可满足。 这样我们就可能创建一些永远也用不到的对象。而且对于那些要使用的对象，我们也在初始化之后立即赋予了它们新值，每个被使用的元素被赋值了两次，第一次是在默认初始化的时候，第二次是在赋值时。标准库中定义了allocator 类可以帮助我们将内存分配和对象构造分离开来。allocator<string> alloc;//可以分配string的allocator对象 auto const p = alloc.allocate(n); //分配n个未初始化的stringallocator 分配的内存是未构造的。我们按照需要在此内存中构造对象。成员函数construct接受一个指向将要被构造的内存的指针，同时可以接受额外参数作为构造对象时的参数。auto q = p; //q 指向下一个将要被构造的位置 alloc.construct(q++); //构造一个空字符串 alloc.construct(q++, 10, 'c'); //构造一个'cccccccccc'的字符串 alloc.construct(q++, "hi"); //构造一个 "hi" 字符串当我们使用完对象后必须调用destroy 来销毁它们while(q != p) { alloc.destroy(--q); }这里要注意我们只能对真正构造了的元素进行destroy操作destroy之后这些内存并没有完全交换给系统，还需要调用deallocate 来完成alloc.deallocate();

关联容器 之前介绍过标准库中的顺序容器，顺序容器是元素在内存中按照一定顺序进行排列的，都是按线性结构进行排列。除了顺序容器外，c++中还有关联容器。与顺序容器不同的是，关联容器中元素是按照关键字来保存和访问的。与之相对的顺序容器是按它们在容器中的位置来顺序的保存和访问的。关联容器支持高效的查找和访问。两个主要的关联容器类型是map和set。标准库提供8种关联容器，这8个容器见的不同体现在3个维度或者是一个set，或者是一个map或者要求不重复的关键字，或者允许重复关键字按顺序保存元素或者无序保存允许重复关键字的容器都包含单词 multi ，不保持关键字按顺序存储的容器的名字都以单词unordered 开头这8中容器分别是 map、set、multimap、multiset、unordered_map、unordered_set、unordered_multimap、unordered_multiset关联容器概述关联容器不支持顺序容器中的位置相关操作，例如 push_back、push_front。原因是关联容器是按照关键字存储的，这些操作对关联容器没有意义对于map、multimap、set、multiset 关键字类型必须定义元素的比较方法。默认情况下标准库使用关键字类型的< 运算符来比较两个关键字在介绍关联容器的操作之前，我们需要了解名为pair的标准库类型。一个pair保存两个数据成员。类似容器，pair是一个用来生成特定类型的模板。当创建一个pair时，需要提供两个类型名，pair的数据成员将具有对应的类型。两个类型不要求一样pair<string, string> anon; pair<string, size_t> word_count; pair<string, vector<int>> line;初始化时，会调用类型的默认构造函数进行初始化，也可以为每个成员提供初始化器:pair<string, string> author{"James", "Joyce"};pair 的数据成员是public的，两个成员分别命名为first和second。我们用普通的成员访问符号来访问它们。关联容器的操作关联容器定义了额外的类型别名key_type: 此容器类型的关键字类型mapped_type: 每个关键字关联的类型：只适用与mapvalue_type: 对于set，与key_value 相同；对于map，为 pair<const key_type, mapped_type>set<string>::value_type v1; //v1 是一个string set<string>::key_value v2; //v2 是一个string map<string, int>::value_type v3; //v3 是一个pair<const string, int> map<string, int>::key_type v4; //v4 是一个string map<string, int>::mapped_type v5; //v5 是一个int我们使用作用域运算符来提取一个类型的成员。当解引用一个关联容器的迭代器的时候，会得到一个类型为容器的value_type 的值的引用。对map而言，value_type 是一个pair 类型，其first成员保存const的关键字，second成员保存值auto map_it = word_count.begin(); cout << map_it->first; cout << " " << map_it->second; map_it->first = "new key"; //错误 first是const类型 ++map_it->second;set 的迭代器是const的。关联容器中键值是无法通过迭代器进行修改的。只能通过迭代器读，每次修改键值都会导致容器中元素的重新排序。因此不允许通过迭代修改键值我们通常不能对关联容器使用泛型算法。关键字是const这一特性意味着不能将关联容器传递给修改或者重排容器元素的算法。关联容器可以使用只读取元素的算法。但是很多这类算法都要搜索序列。由于关联容器中的元素不能通过它们的关键字进行快速查找，因此对其使用泛型算法几乎总是一个坏主意关联容器中有一个find的成员，我们可以使用find算法来根据关键字查找元素。关联容器的insert成员可以向容器中添加一个元素或者元素范围。因为set和map无法包含关键字重复的元素，因此插入已存在的元素对容器没有任何影响vector<int> ivec = {2, 4, 6, 8, 2, 4, 6, 8}; //ivec 有8个元素 set<int> set2; set2.insert(ivec.cbegin(), ivec.cend()); //set2 现在有4个元素 set2.insert({1, 3, 5, 7, 1, 3, 5, 7}); //set2 现在有8个元素对一个map执行insert操作时，需要记住元素类型是pair。通常在insert的参数列表中创建一个pair//向word_count 插入word的4种方法 word_count.insert({word, 1}); word_count.insert(make_pair(word, 1)); word_count.insert(pair<string, size_t)>(word, 1)); word_count.insert(map<string, size_t>::value_type(word, 1));insert 的返回值依赖于容器类型和参数。对于不包含重复关键字的容器，添加单一元素的insert和emplace版本返回一个pair，告诉我们插入是否成功。pair的first成员是一个迭代器，指向具有给定关键字的元素；second成员是一个bool值，指出元素是插入成功还是已经存在于容器中。如果关键字已经存在于容器中，则insert什么也不做，且返回值中的bool部分为false。如果关键字不存在，元素被插入容器，且bool值为true对于允许重复关键字的容器，接受单个元素的insert操作返回一个指向新元素的迭代器。这里无须返回一个bool值，因为insert总是向这类容器中加入一个新元素关联容器定义了三个版本的erase。可以通过传入一个迭代器或者一个迭代器对来删除一个元素或者一个元素范围。如果指定的元素被删除，函数返回void关联容器提供一个额外的erase函数，它允许传入一个key_type 参数，删除所有匹配给定关键字的元素，返回实际删除元素的数量。对于map和unordered_map 容器提供了下标运算，下标中填入key_type的值，得到value_type，如果关键字不在map中，会为它创建一个元素并插入map中。使用容器的find访问关联容器，传入key_type，如果能找到对应值，返回一个指向对应元素的迭代器，否则返回一个指向容器end()位置的迭代器的使用容器的count方法，传入key_type，返回容器中相同关键字元素的个数对于map使用find代替下标操作，使用下标如果未找到对应关键字则会插入一个新的元素，这样会产生未知行为。如果我们只想知道一个给定关键字是否在map中，而不想改变map，这种情况下应该使用find。对于不允许存储重复关键字的关联容器来说，通过关键字查找元素只会找到一个，而对于允许重复关键字的关联容器来说，会返回第一个元素的迭代器，而相同关键字的元素会相邻存储。在遍历所有相同关键字的元素时，可以首先使用find找到第一个元素的迭代器，然后使用count找到公有多少个元素。最后循环递增迭代器即可访问到所有相同关键字的元素string search_item("Alain de Botton"); auto enteris = authors.count(search_item); auto iter = authors.find(search_item); while(enteris) { cout << iter->second << endl; ++iter; --enteris; }除了上述方法，还可以使用 lower_bound和 upper_bound；lower_bound 指向第一个对应的元素，upper_bound 指向匹配的最后一个元素的下一个位置。如果未找到对应元素，则二者指向同一个迭代器，指向一个不影响排序的关键字插入位置for(auto beg = authors.lower_bound(search_item), end = authors.upper_bound(search_item); beg != end; ++beg) { cout << beg->second << endl; }解决此问题的最后一个方法是直接使用容器的equal_range函数。该函数返回一个pair，保存的是两个迭代器。指向的位置与 lower_bound 和 upper_bound 相同解决此问题的最后一个方法是直接使用容器的equal_range函数。该函数返回一个pair，保存的是两个迭代器。指向的位置与 lower_bound 和 upper_bound 相同for(auto pos = authors.equal_range(search_item); pos.first != pos.end; ++pos.first) { cout << pos.first->second << endl; }无序容器新标准中定义了4种无序关联容器，这些容器不是使用比较运算符来组织元素，而是使用一个哈希函数和关键字类型的 == 运算符。在关键字类型的元素没有明显的序关系时，无序容器是非常有用的。对于自定义类型的关键字，无法直接在无序容器中使用，还需要提供该类型的hash操作。

泛型算法 好久没有更新博客了，最近一直想把我以前的老笔记本换成 Arch + dwm 的样式来使用。现在基本已经弄完了。后面会考虑将我的心得发出来。从0开始一点点的增加自己需要的功能确实很繁琐但是也挺有趣的。闲话就到这里，这篇文章继续记录我学习c++ 11的内容。这篇主要是泛型算法相关的内容标准容器自身提供的操作少之又少，在多数情况下可能希望对容器进行其他操作，例如排序、删除指定元素等等。标准库容器中并未针对每个容器都定义成员函数来实现这些操作，而是定义了一组泛型算法，它们实现了一组经典算法的公共接口，可以使用于不同类型的元素和多种容器类型。也就是相同一组算法可以处理多种容器类型概述之所以是泛型的，主要是这些通用算法不依赖于具体的容器类型，所有相同算法采用相同的接口迭代器的存在使得算法不依赖于具体的容器类型，但是算法依赖于元素类型的相关操作，例如我们可以简单的使用下面的代码来说明这个bool find(beg, end, val) { for(auto iter = beg; iter != end; ++iter) { if(*iter == val) { return true; } } return false }上述代码并不限定于只能使用某种类型的容器，只要容器中迭代器支持递增操作，并且元素本身支持比较运算即可。泛型算法本身不会执行容器的操作，它们只会运行于迭代器之上，执行迭代器的操作，最多也就只会修改迭代器所指向的元素的值。对容器自身没有影响。算法永远不会改变底层容器的大小。算法可能改变容器中保存的元素的值，也可能在容器中移动元素。但是永远不会直接添加或者删除元素（当然插入迭代器例外）初识泛型算法除了极少数例外，标准库算法都是对一个范围内的元素进行操作。我们将此元素范围称之为输入范围，接受输入范围的算法总是使用前两个参数来表示此范围。两个参数分别是指向要处理的第一个元素和尾元素之后位置的迭代器。理解基本算法的方法就是了解它们是否读取元素、改变元素或者重新排列元素顺序只读算法一些算法只会读取输入范围内的元素，而从不改变元素。find就是这样一个算法。一些常见的只读算法如下：find:查找容器中出现某个元素的位置，需要容器中元素类型实现 == 操作count: 返回容器中出现某个元素的次数，同样需要容器中元素类型实现 == 操作accumulate: 计算某个迭代器范围内，所有元素的和，需要容器中元素类型实现 + 操作equal: 比较两个序列中元素值是否完全相同，它接受三个参数，前两个表示一个容器的迭代器范围。最后一个参数代表第二个容器的起始位置一般来说对于只读取而不改变元素的算法，通常最好使用cbegin和cend 获取const版本的迭代器。那些只接受一个单一迭代器来表示第二个序列的算法，都假定第二个序列至少与第一个序列一样长。写容器元素的算法这类算法需要确保，容器原大小不能小于我们要求算法写入的元素数目。由于算法不会执行容器操作，因此它们自己不可能改变容器大小一种保证算法有足够元素空间来容纳输出数据的方式是使用插入迭代器，插入迭代器是一种向容器中添加元素的迭代器拷贝算法接受3个迭代器，前两个表示一个源容器的范围，第三个迭代器是目的容器的起始位置的迭代器。同样的源容器的长度不能超过目的容器的长度定制操作很多算法都会比较输入序列中的元素，默认情况下，这类算法使用元素类型的< 或者 == 运算符来完成比较操作。标准库还为这些算法定义了额外的版本，允许我们提供自已定义的操作来代替默认运算符。例如sort 算法默认使用元素类型的 < 运算符，但是可以使用sort的重载版本，额外定义比较的规则向算法传递参数标准库中可以接受的比较函数一般返回一个bool值，表示是否小于或者是否相等。函数接受一个参数或者两个参数。在c++新标准中将这个函数叫做谓词，接受一个参数的函数被成为一元谓词，接受两个参数的函数叫做二元谓词。vector<string> words; //初始化 words //...... bool isShorter(const string& s1, const string& s2) { return s1.size() < s2.size(); } sort(words.cbegin(), words.cend(), isShorter);lambda 表达式在介绍lambda 表达式之前，需要先介绍可调用对象这个概念可调用对象：对于一个对象或者一个表达式，如果可以对其使用调用运算符，则称它是可调用的；例如，e是一个可调用对象，则我们可以编写代码e(args) ，其中args是一个逗号分割的一个或者多个参数的列表到目前为止，我们只接触了函数和函数指针这两类可调用对象，还有其他两种可调用对象：重载了函数调用运算符的类，以及lambda表达式。一个lambda 表达式表示一个可调用的代码单元。我们可以将其理解为一个未命名的内联函数，定义形式如下capture list -> return type {function body}capture list 捕获列表，是一个lambda 所在函数中定义的局部变量的列表。parameter list 函数的参数列表return type 是函数返回值类型function body 是函数体，需要执行的具体代码段与普通函数不同的是 lambda 必须使用尾置返回来指定返回类型我们可以忽略参数列表和返回值,但是必须包含捕获列表和函数体auto f = [] {return 42;};如果lambda 表达式中没有明确指定返回类型，函数体中包含任何单一 return 语句之外的内容，则返回voidlambda 的调用方式和普通函数的调用方式一样，都是调用运算符cout << f() << endl;lambda 表达式不能有默认参数[] (const string& str1, const string& s2) { return s1.size() < s2.size(); }; vector<string> words; stable_sort(words.begin(), words.end(), [](const string& s1, const string& s2){ return s1.size() < s2.size(); });lambda 表达式一般出现在一个函数中，使用其局部变量，但是它只能访问那些明确指明的变量。一个lambda通过将局部变量包含在其捕获列表中来指明将会使用这些变量。捕获列表指引lambda 在其内部包含访问局部变量所需的信息[sz](const string& s){ return a.size() >= sz; }lambda 捕获和返回与参数传递类似，变量捕获的方式可以是值或者引用。void func1() { size_t v1= 42; auto f = [v1]{return v1;}; v1 = 0; auto j = f(); //j 是42， 因为在定义lambda的时候传入的是v1的拷贝，后续v1 的改变不影响捕获中v1 的值 }被捕获变量的值是在lambda创建时拷贝，因此随后对其修改不会影响到lambda内对应的值void func2() { size_t v1 = 42; auto f = [&v1](){return v1;}; v1 = 0; auto j = f(); //j 是0，f保存v1的引用，而非拷贝 }引用捕获与返回引用有着相同的限制，必须保证调用在调用lambda表达式时，是存在的。捕获的都是函数的局部变量，如果lambda 在函数结束之后执行，捕获的引用指向的局部变量已经消失。可以在函数中返回一个lambda表达式，此时返回的lambda 中不应该包含引用捕获使用引用捕获的时候需要注意，在一次或者多次调用lambda表达式的时候应该保证引用的对象仍然有效，同时需要保证对象的值是我们所期待的。因此在使用lambda的时候尽量减少捕获变量的数量，同时尽量不使用引用捕获除了显式列出我们希望使用的所来自所在函数的变量外，还可以让编译器根据lambda体中的代码来推断我们要使用哪些变量。为了指示编译器推断捕获列表，应在捕获列表中写一个&或者=，表示采用引用捕获或者值捕获我们也可以混合使用隐式捕获和显式捕获，混合使用时，捕获列表的第一个元素必须是一个&或者=。当混合使用了显式捕获和隐式捕获时。显式捕获的变量必须与使用隐式捕获不同的方式。当使用值捕获的时候，默认情况下lambda表达式是不能改变其值的，如果希望改变一个被捕获的变量的值，就必须在参数列表后加上关键字 mutablevoid f3() { size_t v1 = 42; auto f = [v1] ()mutable{return ++v1;}; v1 = 0; auto j = f(); // j = 43 }一个引用捕获的变量是否可以修改依赖于此引用指向的是一个const 类型还是一个非const类型void fnc4() { size_t v1 = 42; auto f2 = [&v1]{return ++v1;}; v1 = 0; auto j = f2(); //j = 1 }// 错误，由于有除return之外的其他语句，因此编译器推断lambda 表达式返回void，但是返回了具体值 transform(v1.begin(), v1.end(), vi.begin(), [](int i){ if(i < 0) return -i; else return i; }); //正确，只有return语句，编译器可以推断出返回int类型 transform(v1.begin(), v1.end(), vi.begin(), [](int i){ return (i < 0)? -i : i; }); //正确，明确指定了返回int类型 transform(v1.begin(), v1.end(), vi.begin(), [](int i)->int{ if(i < 0) return -i; else return i; });参数绑定lambda 表达式适用于只在一两个地方使用的简单操作，如果多个地方都需要使用到相同的操作，就需要写上相同的lambda表达式。这个时候最好的办法是定义一个函数。在需要进行捕获的情况下使用函数就不是那么容易了。例如有的泛型算法只传递一个参数，但是我们在函数中需要两个参数。这种情况下就需要用到参数绑定标准库中定义了一个bind函数。可以将bind作为一个函数适配器。它接受一个可调用对象，生成一个新的可调用对象来适应原对象的参数列表auto newCaller = bind(callable, arg_list);其中 callable 是一个可调用对象，返回的newCaller 是一个新的可调用对象，而arg_list 中的参数可能包含形如 _n 的名字，其中n是一个整数。这些参数是“占位符”。表示 newCaller 的参数。它们占据了传递给newCaller的参数位置。数值n表示生成的可调用对象中参数的位置。_1为newCaller的第一个参数，_2 为第二个参数。以此类推auto wc = find_if(words.begin(), words.end(), bind(check_size, _1, sz));此时调用生成一个可调用对象，将check_size 的第二个参数绑定到sz的值，当find_if 对words中的string调用这个对象的时候，这些对象会调用check_size 将给定的string 和 sz 传递给它，因此 find_if 可以有效的对输入序列中的每一个string调用check_size 实现string与 sz的比较_n 都定义在一个名为 placeholders 的命名空间中，而这个命名空间本身定义在std命名空间中。每次在使用_n 这样的名字时，都需要声明这个命名空间。using std::placeholders::_1; using std::placeholders::_2;每个占位符都必须提供单独的using声明，这样比较麻烦。可以使用另一种不同形式的 using 语句using namespace std::placeholders;我们可以使用bind 给可调用对象中参数重新排序，例如f是一个可调用对象，它有5个参数auto g = bind(f, a, b, _2, c, _1);生成的新的可调用对象g接受两个参数，分别是 _2, _1。在调用g时相当于void g(_1, _2) { f(a, b, _2, c, _1); }当我们执行 g(x, y) 最终会执行 f(a, b, y, c, x)在执行时会将 bind 中传入的参数拷贝到原来的函数参数中，如果想向原函数传递引用，可以使用标准库中的 ref函数auto g = bind(f, ref(a), b, _2, c, _1)上述代码中，在执行g的时候会向f中拷贝a的引用。_1, _2 本身在传值的时候可以传入引用再谈迭代器除了之前介绍的迭代器，标准库还定义了几种额外的迭代器：插入迭代器：这些迭代器被绑定到一个容器上，可以用来向容器插入元素流迭代器：这些迭代器绑定到流中，可以用来遍历所有关联的IO流反向迭代器：这些迭代器向后而不是向前移动，除了 forward_list 之外的标准库容器都有迭代器移动迭代器：这些专用迭代器不是拷贝其中的元素，而是移动它们。插入迭代器插入迭代器是一种迭代器适配器，它接受一个容器，生成一个迭代器，能实现向给定容器添加元素。插入迭代器有三种类型，差异在于元素插入的位置:back_iterator: 创建一个使用push_back 的迭代器front_iterator: 创建一个使用push_front 的迭代器inserter: 创建一个使用insert 的迭代器iostream 迭代器虽然iostream并不是容器，但是标准库定义了可以用于这些IO类型对象的迭代器。istream_iterator 读取输入流，ostream_iterator 向一个输出流写数据。这些迭代器将它们对应的流当作一个特定类型的元素序列来处理。通过使用流迭代器，我们可以使用泛型算法从流对象读取数据以及向其写入数据。istream_iterator<int> in(cin), eof; accumulate(in, eof, 0); // 从标准输入中读取整数，并计算它们的和 ostream_iterator<int> out(cout); copy(vec.begin(), vec.end(), out); //将vector中的数据拷贝到ostream流中，也就是输出vector 中的元素istream_iterator 允许使用懒惰求值，即只在需要时进行数据读取泛型算法结构任何算法最基本的特性是它要求其迭代器提供哪些操作。算法要求的迭代器操作可以分为5个迭代器类型：输入迭代器：只读不写；单遍扫描，只能递增输出迭代器：只写不读；单遍扫描，只能递增前向迭代器：可读写，多遍扫描，只能递增双向迭代器：可读写，多遍扫描，可递增递减随机访问迭代器：可读写，多变扫描，支持全部迭代器运算5 类迭代器类似容器，迭代器也定义了一组公共操作。一些操作所有迭代器都支持，另外一些只有特定类别的迭代器才支持。输入迭代器可以读取序列中的元素。一个输入迭代器必须支持：用于比较两个迭代器的相等和不想等运算符用于推进迭代器的前置和后置递增运算符用于读取元素的解引用运算符，解引用只会出现在赋值运算符的右侧箭头运算符输出迭代器可以看作是输入迭代器功能上的补集，只写而不读元素，输出迭代器必须支持用于推进迭代器的前置和后置递增运算解引用运算符，只出现在赋值运算符的左侧前向迭代器可以读写元素，这类迭代器只能在序列中沿一个方向移动。前向迭代器支持所有输入和输出迭代器的操作。双向迭代器可以正向/反向读写序列中的元素。除了支持所有前向迭代器的操作之外，双向迭代器还支持前置和后置的递减运算符。随机访问迭代器提供在常量时间内访问序列中任意元素的能力。除了支持双向迭代器的所有功能外，还支持：用于比较两个迭代器相对位置关系的运算符 (<、<=、>和>=)迭代器和一个整数值的加减运算(+、+=、-、-=)，计算结果是迭代器在序列中前进或者后退给定整数个元素后的位置用于两个迭代器上的减法运算符，得到两个迭代器的距离下标运算符 iter[n] 与 *(iter[n]) 等价算法形参模式大多数算法具有如下4种形式之一：alg(beg, end, other, args)alg(beg, end, dest, other, args)alg(beg, end, beg2, other, args)alg(beg, end, beg2, end2, other, args)其中alg 是算法名字，beg和 end表示算法所操作的输入范围，几乎所有算法都接受一个输入范围。是否有其他参数依赖于要执行的操作。dest参数表示算法可以写入的目的位置的迭代器。算法假定按其需要写入数据，不管写入多少个元素都是安全的。如果dest是一个直接指向容器的迭代器，那么算法将输出数据写到容器中已经存在的元素内。更常见的情况是，dest被绑定到一个插入迭代器或者是一个ostream_iterator。接受单独的beg2 或者 beg2和end2的算法用这些迭代器表示第二个输入范围，这些算法通常使用第二个范围中的元素与第一个输入范围结合来进行一些运算算法命名规范除了参数规范，算法还遵循一套命名和重载。这些规则处理诸如：如何提供一个操作代替默认的 < 或者 == 运算以及算法是将输出数据写入到一个序列还是一个分离的目的位置等问题接受谓词参数来代替 < 或者== 运算符的算法，以及那些不接受额外参数的算法，通常都是重载的函数。一个版本用元素自身的运算符来比较元素，另一版本接受一个额外的谓词参数来代替 <或者==unique(beg, end); unique(beg, end, comp); //使用comp函数比较元素接受一个元素值的算法通常有另一个不同名版本，该版本接受一个谓词，代替元素值，接受谓词参数的算法都有附加的_if 后缀find(beg, end, val); find_if(beg, end, pred); //pred 是一个函数，查找第一个令pred返回真的元素默认情况下，重排元素的算法将重排后的元素写回给指定的输入序列。这些算法还提供了另一个版本，将元素写到一个指定的输出目的位置。这类算法都在名字后加一个_copyreverse(beg,end); reverse(beg,end,dest); //将元素按逆序拷贝到dest一些算法还提供_copy和_if 版本，这些版本接受一个目的位置迭代器和一个谓词remove_if(v1.beg(), v1.end(), [](int i){return i % 2}); remove_if(v1.beg(), v1.end(), back_inserter(v2), [](int i){return i % 2});特定容器算法与其他容器不同，链表定义了几个成语啊函数形式的算法。，它们定义了独有的sort、merge、remove、reverse和unique。这些链表中定义的算法的性能比通用版本要高的多。与通用版本中的不同，链表中的特有操作会改变容器。

顺序容器 所有容器类都共享公共的接口，不同容器按不同的方式进行扩展，这个公共接口使得学习容器更加容器。我们基于这种容器所学习的内容也都适用于其他容器。每种容器都提供了不同的性能和功能权衡一个容器就是一些特定类型对象的集合。顺序容器为程序员提供了控制元素存储顺序的能力。这种顺序不依赖于元素的值，而是与元素加入容器的位置相对应。顺序容器概述所谓的顺序容器是指，在内存中数据存储有一定顺序。数据结构中的顺序容器有：可变数组、队列、数组、链表、栈。c++ 标准库中的顺序容器提供了快速顺序访问元素的能力。但是这些容器在一下方面都有不同的性能折中向容器中添加或者删除元素的代价非顺序访问容器中元素的代价标准库中顺序容器主要有：vector：可变大小的数组。支持快速随机访问，在尾部之外插入或者删除元素可能会很慢dque：双端队列，支持快速随机访问，在头尾位置插入/删除元素速度很快list：双向连标，只支持双向顺序访问，在list中任何位置进行插入删除操作速度都很快forward_list: 单向链表，只支持单向顺序访问，在链表任何位置插入删除元素速度很快array: 固定大小的数组，支持快速随机访问，不能添加或者删除元素string: 与vector容器类似，但专门用于保存字符，随机访问快。在尾部插入与删除速度快c++ 标准库中的容器是经过精心优化设计过的。性能通常会是同类数据结构中最好的。现代c++ 程序应该使用标准库容器，而不是原始的数据结构（如内置数组）通常使用vector 是最好的选择，除非你有很好的理由选择其他容器一下是一些选择容器的基本原则:除非你有很好的理由选择其他容器，否则使用vector如果你的程序有很多小的元素，且额外开销很严重，否则不要使用list或者forward_list如果程序要求随机访问元素，应该使用vector 或者deque如果程序要求在容器中间插入或者删除元素，应该使用list或者forward_list如果程序要在头尾位置插入或者删除元素，但是不会在中间位置插入删除元素，则应该使用deque如果程序只有在读取输入时才需要在容器中间插入元素，随后需要随机访问元素，则： 6.1 首先确定是否真的需要在容器中间位置添加元素。当处理输入数据时通常很容易向vector中添加数据，然后再调用标准库的sort函数，来重排元素，避免在中间位置添加元素 6.2 如果必须在中间位置插入元素考虑在输入阶段使用list，一旦输入完成，将list中的内容拷贝到一个vector中如果你不确定该使用哪种容器，可以在程序中只使用vector 和list公共的操作，不使用下标操作，使用迭代器，避免随机访问容器库概述迭代器迭代器是访问容器中元素的公共接口所有迭代器都通过解引用运算符来实现这个操作。标准库中的所有迭代器都定义了递增运算符，从当前元素移动到下一个元素。部分容器的迭代器也定义了递减运算符，用于从一个元素移动到上一个元素一个迭代器范围是由一对迭代器来表示的。两个迭代器分别指向同一个容器的元素或者尾元素之后的位置。如果两个迭代器满足以下两个条件，则这两个迭代器构成一个迭代器范围：它们指向同一个容器中的元素，或者是容器最后一个元素之后的位置我们可以通过反复递增begin 来到达end位置，换句话说，end不在begin之前如果两个迭代器构成一个迭代器范围，则：如果begin和end相等，则范围为空如果begin和end不等，则范围至少包含一个元素，且begin指向该范围中的第一个元素我们可以对begin递增若干次，使得begin== end容器类型成员每个容器都定义了多个类型，我们已经使用了其中的3种：size_type、iterator、const_iterator除了正向的迭代器，容器库还提供了反向遍历容器的迭代器，反向迭代器就是一种反向遍历容器的迭代器。与正向迭代器相比各种操作的含义也都发生了颠倒。例如对一个反向迭代器执行++操作，会得到上一个元素。剩下的就是类型别名了。通过类型别名，我们可以在不了解容器中元素类型的情况下使用它，如果需要元素类型可以使用容器的value_type ，如果需要元素类型的一个引用可以使用reference或者const_reference。begin 和 end 成员begin 和 end 操作生成一个指向容器中第一个元素和尾元素之后位置的迭代器范围。begin和end有多个版本。带r的版本返回反向迭代器，带c的版本返回const型迭代器容器定义和初始化可以将一个容器初始化为另一个容器的拷贝将一个新容器创建为另一个容器的拷贝的方法有两种：可以直接拷贝整个容器，或者拷贝由一个迭代器对指定的元素范围为了创建一个容器为另一个容器的拷贝，两个容器的类型及其元素类型必须匹配。当传递迭代器参数来拷贝一个范围时，就不要求容器类型是相同的了。而且新容器和原容器中的元素类型也可以不同，只要能将拷贝的元素转化为要初始化的容器的元素类型即可在新标准中我们对一个容器进行列表初始化标准库array在定义之处就应该给出具体的大小，而且后续不允许修改它的大小我们不能直接对内置数组执行拷贝或者对象赋值操作，但是array对象允许赋值和swap我们直接使用 = 运算符来将一个容器赋值为另一个容器的拷贝，但是要求容器类型完全相同，array也支持这种操作顺序容器(array除外)还定义了一个assign的成员，assign操作用参数所指定的元素替换左边容器中的所有元素list<string> name; vector<const char*> oldstyle; name = oldstyle; //错误 = 要求两侧容器类型完全相同 name.assign(oldstyle);可以使用swap交换两个容器中的内容，要求两个容器类型完全相同。除了array外，swap不对任何元素进行拷贝、删除或者插入操作，可以保证在常量时间内完成容器大小操作每个容器都有三大与大小相关的操作。size: 返回容器中元素数目empty: 当容器中元素数量为0时，返回true，否则返回falsemax_size: 返回一个大于或者等于该类型容器所能容纳的最大元素数的值关系运算符除了无序容器外的所有容器都支持关系运算符关系运算符左右两边的运算对象必须是相同类型的容器，且必须保存相同类型的元素比较的过程与比较string大小的过程类似如果两个容器具有相同大小且所有元素都两辆对应相等，则两个容器相等。否则两个容器不等如果两个容器大小不同，但较小容器中每个元素都等于较大容器中对应元素。则较小容器大于较大容器如果两个容器都不是另一个容器的前缀自序列，则它们的比较结果取决于第一个不相等的元素的比较结果容器的相等运算符实际上是使用元素的==运算符实现比较的。而其他关系是使用元素的< 运算符顺序容器的操作向顺序容器中添加元素push_back：将内容追加到容器尾部push_front: 将内容添加到容器的首部insert: 在容器的特定位置插入0个或者多个元素,返回插入元素位置的迭代器emplace_back、emplace_front、emplace: 这些函数是直接在容器内部进行元素构造，而上述函数是将内容进行拷贝。从效率上讲emplace 函数会高一些使用这些操作时必须记得不同类型的容器使用不同的元素分配策略，而这些策略直接影响性能。访问顺序容器每个顺序容器中都有一个front 函数，返回容器内第一个元素的引用。而除了forward_list 之外的所有顺序容器都有一个back成员函数。另外可以使用at来访问随机位置的元素记住，这些访问函数返回的都是引用删除元素pop_front: 删除首元素pop_back: 删除尾元素erase: 可以从容器中删除指定位置的元素,可以传入一个范围，删除指定范围内的元素特殊的 forward_list 操作在对forward_list 进行增删操作的时候，需要找到对应位置的前驱节点，而单向链表无法很容器的找到一个节点的前驱节点。因此对单向链表，提供了类似 insert_after、emplace_after、erase_after等操作改变容器大小可以使用resize 来增大或者缩小容器大小,如果是缩小容器大小，则指向被删除元素的迭代器、引用、指针都会失效容器操作可能使迭代器失效在向容器中添加元素后：如果容器是vector或者string，且存储空间被重新分配，则指向容器的迭代器、指针都会失效。如果存储空间未重新分配，指向插入位置之前的迭代器、指针、引用仍然有效，但是指向插入位置之后元素的迭代器、指针和引用将会失效对于deque，插入到首尾位置之外的任何位置都会导致迭代器、指针和引用失效。如果在首尾位置添加元素，迭代器会失效，但指向存在的元素的引用和指针不会失效对于list和forward_list，指向容器的迭代器、指针和引用仍然有效删除一个元素后，指向原来被删除元素的迭代器、指针和引用都会失效。对于forward_list 和list来说，指向容器其他位置的迭代器、引用和指针仍然有效对于deque，如果在首尾之外的任何位置删除元素，那么指向被删除元素以外的其他元素的迭代器、引用和指针也会失效。如果是删除deque的尾元素，则尾后迭代器也会失效。但是其他迭代器、引用和指针不受影响，如果删除首元素，这些也不会受到影响对于vector和string，指向被删除元素之前元素的迭代器、引用和指针仍然有效删除元素时尾后迭代器总是会失效使用insert插入元素后可以保存返回的迭代器，然后用该迭代器进行迭代可以保证迭代器有效不要保存end返回的迭代器vector 容器是如何增长的为了支持快速随机访问，vector 将元素连续存储。如果往容器中添加一个新元素时，发现容器空间已经不够了，就需要重新分配空间。并将已有元素逐一拷贝到新的内存空间中，然后添加新元素。为了避免这种代价，标准库实现者采用了可以减少容器空间重新分配次数的策略。当不得不获取新的内存空间时，vector和string的实现通常会分配比新的空间需求更大的内存空间vector和string也提供了一些成员函数，允许我们与它的实现中内存分配部分互动。capacity: 告诉我们容器在不扩张内存空间的情况下可以容纳多少个元素reserve: 允许我们同志容器它应该准备保存多少个元素一般来讲，vector 的实现采用的策略似乎是在每次需要分配新内容空间时将当前容量翻倍额外的string操作除了顺序容器共同的操作之外，string类还提供了一些额外的操作。这些操作中的大部分要么是提供string类和C风格字符串之间的互相转换，要么是增加了允许我们用下标代替迭代器的版本。substr: 返回一个string，它是原始string的一部分或者全部的拷贝可以使用insert、erase、assign 来改变字符串的内容append可以在字符串尾部添加一个新字符串; replace 进行查找替换搜索操作标准库中提供了6个不同的搜索函数，每个函数有4中不同形式的重载版本。每个搜索操作都返回string::size_type 值，表示匹配发生位置的下标。如果搜索失败返回一个名为string::npos 的static成员s.find(arg): 查找字符串中第一次出现某个字符串的位置s.rfind(arg): 查找字符串中最后一次出现某个字符串的位置s.find_first_of(arg): 在s中查找arg中任意一个字符第一次出现的位置s.find_last_of(arg): 在s中查找arg中任意一个字符最后一次出现的位置s.find_first_not_of(arg): 在s中查找第一个不在arg 中的字符s.find_last_not_of(arg): 在s中查找最后一个不在arg 中的字符compare 函数compare函数用于比较两个大小字符串，与C标准库中的strcmp类似数值转化to_string: 将数值数据转化为字符串stod: 将字符串转化为doublestof: 将字符串转化为floatstoi: 将字符串转化为intstol: 将字符串转化为longstoul: 将字符串转化为 unsigned longstoll: 将字符串转化为 long longstoull: 将字符串转化为 unsigned long longstold: 将字符串转化为 long double容器适配器适配器是标准库提供的一组概念，能使某种事物的行为看起来像另一种事物一样。一个容器适配器接受一种已有的容器类型，使其行为看起来像另一种事物一样标准库提供了三种适配器: stack、queue、priority_queue(优先级队列)所有的适配器都要求容器具有添加和删除元素的能力。stack 只要求类型容器具有 push_back、pop_back 操作因此可以使用除了array 和 forward_list 之外的任何容器类型来进行构造queue 要求容器类型具有 back、push_back、front、pop_back 因此它可以构造在list 或者deque之上但不能基于vector 构造; priority_queue 要求容器类型具有push_back、front、pop_back之外还要求容器具有随机访问的能力，所以它必须构造在vector之上

IO库 c++ 语言中不直接处理输入和输出，而是通过一族定义在标准库中的类型来处理IO，这些类型支持从设备读取数据、向设备写入数据的IO操作。设备可以是文件、控制台窗口等。还有一些IO运行内存IO，即可以从string中读写数据。IO库IO类最开始接触的c++ 中的io是我们从控制台接受输入的istream和输出到控制台中的ostream。除了基本的istream和ostream以外标准库中还定义了如下的基本类型iostream 用于读写流的基本类型istream、wistream: 从流读取数据ostream、wostream: 向流写入数据iostream、wiostream：从流中读写数据fstream 定义了读写命名文件的类型ifstream、wifstream: 从文件中读写数据ofstream、wofstream: 向文件中写入数据fstream、wfstream: 读写文件sstream 定义了读写内存string对象的类型istringstream、iwstringstream: 从string中读取数据ostringstream、owstringstream: 向string中写入数据stringstream、wstringstream: 读写string其中带w的都是款字节版本无法对io对象进行拷贝或者赋值、因此在函数中无法返回IO类型也无法传递IO类型，只能使用IO类型的引用读写一个IO对象会改变其状态，所以在函数中传递和返回IO的对象不能是const的一个流如果发生错误，其上后续的IO操作都会失败。只有当一个IO流处于无错误状态时，我们才能从它读取数据。因此代码通常应该在使用一个流之前检查它是否处于良好状态，确定一个流对象的状态最简单的方式是将它作为一个条件来使用。作为条件使用只能告诉我们流是否有效，而无法告诉我们具体发生了什么。IO库定义了一组与机器无关的iostate类型，这个类型中使用二进制位来表示每种状态。目前定义了4种错误类型：badbit: 流崩溃failbit: IO操作失败eofbit: 流到达了文件结束位置goodbit: 流未处于错误状态在实际使用时可以将具体值与这些预定义的值做位与运算，得到具体的原因流对象的rstate 成员返回当前流的状态，setstate用来设置流状态。clear不带参用来清理所有错误标志位。clear的带参版本接受一个iostate值，表示流的新状态io操作比较耗时，所以操作系统为了效率会提供缓冲机制。输入输出并不是立即执行的，操作系统提供了一个缓冲区，在适当的实际会使用缓冲区的数据，统一执行输入输出操作。导致刷新的原因有很多：程序正常结束，在main函数执行return时，会进行刷新操作缓冲区满时，会进行换新操作程序中使用操作符例如endl来显式的刷新缓冲区输出操作结束后，使用操作符unitbuf 设置流的内部状态来清空缓冲区，默认情况下cerr 是设置了unitbuf 的，因此cerr的内容都是实时刷新的一个输出流被关联到另一个输出流。当读写被关联到另一个流时，关联到的流的缓冲区会被刷新除了使用endl、flush、ends 都可以来刷新缓冲区。endl在刷新的同时会插入换行符，flush则不添加任何字符，ends会添加一个空字符如果想在每次输出后都刷新缓冲区，可以使用unitbuf 操作符，它告诉流，每次执行写操作之后都进行一个flush操作cout << unitbuf; cout << nounitbuf;如果程序崩溃，缓冲区是不会被刷新的标准库是将cin和cout关联到一起了，所以每次执行cin都会导致cout的缓冲区被刷新可以使用tie 方法将自身关联到另一个流上。tie 带参数的版本，需要传入一个指向ostream 的指针，将自己关联到这个ostream中tie 不带参数的版本用来查询自身关联到了哪个输出流上，返回对应输出流的指针，如果未被关联，则返回空指针每个输入流最多只能关联到一个输出流，但是多个输入流可以关联到同一个ostream文件IO当我们要读写一个文件时可以使用文件流对象ifstream in(ifile); //传入文件名，构造一个ifstream 并打开文件 ofstream out; //定义一个文件输出流，这个流不关联到任何文件当我们定义了空的文件流对象后可以使用open函数将对象和文件关联起来。可以手动调用close函数关闭文件。也可以在fstream对象被销毁时由它的构造函数自动调用close每个流都有一个关联的文件模式，用来指出该如何使用文件in: 以读的方式打开out: 以写的方式打开app: 每次写操作前均定位到文件尾部ate: 每次打开文件后立即定位到文件尾部trunc: 截断文件binary：以二进制的形式打开文件string 流当我们的某些工作是对文本进行处理，而其他一些工作是处理行内的单词时通常可以使用 istringstream 即要在一行字符串中取出单个单词时可以使用字符串流

类 最近好像很久没有更新过关于c++ primer 的读书笔记了，一来自己最近遇到了烦心事，中断了一段时间的读书。第二个是因为我有点想写点随笔之类的东西了，中间更新了两篇随笔《关于读书》、《我的五年计划》。第三个是因为关于类这部分的内容确实有点多了，要读完也需要花费一定时间。因此更新就慢了起来。我发现我已经忘记了如何给这类文章取名字了，还是看着以前的项目想起来的。既然我定下来了未来5年的发展计划，那么从现在开始就应该坚持下来了。定义抽象数据类型这里定义抽象数据类型就是定义一个类，只要学过c++的对定义一个类并并不陌生，这里就不再详细的说明该如何定义一个类了。这部分主要需要注意：1类的const成员函数：一般类的成员函数会隐式的传入当前对象的地址即 ClassExample::func(ClassExample* this);const型的成员函数传入的是一个const型的this指针，ClassExample::func(const ClassExample* this); 从这个角度上说不允许在常函数里面修改对象的值。同时由于const类型无法自动转化为非const类型，所以const型对象只能调用const成员函数。类的作用域：类本身就是一个作用域，类中的所有成员定义在类这个作用域中。编译器在编译类的时候分两步，首先编译成员的声明，然后编译成员函数，因此在成员函数中可以随意使用类的其他成员而不用关心这些成员出现的顺序。如果一个函数在概念上属于这个类，但是不定义为类的成员函数，一般将这个类定义在类声明的头文件中访问控制与封装一般来说定义类的时候应该将类中的数据成员定义为私有或者保护类型，通过成员函数来访问类的数据成员，这样有两个好处：当我们发现数据成员的值不正常的时候，由于类外部是无法访问到数据成员的，所以在调试时只用关注改变了该数据成员的函数即可使用者在使用时只需要关注类提供的功能，不需要知道它里面具体的实现。只用调用类方法就好了，不用关注该如何设置数据成员到此为止，书中提到了两种访问权限，public和private：public: 后定义的成员可以在整个程序内被访问private: 后定义的成员只能在类的成员函数中被访问每个访问说明符指定了接下来的成员的访问级别，其有效范围直到出现下一个访问说明符或者达到类的结尾为止使用class或者struct关键字定义的唯一区别是默认的访问控制符，class默认是private、而struct默认的是public友元在某些时候，可能必须要在类外部使用类的私有成员，这个时候可以将对应的函数或者类声明为类的友元函数或者友元类，友元函数或者友元类可以随意使用类的私有成员。如果类想把一个函数作为它的友元，只需要增加一条以friend 关键字开始的函数声明语句即可友元声明只能出现在类内部，但是在类内出现的具体位置不限，友元不是类的成员也不受它所在区域访问控制级别的约束。需要注意在设计时尽量考虑清楚是不是一定要用到友元，毕竟友元已经在一定程度上破坏了类的封装性类的其他特性除了一些基本的使用和访问权限控制外，书中还提到了类的其他特性：在类中，常有一些规模较小的函数合适于被声明成内联函数。定义在类内部的成员是自动inline的，当然也可以显式的声明为inline函数，这样就可以在类外部定义我们可以仅仅只声明而暂时不定义它，这种声明有时候被称作前向声明。这个类在声明之后，定义之前是一个不完全类型。不完全类型可以用于定义该类型的指针或者引用，也可以声明以该类型作为参数或者返回该类型的函数。对一个类来说，在创建它的对象之前必须被定义。因为编译器在创建对象的时候必须知道类对象占多少存储空间如果一个类指定了友元类，那么这个友元类的成员函数可以访问此类包括非公有成员在内的所有成员友元关系不具备传递性，每个类单独控制自己的友元类或者友元函数除了令整个类作为友元之外，还可以只为某个成员函数单独提供访问权限。当把成员函数声明为友元的时候，我们必须明确指出该成员属于哪个类如果一个类想把一组重载函数声明为友元，它需要对这组函数中的每一个分别声明类的作用域一个类就是一个作用域，在类的外部类成员都被隐藏起来了。在c++ 中，内层作用域中的同名成员会覆盖外层，当函数内部或者类内部定义了与全局作用域相同的变量时，要使用全局作用域中的变量可以使用::类构造函数相关在构造函数中初始化列表相当于先定义再赋值，而要做到对成员变量定义的同时初始化，可以使用初始值列表的形式在某些场合下初始值列表必不可少：初始化const成员或者引用成员构造函数初始值列表只说明用于初始化成员的值，而不限定初始化的具体执行顺序成员的初始化顺序与他们在类中定义的顺序一致。构造函数初始值列表中初始值的前后位置关系不会影响实际的初始化顺序最好令构造函数初始值的顺序与成员声明的顺序保持一致。而且如果可能的话，尽量避免使用某些成员初始化其他成员类的静态成员类的静态数据成员存在于任何对象之外，对象中不包含任何与静态数据成员有关的数据。类似的类的静态函数成员也不与任何对象绑定在一起。它们不包含this指针，静态函数成员不能被声明成const类型，也不能在静态函数成员中调用非类的静态成员不能在类的内部初始化类的静态成员，static关键字只能出现在类内部声明语句中，定义的时候不能加static关键字针对constexpr类型的static成员，可以在类内定义类内初始值由于静态数据成员不与类绑定，所以在计算类大小的时候可以不用考虑静态成员。这样就可以在类内定义该类型的静态数据成员，而非静态数据成员只能定义为该类型的指针或者引用+BEGIN_SRC c++class Menu{private:static Menu me1; Menu* me2; Menu& me3;};+END_SRC另外我们可是用静态成员做成员函数的默认实参

c++基础之函数 距离上次更新又过了一周，又该更新新的读书笔记了。本次更新的主要是c++中函数部分的内容c++ 中的函数与c语言中的函数大致用法或者语法是一样的，这里就不就这点详细展开了。需要注意的是c/c++中并没有规定函数中参数的求值顺序，所以在调用函数时需要特别注意，在传递实参的同时不要修改实参的值，也就是不要写类似func(i, ++i)这样的语句局部对象高级语言中，名字只是用来访问对象所在内存的一个工具，一个对象可以分为对象名和它实际所占的内存空间。这个对象名有它的作用域，对象所在内存有自己的声明周期。这二者不是一个概念，不要弄混淆了。变量的作用域一般只在它所定义的语句块中起作用。但是变量本身根据定义位置不同，生命周期也不同，例如int func() { for(int i = 0; i < 10; i++); }上述代码中i这个名称仅仅在for循环中有效，而i所指代的变量，它会一直持续到函数结束(可以参考鄙人曾经写过的关于c++反汇编分析相关的内容)根据定义位置的不同，变量分为局部变量和全局变量；局部变量，或者在书中有一个新的名字叫自动对象，对于局部变量来说，当代码执行到变量定义语句时创建该对象，当到达定义所在语句块的末端时销毁它，只存在于块执行期间的对象称作自动对象全局变量：定义在函数外部的变量称之为全局变量，全局变量的生命周期从程序启动时创建到程序结束时销毁。除了这两类以外，还有在函数中使用static关键字定义的局部静态变量，局部静态变量在程序第一次经过对象定义语句时初始化，并且直到程序终止时才会销毁。在此期间即使对象所在的函数结束执行也不会对它有影响。它与全局变量的生命周期相同，只是它的变量名被限定在了函数内部(关于什么时候为它分配内存，什么时候销毁的详细内容，也可以参考鄙人曾今写过的关于static的汇编分析)参数传递参数传递主要有值传递、指针传递和引用传递值传递：将实参的值拷贝到形参，然后执行函数，函数中对形参的改变不影响函数外的实参指针传递：指针值本身也是一个拷贝，在函数中可以通过对指针进行解引用操作来间接的改变函数外的实参引用传递：引用本身是对象的别名，可以在函数中通过对引用的修改，来修改函数外实参的值（其实本质上也是通过指针来进行修改）根据这几种传参方式，我们总结出来这样几点：需要改变实参的值，只能传递指针或者引用由于存在值拷贝，所以在传递大的结构体的时候尽量传递结构体的指针或者引用，如果不想修改结构体的值，可以将形参定义为const型函数通过return语句只能返回一个值，如果要返回多个值，可以使用指针或者引用。return 语句本身会进行拷贝，并且在赋值给外部变量时也会进行拷贝，尽量返回4或者8个字节的结构，对于大的结构体尽量使用引用来返回当形参有顶层const时，传给它常量对象或者非常量对象都是可以的。int func(const int i); int func(int i);由于顶层const被自动忽略，所以在上面代码会报错，两个函数的名称、形参列表实际上是相同的。数组形参除了上述这样常规的参数传递，函数中也可以传递数组，这个时候数组会自动退化为指针，例如面试或者笔试题中，经常会问到的一个问题size_t size_arr(int[10] i) { return sizeof(i); }这个时候，如果传递数组的首地址，在函数中会退化为指针，所以实际计算的是int*指针所占的内存。根据平台的不同，指针大小为4字节(32位版本)或者8字节(64位版本)如果想要真正的传递数组，可以使用引用的方式size_t size_arr(int (&arr)[10]) { return sizeof(arr); }此时arr表示有10个int型数据的数组的引用，最终得到的结果应该是 sizeof(int) * 10由于传递数组名时，数组名会退化为指针，所以如果只传递数组名，则在函数中无法确定数组的大小，为了解决这个问题，一般有3种方案：使用特殊标记，表示数组的结尾，一般字符串会这么干传递两个指针，表示数组的首地址和尾部地址，可以使用标准库中的begin 和 end 函数分别获取数组的首地址与尾地址显式传递一个表示数组元素个数的形参。这种情况一般使用下标运算，当下标达到这个指定值时退出循环当我们传递的是多维数组时，按照两个思路进行分析，多维数组其实是数组的数组，传递数组名实质上是数组的首元素地址。根据这两个原则进行分析，在传递多维数组时，后面的维度是数组元素类型，不能省略。而真正传递的是第一个该类型元素的地址。void print(int (*matrix)[10]); void print(int matrix[][10], int rowSize); //等价定义上述定义中，数组的第一维被忽略掉，第二维是10个整数的数组。上面的两个定义其实是等价的可变形参与以往使用 ... 来表示可变形参不同的是，在c++ 中新增了一个名为initializer_list 的标准库类型，这个类型只能处理所有实参类型相同的情况，对于实参类型不同的情况，可以使用可变参函数模板。initializer_list 本身是一个类似与list的结构，但是与list不同的是，initializer_list中的对象永远是常量，无法修改该容器中的值，换一个角度来说，也就无法修改实参的值了。void error_msg(initializer_list<string> il) { for(auto beg = il.begin(); beg != il.end(); ++beg) { cout << *beg << " "; } cout << endl; } //由于它是一个容器，所以在传递值的时候应该使用一对花括号把所有值括起来 if(expected != actual) { error_msg({"functionX", "expected", "actual"}); }else { error_msg({"functionX", "okay"}); }返回类型和return语句函数根据返回值类型可以分为三大类，无返回值的函数、返回普通值的函数、返回指针或者引用的函数。无返回值的函数无返回值的函数不要求非要有return 语句，这类函数在最后一句执行完后会隐式的执行return语句如果无返回值的函数需要在中间位置提前退出的话，可以使用return语句另一个使用return的场景是，直接在return后面加上函数调用，不过被调用的函数需要也是无返回值的函数返回普通值的函数有返回值的函数，必须使用return 返回一个值，返回的值必须与函数的返回类型相同，或者能隐式的转化成函数的返回值要注意保证所有路径都有返回值，一般编译器能发现这类情况，但是有的编译器不能，如果执行了没有返回值的分支，将产生未定义错误不要返回局部对象的指针或者引用函数的调用优先级与点运算和箭头运算的优先级相同，并且也附和左结合律函数的返回类型决定函数调用是否是左值，调用一个返回引用的函数得到一个左值，其他返回类型得到右值，我们能为返回类型是非常量引用的函数结果赋值当返回一个容器时，c++ 11开始，可以返回由大括号组成的初始化列表针对main函数来说，最后可以不加return语句，如果最后没有return 则编译器默认给它加上一个return 0返回数组指针的函数因为数组不能被拷贝，所以不能直接返回数组，不过可以返回数组的指针或者引用定义指向数组的指针采用的是int (*p)[10]; 的方式，同样的定义返回数组指针的函数，只需要把p定义为函数形式即可:int (*func(int i))[10];。上述定义写起来比较麻烦，而且也不容易理解，因此可以使用类型别名的方式来简化定义方式int odd[] = {1, 3, 5, 7, 9}; int even[] = {2, 4, 6, 8, 10}; decltype(odd)* arrPtr(int i) { return (i % 2) ? &odd, &even; }当我们直到返回的数组指针具体指向哪个数组，可以使用decltype关键字来声明函数的返回类型。从c++11 开始，提供了一种新的定义方式，即尾置返回类型的方式auto func(int i) -> int (*)[10];函数重载c++ 与 c语言中的一个很大的不同就是c++ 允许函数重载。同一作用域内的几个函数名称相同，但形参列表不同的，称之为函数重载。注意这里的几个前提条件：同一作用域、函数名称相同、形参列表不同；这些条件缺一不可。而且这里说的是形参列表不同，返回值不同的不能算是重载。main函数作为入口函数，只能有一个顶层const不影响传入的参数，因此认为顶层const与普通形参相同，不认为是重载如果传入的参数是引用或者指针，可以根据它所指向的对象是否为const来进行区分，所以底层const可以作为重载由于非const型参数能转化为const型，所以当传参中多个函数都满足，编译器会优先选择const版本在实际使用时，根据调用时的传参，来与一组重载函数中的某一个关联起来，这个过程叫做函数匹配或者叫做重载确定一般情况下函数匹配过程很容易分别出来，要么是形参个数不同，要么是类型毫无关系，但是也有例外，例如：形参中存在默认值形参中一种类型可以转化为另一种类型目前来说调用函数的时候会出现下列三种情况：可以从一堆重载函数中正确匹配，编译通过没有函数复合调用时传入的实惨，此时编译报错，无法找到对应函数多个重载形式都复合传入的实惨，此时编译报错，存在二义性不要在局部作用域中定义函数，因为局部作用域内出现重名情况时，会进行名称覆盖特殊用途的语言特性默认实参在定义函数时，对于后续多次调用时，传入相同实参值的形参，可以给予一个默认值。这样在调用这个函数时，针对提供了默认值的参数，可以传参也可以不传函数调用时按照实参位置解析，默认实参负责填补函数调用缺少的尾部实参内联函数一般函数调用涉及到参数的拷贝，返回值的拷贝，以及最终栈的回收等一系列操作。调用函数存在一定的性能开销，因此为了提高性能或者提高代码的重复使用率，c中可以使用宏定义来定义一个短小的常规操作，最终编译时会被编译器展开。但是宏定义无法对传入参数进行校验，而且需要注意的问题较多，不好理解。C++中引入内联函数，它与宏的功能类似，是一种没有额外开销的函数一般在函数的返回值类型前面加上inline 关键字就定义了一个内联函数并不是所有的函数都可以定义为内联函数。内联函数用于优化规模小、流程直接、调用频繁的函数，很多编译器不支持内联递归函数。而且一个大于75行的函数也不大可能在调用点内联展开constexpr 函数constexpr 函数是指能用于常量表达式的函数。constexpr函数与普通函数的定义相同，不过要遵循几项约定：函数的返回值以及所有形参类型都是字面值类型函数体中必须有且只有一条return语句在编译阶段，constexpr函数会被直接替换为它返回的具体的值，为了便于函数正常展开，constexpr函数默认都是内联函数由于在编译阶段编译器需要知道内联函数和constexpr 函数的定义。因此这两种函数可以重复定义。但是定义时要保证内容完全相同，基于这个理由，可以将这两种函数统一放到一个头文件中，在需要使用的时候包含它调试帮助可以使用assert预处理宏与NODEBUG宏，其中assert只有在调试模式下才会起作用，而NODEBUG宏则表示当前在发布模式下，此时assert函数不会起作用另外C++ 也定义一些名字便于调试：__FILE__: 当前代码所在文件的名称__LINE__: 当前代码所在行数__TIME__: 当前代码文件被编译的时间__DATE__: 当前代码文件被编译的日期__func__: 当前代码所在的函数函数匹配在大多数情况下，很容易分辨某次调用应该选择哪个重载函数，然而当几个重载函数的形参数量相等以及某些形参的类型可以由其他类型转化得来时，这项工作就不那么容易了。void f(); void f(int); void f(int, int); void f(double, double = 3.14); //调用 f(5.6);函数匹配过程一般经历如下步骤：确定候选函数和可行函数第一步选定本次调用对应的重载函数集，集合中的函数被称之为候选函数。候选函数具备两个特点，一是与被调用的函数同名，二是其声明在调用点可见，这步下来，上述例子中所有f函数都满足条件第二步考察本次调用提供的实参，然后从候选函数中选择能被这组实参调用的函数，这些函数被称为可行函数，可行函数也有两个特征，一是其形参数量与本次调用提供的实参数量相同，二是每个实参与对应形参类型相同，或者能转化成形参的类型。上述实例，调用传入的是一个double类型的参数，double可以转化为int，因此这个时候发现满足条件的是 void f(int); 和 void f(double, double=3.14);寻找最佳匹配第三步是从可行函数中寻找与本次调用最匹配的函数，它的基本思想是实参类型与形参类型越接近，它们匹配的越好。如果多个形参都与调用函数的实参较为接近且，如果有且只有一个函数同时满足下面两个条件，则匹配成功：该函数每个实参的匹配不劣与其他可行函数需要的匹配至少有一个实参的匹配优于其他可行函数提供的方案如果检查了所有实参后没有任何一个函数脱颖而出，则调用错误，编译器将报告二义性。调用重载函数尽量避免强制类型转换，如果在实际应用中需要进行强制类型转换，说明我们设计的形参集合不合理分析上面的例子，如果采用 void f(int); 在调用时会进行一次将double转化为int的类型转化，如果使用 void f(double, double=3.14); 5.6作为double的第一个参数进行传递不需要类型转化，而第二个参数使用默认形参，这里可以不传，因此相比较与第一种int的传参方式，后一种显然更加复合实参类型转化为了确定最佳匹配，编译器将实参类型到形参类型的转化划分为几个等级，具体排序如下所示：精确匹配，包括下列情况 1.1. 实参类型和形参类型相同 1.2. 实参从数组类型或者函数类型转化为对应的指针类型 1.3. 像实参添加顶层const或者从实参中删除顶层const通过const转换实现的类型匹配通过类型提升实现的类型匹配通过算术类型转换或者指针转换实现的匹配通过类类型转换实现的匹配函数指针声明函数指针时，只需要将函数声明中的函数名写为指针名即可，但是需要注意使用括号将表示指针的*与指针名称括起来void (*f)(int);当我们把函数名直接作为一个值使用时，该函数自动转化为指针；也可以使用取地址符针对函数名称取地址，二者是等价的。指向不同类型函数的指针不存在类型转化重载函数的指针必须与某个函数精确匹配，不存在形参类型转化之类的规则可以使用typedef来为函数指针类型定义一个类型别名typedef void(*f)(int); //将返回void、传入一个int参数的函数指针取类型别名为f

c++基础之语句 上一次总结了一下c++中表达式的相关内容，这篇博文主要总结语句的基础内容简单语句c++ 中语句主要是以分号作为结束符的，最简单的语句是一个空语句，空语句主要用于，语法上需要某个地方，但是逻辑上不需要；最常见的就是循环里面复合语句是用大括号括起来的语句块叫做复合语句，复合语句也叫做块。一个块就是一个作用域，在块中引入的名字只能在块内部以及嵌套在块里面的子块中访问。通常名字在有限的区域内可见，该区域从名字定义开始，到名字所在块的结尾为止。语法上需要一条语句，但是逻辑上需要多条语句的，应该使用语句块，例如if或者while等循环里面。块不以分号结束。{};, 算两条语句空块是指内部没有任何语句的一对花括号语句作用域语句中变量的作用域只在当前语句块中有效，如果其他代码也想访问控制变量，则变量必须定义在语句块的外部。条件语句条件语句需要注意：if语句每个分支尽量加上大括号，即好读，也能避免很多问题switch 语句中case后面必须跟上整型常量表达式一般不要省略case分支最后的break语句，如果是特殊逻辑需要这么做的，使用注释进行说明即使不准备在default分支中做任何事，最好也写上default分支。其目的在于告诉程序的读者，我们已经考虑到了默认的情况，只是目前什么也没有做要在case分支中定义变量应该定义在大括号中，并且只在当前分支中使用它迭代语句迭代语句又叫做循环语句，一般有while、do while、for三种形式这些语句一般的语言中都有，这里就不多做介绍，主要介绍c++ 11中新增的一种范围for的形式范围for可以遍历容器或者其他序列的所有元素，它的简单形式是for(declaration: expression) statementdeclaration 定义一个变量，序列中的每一个元素要都能转化为该变量的类型，然后执行拷贝操作，将每次迭代的值拷贝到该变量中。变量只是序列中元素的拷贝，无法修改元素的值，如果想要修改元素的值，需要将变量定义为引用类型。statement 是一个语句或者语句块，所有元素都处理完后，循环结束跳转语句跳转语句主要有break、continue以及goto语句。break：用于跳出离它最近的while、do while、for或者switch语句，并从这些语句之后的第一条语句开始执行。continue：终止最近的循环语句中当前迭代并立即进入下一次迭代，它只能出现在循环语句中。goto：跳转到对应标签处，标签可以定义在函数任意位置。注意只能作用于函数内部，不能由一个函数跳转到另一个函数。尽量少用goto，因为它可读性差，而且不好控制。异常处理语句c++中的异常处理包括这样几个部分：throw表达式：用于抛出一个异常try: 异常处理部分使用try语句块处理异常，try语句块以关键字try开始，并以一个或者多个catch子句结束。try语句块中代码抛出的异常通常会被某个catch子句处理。因为catch子句处理异常，所以它们也被称之为异常处理代码异常类：用于在throw表达式和相关的catch子句之间传递异常的具体信息throw 后面跟一个表达式，表达式返回值的类型就是抛出异常的类型。跟在try 语句块之后的是一个或者多个catch子句，当try中的异常与某一个catch中捕获的异常类型匹配，则执行该catch块中的内容。注意try块与catch子句是两个语句块，在try中定义的变量无法在catch块中使用。标准异常库标准异常库被分别定义在4个头文件中：exception 头文件定义了最为通用的异常类exception。它只报告异常的发生，不提供任何额外信息stdexcept 头文件中定义几种常见的异常类new 头文件中定义了bad_alloc 异常type_info 头文件定义了bad_cast 异常类型在stdexcept 头文件中定义的异常类主要有:exception: 最常见的问题runtime_error: 只有在运行时才能检测出来的问题range_error: 运行时错误，生成的结果超出了有意义的值域范围overflow_error: 运行时错误，计算上溢underflow_error: 运行时错误，计算下溢logic_error: 程序逻辑错误domain_error: 逻辑错误,参数对应的结果值不存在invalid_argument: 逻辑错误，无效的参数length_error: 逻辑错误，试图创建一个超出该类型最大长度的对象out_of_range: 逻辑就错误，使用一个超出有效范围的值标准库异常类只定义了几种运算，包括创建或者拷贝异常类型的对象，以及为异常类型的对象赋值异常类型中只定义了一个名为what的成员函数，返回值为const char* 的c风格的字符串，该字符串的目的是提供关于异常的一些文本信息。

c++基础之表达式 这次接着更新《c++ primer》 这本书的读书笔记，上一篇博文更新到了书中的第三章，本次将记录书中的第四章——表达式左值与右值在理解表达式之前需要先理解c++中左值和右值的概念。c++ 的表达式要么是右值，要么是左值，这两个名词是从c语言中继承过来的，在c语言中，左值指的是可以位于赋值语句左侧的表达式，右值则不能。在c++中二者的区别就相对复杂一些了。在c++要区分左值和右值，可以采取一个原则：一般来说当一个对象被用作左值时，用的是对象的地址，也就是在内存中的位置，而右值可以采取排他性原则，只要不是左值的都是右值。不同运算符对运算对象的要求各不相同，有的要求左值、有的要求右值；返回值也有差异，有的作为左值返回，有的作为右值返回。一个重要的原则是：凡事需要右值的地方可以使用左值来代替，但是不能把左值当成右值来使用。一般下列运算符需要用到左值赋值运算符的左侧需要一个左值。返回的结果也是一个左值取地址运算符作用于一个左值运算对象，返回一个指向该对象的指针，结果是一个右值内置解引用运算符、下表运算符迭代器解引用运算符、string、vector的下标运算符的求值结果都是左值内置类型和迭代器的递增递减运算符作用于左值对象，其前置版本所得到的结果也是左值优先级与结合律复合表达式是指含有两个或者多个运算符的表达式,计算复合表达式的值需要将运算符和运算对象合理的组织在一起，优先级与结合律决定了运算对象的组合方式。表达式中的括号无视运算优先级与结合律的规则，如果表达式中有括号，先运算括号中的内容。表达式的最终值取决与子表达式的结合方式，在计算表达式的值时，先看运算符的优先级，先处理优先级高的子表达式，而优先级相同的情况下，则由其结合律规则决定3 + 4 * 5 //根据运算符的优先级，乘法高于加法，所以先计算4 * 5 为20，再计算3 + 20 得到23 20 - 15 - 3 //先看运算符的优先级，都是减法优先级相同，再看结合律，减法的结合律是从左到右，所以先计算20 -15 得到 5，然后再计算5 - 3 得到2 6 + 3 * 4 / 2 + 2 //先看运算符的优先集，乘法除法的优先级大于加法，而乘法除法的结合律都是从左到右结合，所以这个表达式先计算 3 * 4 得到12，再计算 12 / 2 得到 6 ，最后加法的结合律也是从左到右，最后计算 6 + 6 + 2 得到 14求值顺序优先级规定了运算对象的组合方式，但是并没有规定运算对象按照什么顺序求值，在大多数情况下不会明确指定求值顺序。例如在表达式 int i = f1() * f2(); 中，先计算函数的返回值，然后再将结果赋值进行乘法运算，最后将结果赋值给i变量，但是究竟是先计算f1函数还是先计算f2函数，这个c++标准没有明确规定。对于没有指定执行顺序的运算符来说，如果表达式指向并修改了同一个对象，将会引发错误并产生未定义的行为，例如int i = 0; int j = i + ++i;根据结合律，会先计算i和 ++i但是不确定是该先计算i还是先计算++i 这里会产生未定义行为。如果先计算i则表达式可以转化为 j = 0 + 1 如果先计算 ++i，则表达式可以转化为 j = 1 + 1;有4中表达式明确规定了求值顺序逻辑与(&&):只有当左侧的结果为真时，才计算右侧的结果逻辑或(||):只有当左侧的运算结果为假时，才会计算右侧结果三目运算符(?:)当条件为真时，计算:左侧的表达式，否则计算右侧的表达式逗号表达式:运算顺序是从左到右，最后返回最右侧的表达式的值在处理复合表达式时，有下面两条准则：在不清楚运算对象的优先级和结合律的时候，按照实际的结合逻辑使用括号如果改变了某个运算对象的值，在表达式的其他地方不要使用这个运算对象，但是能明确知道求值顺序的时候这个规则就不适用了算术运算符算术运算符的求值对象和求值结果都是右值。算术运算符的优先级顺序为：单目运算符(+表示取当前值,-表示取相反数) > 乘除法 > 加减法；结合律：采用从左至右结合的方式算术运算符能作用与所有的算术类型，算术类型的数据在运算前会被转化为精度较大的类型(运算对象只有byte，char, short时会被统一转化为int)，在转化为同一类型后执行再进行运算bool b = false; int k = 1; bool i = +k + -b;在上述代码中，bool类型参与算术运算时，会将true变为1，false变为0，然后针对0和1进行操作，根据优先级得到 i = 1 + 0; 最后再将算术类型转化为bool类型赋值，i最终为true除法运算中如果除数和被除数符号相同，商为正数，否则为负数，c++11 标准中规定负数商一律向0取整取余运算，要求除数和被除数都是整数，如果m/n的结果不为0，则m%n的结果符号与m相同(m/n)*n + m%n = m(-m)/n=m/(-n)=-(m/n)(-m)%n=-(m%n); m%(-n)=m%n逻辑运算符逻辑运算符作用与任何能转化为boo类型的运算对象上优先级为 逻辑非 > 大于/小于/大于等于/小于等于 > 相等/不等 > 逻辑与 > 逻辑非逻辑运算符一般的语言中都有，而且用法基本类似，这里就不再详细说明了，需要注意的是：使用非bool类型来做判断时，不要写成 if(!val) 或者 if(val == true)；同样的使用bool类型来判断时，也不要写成 if(val == true) 或者 if(val == 1)在进行数值相等的比较时，为了防止少写=，习惯上把常量写在前面例如 if(1 == val)赋值运算符赋值运算符一般作用与初始化给对象赋值或者在后续修改对象的值，但是需要注意区分二者的不同，这点在初始化或者给类对象赋初始值的时候尤其重要赋值运算符的左侧必须是一个可修改的左值。赋值运算符的结果是它左侧的运算对象，并且是一个左值。结果的类型就是左侧运算对象的类型，如果赋值运算符左右两个运算对象的类型不同，则运算对象将转化成左侧运算对象的类型。int i, j; i = j = 10; const k = 10; //这里是初始化，不是赋值 k = i; //错误，左侧需要可以修改的左值新的c++ 标准中允许使用初始化列表来给对象进行赋值i = {3.14}; //错误，使用初始化列表时，不能出现精度丢失 i = 3.14; //正确，值为3 vector<int> vi; vi = {0, 1, 2, 3, 4, 5};对于内置类型，初始化列表赋值时，列表中最多只能有一个值，而且值的精度不能大于左侧对象的精度赋值运算符满足右结合律，对于多重赋值语句中的每一个对象，它的类型或者与右边的对象相同，或者可以又右边对象的类型转化得到赋值运算符的优先级较低赋值运算符也包括复合赋值运算符，例如 += 、-=、*= /=递增和递减运算符递增和递减运算符为对象的加一和减一提供了一种简洁的书写形式。这两个运算符还可以应用于迭代器。递增和递减运算符有前置版本和后置版本，前置版本是先加一，然后将改变后对象的值作为求值结果；后置版本是先将对象的结果作为求值结果返回，然后再改变对象的值。在性能上，在涉及复杂的迭代运算时，前置版本会大大优于后置版本，因此尽量养成使用前置版本的习惯。auto pbeg = v.begin() while(pbeg != v.end() && *pbeg >= 0) { cout << *pbeg++ << endl; }这里后置递增运算符的优先级要大于解引用的优先级，所以这里等价于 *(pbeg++)，即先进行后置递增运算，但是返回变化之前的迭代器，然后将变化之前的迭代器进行解引用操作，得到具体元素的值递增和递减运算符可以修改对象的值，而一般的运算符没有严格规定求值的顺序，所以在复合表达式中需要额外注意，不要在可能修改变量值的位置访问该变量string s = "hello world"; auto beg = s.begin(); while(beg != s.end() && !isspace(*beg)) { *beg = toupper(*beg++); }上述例子由于赋值运算符未定义两侧运算对象的求值顺序，可能先求值左侧，那么循环中的语句等效于 beg = toupper(beg); 如果先求值右侧，则等效于 (beg + 1) = toupper(beg);条件运算符条件运算符也叫做三目运算符。cond ? expr1:expr2;条件运算符也可以嵌套使用, 条件运算符满足右结合律。随着嵌套层数的增加，代码的可读性极具下降，因此条件运算的嵌套最好不要超过三层。条件运算符的优先级非常低，一般使用的时候建议加上括号cout << ((grade > 60) ? "pass" : "fail"); // 输出pass 或者 fail cout << (grade > 60)? "pass" : "fail"; // 输出 1或者0，运算结果 是 "pass" 或者 "fail" cout << grade > 60 ? "pass" : "fail"; // 试图将cout 与 60 进行比较，错误位运算符位运算是作用与对象的二进制值的，理论上它可以处理任何对象，但是为了代码安全和可读性，建议只处理整型数据，而且最好是无符号整型运算符功能用法~按位求反~expr<<左移expr << expr2>>右移expr >> expr2&位与expr & expr2^位异或expr ^ expr2\ 位或exprexpr2sizeof 运算符sizeof 返回一个类型或者一个表达式所占的字节数。它满足右结合律针对表达式，sizeof并不计算表达式的值，只返回表达式结果类型的大小由于sizeof 不计算表达式的值，因此即使在sizeof中解引用指针也不会有什么影响逗号表达式逗号运算符含有两个表达式，按照从左至右的顺序依次求值逗号表达式先对左侧表达式进行求值，然后丢弃返回的结果，然后再对右侧表达式进行求值。逗号表达式的返回值是右侧的表达式的值类型转换何时发生隐式转换大多数情况下，比int小的整型值会被转化为int条件中，非布尔值会被转化为布尔类型初始化过程中，初始值转化为变量类型；赋值语句中右侧运算对象转化成左侧运算对象的类型如果是算术运算或者关系运算的运算对象有多种类型，需要转化为同一种类型。而且会尽量往精度较大的一方转化调用函数时也可能会发生类型转化算术类型转换算术转换总是朝着精度更高的一级转换较小的整型会被转化为int，较大的整型会被转化为long、unsigned long、unsigned longlong 等其他隐式类型转换除了算术类型的隐式转换外，还有下面几种数组转化为指针：当数组被用作 decltype、sizeof、取地址符一级typeid 等运算符的运算对象时，该转换不会发生指针的转化：常量整数0和nullptr可以转化为任意类型的指针，指向任意非常量的指针能转化成void，指向任意对象的指针能转化为const void转化为布尔类型: 算术类型或者指针，值为0或者nullptr的被转化为false，其他的值被转化为true转化为常量：常量的指针或者引用可以指向非常量对象，反过来则不行；类类型定义的转化：由程序员预先定义，在需要转化时，由编译器自动调用进行转化显式类型转换显式类型转换绕过了编译器的类型检查，是不安全的一种转化方式显示类型转换的语法规则如下：cast-name<type>(express);其中type是目标类型，express是要转化的值，如果type是引用类型则结果是一个左值。cast-name是 static_cast、dynamic_cast、const_cast 和 reinterpret_cast 中的一种static_cast 只要不包含底层const，都可以使用static_cast，在对指针进行强制类型转化时，要保证转化前与转化后指针所指向的对象类型相同,用于同类型数据之前的转化，如算术类型之前的相互转化。const_cast 只能改变运算对象的底层const、与static_const互相补充reinterpret_cast 重新解释比特位，通常为运算对象的位模式提供较低层次上的重新解释。一般用于指针之间的转化，它没有限制，任何类型间都可以进行转化。但是也十分危险dynamic_cast 动态类型转化，主要用于多重继承类类型之间的转化

c++基础之字符串、向量和数组 上一次整理完了《c++ primer》的第二章的内容。这次整理本书的第3章内容。这里还是声明一下，我整理的主要是自己不知道的或者需要注意的内容，以我本人的主观意志为准，并不具备普适性。第三章就开始慢慢的接触连续、线性存储的数据结构了。字符串、数组、vector等都是存储在内存的连续空间中，而且都是线性结构。算是c++语言中的基础数据结构了。命名空间与using使用方式如下using namespace::name;其中name表示命名空间的具体名字如标准库都在std 这个命名空间，如果要引用这个命名空间的内容就写作 using namespace::std;另外namespace可以表示作为关键字，也可以作为具体的命名空间，如果作为具体命名空间的话，name此时应该是命名空间中的类或者函数等等成员，例如要引用cin这个函数的话，可以这样写 using std::cin在使用时除了使用命名空间之外也可以直接带上命名空间的名称，例如要使用cout 做输出时可以这么写 std::cout << "hell world" << std::endl;使用using 可以直接引入命名空间，减少代码编写的字符数，但是当引入多个命名空间，而命名空间中又有相同的成员时，容易引发冲突。所以在使用命名空间时有下面几条建议头文件中不要包含using声明尽量做到每个成员单独使用using声明string 对象定义和初始化string对象初始化string对象有如下几种方式:string() : 初始化一个空字符串string(const string&): 使用一个字符串来初始化另一个字符串，新字符串是传入字符串的一个副本string(char*): 使用一个字符数组来初始化字符串string(int, char): 新字符串是由连续几个相同字符组成需要注意的是，在定义的语句中使用赋值操作符相当于调用对应的初始化语句。而在其他位置使用赋值操作符在执行复写操作string str = "hello world"; //此处调用拷贝构造，并没有调用赋值重载函数string 对象的操作string的操作主要有：os << s: 将s的值写入到os流中，返回osis >> s: 从is流中读取字符串，并赋值给s，字符串以空白分分隔，返回isgetline(is, s): 从is中读取一行，赋值给s，返回iss.empty(): 判断字符串是否为空，为空则返回true，否则返回falses.size(): 返回字符串中字符个数， 类型为string::size_type。它是一个无符号类型的值，而且编译器需要保证它能够存放任何string对象的大小。不要使用size()的返回值与int进行混合运算s[n]: 返回第n个字符s+s1: 返回s和s1拼接后的结果s1=s2: 将s2的值赋值给s1，执行深拷贝s1 == s2: 判断两个字符串是否相等s1 != s2:判断两个字符串不等<, <=, >, >=:字符串比较处理string 中的字符string 本身是一个字符的容器，我们可以使用迭代的方式来访问其中的每一个字符。例如// 字符转化为大写 string s = "hello world"; for(auto it = s.begin(); it != s.end(); it++) { *it = toupper(*it); }针对这种需要在循环中迭代访问每个元素的情况，c++针对for语句进行扩展，使其能够像Java等语言那样支持自动迭代每一个元素，这种语句一般被称之为范围for。// 统计可打印字符 string s = "hello world"; int punctt_count = 0; for(auto c : s){ if(ispunct(c)){ ++punct_count; } }上述代码中c 只是s中每一个字符的拷贝，如果想像之前那样修改字符串中的字符，可以在迭代时使用引用类型//字符串转化为大写 s = "hello world"; for(auto& c : s){ c = toupper(c); }所有同时具有连续存储和线性存储两个特点的数据结构都可以使用下标访问其中的元素。字符串中字符是采用线性和连续存储的。所以这里它也可以采用下标运算符// 字符串转化为大写 string s = "hello world"; for(auto index = 0; index < s.size(); ++index) { s[index] = toupper(s[index]); } 在使用下标时需要注意下标是否超过容器中存储的元素个数。由于在编译与链接时不会检查这个，如果超出在运行时将会产生未定义结果。标准库 vector标准库vector 表示对象的集合，里面需要存储相同类型的对象。可以看作是一个动态数组。vector 被定义在头文件 vector中由于vector中存储的是对象，而引用不是对象，所以不存在存储引用的vector定义和初始化除了可以使用与string相同的初始化方法外，新的标准还支持使用初始化列表来初始化vectorvector<string> vec = {"Hello", "World", "Boy", "Next", "Door"};一般来说都是预先定义一个空的vector对象，在需要的时候使用push_back或者push_front添加元素。需要注意的是在使用迭代器的过程中，不要针对容器做删减操作同样的vector可以使用下标来访问元素，但是需要注意下标只能访问已有元素不能使用下标来添加元素，同时使用下标时需要注意范围。访问超过范围的元素，会引起越界的问题迭代器迭代器是一组抽象，是用来统一容器中元素访问方式的抽象。它能保证不管什么类型的容器，只要使用迭代器，就能使用相同的方式方法从头到尾访问到容器中的所有元素。在这里不用过于纠结跌打器究竟是如何实现的，只需要知道如何使用它。另外提一句，我当初在初学的时候一直把c语言的思路带入到c++中，导致我一直认为跌迭代器就是指针或者下标，我试图使用指针和下标的方式来理解，然后发现很多地方搞的很乱，也很模糊。这个概念我是一直等待学习python和Java这种没有指针、完全面向对象的语言之后，才纠正过来。这里我想起《黑客与画家》书中提到的，编程语言的高度会影响我们看待问题高度。从我的经历来看，我慢慢的理解了这句话的意思。所以这也是我当初学习lisp的一个原因。我想看看被作者称之为数学语言，抽象程度目前最高的语言是什么样的，对我以后看问题有什么影响迭代器提供了两种重要的抽象：提供统一的接口来遍历容器中所有元素；另外迭代器提供统一接口，让我们实际操作容器中的元素使用迭代器迭代器的使用如下：迭代器都是使用begin 获取容器中的第一个元素；使用end获取尾元素的下一个元素迭代器自身可以像操作对象的指针一样操作容器中的对象迭代器比较时，比较的是两个迭代器指向的是否是同一个元素,不支持 >、<比较++ 来使迭代器指向容器中下一个位置的对象，--来指向上一个位置的对象如果不想通过迭代器改变容器中元素的值，可以使用const类型的迭代器，即 const_iterator类型的迭代器#+BEGIN_SRC c++ string s = "Hello World"; for(string::const_iterator it = s.begin(); it != s.end(); it++) { cout << *it << endl; } #+END_SRCbegin 和end返回的是普通类型的迭代器，c++ 11中提供了一套新的方法来获取const类型的迭代器，cbegin和 cend迭代器的常见运算迭代器常见运算：iter + n: 迭代器向前可以加上一个整数，类似于指针加上一个整数，表示迭代器向前移动了若干个元素iter - n: 迭代器往前移动了若干个元素，类似于指针减去一个整数iter1 - iter2: 表示两个迭代器之间的间距，类似于指针的减法、<、>=、<=:根据迭代器的位置来判断迭代器的大小，类似于指针的大小比较迭代器与整数运算，如果超过了原先容器中元素的个数，那么最多只会返回容器中最后一个元素的下一个跌打器，也就是返回值为 end函数的返回迭代器相减得到迭代器之间的距离，这个距离指的是右侧的迭代器移动多少个元素后到达左侧迭代器的位置，其类型定义为difference_type使用迭代器来访问元素时，与使用指针访问指向的对象的方式一样，它重载了解引用运算符和箭头运算符。使我们能够像使用指针那样使用迭代器数组数组与vector相似二者都是线性存储二者存储的都是相同类型的元素与vector不同的是：数组大小固定由于大小在初始化就已经确定，所以在性能上优于vector，灵活性上有些不足定义和初始化内置数组在初始化数组的时候需要注意：数组大小的值可以是字面值常量、常量表达式、或者普通常量定义数组时必须指明类型，不允许用auto由初始化值来进行推断const unsigned int cnt = 42; //常量 constexpr unsigned int sz = 42; //常量表达式 int arr[10]; //使用字面常量指定大小 int arr2[cnt]; //使用常量初始化 int arr3[sz]; //使用常量表达式初始化可以在初始化时不指定大小，后续会根据初始化列表中的元素个数自动推导出数组大小同时指定了数组大小和初始化列表，如果指定大小大于初始化列表中的元素个数，那么前面几个元素按照初始化列表中的值进行初始化，后面多余的元素则初始化为默认值如果指定大小小于初始化列表中元素个数，则直接报错const unsigned int sz = 3; int arr1[sz] = {1, 2, 3}; int arr2[sz] = {1}; // 等价与 arr2[sz] = {1, 0, 0} int arr3[] = {1, 2, 3}; int arr4[sz] = {1, 2, 3, 4}; //错误，初始化列表中元素个数不能大于数组中定义的元素个数字符数组可以直接使用字符串常量进行赋值，数组大小等于字符串长度加一我们可以对数组中某个元素进行赋值，但是数组之间不允许直接进行拷贝和赋值和vector中一样，数组中存储的也是对象，所以不存在存储引用的数组。在理解关于数组的复杂声明时，采用的也是从右往左看理解的方式。或者说我们先找到与[] 结合的部分来理解，与[]结合的部分去掉之后就是数组中元素的类型。int * ptrs[10]; int & refs[10]; int (*Parry)[10]; int (&arrRef)[10];上面的例子中：ptrs，首先与[]结合最紧密的是ptrs 去掉这两个部分，剩下的就是int 这部分表示数组中元素类型是int , 也就是这里定义了一个包含10个int指针元素的数组refs, 首先与[]结合最紧密的是ref2,去掉这个部分，剩下的就是int&，这部分表示数组中元素类型是int&，也就是这里定义了一个包含10个指向int数据的引用的数组，由于不存在存储引用的数组，所以这里是错误的Parry，由于有了括号，与[]结合最紧密的就变成了 int，也就是我们先定义了一个包含10个int类型的数组，而Parry本身是一个指针，所以这里定义的其实是一个指向存储了10个int类型数据的数组的指针同样的方式分析，得到arrRef 其实是一个指向存储了10个int类型数据的数组的引用指针和数组在上面的例子中，已经见过了指针和数组的一些定义方式，例如ptrs 是一个存储了指针的数组，这种数组一般称之为指针数组；Parry是一个指向数组的指针，这种指针被称之为数组指针在某些时候使用数组的时候，编译器会直接将它转化为指针，其中在使用数组名时，编译器会自动转化为数组首元素的地址。int ia[] = {1, 2, 3, 4, 5}; auto ia2 = ia; ia2[2] = 10; // 这里ia2是指向ia数组首元素的指针，这里其实是在修改ia第3个元素的值需要注意的是在使用decltype时，该现象不会发生，decltype只会根据表达式推断出类型，而不会具体计算表达式的值，所以它遇到数组名时，根据上下文知道它是一个数组，而不会实际取得数组首元素的地址int ia[] = {1, 2, 3, 4, 5}; decltype(ia) ia2 = {0}; //这里ia2 是一个独立的数组，与ia无关 ia2[2] = 10;指针也可以看作迭代器的一种，进行迭代时终止条件是数组尾元素下一个位置的地址int ai[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; int *pbegin = &ai[0]; int *pend = &ai[10]; for(int* it = pbegin; it != pend; it++) { cout << *it << endl; }c++ 11中引入两个函数来获取数组的begin位置和end位置，分别为begin() 与 end()int ai[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; for(int *p = begin(ai); p != end(ai); p++) { cout << *p << endl; }c 风格的字符串string转化为char 可以使用string.c_str()函数,该函数返回的是const char，以取保无法通过这个指针修改字符串本身的值，另外该函数返回的地址一直有效，如果后续修改了string的值，那么根据字符串的算法，字符串中保存字符的地址可能发生变化，此时再使用原来返回的指针访问新的字符串，可能会出现问题如果执行完c_str函数后，程序想一直访问其返回的数组，最好将该数组重新拷贝一份string s = "hello world"; const char* pszBuf = s.c_str() char* pBuff = new char[s.size() + 1]; memset(pBuff, 0x00, sizeof(char) * s.size() + 1); strcpy(pBuff, pszBuff); //后面可以直接使用pbuf，即使s字符串改变 s = "boy next door"; //do something delete[] pBuf;为了与旧代码兼容，允许使用数组来初始化一个vector容器，只需要指明需要拷贝的首元素地址和尾元素地址int arr[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ,10}; vector<int> va(begin(arr), end(arr));多维数组多维数组是数组的数组，数组中每一个成员都是一个数组。当一个数组的元素仍是数组时，需要多个维度来表示，一个表示数组本身的大小，一个维度表示元素中数组大小对于二维数组来说，一般把第一个维度称之为行，第二个维度称之为列。int ia[3][4] = { {0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11} }; //等价于 int ia[3][4] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};多维数组的初始化可以用打括号初始化每个维度的数据，也可以省略中间的大括号，这样它会按照顺序初始化但是需要注意int ia[3][4] = { {0}, {1, 2}, {3, 4, 5} }; int ia[3][4] = {0, 1, 2, 3, 4, 5};上述代码中，二者含义完全不一样,上一个表示每个子元素中的数组如何初始化，最终结果为{0, 0, 0, 0, 1, 2, 0, 0, 3, 4, 5, 0}。下面一个是从第一行开始依次初始化所有元素,最终结果为{0, 1, 2, 3, 4, 5, 0, 0, 0, 0, 0, 0}可以使用下标访问数组元素，一个维度对应一个下标int ai[3][4] = {0}; cout << ai[2][3] << endl; //如果下标个数和数组维度一样，将得到具体类型的值 cout << ai[2] << endl; //下标数小于数组维度，得到对应子数组的首地址可以使用for循环遍历数组int a[3][4] = {0}; for(auto row : a){ for(auto i : row) //错误不能对指针使用迭代 { cout << i << endl; } }上述例子中，由于多维数组中存储的是数组元素，所以row默认是数组元素，也就是数组首地址，是指针类型，也就不能使用内层的迭代了我们可以稍微做一些修改int a[3][4] = {0}; for(auto& row : a){ for(auto i : row) //错误不能对指针使用迭代 { cout << i << endl; } }使用引用声明之后，row就表示指向内层子数组的一个数组的引用，也就是一个子数组本身，针对数组就可以使用范围for了注意：使用for范围遍历时，除了最内层元素，其余的都需要声明为引用类型多维数组的名称也是数组的首地址定义多维数组的指针时，需要明确，多维数组是存储数组的特殊数组int ai[3][4] = {0}; int (*p)[4] = ai; // int *p[4] 表示的是指针数组，数组有4个成员，每个成员都是一个int* 上述代码，ai是一个存储3个数组元素的数组，每个元素又是存储4个整型元素的数组，因此定义它的指针的时候，需要明确，指针类型应该是数组元素的类型，也就是有4个int型元素的数组的指针当然如果嫌麻烦或者不会写，可以使用auto来定义一般来说，书写多维数组的指针是比较麻烦的一件事，可以使用类型别名让它变得简单点，上面的例子可以改写一下//typedef int int_array_4[4]; 二者是完全等价的 using int_array_4 = int[4]; int_array_4 *pArr = ai; for(; pArr != ai + 3; ++pArr) { for(int *p = *pArr; p != *pArr+4; ++p) { cout << *p << " "; } cout << endl; } 数组名代表的是数组的首元素，多维数组又可以看作是一个存储数组的数组。所以这里ai的名称代表的是一个存储了3个元素的数组，每个元素都是存储4个整型数据的数组。pArr 的类型是存储了4个整型元素的数组的指针，所以这里与ai表示的指针的类型相同。这里我们将ai的值赋值给指针。在循环中，外层循环用来找到ai数组中每个子数组的指针。内层循环中，使用pArr解引用得到指针指向的每一个对象，也就是一个存储了4个整型元素的数组。针对这个数组进行循环，依次取出数组中每一个元素。