【補充】?initializer_list——vector的另一種構造方法

見下：initializer_list，用 {10,20,30} 去初始化 il 對象，此時這個 il 就是 initializer_list 類型，可以認為 initializer_list 是一個容器，只不過 initializer_list 支持用花括號去初始化

?只不過這個容器只支持遍歷，不支持修改

見下：initializer_list 底層的原理—在底層開一個數組，將括號內的數據拷貝到數組里面，這個 il 對象里面有兩個指針指向這個數組空間

auto il = { 10, 20, 30 };  // the type of il is an initializer_list 

單參數的構造函數支持隱式類型轉換，第一行其實是隱式類型轉換，右邊的其實是 initializer_list 類型的對象，不能直接給 vector 進行初始化，在語法邏輯上其實是用 initializer_list 去構造一個 vector 類型的臨時對象，再將這個臨時對象拷貝構造給v1，編譯器在這樣連續的構造加拷貝優化成了直接進行構造，第二行的就是直接構造

vector<int> v1 = {10,20,30,40,50};
vector<int> v2({10,20,30,40,50});

（2）vector的三種遍歷方式總結——下標，迭代器，范圍for

#include<iostream>
#include<vector>using namespace std;int main()
{vector<int> v1;vector<int> v2(10, 1);v1.push_back(1);v1.push_back(2);v1.push_back(3);v1.push_back(4);v1.push_back(5);//遍歷for (size_t i = 0; i < v1.size(); i++){cout << v1[i] << " ";}cout << endl;//迭代器vector<int>::iterator it1 = v1.begin();while (it1 != v1.end()){cout << *it1 << " ";it1++;}cout << endl;//范圍forfor (auto e : v1){cout << e << " ";}cout << endl;return 0;
}

（3）vector iterator 的使用—迭代器

迭代器不一定就是指針，迭代器是像指針一樣的類對象

【補充】?

?string s1 和 vector<char> vs 的區別是什么？

1. s1的結尾有\0，vs的結尾沒有\0；
2. 我們前面學習了string，知道它們之間的成員接口有很大的區別

不過，還有一個有意思的東西—vector<string> vstr，vector里面存儲的是string類型的對象

直接隱式類型轉換，不用創建string類的對象，單參數構造函數支持隱式類型轉換，因為string支持const char* 的傳字符串去構造一個string類的對象

vector<string> vstr;
string s1 = "張三";
vstr.push_back(s1);
vstr.push_back("李四");

對于vector<string> vstr遍歷的方式

范圍for的遍歷，是將vstr里面的變量拷貝賦值給左邊的變量e，如果vector里面存的是int類型關系不大，但是如果是string類型的對象，調用拷貝構造代價就比較大，所以推薦第二種遍歷方式—引用+const(不希望改變里面的值)

//遍歷
for (auto e : vstr)
{cout << e << " ";
}cout << endl;for (const auto& e : vstr)
{cout << e << " ";
}
cout << endl;

vstr[0]和vstr[0][0]，這個也比較有意思

vstr[0]——原來插入了兩個string類的對象，vstr[0]下標為0的元素是s1（“張三”），+=的時候其實就是調用string的接口了，所以第一行和第二行代碼是在“張三”的后面去尾插；vstr[0][0]——一個漢字是由兩個字符構成，這里訪問其實是‘張’的兩個字符的前一個字符（這里涉及到編碼表）

vstr[0] += 'h';
vstr[0] += "hello";
vstr[0][0]++;
//等價于:vstr.oerator[](0).operator[](0)++;

（4）vector 空間增長問題

• capacity的代碼在vs和g++下分別運行會發現，vs下capacity是按1.5倍增長的，g++是按2倍增長的。這個問題經常會考察，不要固化的認為，vector增容都是2倍，具體增長多少是根據具體的需求定義的。vs是PJ版本STL，g++是SGI版本STL。
• reserve只負責開辟空間，如果確定知道需要用多少空間，reserve可以緩解vector增容的代價缺陷問題。
• resize在開空間的同時還會進行初始化，影響size。

// 測試vector的默認擴容機制
void TestVectorExpand()
{size_t sz;vector<int> v;sz = v.capacity();cout << "making v grow:\n";for (int i = 0; i < 100; ++i){v.push_back(i);if (sz != v.capacity()){sz = v.capacity();cout << "capacity changed: " << sz << '\n';}}
}vs：運行結果：vs下使用的STL基本是按照1.5倍方式擴容
making foo grow:
capacity changed: 1
capacity changed: 2
capacity changed: 3
capacity changed: 4
capacity changed: 6
capacity changed: 9
capacity changed: 13
capacity changed: 19
capacity changed: 28
capacity changed: 42
capacity changed: 63
capacity changed: 94
capacity changed: 141g++運行結果：linux下使用的STL基本是按照2倍方式擴容
making foo grow:
capacity changed: 1
capacity changed: 2
capacity changed: 4
capacity changed: 8
capacity changed: 16
capacity changed: 32
capacity changed: 64
capacity changed: 128

【補充】?shrink_to_fit

不要輕易地去縮容?

（5）vector的增刪查改

• insert，erase不支持下標插入刪除，而是支持迭代器，其實也是間接的代替了下標的用法。不建議多用，插入和刪除都是要整體挪動數據的。

（6）vector 迭代器失效的問題—重點

迭代器的主要作用就是讓算法能夠不用關心底層數據結構，其底層實際就是一個指針，或者是對指針進行了封裝，比如：vector的迭代器就是原生態指針T* 。因此迭代器失效，實際就是迭代器底層對應指針所指向的空間被銷毀了，而使用一塊已經被釋放的空間，造成的后果是程序崩潰(即如果繼續使用已經失效的迭代器，程序可能會崩潰)。

對于vector可能會導致其迭代器失效的操作有：?

1. 會引起其底層空間改變的操作，都有可能是迭代器失效，比如：resize、reserve、insert、 assign、push_back等。

?
#include <iostream>
using namespace std;
#include <vector>
int main()
{vector<int> v{ 1,2,3,4,5,6 };auto it = v.begin();// 將有效元素個數增加到100個，多出的位置使用8填充，操作期間底層會擴容// v.resize(100, 8);// reserve的作用就是改變擴容大小但不改變有效元素個數，操作期間可能會引起底層容量改變// v.reserve(100);// 插入元素期間，可能會引起擴容，而導致原空間被釋放// v.insert(v.begin(), 0);// v.push_back(8);// 給vector重新賦值，可能會引起底層容量改變v.assign(100, 8);/*出錯原因：以上操作，都有可能會導致vector擴容，也就是說vector底層原理舊空間被釋放掉，而在打印時，it還使用的是釋放之間的舊空間，在對it迭代器操作時，實際操作的是一塊已經被釋放的空間，而引起代碼運行時崩潰。解決方式：在以上操作完成之后，如果想要繼續通過迭代器操作vector中的元素，只需給it重新賦值即可。*/while (it != v.end()){cout << *it << " ";++it;}cout << endl;return 0;
}

2. 指定位置元素的刪除操作--erase

erase刪除pos位置元素后，pos位置之后的元素會往前搬移，沒有導致底層空間的改變，理 論上講迭代器不應該會失效，但是：如果pos剛好是最后一個元素，刪完之后pos剛好是end 的位置，而end位置是沒有元素的，那么pos就失效了。因此刪除vector中任意位置上元素 時，vs就認為該位置迭代器失效了。?

#include <iostream>
using namespace std;
#include <vector>
int main()
{int a[] = { 1, 2, 3, 4 };vector<int> v(a, a + sizeof(a) / sizeof(int));// 使用find查找3所在位置的iteratorvector<int>::iterator pos = find(v.begin(), v.end(), 3);// 刪除pos位置的數據，導致pos迭代器失效。v.erase(pos);cout << *pos << endl; // 此處會導致非法訪問return 0;
}

以下代碼的功能是刪除vector中所有的偶數，請問那個代碼是正確的，為什么？?

#include <iostream>
using namespace std;
#include <vector>
int main()
{vector<int> v{ 1, 2, 3, 4 };auto it = v.begin();while (it != v.end()){if (*it % 2 == 0)v.erase(it);++it;}return 0;
}
int main()
{vector<int> v{ 1, 2, 3, 4 };auto it = v.begin();while (it != v.end()){if (*it % 2 == 0)it = v.erase(it);else++it;}return 0;
}

3. 注意：Linux下，g++編譯器對迭代器失效的檢測并不是非常嚴格，處理也沒有vs下極端。

// 1. 擴容之后，迭代器已經失效了，程序雖然可以運行，但是運行結果已經不對了
int main()
{vector<int> v{ 1,2,3,4,5 };for (size_t i = 0; i < v.size(); ++i)cout << v[i] << " ";cout << endl;auto it = v.begin();cout << "擴容之前，vector的容量為: " << v.capacity() << endl;// 通過reserve將底層空間設置為100，目的是為了讓vector的迭代器失效v.reserve(100);cout << "擴容之后，vector的容量為: " << v.capacity() << endl;// 經過上述reserve之后，it迭代器肯定會失效，在vs下程序就直接崩潰了，但是linux下不會// 雖然可能運行，但是輸出的結果是不對的while (it != v.end()){cout << *it << " ";++it;}cout << endl;return 0;
}//程序輸出：
//1 2 3 4 5
//擴容之前，vector的容量為: 5
//擴容之后，vector的容量為 : 100
//0 2 3 4 5 409 1 2 3 4 5// 2. erase刪除任意位置代碼后，linux下迭代器并沒有失效
// 因為空間還是原來的空間，后序元素往前搬移了，it的位置還是有效的
#include <vector>
#include <algorithm>
int main()
{vector<int> v{ 1,2,3,4,5 };vector<int>::iterator it = find(v.begin(), v.end(), 3);v.erase(it);cout << *it << endl;while (it != v.end()){cout << *it << " ";++it;}cout << endl;return 0;
}//程序可以正常運行，并打印：
//4
//4 5

// 3: erase刪除的迭代器如果是最后一個元素，刪除之后it已經超過end
// 此時迭代器是無效的，++it導致程序崩潰
int main()
{vector<int> v{ 1,2,3,4,5 };// vector<int> v{1,2,3,4,5,6};auto it = v.begin();while (it != v.end()){if (*it % 2 == 0)v.erase(it);++it;}for (auto e : v)cout << e << " ";cout << endl;return 0;
}
========================================================
// 使用第一組數據時，程序可以運行
[sly@VM - 0 - 3 - centos 20220114]$ g++ testVector.cpp - std = c++11
[sly@VM - 0 - 3 - centos 20220114]$ . / a.out
1 3 5
======================================================== =
// 使用第二組數據時，程序最終會崩潰
[sly@VM - 0 - 3 - centos 20220114]$ vim testVector.cpp
[sly@VM - 0 - 3 - centos 20220114]$ g++ testVector.cpp - std = c++11
[sly@VM - 0 - 3 - centos 20220114]$ . / a.out
Segmentation fault

從上述三個例子中可以看到：SGI STL中，迭代器失效后，代碼并不一定會崩潰，但是運行 結果肯定不對，如果it不在begin和end范圍內，肯定會崩潰的。

4. 與vector類似，string在插入+擴容操作+erase之后，迭代器也會失效

#include <string>
void TestString()
{string s("hello");auto it = s.begin();// 放開之后代碼會崩潰，因為resize到20會string會進行擴容// 擴容之后，it指向之前舊空間已經被釋放了，該迭代器就失效了// 后序打印時，再訪問it指向的空間程序就會崩潰//s.resize(20, '!');while (it != s.end()){cout << *it;++it;}cout << endl;it = s.begin();while (it != s.end()){it = s.erase(it);// 按照下面方式寫，運行時程序會崩潰，因為erase(it)之后// it位置的迭代器就失效了// s.erase(it);++it;}
}

迭代器失效解決辦法：在使用前，對迭代器重新賦值即可。

理論結束，上圖！

第一種迭代器失效——擴容引起的野指針

?第二種迭代器失效——刪除數據，導致數據位置挪動，it不再指向之前的位置了，it也失效了，因為it已經不是指向之前的位置了，可能會導致邏輯問題

1.3 vector OJ——楊輝三角

118. 楊輝三角 - 力扣（LeetCode）

其實是用同一種類型的模版實例化出兩種類型，一個是vector<int>，一個是vector<vector<int>>。

相比于C語言的動態開辟二維數組，用vector開辟二維數組來說，它們之間的效率相比，雖然vector需要多次調用operator[]這個函數，但是vector里面operator[]是內聯函數，在函數調用處直接將函數體展開，就減少了在函數調用機制上花費的時間。??

class Solution {
public:vector<vector<int>> generate(int numRows) {//相當于n個val進行構造，每個val是一個默認構造的vector<int>類型的匿名對象vector<vector<int>> vv(numRows,vector<int>());for(size_t i = 0;i < vv.size();i++){//對每行的vector<int>開空間+進行初始化vv[i].resize(i+1,1);}//根據楊輝三角進行賦值操作for(size_t i = 0;i < vv.size();i++){//每一行的第一個位置和最后一個位置都是1，不需要改變for(size_t j = 1;j < vv[i].size()-1;j++){vv[i][j] = vv[i-1][j] + vv[i-1][j-1];}} return vv;}
};

二、vector深度剖析及模擬實現

嘗試看源碼（下面就是vector的一點點源碼）

• 先看框架
• 連蒙帶猜

2.1?std::vector的核心框架接口的模擬實現lrq::vector的一些問題

（1）reserve()中的size()問題

（2）注意迭代器失效的問題，翻看上面的第【6】有關細講迭代器失效的問題

（3）initialize_list

//initializer_list支持迭代器就支持范圍for，看文檔
vector(initializer_list<T> il):_start(nullptr), __finish(nullptr),_endofstorage(nullptr)
{reserve(il.size());for (auto& e : il)//如果是string類型用&減少拷貝，遍歷il里面的數據，將數據插入{push_back(e);}
}

vector<int> v2 = { 1,2,3,4,5,6 };//用initializer_list類型進行初始化
for (auto e : v2)
{cout << e << " ";
}
cout << endl

（4）構造函數的int匹配問題

先實現了兩個函數，一個是利用迭代器區間進行構造，一個是用n個val進行構造

//類模版的成員函數，也可以是一個函數模版
template <class InputIterator>
vector(InputIterator first, InputIterator last)
{while (first != last){push_back(*first);first++;}
}//	vector<int> v3(10, 1);
// 第一個參數可以類型轉換成size_t類型，第二個識別出T為int類型
// 這兩個實參對于上面那個函數模版會更加適配，推算出InputIterator為int類型，但是int類型不能進行解引用，此處報錯
vector(size_t n, const T& val = T())
{reserve(n);for (size_t i = 0; i < n; i++){push_back(val);}
}

但是當執行 vector<int> v3(10, 1)這句代碼時，會出現下面的錯誤

此時這句代碼匹配到迭代器區間構造的函數，而不是我們所期待匹配到第二個函數——用n個val構造的函數

why？

//?vector<int> v3(10, 1);
// 第一個參數可以類型轉換成size_t類型，第二個識別出T為int類型
// 但是但是！這兩個實參對于上面那個函數模版會更加適配，直接推算出InputIterator為int類型，但是int類型不能進行解引用，所以此處報錯

如何解決？——對于這種只有val為int類型時會出現的問題，那就直接來個現成的，有現成的就不會去匹配調用函數模版了

vector(int n, const T& val = T())
{reserve(n);for (size_t i = 0; i < n; i++){push_back(val);}
}

解決！

2.2 使用memcpy拷貝問題

現在向vector內插入string類型，此時沒有擴容，此時運行結果沒有報錯，一切正常

void test_vector9()
{vector<string> v1;v1.push_back("1111111111");v1.push_back("1111111111");v1.push_back("1111111111");v1.push_back("1111111111");for (auto e : v1){cout << e << " ";}cout << endl;
}

但是當我們再次插入，此時就需要擴容，結果運行出錯

?我們調試發現問題出在resever()問題上（自己嘗試調試），我們來分析一下問題

修改之后的reserve() ：

void reserve(size_t n)
{if (n > capacity()){size_t oldsize = size();T* tmp = new T[n];if (_start){//這里的memcpy只適用于內置類型和類似于Date日期類等的淺拷貝，但是遇到string類就不能只是簡單的淺拷貝，需要深拷貝//memcpy(tmp, _start, sizeof(T) * oldsize);for (size_t i = 0; i < oldsize; i++){tmp[i] = _start[i];//自定義類型的賦值重載會完成深拷貝}delete[] _start;}_start = tmp;_finish = tmp + oldsize;_endofstorage = _start + n;}
}

問題解決，結果正確！?

2.3 模擬實現vector源碼

模版不支持分離編譯到兩個文件否則會報鏈接錯誤，具體原因后面的模版進階會講。前面的string我們并不是按照模版去寫的，所以一個.cpp，一個.h

vector.h

#pragma once
#include<assert.h>
#include<iostream>using namespace std;namespace lrq
{template<class T>class vector{public:typedef T* iterator;typedef const T* const_iterator;//初始化列表vector():_start(nullptr), _finish(nullptr), _endofstorage(nullptr){}//initializer_list支持迭代器就支持范圍for，看文檔vector(initializer_list<T> il):_start(nullptr), _finish(nullptr),_endofstorage(nullptr){reserve(il.size());for (auto& e : il)//如果是string類型用&減少拷貝，遍歷il里面的數據，將數據插入{push_back(e);}}~vector(){if (_start){delete[] _start;_start = _finish = _endofstorage = nullptr;}}//v2(v1)//拷貝賦值，盡可能采用復用vector(const vector<T>& v){reserve(v.capacity());for (auto& e : v){push_back(e);}}//類模版的成員函數，也可以是一個函數模版template <class InputIterator>vector(InputIterator first, InputIterator last){while (first != last){push_back(*first);first++;}}vector(size_t n, const T& val = T()){reserve(n);for (size_t i = 0; i < n; i++){push_back(val);}}vector(int n, const T& val = T()){reserve(n);for (int i = 0; i < n; i++){push_back(val);}}void swap(vector<T>& tmp){std::swap(_start, tmp._start);std::swap(_finish, tmp._finish);std::swap(_endofstorage, tmp._endofstorage);}vector<T>& operator=(vector<T> v){swap(v);return *this;}//迭代器iterator begin(){return _start;}iterator end(){return _finish;}const_iterator begin()const{return _start;}const_iterator end()const{return _finish;}size_t size()const{return _finish - _start;}size_t capacity()const{return _endofstorage - _start;}T& operator[](size_t i){assert(i < size());return _start[i];}const T& operator[](size_t i)const{assert(i < size());return _start[i];}/*void reserve(size_t n){if (n > capacity()){T* tmp = new T[n];memcpy(tmp, _start, sizeof(T) * size());delete[] _start;_finish = tmp + size();_start = tmp;_endofstorage = _start + n;}}*/void reserve(size_t n){if (n > capacity()){size_t oldsize = size();T* tmp = new T[n];if (_start){//這里的memcpy只適用于內置類型和類似于Date日期類等的淺拷貝，但是遇到string類就不能只是簡單的淺拷貝，需要深拷貝//memcpy(tmp, _start, sizeof(T) * oldsize);for (size_t i = 0; i < oldsize; i++){tmp[i] = _start[i];//自定義類型的賦值重載會完成深拷貝}delete[] _start;}_start = tmp;_finish = tmp + oldsize;_endofstorage = _start + n;}}bool empty(){return _finish == _start;}void push_back(const T& x){if (_finish == _endofstorage){reserve(capacity() == 0 ? 4 : capacity() * 2);}*_finish = x;_finish++;}void pop_back(){assert(!empty());--_finish;}iterator insert(iterator pos, const T& x){//判斷pos位置是否合理assert(pos >= _start && pos <= _finish);//擴容if (_finish == _endofstorage){size_t len = pos - _start;reserve(capacity() == 0 ? 4 : 2 * capacity());pos = _start + len;}iterator i = _finish - 1;while (i >= pos){*(i + 1) = *i;i--;}*pos = x;_finish++;return pos;}//erase返回刪除位置的下一個位置iterator erase(iterator pos){assert(pos >= _start);assert(pos < _finish);iterator i = pos + 1;while (i < _finish){*(i - 1) = *i;i++;}_finish--;return pos;}void resize(size_t n,T val = T())//內置類型也有默認構造，取決于T的類型，是哪種類型就是哪種類型的默認構造{if (n <= size()){_finish = _start + n;}else{reserve(n);while (_finish < _start + n){*_finish = val;_finish++;}}}private:iterator _start = nullptr;iterator _finish = nullptr;iterator _endofstorage = nullptr;};void test_vector1(){vector<int> v1;v1.push_back(1);v1.push_back(2);v1.push_back(3);v1.push_back(4);v1.push_back(5);for (size_t i = 0; i < v1.size(); i++){cout << v1[i] << " ";}cout << endl;for (auto e : v1){cout << e << " ";}cout << endl;v1.pop_back();vector<int>::iterator it1 = v1.begin();while (it1 != v1.end()){cout << *it1 << " ";it1++;}cout << endl;}void test_vector2(){vector<int> v1;v1.push_back(1);v1.push_back(2);v1.push_back(3);v1.push_back(4);v1.push_back(5);v1.insert(v1.begin()+2, 999);for (auto e : v1){cout << e << " ";}cout << endl;vector<int> v2 = { 1,2,3,4,5,6 };//用initializer_list類型進行初始化for (auto e : v2){cout << e << " ";}cout << endl;cout << typeid(vector<int>::iterator).name() << endl;}void test_vector3(){vector<int> v1;v1.push_back(1);v1.push_back(2);v1.push_back(3);v1.push_back(4);for (auto e : v1){cout << e << " ";}cout << endl;int x = 0;cin >> x;auto it = find(v1.begin(), v1.end(), x);if (it != v1.end()){it = v1.insert(it, 10 * x);cout << *it << endl;}for (auto e : v1){cout << e << " ";}cout << endl;}void test_vector4(){vector<int> v1;v1.push_back(1);v1.push_back(2);v1.push_back(3);v1.push_back(4);for (auto e : v1){cout << e << " ";}cout << endl;int x = 0;cin >> x;auto it = find(v1.begin(), v1.end(), x);if (it != v1.end()){v1.erase(it);cout << *it << endl;}for (auto e : v1){cout << e << " ";}cout << endl;}void test_vector5(){vector<int> v1;v1.push_back(1);v1.push_back(2);v1.push_back(2);v1.push_back(3);v1.push_back(4);v1.push_back(4);for (auto e : v1){cout << e << " ";}cout << endl;//刪除所有的偶數auto it = v1.begin();while (it != v1.end()){if (*it % 2 == 0){//erase返回刪除數據的下一個位置//失效的迭代器，更新以后再去訪問it = v1.erase(it);}else{it++;}}for (auto e : v1){cout << e << " ";}cout << endl;}void test_vector6(){vector<int> v1;v1.push_back(1);v1.push_back(2);v1.push_back(2);v1.push_back(3);v1.push_back(4);v1.push_back(4);for (auto e : v1){cout << e << " ";}cout << endl;v1.resize(15, 0);for (auto e : v1){cout << e << " ";}cout << endl;}void test_vector7(){vector<int> v1;v1.push_back(1);v1.push_back(2);v1.push_back(2);v1.push_back(3);v1.push_back(4);v1.push_back(4);vector<int> v2(v1);for (auto e : v2){cout << e << " ";}cout << endl;}void test_vector8(){vector<int> v1;v1.push_back(1);v1.push_back(2);v1.push_back(2);v1.push_back(3);v1.push_back(4);v1.push_back(4);for (auto e : v1){cout << e << " ";}cout << endl;//用迭代器區間進行初始化vector<int> v2(v1.begin(), v1.end());for (auto e : v2){cout << e << " ";}cout << endl;vector<int> v3(10, 1);for (auto e : v3){cout << e << " ";}cout << endl;} void test_vector9(){vector<string> v1;v1.push_back("1111111111");v1.push_back("1111111111");v1.push_back("1111111111");v1.push_back("1111111111");v1.push_back("1111111111");for (auto e : v1){cout << e << " ";}cout << endl;}
}

main.cpp——測試

#include"vector.h"int main()
{lrq::test_vector9();return 0;
}

2.4?動態二維數組理解

// 以楊輝三角的前n行為例：假設n為5
void test2vector(size_t n)
{// 使用vector定義二維數組vv，vv中的每個元素都是vector<int>bit::vector<bit::vector<int>> vv(n);// 將二維數組每一行中的vecotr<int>中的元素全部設置為1for (size_t i = 0; i < n; ++i)vv[i].resize(i + 1, 1);// 給楊慧三角出第一列和對角線的所有元素賦值for (int i = 2; i < n; ++i){for (int j = 1; j < i; ++j){vv[i][j] = vv[i - 1][j] + vv[i - 1][j - 1];}}
}

bit::vector> vv(n); 構造一個vv動態二維數組，vv中總共有n個元素，每個元素都是vector類型的，每行沒有包含任何元素，如果n為5時如下所示：

vv中元素填充完成之后，如下圖所示：

使用標準庫中vector構建動態二維數組時與上圖實際是一致的。

哇哦，歷時幾天vector終于結束了，前面的知識在本節里面滲透好多，so......我要記得復習+多敲代碼多理解。

關于vector的幾道習題有機會繼續！下節list

完——

我的秘密_G.E.M. 鄧紫棋——————