C/C++编程：动态连续数组vector

╰+哭是因爲堅強的太久メ 2022-05-16 22:36 276阅读 0赞

![2021090210175152.png][]vector（栈上数组）

*  vector是一种序列式容器-----> 每个元素都有自己的固定位置，跟元素的插入时机有关，跟元素值无关
 *  vector将其元素置于一个dynamic array中加以管理。
 *  它允许随机存取，也就是可以利用索引直接存取任何一个元素。
 *  数组尾部添加或者移除元素非常快速，但是在中部或者头部插入元素比较费时，因为为了保持原本的相对次序，有些元素必须移动
 *  元素相继存储，这意味着不仅可通过迭代器，还能用指向元素的常规指针访问元素

## 定义和初始化vector对象 ##

![20210222095643304.png][]

例子：

1、可以默认初始化vector对象；也可以将一个vector对象的值拷贝给另一个对象，但是这两个vector对象类型必须相同

![20210222095727500.png][]

2、列表初始化vector对象：如果提供的是初始元素值的列表，只能放在｛｝里面进行列表初始化，不能放在()里面初始化

![20210222100049117.png][]

![20210222100058122.png][]

3、创建指定数量的元素：

![20210222100135695.png][]

4、值初始化：如果只提供vector对象容纳的元素数量而不提供初始值，默认会创建一个值初始化元素初值，并把它赋给容器中的所有元素

![20210222100334621.png][]

![20210222100533136.png][]

这种方法有一个要求：vector元素的类型必须支持默认初始化

5、注意：（）表示构造vector对象，｛｝一般是列表初始化，只要无法列表初始化才考虑其他  
![20210222100631640.png][]

![2021022210082149.png][]

#include <vector>
    #include <string>
    #include <iostream>
     
    template<typename T>
    std::ostream& operator<<(std::ostream& s, const std::vector<T>& v)
    {
        s.put('[');
        char comma[3] = {'\0', ' ', '\0'};
        for (const auto& e : v) {
            s << comma << e;
            comma[0] = ',';
        }
        return s << ']';
    }
     
    int main() 
    {
        // C++11 初始化器列表语法：
        std::vector<std::string> words1 {"the", "frogurt", "is", "also", "cursed"};
        std::cout << "words1: " << words1 << '\n';
     
        // words2 == words1
        std::vector<std::string> words2(words1.begin(), words1.end());
        std::cout << "words2: " << words2 << '\n';
     
        // words3 == words1
        std::vector<std::string> words3(words1);
        std::cout << "words3: " << words3 << '\n';
     
        // words4 为 {"Mo", "Mo", "Mo", "Mo", "Mo"}
        std::vector<std::string> words4(5, "Mo");
        std::cout << "words4: " << words4 << '\n';
    }

![20210308164212218.png][]

## 元素要求 ##

vector除了要求所存数据是可复制构造外，还要求是可赋值的（赋值操作符不能是私有的）。在vector的多种操作中，多出用到赋值语句

## 赋值操作 ##

### operator= ###

作用：替换容器内容

#include <vector>
    #include <iostream>
     
    void display_sizes(char const* comment,
                       const std::vector<int>& nums1,
                       const std::vector<int>& nums2,
                       const std::vector<int>& nums3)
    {
        std::cout << comment
                  << " nums1: " << nums1.size() << ','
                  << " nums2: " << nums2.size() << ','
                  << " nums3: " << nums3.size() << '\n';
    }
     
    void display(char const* comment, const std::vector<int>& v)
    {
        std::cout << comment << "{ ";
        for (int e : v) {
            std::cout << e << ' ';
        }
        std::cout << "}\n";
    }
     
    int main()
    {
        std::vector<int> nums1 {3, 1, 4, 6, 5, 9};
        std::vector<int> nums2;
        std::vector<int> nums3;
     
        display_sizes("Initially:\n", nums1, nums2, nums3);
     
        // 从 nums1 复制赋值数据到 nums2
        nums2 = nums1;
     
        display_sizes("After assigment:\n", nums1, nums2, nums3);
     
        // 从 nums1 移动赋值数据到 nums3,
        // 修改 nums1 和 nums3
        nums3 = std::move(nums1);
     
        display_sizes("After move assigment:\n", nums1, nums2, nums3);
     
        display("Now nums3 = ", nums3);
     
        // initializer_list 的复制赋值复制数据给 nums3
        nums3 = {1, 2, 3};
     
        display("After assignment of initializer_list \n nums3 = ", nums3);
    }

## ![20210308164434140.png][] ##

### std::vector::assign ###

作用：替换容器的内容

#include <vector>
    #include <iostream>
     
    int main()
    {
        std::vector<char> characters;
     
        characters.assign(5, 'a');
     
        for (char c : characters) {
            std::cout << c << ' ';
        } 
     
        characters.assign({'\n', 'C', '+', '+', '1', '1', '\n'});
     
        for (char c : characters) {
            std::cout << c;
        }
    
    
        int array[] = {0, 1, 2, 3, 4};
    
        std::vector<int> v;
        v.assign(array, array+5);
    }

## 元素访问 ##

![20210308164644679.png][]

### std::vector::at ###

作用：

*  返回位于指定位置 `pos` 的元素的引用，有边界检查。
 *  若 `pos` 不在容器范围内，则抛出 [std::out\_of\_range][std_out_of_range] 类型的异常。

#include <iostream>
    #include <vector>
     
    int main()
    {
        std::vector<int> data = { 1, 2, 4, 5, 5, 6 };
     
        // Set element 1
        data.at(1) = 88;
     
        // Read element 2
        std::cout << "Element at index 2 has value " << data.at(2) << '\n';
     
        std::cout << "data size = " << data.size() << '\n';
     
        try {
            // Set element 6
            data.at(6) = 666;
        } catch (std::out_of_range const& exc) {
            std::cout << exc.what() << '\n';
        }
     
        // Print final values
        std::cout << "data:";
        for (int elem : data)
            std::cout << " " << elem;
        std::cout << '\n';
    }

## ![20210308164950142.png][] ##

### std::vector::operator\[\] ###

作用：返回位于指定位置 `pos` 的元素的引用。不进行边界检查。

#include <vector>
    #include <iostream>
     
    int main()
    {
        std::vector<int> numbers {2, 4, 6, 8};
     
        std::cout << "Second element: " << numbers[1] << '\n';
     
        numbers[0] = 5;
     
        std::cout << "All numbers:";
        for (auto i : numbers) {
            std::cout << ' ' << i;
        }
        std::cout << '\n';
    }

![20210308165046367.png][]

### std::vector::front、std::vector::back ###

> std::vector::front

作用：

*  返回到容器首元素的引用。
 *  在空容器上对 `front` 的调用是未定义的

注解：

*  对于容器 `c` ，表达式 c.front() 等价于 \*c.begin() 。

> std::vector::back

作用：

*  返回到容器中最后一个元素的引用。
 *  在空容器上调用 `back` 导致[未定义行为][Link 1]。

注解：

*  对于非空容器 `c` ，表达式 c.back() 等价于 \*[std::prev][std_prev](c.end()) 。

#include <vector>
    #include <iostream>
     
    int main()
    {
        std::vector<char> letters {'o', 'm', 'g', 'w', 't', 'f'};
     
        if (!letters.empty()) {
            std::cout << "The first character is: " << letters.front() << '\n';
            std::cout << "The last character is: " << letters.back() << '\n';
        }  
    }

## ![20210308165406446.png][] ##

### std::vector::data ###

作用：返回指向作为元素存储工作的底层数组的指针。指针满足范围 `[data(); data() + size())` 始终是合法范围，即使容器为空（该情况下 `data()` 不可解引用）。

返回值：指向底层元素存储的指针。对于非空容器，返回的指针与首元素地址比较相等

##    容量 ##

![20210308165825866.png][]

### std::vector::empty ###

作用： 检查容器是否无元素，即是否 begin() == end()

#include <vector>
    #include <iostream>
     
    int main()
    {
        std::cout << std::boolalpha;
        std::vector<int> numbers;
        std::cout << "Initially, numbers.empty(): " << numbers.empty() << '\n';
     
        numbers.push_back(42);
        std::cout << "After adding elements, numbers.empty(): " << numbers.empty() << '\n';
    }

![20210308165659537.png][]

### std::vector::size ###

作用： 返回容器中的元素数，即 [std::distance][std_distance](begin(), end())

#include <vector>
    #include <iostream>
     
    int main()
    { 
        std::vector<int> nums {1, 3, 5, 7};
     
        std::cout << "nums contains " << nums.size() << " elements.\n";
    }

![20210308165810110.png][]

### std::vector::max\_size ###

作用：

*  返回根据系统或库实现限制的容器可保有的元素最大数量
 *  此值通常反映容器大小上的理论极限，至多为 [std::numeric\_limits][std_numeric_limits]<difference\_type>::max() 。运行时，可用 RAM 总量可能会限制容器大小到小于 `max_size()` 的值。

#include <iostream>
    #include <vector>
     
    int main()
    {
        std::vector<char> s;
        std::cout << "Maximum size of a 'vector' is " << s.max_size() << "\n";
    }

![20210308165919358.png][]

### std::vector::capacity ###

作用：返回容器当前已为之分配空间的元素数。

#include <iostream>
    #include <vector>
     
    int main()
    {
        int sz = 200;
        std::vector<int> v1;
     
        auto cap = v1.capacity();
        std::cout << "initial capacity=" << cap << '\n';
     
        for (int n = 0; n < sz; ++n) {
            v1.push_back(n);
            if (cap != v1.capacity()) {
                cap = v1.capacity();
                std::cout << "new capacity=" << cap << '\n';
            }
        }
     
        std::cout << "final size=" << v1.size() << '\n';
        std::cout << "final capacity=" << v1.capacity() << '\n';
    }

![20210308170035878.png][]

### std::vector::reserve ###

void reserve( size_type new_cap );              (C++20 前)
    constexpr void reserve( size_type new_cap );     (C++20 起)

作用：增加 `vector` 的容量到大于或等于 `new_cap` 的值。

*  若 `new_cap` 大于当前的 [capacity()][capacity] ，则分配新存储，并且所有迭代器和所有到元素的引用都被非法化
 *  若 `new_cap` 大于当前的 [capacity()][capacity] ，则什么也不做

#include <cstddef>
    #include <new>
    #include <vector>
    #include <iostream>
     
    // 带调试输出的最小 C++11 分配器
    template <class Tp>
    struct NAlloc {
        typedef Tp value_type;
        NAlloc() = default;
        template <class T> NAlloc(const NAlloc<T>&) {}
        Tp* allocate(std::size_t n)
        {
            n *= sizeof(Tp);
            std::cout << "allocating " << n << " bytes\n";
            return static_cast<Tp*>(::operator new(n));
        }
        void deallocate(Tp* p, std::size_t n)
        {
            std::cout << "deallocating " << n*sizeof(Tp) << " bytes\n";
            ::operator delete(p);
        }
    };
    template <class T, class U>
    bool operator==(const NAlloc<T>&, const NAlloc<U>&) { return true; }
    template <class T, class U>
    bool operator!=(const NAlloc<T>&, const NAlloc<U>&) { return false; }
     
    int main()
    {
        int sz = 100;
        std::cout << "using reserve: \n";
        {
            std::vector<int, NAlloc<int>> v1;
            v1.reserve(sz);
            for(int n = 0; n < sz; ++n)
                v1.push_back(n);
        }
        std::cout << "not using reserve: \n";
        {
            std::vector<int, NAlloc<int>> v1;
            for(int n = 0; n < sz; ++n)
                v1.push_back(n);
        }
    }

![20210308170818468.png][]

### std::vector::shrink\_to\_fit ###

引入原因：

*  数据增加会促进vector申请更大的空间，但是数据减少一般不会导致vector自动减少内存空间。在C++11中新增了shink\_to\_fit用于指导缩减内存空间，但不强制要求调用之后capacity()==size()。各个库提供方可以用自己的策略判断是否需要将数据迁移到较小空间

作用：

*  请求移除未使用的容量。
 *  它是减少 [capacity()][capacity] 到 [size()][size]非强制性请求。请求是否达成依赖于实现。
 *  若发生重分配，则所有迭代器，包含尾后迭代器，和所有到元素的引用都被非法化。若不发生重分配，则没有迭代器或引用被非法化。

#include <iostream>
    #include <vector>
     
    int main()
    {
        std::vector<int> v;
        std::cout << "Default-constructed capacity is " << v.capacity() << '\n';
        v.resize(100);
        std::cout << "Capacity of a 100-element vector is " << v.capacity() << '\n';
        v.resize(50);
        std::cout << "Capacity after resize(50) is " << v.capacity() << '\n';
        v.shrink_to_fit();
        std::cout << "Capacity after shrink_to_fit() is " << v.capacity() << '\n';
        v.clear();
        std::cout << "Capacity after clear() is " << v.capacity() << '\n';
        v.shrink_to_fit();
        std::cout << "Capacity after shrink_to_fit() is " << v.capacity() << '\n';
        for (int i = 1000; i < 1300; ++i)
            v.push_back(i);
        std::cout << "Capacity after adding 300 elements is " << v.capacity() << '\n';
        v.shrink_to_fit();
        std::cout << "Capacity after shrink_to_fit() is " << v.capacity() << '\n';
    }

### ![2021030817093068.png][] ###

## 迭代器 ##

![20210308171103817.png][]

int main(){
        std::vector<int> nums {1, 2, 4, 8, 16};
        for (auto  iter = nums.begin(); iter != nums.end(); iter++){
            printf("%d\t", *iter);
        }
    
        printf("\n--------------------------------------\n");
        for (auto  iter = nums.rbegin(); iter != nums.rend(); iter++){
            printf("%d\t", *iter);
        }
    }

![20210902101827776.png][]

#include <iostream>
    #include <numeric>
    #include <vector>
    #include <string>
     
    int main()
    {
    	std::vector<int> nums {1, 2, 4, 8, 16};
    	std::vector<std::string> fruits {"orange", "apple", "raspberry"};
    	std::vector<char> empty;
     
    	// 求和 vector nums 中的所有整数（若存在），仅打印结果。
    	std::cout << "Sum of nums: " <<
                    std::accumulate(nums.begin(), nums.end(), 0) << "\n";
     
    	// 打印 vector fruits 中的首个 fruis ，不检查是否有一个。
    	std::cout << "First fruit: " << *fruits.begin() << "\n";
     
    	if (empty.begin() == empty.end())
    		std::cout << "vector 'empty' is indeed empty.\n";
    }

### ![20210308171033842.png][] ###

## 修改器 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70][]

### std::vector::erase ###

作用：从容器擦除指定的元素

1) 移除位于 `pos` 的元素。

2) 移除范围 `[first; last)` 中的元素。

#include <vector>
    #include <iostream>
     
     
    int main( )
    {
        std::vector<int> c{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
        for (auto &i : c) {
            std::cout << i << " ";
        }
        std::cout << '\n';
     
        c.erase(c.begin());
     
        for (auto &i : c) {
            std::cout << i << " ";
        }
        std::cout << '\n';
     
        c.erase(c.begin()+2, c.begin()+5);
     
        for (auto &i : c) {
            std::cout << i << " ";
        }
        std::cout << '\n';
    
        typedef std::vector<int>::iterator it;
        it p = c.begin();
        it q = c.end()-1;
        c.erase(p, q);
    }

### ![20210308172232920.png][] ###

### std::vector::clear ###

作用：

*  从容器擦除所有元素。此调用后 [size()][size] 返回零。
 *  非法化任何指代所含元素的引用、指针或迭代器。
 *  保持 `vector` 的 [capacity()][capacity] 不变

#include <algorithm>
    #include <iostream>
    #include <vector>
     
    int main()
    {
        std::vector<int> container{1, 2, 3};
     
        auto print = [](const int& n) { std::cout << " " << n; };
     
        std::cout << "Before clear:";
        std::for_each(container.begin(), container.end(), print);
        std::cout << "\nSize=" << container.size() << '\n';
     
        std::cout << "Clear\n";
        container.clear();
     
        std::cout << "After clear:";
        std::for_each(container.begin(), container.end(), print);
        std::cout << "\nSize=" << container.size() << '\n';
    }

### ![20210308171258766.png][] ###

### std::vector::insert ###

作用：插入元素到容器中的指定位置。

#include <iostream>
    #include <vector>
     
    void print_vec(const std::vector<int>& vec)
    {
        for (auto x: vec) {
             std::cout << ' ' << x;
        }
        std::cout << '\n';
    }
     
    int main ()
    {
        std::vector<int> vec(3,100);
        print_vec(vec);
     
        auto it = vec.begin();
        it = vec.insert(it, 200);
        print_vec(vec);
     
        vec.insert(it,2,300);
        print_vec(vec);
     
        // "it" 不再合法，获取新值：
        it = vec.begin();
     
        std::vector<int> vec2(2,400);
        vec.insert(it+2, vec2.begin(), vec2.end());
        print_vec(vec);
     
        int arr[] = { 501,502,503 };
        vec.insert(vec.begin(), arr, arr+3);
        print_vec(vec);
    }

### ![20210308171834517.png][] ###

### std::vector::emplace ###

template< class... Args >
    iterator emplace( const_iterator pos, Args&&... args );
    
    template< class... Args >
    constexpr iterator emplace( const_iterator pos, Args&&... args );

作用：

*  直接于 `pos` 前插入元素到容器中。
 *  通过 [std::allocator\_traits::construct][std_allocator_traits_construct] 构造元素，常用布置 new 在容器提供的位置原位构造元素。然而若要求的位置已被既存的元素占据，则首先在另一位置构造被插入的元素，然后再将他移动赋值到要求的位置中。
 *  将参数 `args...` 作为 [std::forward][std_forward]<Args>(args)... 转发给构造函数。 `args...` 可以直接或间接地指代容器中的值。

#include <iostream>
    #include <string>
    #include <vector>
     
    struct A {
        std::string s;
        A(std::string str) : s(std::move(str))  { std::cout << " constructed\n"; }
        A(const A& o) : s(o.s) { std::cout << " copy constructed\n"; }
        A(A&& o) : s(std::move(o.s)) { std::cout << " move constructed\n"; }
        A& operator=(const A& other) {
            s = other.s;
            std::cout << " copy assigned\n";
            return *this;
        }
        A& operator=(A&& other) {
            s = std::move(other.s);
            std::cout << " move assigned\n";
            return *this;
        }
    };
     
    int main()
    {
        std::vector<A> container;
        // 预留足够的空间以使 vector 不必重设大小
        container.reserve(10);
        std::cout << "construct 2 times A:\n";
        A two { "two" };
        A three { "three" };
     
        std::cout << "emplace:\n";
        container.emplace(container.end(), "one");
     
        std::cout << "emplace with A&:\n";
        container.emplace(container.end(), two);
     
        std::cout << "emplace with A&&:\n";
        container.emplace(container.end(), std::move(three));
     
        std::cout << "content:\n";
        for (const auto& obj : container)
            std::cout << ' ' << obj.s;
        std::cout << '\n';
    }

### ![20210308172125399.png][] ###

###  ###

### std::vector::push\_back ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 1][]

#include <vector>
    #include <iostream>
    #include <iomanip>
     
    int main()
    {
        std::vector<std::string> letters;
     
        letters.push_back("abc");
        std::string s = "def";
        letters.push_back(std::move(s));
     
        std::cout << "vector holds: ";
        for (auto&& i : letters) std::cout << std::quoted(i) << ' ';
        std::cout << "\nMoved-from string holds " << std::quoted(s) << '\n';
    }

![2021030817233922.png][]

### std::vector::emplace\_back ###

![20210308172431144.png][]

#include <vector>
    #include <string>
    #include <iostream>
     
    struct President
    {
        std::string name;
        std::string country;
        int year;
     
        President(std::string p_name, std::string p_country, int p_year)
            : name(std::move(p_name)), country(std::move(p_country)), year(p_year)
        {
            std::cout << "I am being constructed.\n";
        }
        President(President&& other)
            : name(std::move(other.name)), country(std::move(other.country)), year(other.year)
        {
            std::cout << "I am being moved.\n";
        }
        President& operator=(const President& other) = default;
    };
     
    int main()
    {
        std::vector<President> elections;
        std::cout << "emplace_back:\n";
        elections.emplace_back("Nelson Mandela", "South Africa", 1994);
     
        std::vector<President> reElections;
        std::cout << "\npush_back:\n";
        reElections.push_back(President("Franklin Delano Roosevelt", "the USA", 1936));
     
        std::cout << "\nContents:\n";
        for (President const& president: elections) {
            std::cout << president.name << " was elected president of "
                      << president.country << " in " << president.year << ".\n";
        }
        for (President const& president: reElections) {
            std::cout << president.name << " was re-elected president of "
                      << president.country << " in " << president.year << ".\n";
        }
    }

![20210308172500555.png][]

### std::vector::pop\_back ###

![20210308172534154.png][]

#include <vector>
    #include <iostream>
     
    template<class T>
    void print(T const & xs)
    {
        std::cout << "[ ";
        for(auto && x : xs) {
            std::cout << x << ' ';
        }
        std::cout << "]\n";
    }
     
    int main()
    {
        std::vector<int> numbers;
     
        print(numbers); 
     
        numbers.push_back(5);
        numbers.push_back(3);
        numbers.push_back(4);
     
        print(numbers); 
     
        numbers.pop_back();
     
        print(numbers); 
    }

![20210308172552865.png][]

### std::vector::resize ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 2][]

#include <iostream>
    #include <vector>
    int main()
    {
        std::vector<int> c = {1, 2, 3};
        std::cout << "The vector holds: ";
        for(auto& el: c) std::cout << el << ' ';
        std::cout << '\n';
        c.resize(5);
        std::cout << "After resize up to 5: ";
        for(auto& el: c) std::cout << el << ' ';
        std::cout << '\n';
        c.resize(2);
        std::cout << "After resize down to 2: ";
        for(auto& el: c) std::cout << el << ' ';
        std::cout << '\n';
    }

![20210308172653601.png][]

### std::vector::swap ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 3][]

#include <iostream>
    #include <vector>
     
    template<class Os, class Co> Os& operator<<(Os& os, const Co& co) {
        os << "{";
        for (auto const& i : co) { os << ' ' << i; }
        return os << " } ";
    }
     
    int main()
    {
        std::vector<int> a1{1, 2, 3}, a2{4, 5};
     
        auto it1 = std::next(a1.begin());
        auto it2 = std::next(a2.begin());
     
        int& ref1 = a1.front();
        int& ref2 = a2.front();
     
        std::cout << a1 << a2 << *it1 << ' ' << *it2 << ' ' << ref1 << ' ' << ref2 << '\n';
        a1.swap(a2);
        std::cout << a1 << a2 << *it1 << ' ' << *it2 << ' ' << ref1 << ' ' << ref2 << '\n';
     
        // 注意交换后迭代器与引用保持与其原来的元素关联，例如指向 'a1' 中值为 2 的元素的 it1 仍指向同一元素，
        // 尽管此元素被移动到 'a2' 中。
    }

![20210308172746643.png][]

## 其他 ##

![20210308173054816.png][]

### std::swap(std::vector) ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 4][]

#include <algorithm>
    #include <iostream>
    #include <vector>
     
    int main()
    {
        std::vector<int> alice{1, 2, 3};
        std::vector<int> bob{7, 8, 9, 10};
     
        auto print = [](const int& n) { std::cout << " " << n; };
     
        // 打印交换前的状态
        std::cout << "alice:";
        std::for_each(alice.begin(), alice.end(), print);
        std::cout << '\n';
        std::cout << "bob  :";
        std::for_each(bob.begin(), bob.end(), print);
        std::cout << '\n';
     
        std::cout << "-- SWAP\n";
        std::swap(alice,bob);
     
        // 打印交换后的状态
        std::cout << "alice:";
        std::for_each(alice.begin(), alice.end(), print);
        std::cout << '\n';
        std::cout << "bob  :";
        std::for_each(bob.begin(), bob.end(), print);
        std::cout << '\n';
    }

### ![20210308173240375.png][] ###

### ==,!=,<,<=,>,>=,<=> ###

作用：按照字典顺序比较 vector 中的值

#include <iostream>
    #include <vector>
     
    int main()
    {
        std::vector<int> alice{1, 2, 3};
        std::vector<int> bob{7, 8, 9, 10};
        std::vector<int> eve{1, 2, 3};
     
        std::cout << std::boolalpha;
     
        // 比较不相等的容器
        std::cout << "alice == bob returns " << (alice == bob) << '\n';
        std::cout << "alice != bob returns " << (alice != bob) << '\n';
        std::cout << "alice <  bob returns " << (alice < bob) << '\n';
        std::cout << "alice <= bob returns " << (alice <= bob) << '\n';
        std::cout << "alice >  bob returns " << (alice > bob) << '\n';
        std::cout << "alice >= bob returns " << (alice >= bob) << '\n';
     
        std::cout << '\n';
     
        // 比较相等的容器
        std::cout << "alice == eve returns " << (alice == eve) << '\n';
        std::cout << "alice != eve returns " << (alice != eve) << '\n';
        std::cout << "alice <  eve returns " << (alice < eve) << '\n';
        std::cout << "alice <= eve returns " << (alice <= eve) << '\n';
        std::cout << "alice >  eve returns " << (alice > eve) << '\n';
        std::cout << "alice >= eve returns " << (alice >= eve) << '\n';
    }

![20210308173014856.png][]

### std::erase, std::erase\_if ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 5][]

#include <iostream>
    #include <numeric>
    #include <vector>
     
    void print_container(const std::vector<char>& c)
    {
        for (auto x : c) {
            std::cout << x << ' ';
        }
        std::cout << '\n';
    }
     
    int main()
    {
        std::vector<char> cnt(10);
        std::iota(cnt.begin(), cnt.end(), '0');
     
        std::cout << "Init:\n";
        print_container(cnt);
     
        auto erased = std::erase(cnt, '3');
        std::cout << "Erase \'3\':\n";
        print_container(cnt);
     
        std::erase_if(cnt, [](char x) { return (x - '0') % 2 == 0; });
        std::cout << "Erase all even numbers:\n";
        print_container(cnt);
        std::cout << "In all " << erased << " even numbers were erased.\n";
    }

![20210308173351283.png][]

## operator \* ##

#include <iostream>
    #include <vector>
    using namespace std;
    /*
    总结：使用数组初始化vector数组：必须指出数组第n个元素以及数组n+x元素的下一位置的地址
    如果超过原数组的下一个元素的范围，就会把超出部分初始化为垃圾数字
    */
    int main()
    {
    	const size_t arr_size = 6;
    	int arr[arr_size] = {0, 1, 2, 3, 4, 5};
    
    	vector<int> vec0(arr, arr+arr_size);   
    	for (vector<int>::iterator i = vec0.begin(); i!=vec0.end(); ++i)  //6
    		cout << *i << ends;   //0, 1, 2, 3, 4, 5
    	cout << endl;
    
    	vector<int> vec1(arr, arr + arr_size+1);
    	for (vector<int>::iterator i = vec1.begin(); i != vec1.end(); ++i)
    		cout << *i << ends;   //0， 1, 2, 3, 4, 5，垃圾
    	cout << endl;
    
    	vector<int> vec2(arr+1, arr + 3);
    	for (vector<int>::iterator i = vec2.begin(); i != vec2.end(); ++i)
    		cout << *i << ends;  // 1, 2
    
    	system("pause");
    }

### 迭代器非法化 ###

![20210308173720315.png][]

## array与vector ##

*  array是静态数组容器，不能自动变长，长度是固定的。它的元素不能超过给定长度大小。array<int, 3> my12 = \{0, 1, 3,\};
 *  vector会预先预留一段内存\[编译器决定\]，如果元素超过这段内存大小，会重新分配一块更大的内存，然后将原来的内存复制到新内存里面，删除原来内存。vector<int> my12 = \{0, 1, 3, 4\};

[2021090210175152.png]: /images/20220517/b7caa6befb6d4ef296ff31b740c35f3c.png
[20210222095643304.png]: /images/20220517/86a02f4f6f2b42ab830e604438f7870c.png
[20210222095727500.png]: /images/20220517/41c1064a5a114a1d8fe842befbc38df4.png
[20210222100049117.png]: /images/20220517/5d40259c3d0143959acef33f5d697be8.png
[20210222100058122.png]: /images/20220517/947f4c2af78d431a8b00b5ba0c7301e2.png
[20210222100135695.png]: /images/20220517/5c1d3bdbcdcf4049985bf8d6eac5cf57.png
[20210222100334621.png]: /images/20220517/52aabf09831b47dbb2e3842dd3887b2f.png
[20210222100533136.png]: /images/20220517/e460b94bc7bc4b86a7089e14239a73b0.png
[20210222100631640.png]: /images/20220517/c3ce090391d643eaac658abcbe70a516.png
[2021022210082149.png]: /images/20220517/2f7aeae607b24e40953d99f57d67e4d7.png
[20210308164212218.png]: /images/20220517/423a16cb42f645ee95a7d4f8b33f82bf.png
[20210308164434140.png]: /images/20220517/de3d920e23d244caaec16274d1d377f2.png
[20210308164644679.png]: /images/20220517/804fef534cd746d9a5e747d13655903d.png
[std_out_of_range]: https://zh.cppreference.com/w/cpp/error/out_of_range
[20210308164950142.png]: /images/20220517/05dcfd67bdeb4c64968cd8e374476523.png
[20210308165046367.png]: /images/20220517/0969dccd8de1456789dc9cda63681f0f.png
[Link 1]: https://zh.cppreference.com/w/cpp/language/ub
[std_prev]: http://zh.cppreference.com/w/cpp/iterator/prev
[20210308165406446.png]: /images/20220517/181cfa4a994f451d9c540c60d47f8555.png
[20210308165825866.png]: /images/20220517/e1864465318a43a998676505cd877ef2.png
[20210308165659537.png]: /images/20220517/382179ef27ea44de95111157311c83fe.png
[std_distance]: http://zh.cppreference.com/w/cpp/iterator/distance
[20210308165810110.png]: /images/20220517/107e1535b1bd48f8ba29c43256a69dac.png
[std_numeric_limits]: http://zh.cppreference.com/w/cpp/types/numeric_limits
[20210308165919358.png]: /images/20220517/32c77efc8f2e4c73a267ada1c46fc16f.png
[20210308170035878.png]: /images/20220517/b90bc470c1fd415f998ac63e854975c2.png
[capacity]: https://zh.cppreference.com/w/cpp/container/vector/capacity
[20210308170818468.png]: /images/20220517/806450cc1d8f40d5b7f6b41fe9122957.png
[size]: https://zh.cppreference.com/w/cpp/container/vector/size
[2021030817093068.png]: /images/20220517/08023176a90141daa2a7d9201fee5bf8.png
[20210308171103817.png]: /images/20220517/f60c8597e8674680ba9b87b4fb4d3705.png
[20210902101827776.png]: /images/20220517/19442df474864cbea44259923ee952de.png
[20210308171033842.png]: /images/20220517/e1e73a4d1b4046319e7c666bb6a055c0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70]: /images/20220517/82d305b2c6e34166800135e4bd011439.png
[20210308172232920.png]: /images/20220517/2c6696c4458841ffa84d4b87fee83d09.png
[20210308171258766.png]: /images/20220517/420a5e553e2b41798653820032cad8c8.png
[20210308171834517.png]: /images/20220517/7c4e60880c474117b8e9eadef84794d3.png
[std_allocator_traits_construct]: https://zh.cppreference.com/w/cpp/memory/allocator_traits/construct
[std_forward]: http://zh.cppreference.com/w/cpp/utility/forward
[20210308172125399.png]: /images/20220517/67a5219dc2c546ee9e5ee2af6d981663.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 1]: /images/20220517/1a9433ac0bc24b01ae3600d33927847a.png
[2021030817233922.png]: /images/20220517/d45b81b8d203432bba10782c35fbdc45.png
[20210308172431144.png]: /images/20220517/bedfe8a65e3c4ccba7416c2808f3bb26.png
[20210308172500555.png]: /images/20220517/2fad7d8d563043578601a8eae6363e93.png
[20210308172534154.png]: /images/20220517/20383239e7004f5e8a127b2d93a88d77.png
[20210308172552865.png]: /images/20220517/258839482fd740c9bbc9dd35ef80b300.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 2]: /images/20220517/9097fcf17ce74f868d883baf9543ed06.png
[20210308172653601.png]: /images/20220517/ae841a36067348fdad6f72d7c1ce7ef4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 3]: /images/20220517/8b45762513744af3ad8abfea08cea626.png
[20210308172746643.png]: /images/20220517/c2ac4ce8b62145b095758aff7f1090a2.png
[20210308173054816.png]: /images/20220517/0aab920aa7814a748dacc5995d772b62.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 4]: /images/20220517/452af757225541c1a6a1880ce27ba6ee.png
[20210308173240375.png]: /images/20220517/86292df59323466caa7162ce4910f7f4.png
[20210308173014856.png]: /images/20220517/4e2cd5462c8f4054b43e22a4d10cc81e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 5]: /images/20220517/89e8979dd4464886832187608170c8b5.png
[20210308173351283.png]: /images/20220517/2c1629a7eddd4f939eae514fc59bd0ed.png
[20210308173720315.png]: /images/20220517/cea96191cc7b4cd5bccfcaa13a9b914e.png