1. 順序容器類(lèi)型

2. string和vector將元素保存在連續(xù)的內(nèi)存空間中。由元素的下標(biāo)來(lái)計(jì)算其地址是非?？焖俚模谥虚g位置添加或刪除元素就會(huì)非常耗時(shí)。list和forward_list兩個(gè)容器的設(shè)計(jì)目的是令容器任何位置的添加和刪除操作都很快速，作為代價(jià)，這兩個(gè)容器不支持元素的隨機(jī)訪(fǎng)問(wèn)，并且相比vector、deque、array，這兩個(gè)容器的額外內(nèi)存開(kāi)銷(xiāo)也很大。deque支持快速的隨機(jī)訪(fǎng)問(wèn)，在deque的兩端添加或刪除元素都是很快的，與list或forward_list添加刪除元素的速度相當(dāng)。array對(duì)象的大小是固定的。因此，array不支持添加和刪除元素以及改變?nèi)萜鞔笮〉牟僮鳌?code>forward_list的設(shè)計(jì)目標(biāo)是達(dá)到與最好的手寫(xiě)的單向鏈表數(shù)據(jù)結(jié)構(gòu)相當(dāng)?shù)男阅堋Ｒ虼?，forward_list沒(méi)有size操作，因?yàn)楸４婊蛴?jì)算其大小就會(huì)比手寫(xiě)鏈表多出額外的開(kāi)銷(xiāo)。對(duì)其他容器而言，size保證是一個(gè)快速的常量時(shí)間的操作。
3. 以下是一些選擇容器的基本原則：
   • 除非你有很好的理由選擇其他容器，否則應(yīng)使用vector。
   • 如果你的程序有很多小的元素，且空間的額外開(kāi)銷(xiāo)很重要，則不要使用list或forward_list。
   • 如果程序要求隨機(jī)訪(fǎng)問(wèn)元素，應(yīng)使用vector或deque。
   • 如果程序要求在容器的中間插入或刪除元素，應(yīng)使用list或forward_list。
   • 如果程序需要在頭尾位置插入或刪除元素，但不會(huì)在中間位置進(jìn)行插入或刪除操作，則使用deque。
   • 如果程序只有在讀取輸入時(shí)才需要在容器中間位置插入元素，隨后需要隨機(jī)訪(fǎng)問(wèn)元素，則
     • 首先，確定是否真的需要在容器中間位置添加元素。當(dāng)處理輸入數(shù)據(jù)時(shí)，通?？梢院苋菀椎叵騰ector追加數(shù)據(jù)，然后再調(diào)用標(biāo)準(zhǔn)庫(kù)的sort函數(shù)來(lái)重排容器中的元素，從而避免在中間位置添加元素。
     • 如果必須在中間位置插入元素，考慮在輸入階段使用list，一旦輸入完成，將list中的內(nèi)容拷貝到一個(gè)vector中。
4. 如果你不確定應(yīng)該使用哪種容器，那么可以在程序中只使用vector和list公共的操作：使用迭代器，不使用下標(biāo)操作，避免隨機(jī)訪(fǎng)問(wèn)。這樣，在必要時(shí)選擇使用vector或list都很方便。
5. 容器類(lèi)型上的操作形成了一種層次：
   • 某些操作是所有容器類(lèi)型都提供的。
   • 另外一些操作僅針對(duì)順序容器、關(guān)聯(lián)容器或無(wú)序容器。
   • 還有一些操作只適用于一小部分容器。
6. 順序容器構(gòu)造函數(shù)的一個(gè)版本接受容器大小參數(shù)，它使用了元素類(lèi)型的默認(rèn)構(gòu)造函數(shù)。但某些類(lèi)沒(méi)有默認(rèn)構(gòu)造函數(shù)。我們可以定義一個(gè)保存這種類(lèi)型對(duì)象的容器，但我們?cè)跇?gòu)造這種容器時(shí)不能只傳遞給它一個(gè)元素?cái)?shù)目參數(shù)：

     // 假定noDefault是一個(gè)沒(méi)有默認(rèn)構(gòu)造函數(shù)的類(lèi)型
     vector<noDefault> v1(10, init); // 正確：提供了元素初始化器
     vector<noDefault> v2(10); // 錯(cuò)誤：必須提供一個(gè)元素初始化器
   

7. 容器操作：

8. forward_list迭代器不支持遞減運(yùn)算符（--）。

9. 一個(gè)迭代器范圍由一對(duì)迭代器表示，兩個(gè)迭代器分別指向同一個(gè)容器中的元素或者是尾元素之后的位置。

10. 迭代器范圍中的元素包含first所表示的元素以及從first開(kāi)始直至last（但不包含last）之間的所有元素。左閉合區(qū)間：[left, right)。

11. 如果滿(mǎn)足如下條件，兩個(gè)迭代器begin和end構(gòu)成一個(gè)迭代器范圍：

    • 它們指向同一個(gè)容器中的元素，或者是容器最后一個(gè)元素之后的位置，且
    • 我們可以通過(guò)反復(fù)遞增begin來(lái)到達(dá)end。換句話(huà)說(shuō)，end不在begin之前。

12. 標(biāo)準(zhǔn)庫(kù)使用左閉合范圍是因?yàn)檫@種范圍有三種方便的性質(zhì)。假定begin和end構(gòu)成一個(gè)合法的迭代器范圍，則

    • 如果begin與end相等，則范圍為空
    • 如果begin與end不等，則范圍至少包含一個(gè)元素，且begin指向該范圍中的第一個(gè)元素
    • 我們可以對(duì)begin遞增若干次，使得begin==end

13. 這些性質(zhì)意味著我們可以用循環(huán)來(lái)處理一個(gè)元素范圍。

    while (begin != end)
    {
        *begin = val; // 正確：范圍非空，因此begin指向一個(gè)元素
        // 在while循環(huán)中，可以安全地解引用begin，因?yàn)閎egin必然指向一個(gè)元素。
        ++begin; // 移動(dòng)迭代器，獲取下一個(gè)元素
    }
    

14. 反向迭代器就是一種反向遍歷容器的迭代器，與正向迭代器相比，各種操作的含義也都發(fā)生了顛倒。例如，對(duì)一個(gè)反向迭代器執(zhí)行++操作，會(huì)得到上一個(gè)元素。

15. begin和end有多個(gè)版本：帶r的版本返回反向迭代器；以c開(kāi)頭的版本則返回const迭代器；不以c開(kāi)頭的函數(shù)都是被重載過(guò)的。一個(gè)是const成員，返回容器的const_iterator類(lèi)型；另一個(gè)是非常量成員，返回容器的iterator類(lèi)型。當(dāng)我們對(duì)一個(gè)非常量對(duì)象調(diào)用這些成員時(shí)，得到的是返回iterator的版本。只有在對(duì)一個(gè)const對(duì)象調(diào)用這些函數(shù)時(shí)，才會(huì)得到一個(gè)const版本。與const指針和引用類(lèi)似，可以將一個(gè)普通的iterator轉(zhuǎn)換為對(duì)應(yīng)的const_iterator，但反之不行。

16. 當(dāng)auto與begin或end結(jié)合使用時(shí)，獲得的迭代器類(lèi)型依賴(lài)于容器類(lèi)型，與我們想要如何使用迭代器毫不相干。但以c開(kāi)頭的版本還是可以獲得const_iterator的，而不管容器的類(lèi)型是什么。當(dāng)不需要寫(xiě)訪(fǎng)問(wèn)時(shí)，應(yīng)該使用cbegin和cend。

17. 容器定義和初始化

18. 當(dāng)將一個(gè)容器初始化為另一個(gè)容器的拷貝時(shí)，兩個(gè)容器的容器類(lèi)型和元素類(lèi)型都必須相同。但當(dāng)傳遞迭代器參數(shù)來(lái)拷貝一個(gè)范圍時(shí)，就不要求容器類(lèi)型是相同的了。而且，新容器和原容器中的元素類(lèi)型也可以不同，只要能將要拷貝的元素轉(zhuǎn)換為要初始化的容器的元素類(lèi)型即可（構(gòu)造函數(shù)只是讀取范圍中的元素并進(jìn)行拷貝）。

    // 每個(gè)容器有三個(gè)元素，用給定的初始化器進(jìn)行初始化
    list<string> authors = {"Milton", "Shakespeare", "Austen"};
    vector<const char*> articles = {"a", "an", "the"};
    
    list<string> list2(authors); // 正確：類(lèi)型匹配
    deque<string> authList(authors); // 錯(cuò)誤：容器類(lèi)型不匹配
    vector<string> words(articles); // 錯(cuò)誤：容器類(lèi)型必須匹配
    // 正確：可以將const char*元素轉(zhuǎn)換為string
    forward_list<string> words(articles.begin(),articles.end());
    

19. 如果元素類(lèi)型是內(nèi)置類(lèi)型或者是具有默認(rèn)構(gòu)造函數(shù)的類(lèi)類(lèi)型，可以只為構(gòu)造函數(shù)提供一個(gè)容器大小參數(shù)。如果元素類(lèi)型沒(méi)有默認(rèn)構(gòu)造函數(shù)，除了大小參數(shù)外，還必須指定一個(gè)顯示的元素初始值。

    #include <iostream>
    #include <vector>
    using namespace std;
    
    class A
    {
    private:
        vector<int> data;
    
    public:
        A(vector<int>::iterator beg, vector<int>::iterator end)
        {
            data.assign(beg, end);
        }
        void display()
        {
            for (auto i : data)
                cout << i << " ";
            cout << endl;
        }
    };
    
    int main()
    {
        vector<int> iv{1, 2, 3};
        vector<A> one(5, A(iv.begin(), iv.end()));
        for (auto i : one)
            i.display();
        cout << endl;
        return 0;
    }
    

20. 只有順序容器的構(gòu)造函數(shù)才接受大小參數(shù)，關(guān)聯(lián)容器并不支持。

21. 標(biāo)準(zhǔn)庫(kù)array的大小也是類(lèi)型的一部分。當(dāng)定義一個(gè)array時(shí)，除了指定元素類(lèi)型，我們必須同時(shí)指定元素類(lèi)型和大小。

    array<int, 42> // 類(lèi)型為：保存42個(gè)int的數(shù)組
    array<string, 10> // 類(lèi)型為：保存10個(gè)string的數(shù)組
    
    array<int, 10>::size_type i; // 數(shù)組類(lèi)型包括元素類(lèi)型和大小
    array<int>::size_type j; // 錯(cuò)誤：array<int>不是一個(gè)類(lèi)型
    

22. 一個(gè)默認(rèn)構(gòu)造的array是非空的：它包含了于其大小一樣多的元素。這些元素都被默認(rèn)初始化，就像一個(gè)內(nèi)置數(shù)組中的元素那樣。如果我們對(duì)array進(jìn)行列表初始化，初始值的數(shù)目必須等于或小于array的大小。如果初始值數(shù)目小于array的大小，則它們被用來(lái)初始化array中靠前的元素，所有剩余元素都會(huì)進(jìn)行值初始化。在這兩種情況下，如果元素類(lèi)型是一個(gè)類(lèi)類(lèi)型，那么該類(lèi)必須有一個(gè)默認(rèn)構(gòu)造函數(shù)，以使值初始化能夠進(jìn)行。

    array<int, 10> ia1; // 10個(gè)默認(rèn)初始化的int
    array<int, 10> ia2 = {0,1,2,3,4,5,6,7,8,9}; // 列表初始化
    array<int, 10> ia3 = {42}; // ia3[0]為42，剩余元素為0
    
    int digs[10] = {0,1,2,3,4,5,6,7,8,9};
    int cpy[10] = digs; // 錯(cuò)誤：內(nèi)置數(shù)組不支持拷貝或賦值
    array<int, 10> digits = {0,1,2,3,4,5,6,7,8,9};
    array<int, 10> copy = digits; // 正確：只要數(shù)組類(lèi)型匹配即合法
    

23. 與其他容器一樣，array也要求初始值的類(lèi)型必須與要?jiǎng)?chuàng)建的容器類(lèi)型相同。此外，array還要求元素類(lèi)型和大小也都一樣，因?yàn)榇笮∈莂rray類(lèi)型的一部分。

24. 與賦值相關(guān)的運(yùn)算符可用于所有容器。賦值運(yùn)算符將其左邊容器中的全部元素替換為右邊容器中元素的拷貝。如果兩個(gè)容器原來(lái)大小不同，賦值運(yùn)算后兩者的大小都與右邊容器的原大小相同。

    c1 = c2; // 將c1的內(nèi)容替換為c2中元素的拷貝
    c1 = {a,b,c}; // 賦值后，c1大小為3
    

25. 與內(nèi)置數(shù)組不同，標(biāo)準(zhǔn)庫(kù)array類(lèi)型允許賦值。賦值號(hào)左右兩邊的運(yùn)算對(duì)象必須具有相同的類(lèi)型。由于右邊運(yùn)算對(duì)象的大小可能與左邊運(yùn)算對(duì)象的大小不同，因此array類(lèi)型不支持assign，也不允許用花括號(hào)包圍的值列表進(jìn)行賦值。

    array<int, 10> a1 = {0,1,2,3,4,5,6,7,8,9};
    array<int, 10> a2 = {0}; // 所有元素值均為0
    a1 = a2; // 替換a1中的元素
    a2 = {0}; // 錯(cuò)誤：不能將一個(gè)花括號(hào)列表賦予數(shù)組
    

26. 賦值相關(guān)運(yùn)算會(huì)導(dǎo)致指向左邊容器內(nèi)部的迭代器、引用和指針失效。而swap操作將容器內(nèi)容交換不會(huì)導(dǎo)致指向容器的迭代器、引用和指針失效（容器類(lèi)型為array和string的情況除外）。

27. 順序容器的assign成員允許我們從一個(gè)不同但相容的類(lèi)型賦值，或者從容器的一個(gè)子序列賦值。assign操作用參數(shù)所指定的元素（的拷貝）替換左邊容器中的所有元素。

    list<string> names;
    vector<const char*> oldstyle;
    names = oldstyle; // 錯(cuò)誤：容器類(lèi)型不匹配
    // 正確：可以將const char*轉(zhuǎn)換為string
    names.assign(oldstyle.cbegin(), oldstyle.cend());
    

28. 由于其舊元素被替換，因此傳遞給assign的迭代器不能指向調(diào)用assign的容器。

29. 除array外，swap不對(duì)任何元素進(jìn)行拷貝、刪除或插入操作，因此可以保證在常數(shù)時(shí)間內(nèi)完成。

30. 除string外，指向容器的迭代器、引用和指針在swap操作之后都不會(huì)失效。它們?nèi)灾赶騭wap操作之前所指向的那些元素。但是，在swap之后，這些元素已經(jīng)屬于不同的容器了。對(duì)一個(gè)string調(diào)用swap會(huì)導(dǎo)致迭代器、引用和指針失效。

31. swap兩個(gè)array會(huì)真正交換它們的元素。因此，交換兩個(gè)array所需的時(shí)間與array中元素的數(shù)目成正比。

32. 對(duì)于array，在swap操作之后，指針、引用和迭代器所綁定的元素保持不變，但元素值已經(jīng)與另一個(gè)array中對(duì)應(yīng)元素進(jìn)行了交換。

33. 在標(biāo)準(zhǔn)庫(kù)中，容器既提供成員函數(shù)版本的swap，也提供非成員版本的swap。非成員版本的swap在泛型編程中是非常重要的。統(tǒng)一使用非成員版本的swap是一個(gè)好習(xí)慣。

34. 成員函數(shù)size返回容器中元素的數(shù)目；empty當(dāng)size為0時(shí)返回布爾值true，否則返回false；max_size返回一個(gè)大于或等于該類(lèi)型容器所能容納的最大元素?cái)?shù)的值。forward_list支持max_size和empty，但不支持size。

35. 每個(gè)容器類(lèi)型都支持相等運(yùn)算符（==和!=）；除了無(wú)序關(guān)聯(lián)容器都支持關(guān)系運(yùn)算符（>、>=、<、<=）。關(guān)聯(lián)運(yùn)算符左右兩邊的運(yùn)算對(duì)象必須是相同類(lèi)型的容器，且必須保存相同類(lèi)型的元素。

36. 比較兩個(gè)容器實(shí)際上是進(jìn)行元素的逐對(duì)比較。這些運(yùn)算符的工作方式與string的關(guān)系運(yùn)算類(lèi)似。

    • 如果兩個(gè)容器具有相同大小且所有元素都兩兩對(duì)應(yīng)相等，則這兩個(gè)容器相等；否則兩個(gè)容器不等。
    • 如果兩個(gè)容器大小不同，但較小容器中每個(gè)元素都等于較大容器中的對(duì)應(yīng)元素，則較小容器小于較大容器。
    • 如果兩個(gè)容器都不是另一個(gè)容器的前綴子序列，則它們的比較結(jié)果取決于第一個(gè)不相等的元素的比較結(jié)果。

37. 只有當(dāng)其元素類(lèi)型也定義了相應(yīng)的比較運(yùn)算符時(shí)，我們才可以使用關(guān)系運(yùn)算符來(lái)比較兩個(gè)容器。

38. 容器的相等運(yùn)算符實(shí)際上是使用元素的==運(yùn)算符實(shí)現(xiàn)比較的，而其他關(guān)系運(yùn)算符是使用元素的<運(yùn)算符。如果元素類(lèi)型不支持所需運(yùn)算符，那么保存這種元素的容器就不能使用相應(yīng)的關(guān)系運(yùn)算。

39. 向一個(gè)vector、string或deque插入元素會(huì)使所有指向容器的迭代器、引用和指針失效。

40. 不同容器使用不同的策略來(lái)分配元素空間，而這些策略直接影響性能。

41. 當(dāng)我們用一個(gè)對(duì)象來(lái)初始化容器時(shí)，或?qū)⒁粋€(gè)對(duì)象插入到容器中時(shí)，實(shí)際上放入到容器中的是對(duì)象的一個(gè)拷貝，而不是對(duì)象本身。就像我們將一個(gè)對(duì)象傳遞給非引用參數(shù)一樣，容器中的元素與提供值的對(duì)象之間沒(méi)有任何關(guān)聯(lián)。隨后對(duì)容器中元素的任何改變都不會(huì)影響到原始對(duì)象，反之亦然。

42. 通過(guò)使用insert的返回值，可以在容器中一個(gè)特定位置反復(fù)插入元素：

    list<string> lst;
    auto iter = lst.begin();
    while (cin >> word)
    iter = lst.insert(iter, word); // 等價(jià)于調(diào)用push_front
    

43. emplace_front、emplace和emplace_back這些操作構(gòu)造而不是拷貝元素。

44. emplace函數(shù)在容器中直接構(gòu)造元素。傳遞給emplace函數(shù)的參數(shù)必須與元素類(lèi)型的構(gòu)造函數(shù)相匹配。

    #include <iostream>
    #include <vector>
    using namespace std;
    
    class A
    {
    private:
        vector<int> data;
    
    public:
        A(vector<int>::iterator beg, vector<int>::iterator end)
        {
            data.assign(beg, end);
        }
        void display()
        {
            for (auto i : data)
                cout << i << " ";
            cout << endl;
        }
    };
    
    int main()
    {
        vector<int> iv{1, 2, 3};
        vector<A> one(5, A(iv.begin(), iv.end()));
        for (auto i : one)
            i.display();
        cout << endl;
        
        vector<int> ivv{2, 3, 6};
        one.emplace_back(ivv.begin(), ivv.end());
        one.back().display();
        return 0;
    }
    

45. 包括array在內(nèi)的每個(gè)順序容器都有一個(gè)front成員函數(shù)，而除forward_list之外的所有順序容器都有一個(gè)back成員函數(shù)。這兩個(gè)操作分別返回首元素和尾元素的引用：

    // 在解引用一個(gè)迭代器或調(diào)用front或back之前檢查是否有元素
    if (!c.empty())
    {
    // val和val2是c中第一個(gè)元素值的拷貝
    auto val = *c.begin(), val2 = c.front();
    // val3和val4是c中最后一個(gè)元素值的拷貝
    auto last = c.end();
    auto val3 = *(--last); // forward_list迭代器不能執(zhí)行--操作
    auto val4 = c.back(); // forward_list不支持
    }
    

46. 在調(diào)用front和back（或解引用begin和end返回的迭代器）之前，要確保c非空。如果容器為空，if中操作的行為將是未定義的。

47. 對(duì)一個(gè)空容器調(diào)用front和back，就像使用一個(gè)越界的下標(biāo)一樣，是一種嚴(yán)重的程序設(shè)計(jì)錯(cuò)誤。

48. 在容器中訪(fǎng)問(wèn)元素的成員函數(shù)（即，front、back、下標(biāo)和at）返回的都是引用。如果容器是一個(gè)const對(duì)象，則返回值是const的引用。如果容器不是const的，則返回值是普通引用，我們可以用來(lái)改變?cè)氐闹担?/p>

    if (!c.empty())
    {
    c.front() = 42; // 將42賦予c中的第一個(gè)元素
    auto &v = c.back(); // 獲得指向最后一個(gè)元素的引用
    v = 1024; // 改變c中的元素
    auto v2 = c.back(); // v2不是一個(gè)引用，它是c.back()的一個(gè)拷貝
    v2 = 0; // 未改變c中的元素
        // 如果我們使用auto變量來(lái)保存這些函數(shù)的返回值，并且希望使用此變量來(lái)改變?cè)氐闹?，必須記得將變量定義為引用類(lèi)型
    }
    

49. 刪除deque中除首尾位置之外的任何元素都會(huì)使所有迭代器、引用和指針失效。指向vector或string中刪除點(diǎn)之后位置的迭代器、引用和指針都會(huì)失效。
50. 刪除元素的成員函數(shù)并不檢查其參數(shù)。在刪除元素之前，程序員必須確保它（們）是存在的。
51. 在一個(gè)單向鏈表中，沒(méi)有簡(jiǎn)單的辦法來(lái)獲取一個(gè)元素的前驅(qū)。因此，在一個(gè)forward_list中添加或刪除元素的操作是通過(guò)改變給定元素之后的元素來(lái)完成的。為了支持這些操作，forward_list也定義了before_begin，它返回一個(gè)首前迭代器（允許我們添加刪除鏈表首元素）

// 示例代碼：
forward_list<int> flst = {0,1,2,3,4,5,6,7,8,9};
auto prev = flst.before_begin(); // 表示flst的“首前元素”
auto curr = flst.begin(); // 表示flst中的第一個(gè)元素
while (curr != flst.end()) // 仍有元素要處理
{
if (*curr % 2) // 若元素為奇數(shù)，也可以用*curr & 1
curr = flst.erase_after(prev); // 刪除它并移動(dòng)curr
else
{
prev = curr; // 移動(dòng)迭代器curr，指向下一個(gè)元素，prev指向
++curr; // curr之前的元素
}
}

52. 如果resize縮小容器，則指向被刪除元素的迭代器、引用和指針都會(huì)失效；對(duì)vector、string或deque進(jìn)行resize可能導(dǎo)致迭代器、指針和引用失效。

53. 容器操作可能使迭代器失效。使用失效的迭代器、指針或引用是嚴(yán)重的運(yùn)行時(shí)錯(cuò)誤。

    • 在向容器添加元素后：
      • 如果容器是vector或string，且存儲(chǔ)空間被重新分配，則指向容器的迭代器、指針和引用都會(huì)失效。如果存儲(chǔ)空間未重新分配，指向插入位置之前的元素的迭代器、指針和引用仍有效，但指向插入位置之后元素的迭代器、指針和引用將會(huì)失效。
      • 對(duì)于deque，插入到除首尾位置之外的任何位置都會(huì)導(dǎo)致迭代器、指針和引用失效。如果在首尾位置添加元素，迭代器會(huì)失效，但指向存在的元素的引用和指針不會(huì)失效。
      • 對(duì)于list和forward_list，指向容器的迭代器（包括尾后迭代器和首前迭代器）、指針和引用仍有效。
    • 當(dāng)我們從一個(gè)容器中刪除元素后，指向被刪除元素的迭代器、指針和引用一定會(huì)失效，畢竟，這些元素都已經(jīng)被銷(xiāo)毀了。當(dāng)我們刪除一個(gè)元素后：
      • 對(duì)于list和forward_list，指向容器其他位置的迭代器（包括尾后迭代器和首前迭代器）、引用和指針仍有效。
      • 對(duì)于deque，如果在首尾之外的任何位置刪除元素，那么指向被刪除元素外其他元素的迭代器、引用和指針也會(huì)失效。如果是刪除deque的尾元素，則尾后迭代器也會(huì)失效，但其他迭代器、引用和指針不受影響；如果是刪除首元素，這些也不會(huì)受影響。
      • 對(duì)于vector和string，指向被刪元素之前元素的迭代器、引用和指針仍有效。注意：當(dāng)我們刪除元素時(shí)，尾后迭代器總是會(huì)失效。

54. 當(dāng)你使用迭代器（或指向容器元素的引用或指針）時(shí)，最小化要求迭代器必須保持有效的程序片段是一個(gè)好的辦法。由于向迭代器添加元素和從迭代器刪除元素的代碼可能會(huì)使迭代器失效，因此必須保證每次改變?nèi)萜鞯牟僮髦蠖颊_地重新定位迭代器。這個(gè)建議對(duì)vector、string和deque尤為重要。

55. 程序必須保證每個(gè)循環(huán)布中都更新迭代器、引用和指針：

    // 傻瓜循環(huán)，刪除偶數(shù)元素，復(fù)制每個(gè)奇數(shù)元素
    vector<int> vi = {0,1,2,3,4,5,6,7,8,9};
    auto iter = vi.begin(); // 調(diào)用begin而不是cbegin，因?yàn)槲覀円淖僾i
    while (iter != vi.end())
    {
    if (*iter % 2)
    {
    iter = vi.insert(iter, *iter); // 復(fù)制當(dāng)前元素
    iter += 2; // 向前移動(dòng)迭代器，跳過(guò)插入到它之前的元素以及當(dāng)前元素
    }
    else
    {
    iter = vi.erase(iter); // 刪除偶數(shù)元素
    // 不應(yīng)向前移動(dòng)迭代器，iter指向我們刪除的元素之后的元素
    }
    }
    

56. 不要保存end返回的迭代器。當(dāng)我們添加、刪除vector或string的元素后，或在deque中首元素之外任何位置添加、刪除元素后，原來(lái)end返回的迭代器總是會(huì)失效。因此，添加或刪除元素的循環(huán)程序必須反復(fù)調(diào)用end，而不能在循環(huán)之前保存end返回的迭代器，一直當(dāng)作容器末尾使用。

57. reserve并不改變?nèi)萜髦性氐臄?shù)量，它僅影響vector預(yù)先分配多大的內(nèi)存空間。只有當(dāng)需要的內(nèi)存空間超過(guò)當(dāng)前容量時(shí)，reserve調(diào)用才會(huì)改變vector的容量，如果需求大小大于當(dāng)前容量，reserve至少分配與需求一樣大的內(nèi)存空間（可能更大）。如果需求大小小于或等于當(dāng)前容量，reserve什么也不做。特別是，當(dāng)需求大小小于當(dāng)前容量時(shí)，容器不會(huì)退回內(nèi)存空間。因此，在調(diào)用reserve之后，capacity將會(huì)大于或等于傳遞給reserve的參數(shù)。這樣，調(diào)用reserve永遠(yuǎn)也不會(huì)減少容器占用的內(nèi)存空間。類(lèi)似的，resize成員函數(shù)只能改變?nèi)萜髦性氐臄?shù)目，而不是容器的容量。我們同樣不能使用resize來(lái)減少容器預(yù)留的內(nèi)存空間。

58. 每個(gè)vector實(shí)現(xiàn)都可以選擇自己的內(nèi)存分配策略。但是必須遵守的一條原則是：只有當(dāng)迫不得已（在執(zhí)行insert操作時(shí)size與capacity相等，或者調(diào)用resize或reserve時(shí)給定的大小超過(guò)當(dāng)前capacity）時(shí)才可以分配新的內(nèi)存空間。

59. 在c++11中，vector 增加了data()的用法，它返回內(nèi)置vecotr所指的數(shù)組內(nèi)存的第一個(gè)元素的指針。

60. string搜索函數(shù)返回string::size_type值，該類(lèi)型是一個(gè)unsigned類(lèi)型。因此，用一個(gè)int或其他帶符號(hào)類(lèi)型來(lái)保存這些函數(shù)的返回值不是一個(gè)好主意。

61. 指定在哪里開(kāi)始搜索：

    string numbers("0123456789"), name("r2d2");
    string::size_type pos = 0;
    // 每步循環(huán)查找name中下一個(gè)數(shù)
    while ((pos = name.find_first_of(numbers, pos)) != string::npos)
    {
    cout << "found number at index: " << pos
    << " element is " << name[pos] << endl;
    ++pos; // 移動(dòng)到下一個(gè)字符
    }
    

62. 適配器是標(biāo)準(zhǔn)庫(kù)中的一個(gè)通用概念。本質(zhì)上，一個(gè)適配器是一種機(jī)制，能使某種事物的行為看起來(lái)像另外一種事物一樣。一個(gè)容器適配器接受一種已有的容器類(lèi)型，是其行為看起來(lái)像一種不同的類(lèi)型。

63. 默認(rèn)情況下，stack和queue是基于deque實(shí)現(xiàn)的，priority_queue是在vector之上實(shí)現(xiàn)的。我們可以在創(chuàng)建一個(gè)適配器時(shí)將一個(gè)命名的順序容器作為第二個(gè)類(lèi)型參數(shù)，來(lái)重載默認(rèn)容器類(lèi)型。

    // 從deq拷貝元素到stk
    stack<int> stk(deq);
    // 在vector上實(shí)現(xiàn)的空棧
    stack<string, vector<string>> str_stk;
    // str_stk2在vector上實(shí)現(xiàn)，初始化時(shí)保存svec的拷貝
    stack<string, vector<string>> str_stk2(svec); // svec是vector<string>類(lèi)型
    

64. deque支持在容器頭尾位置的快速插入和刪除，而且在兩端插入或刪除元素都不會(huì)導(dǎo)致重新分配空間。