模拟编写一个简易的vector

vector底层是模板1.创建三个成员变量namespace bit { templateclass T class vector { public: typedef T* iterator; typedef const T* const_iterator; private: iterator _start nullptr; iterator _finish nullptr; iterator _end_of_storage nullptr; }; }private: iterator _start nullptr; // 指向数组起始位置iterator _finish nullptr; // 指向最后一个有效元素的下一个位置iterator _end_of_storage nullptr; // 指向已分配内存的末尾2.size()、capacity()size_t size() { return _finish - _start; } size_t capacity() { return _end_of_storage - _start; }3.reservevoid reserve(size_t n) { if (n capacity()) { T* tmp new T[n]; memcpy(tmp, _start, size() * sizeof(T)); delete[] _start; _start tmp; _finish _start size(); _end_of_storage _start n; } }new不用检查失败了会抛异常4.push_back为什么加呢因为这个T有可能是int有可能是string有可能还是个vector.void push_back(const T x) { if (_finish ! _end_of_storage) { *_finish x; _finish; } else { reserve(capacity() 0 ? 4 : capacity() * 2); *_finish x; _finish; } }融合一下void push_back(const T x) { //扩容 if (_finfish _end_of_storage) { reserve(capacity() 0 ? 4 : capacity() * 2); } *_finish x; _finish; }5.operator[]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 test_vector1() { vectorint v; v.push_back(1); v.push_back(2); v.push_back(3); v.push_back(4); v.push_back(5); for (size_t i 0;i v.size();i) { cout v[i] ; } cout endl; }结果崩溃了发现finsh是个空指针为什么呢?_finish _start size();看finsh发现问题出在size()上size_t size() { return _finish - _start; }_start已经更新了。_finish - _start; 这里finish是扩容前的start是扩容后的。所以更改一下代码void reserve(size_t n) { if (n capacity()) { T* tmp new T[n]; memcpy(tmp, _start, size() * sizeof(T)); delete[] _start; _finish tmp size(); _start tmp; _end_of_storage _start n; } }但是这样也不是很稳妥所以把size给一个old_size()void reserve(size_t n) { if (n capacity()) { size_t old_size size(); T* tmp new T[n]; memcpy(tmp, _start, size() * sizeof(T)); delete[] _start; _start tmp; _finish tmp old_size; _end_of_storage tmp n; } }6.iterator迭代器iterator begin() { return _start; } iterator end() { return _finish; }测试vectorint::iterator it v.begin(); while (it ! v.end()) { cout *it ; it; } cout endl; for (auto e : v) { cout e ; } cout endl;通过写一个print_vectorvoid print_vector(const vectorint v) { vectorint::iterator it v.begin(); while (it ! v.end()) { cout *it ; it; } cout endl; for (auto e : v) { cout e ; } cout endl; }测试print_vector(v);失败原因是因为const函数调用了非const的begin(),end()导致范围扩大无法调用。所以应该实现const版本的begin()、end()。typedef const T* const_iterator;const_iterator begin() const { return _start; } const_iterator end() const { return _finish; }void print_vector(const vectorint v) { vectorint::const_iterator it v.begin(); while (it ! v.end()) { cout *it ; it; } cout endl; for (auto e : v) { cout e ; } cout endl; }测试成功但是我如果想打印vectordouble vd; vd.push_back(1.1); vd.push_back(2.1); vd.push_back(3.1); vd.push_back(4.1); vd.push_back(5.1); print_vector(vd);print_vector不就写死成int了吗所以可以套一层模板templateclass T void print_vector(const vectorT v) { vectorT::const_iterator it v.begin(); while (it ! v.end()) { cout *it ; it; } cout endl; for (auto e : v) { cout e ; } cout endl; }结果发现还是编不过是因为编译器分不清究竟是类型还是静态成员变量所以用typename去表明T是一个类型参数typename vectorT::const_iterator it v.begin();规定,没有实例化的类模板里面取东西,编译器不能区分这里const_iterator是类型还是静态成员变量或者直接autoauto it v.begin();6.pop_backsize_t capacity() { return _end_of_storage - _start; } void pop_back() { assert(!empty()); --_finish; }7.insert迭代器失效问题迭代器失效string也有迭代器失效1.发生扩容仍指向原来的空间致使迭代器失效 野指针2.没有扩容位置意义已经变了所以insert以后我们认为迭代器也失效了不要访问vs强制检查了g没有1.第一种迭代器失效---野指针void insert(iterator pos, const T x) { //扩容 if (_finish _end_of_storage) { reserve(capacity() 0 ? 4 : capacity() * 2); } iterator end _finish - 1; while (end pos) { *(end 1) *end; --end; } *pos x; _finish; }测试void test_vector2() { vectorint v; v.push_back(1); v.push_back(2); v.push_back(3); v.push_back(4); v.push_back(5); print_vector(v); v.insert(v.begin() 2, 30); print_vector(v); }没有问题如果注释v.push_back(5);呢会发现程序没有正常输出这就是经典的迭代器失效也就是上面提到的第一种迭代器失效问题---野指针解决先记录相对位置len然后更新lenvoid insert(iterator pos, const T x) { //扩容 if (_finish _end_of_storage) { size_t len pos - _start; reserve(capacity() 0 ? 4 : capacity() * 2); pos _start len; } iterator end _finish - 1; while (end pos) { *(end 1) *end; --end; } *pos x; _finish; }就解决了8.findfind在algorithm中有传迭代器左闭右开2.第二种迭代器失效---位置改变vectorint v; v.push_back(1); v.push_back(2); v.push_back(3); v.push_back(4); //v.push_back(5); print_vector(v); v.insert(v.begin() 2, 30); print_vector(v);接下面代码划开是为了显示清楚int x; cin x; auto pos find(v.begin(), v.end(), x); if (pos ! v.end()) { v.insert(pos, 40); } print_vector(v);输入了2结果void test_vector2() { vectorint v; v.push_back(1); v.push_back(2); v.push_back(3); v.push_back(4); v.push_back(5); print_vector(v); int x; cin x; auto p find(v.begin(), v.end(), x); if (p ! v.end()) { //insert以后p就是失效了不要访问 v.insert(p, 40); (*p) * 10; } print_vector(v); }想让2这个位置的值乘等10但是结果却变成了400 和2这其实也是一种变相的迭代器失效也就是上面的第二种迭代器失效问题由于数据挪动p已经不是指向2了位置已经变了insert以后p就是失效了不要直接访问要访问就要更新这个失效的迭代器的值用真正的vector去试试先再写一种泛型的模板templateclass Container void print_container(const Container v) { auto it v.begin(); while (it ! v.end()) { cout *it ; it; } cout endl; for (auto e : v) { cout e ; } cout endl; }完整代码#pragma once #includeiostream #includeassert.h #includevector using namespace std; namespace bit { templateclass T class vector { public: typedef T* iterator; typedef const T* const_iterator; iterator begin() { return _start; } iterator end() { return _finish; } const_iterator begin() const { return _start; } const_iterator end() const { return _finish; } void reserve(size_t n) { if (n capacity()) { size_t old_size size(); T* tmp new T[n]; memcpy(tmp, _start, size() * sizeof(T)); delete[] _start; _start tmp; _finish tmp old_size; _end_of_storage tmp n; } } size_t size() { return _finish - _start; } size_t capacity() { return _end_of_storage - _start; } bool empty() { return _start _finish; } void push_back(const T x) { //扩容 if (_finish _end_of_storage) { reserve(capacity() 0 ? 4 : capacity() * 2); } *_finish x; _finish; } void pop_back() { assert(!empty()); --_finish; } iterator insert(iterator pos, const T x) { //扩容 if (_finish _end_of_storage) { size_t len pos - _start; reserve(capacity() 0 ? 4 : capacity() * 2); pos _start len; } iterator end _finish - 1; while (end pos) { *(end 1) *end; --end; } *pos x; _finish; return pos; } T operator[](size_t i) { assert(i size()); return _start[i]; } const T operator[](size_t i) const { assert(i size()); return _start[i]; } private: iterator _start nullptr; iterator _finish nullptr; iterator _end_of_storage nullptr; }; templateclass T void print_vector(const vectorT v) { auto it v.begin(); while (it ! v.end()) { cout *it ; it; } cout endl; for (auto e : v) { cout e ; } cout endl; } templateclass Container void print_container(const Container v) { auto it v.begin(); while (it ! v.end()) { cout *it ; it; } cout endl; for (auto e : v) { cout e ; } cout endl; } void test_vector1() { vectorint v; v.push_back(1); v.push_back(2); v.push_back(3); v.push_back(4); v.push_back(5); for (size_t i 0;i v.size();i) { cout v[i] ; } cout endl; vectorint::iterator it v.begin(); while (it ! v.end()) { cout *it ; it; } cout endl; for (auto e : v) { cout e ; } cout endl; print_vector(v); vectordouble vd; vd.push_back(1.1); vd.push_back(2.1); vd.push_back(3.1); vd.push_back(4.1); vd.push_back(5.1); print_vector(vd); } void test_vector2() { std::vectorint v; v.push_back(1); v.push_back(2); v.push_back(3); v.push_back(4); v.push_back(5); print_container(v); int x; cin x; auto p find(v.begin(), v.end(), x); if (p ! v.end()) { v.insert(p, 20); (*p) * 10; } print_container(v); } }测试在vs下崩溃这就是第二种迭代器问题在test_vector2中使用了std::vector并在插入后继续使用之前的迭代器p导致迭代器失效进而引发崩溃。std::vector::insert会在插入点之前插入新元素。如果插入导致重新分配内存所有迭代器失效即使没有重新分配插入点及之后的所有迭代器也会失效因为元素被移动。p是指向被查找元素的迭代器它在插入后不再有效。解引用失效的迭代器是未定义行为通常导致程序崩溃。Linux下但是在Linux下不会这是因为未定义行为在不同平台/编译器下的表现不同。具体来说VSVisual Studio的 Debug 模式下标准库容器如std::vector会启用迭代器调试_ITERATOR_DEBUG_LEVEL默认为 2对迭代器有效性进行严格检查。当你使用一个已经失效的迭代器如插入后的p时库会检测到并触发断言_DEBUG_ERROR或直接崩溃以帮助开发者及早发现错误。Linux 下常用的 GCC/libstdc默认不开启类似的迭代器调试除非明确定义_GLIBCXX_DEBUG因此使用失效迭代器时程序可能继续运行看起来“没崩溃”但实际仍处于未定义状态——可能访问错误内存造成数据损坏或潜伏的 bug。所以说不知道什么时候扩容不同平台扩容的时机都不一样不知道访问是否有效。这样非常危险所以最好的方式是让他们统统失效相对好的方法iterator insert(iterator pos, const T x) { //扩容 if (_finish _end_of_storage) { size_t len pos - _start; reserve(capacity() 0 ? 4 : capacity() * 2); pos _start len; } iterator end _finish - 1; while (end pos) { *(end 1) *end; --end; } *pos x; _finish; return pos; }int x; cin x; auto p find(v.begin(), v.end(), x); if (p ! v.end()) { //insert以后p就是失效了不要访问 //v.insert(p, 40); //(*p) * 10; p v.insert(p, 40); (*(p 1)) * 10; } print_vector(v);8.eraseerase应该也有insert那样的问题涉及到挪动数据void erase(iterator pos) { assert(pos _start); assert(pos _finish); iterator it pos 1; while (it ! end()) { *(it - 1) *it; it; } --_finish; }引数据测试1.先测我们自己实现的与g1.情况一void test_vector3() { vectorint v; v.push_back(1); v.push_back(2); v.push_back(3); v.push_back(4); v.push_back(5); print_container(v); //删除所有的偶数 auto it v.begin(); while (it ! v.end()) { if(*it% 2 0) { v.erase(it); } it; } print_container(v); }没有问题2.情况二vectorint v; v.push_back(1); v.push_back(2); v.push_back(3); v.push_back(4); v.push_back(4); v.push_back(5);如果写两个 v.push_back(4);会发现没有删除干净是因为it给第二个四跳过了3.情况三vectorint v; v.push_back(1); v.push_back(2); v.push_back(3); v.push_back(4);发现崩溃了是因为it是其越过边界2.测vs的照样崩溃检查更加严格相对好的方法改成这样就行void test_vector3() { std::vectorint v; v.push_back(1); v.push_back(2); v.push_back(3); v.push_back(4); v.push_back(5); print_container(v); //删除所有的偶数 auto it v.begin(); while (it ! v.end()) { if(*it% 2 0) { itv.erase(it); } else { it; } } print_container(v); }迭代器失效之后的原则是更新之后再访问string也有迭代器失效9.resize这里val的缺省值给T是因为不知道到底是什么类型void resize(size_t n, T val T())void test_vector4() { int i int(); int j int(1); int k(2); }监视窗口如果1.nsize直接截断将_finish指针移动到_start n处即丢弃末尾的多余元素。容量不变只是size减小。被删除的元素会被析构如果T是自定义类型但内存不释放。2.sizencapacity不需要扩容因为n capacity()reserve不会被调用或调用后判断容量足够不分配新内存。循环将新元素从_finish开始逐个赋值为val直到达到n个元素。size变为ncapacity不变。3.ncapacity首先需要扩容调用reserve(n)实际可能先扩容到n或更大的值取决于实现策略扩容后_start指向新内存_finish指向原数据末尾即_start old_size_end_of_storage指向_start n。然后循环将剩余位置从原_finish到_start n - 1赋值为val。size变为ncapacity变为n因为你的reserve直接分配精确大小。void resize(size_t n, T val T()) { if (n size()) { _finish _start n; } else { reserve(n); while (_finish _start n) { *_finish val; _finish; } } }void test_vector4() { int i int(); int j int(1); int k(2); vectorint v; v.resize(10, 1); v.reserve(20); print_container(v); cout v.size() endl; cout v.capacity() endl; v.resize(15, 2); print_container(v); }10.构造拷贝问题void test_vector5() { vectorint v1; v1.push_back(1); v1.push_back(2); v1.push_back(3); v1.push_back(4); print_container(v1); vectorintv2 v1;//拷贝构造 print_container(v2); }库里面跟自己的都正常通过但是通过调试窗口可以看到v,v1指向相同的空间所以会有潜在的问题析构函数添加一个析构函数~vector() { if (_start) { delete[] _start; _start _finish _end_of_storage nullptr; } }拷贝构造函数添加一个拷贝构造vector(const vectorT v) { for (auto e : v) { push_back(e); } }这样写会报错--没有合适的构造函数可以用。因为自己写了拷贝构造就不会自动给你生成。构造函数vector() {}或者C11中用法强制生成// C11 强制生成默认构造 vector() default;扩容有溢出的消耗reserve一下再改拷贝构造vector(const vectorT v) { reserve(v.size()); for (auto e : v) { push_back(e); } }operator 赋值重载传统写法void clear() { _finish _start; } //传统写法 // v1 v3 vectorT operator(const vectorT v) { if (this ! v) { clear(); reserve(v.size()); for (auto e : v) { push_back(e); } } return *this; }vectorint v3; v3.push_back(10); v3.push_back(20); v3.push_back(30); v1 v3; print_container(v1); print_container(v3);现代写法void swap(vectorT v) { std::swap(_start, v._start); std::swap(_finish, v._finish); std::swap(_end_of_storage, v._end_of_storage); } // v1 v3 //vector operator(vector v) //类外面不行类里面可以。 vectorT operator(vectorT v) { swap(v); return *this; }11.迭代器区间构造类模板的成员函数还可以继续是函数模板这个模板构造函数是通用的可以接受任何迭代器类型不仅仅是 vector 的迭代器。templateclass InputIterator vector(InputIterator first, InputIterator last) { while (first ! last)//vector可以用但是后面的容器可能是链表什么的就不好,所以统一下。 { push_back(*first); first; } }测试void test_vector6() { vectorint v1; v1.push_back(1); v1.push_back(2); v1.push_back(3); v1.push_back(4); v1.push_back(4); v1.push_back(5); vectorint v2(v1.begin(), v1.begin() 3);//只想要前三个 print_container(v1); print_container(v2); }成功使用list#includelist.listint lt; lt.push_back(10); lt.push_back(10); lt.push_back(10); lt.push_back(10); vectorint v2(lt.begin(), lt.begin()); print_container(lt); print_container(v2);还可以使用list这样就体现了这个的价值可以使用任意迭代器初始化要求类型是匹配的12.第二个构造使用string初始化#includestringvectorstring v3(10, 11111111111); print_container(v3);提供一个对应的构造第二个构造//string,vector的用n个val构造 vector(size_t n, const T val T()) { reserve(n); for (size_t i 0;i n;i) { push_back(val); } }vectorstring v4(10, 11111111111); print_container(v4);vectorint v5(10); print_container(v5);继续测试vectorint v6(10,1); print_container(v6);报错,编译器把10跟1识别成了迭代器对应前面的迭代器区间构造把10、1分别给了first、last。InputIterator识别成intint不能解引用1.加u可以这么解决加个u让他识别成unsigned intvectorint v6(10u,1); print_container(v6);2.加一个更加匹配的构造vector(int n, const T val T()) { reserve(n); for (size_t i 0;i n;i) { push_back(val); } }13.测试void test_vector7() { vectorstring v; v.push_back(11111111111111111); v.push_back(11111111111111111); v.push_back(11111111111111111); v.push_back(11111111111111111); print_container(v); v.push_back(11111111111111111); print_container(v); }报错通过调试可以发现在reserve中delete后出现问题void reserve(size_t n) { if (n capacity()) { size_t old_size size(); T* tmp new T[n]; memcpy(tmp, _start, size() * sizeof(T)); delete[] _start; _start tmp; _finish tmp old_size; _end_of_storage tmp n; } }是memecpy出现了问题v指向一段空间上面有一个个_str,_size,_capacity_str指向1111111111111111111扩容要创建新的空间也就是tmpmemcpy把_start上的值拷贝给tmp。从而导致浅拷贝都指向同一块空间所以后面delete[] _start把这些空间都析构变成随机值了那么如何解决这个问题用深拷贝调用赋值来解决这里的问题for (size_t i 0;i old_size;i) { tmp[i] _start[i]; }_start的赋值就完成了深拷贝测试成功14.完整代码vector.h#pragma once #includeiostream #includeassert.h #includevector #includelist #includestring using namespace std; namespace bit { templateclass T class vector { public: typedef T* iterator; typedef const T* const_iterator; //vector() //{ } // C11 强制生成默认构造 vector() default; vector(const vectorT v) { reserve(v.size()); for (auto e : v) { push_back(e); } } //迭代器区间构造 //类模板的成员函数还可以继续是函数模板 //这个模板构造函数是通用的可以接受任何迭代器类型不仅仅是 vector 的迭代器。 templateclass InputIterator vector(InputIterator first, InputIterator last) { while (first ! last)//vector可以用但是后面的容器可能是链表什么的就不好,所以统一下。 { push_back(*first); first; } } //string,vector的用n个val构造 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 clear() { _finish _start; } ////传统写法 //// v1 v3 //vectorT operator(const vectorT v) //{ // if (this ! v) // { // clear(); // reserve(v.size()); // for (auto e : v) // { // push_back(e); // } // } // return *this; //} void swap(vectorT v) { std::swap(_start, v._start); std::swap(_finish, v._finish); std::swap(_end_of_storage, v._end_of_storage); } //现代写法 // v1 v3 //vector operator(vector v) //类外面不行类里面可以。 vectorT operator(vectorT v) { swap(v); return *this; } ~vector() { if (_start) { delete[] _start; _start _finish _end_of_storage nullptr; } } iterator begin() { return _start; } iterator end() { return _finish; } const_iterator begin() const { return _start; } const_iterator end() const { return _finish; } void reserve(size_t n) { if (n capacity()) { size_t old_size size(); T* tmp new T[n]; //memcpy(tmp, _start, size() * sizeof(T)); for (size_t i 0;i old_size;i) { tmp[i] _start[i]; } delete[] _start; _start tmp; _finish tmp old_size; _end_of_storage tmp n; } } void resize(size_t n, T val T()) { if (n size()) { _finish _start n; } else { reserve(n); while (_finish _start n) { *_finish val; _finish; } } } size_t size() const { return _finish - _start; } size_t capacity() const { return _end_of_storage - _start; } bool empty() { return _start _finish; } void push_back(const T x) { //扩容 if (_finish _end_of_storage) { reserve(capacity() 0 ? 4 : capacity() * 2); } *_finish x; _finish; } void pop_back() { assert(!empty()); --_finish; } iterator insert(iterator pos, const T x) { assert(pos _start); assert(pos _finish); //扩容 if (_finish _end_of_storage) { size_t len pos - _start; reserve(capacity() 0 ? 4 : capacity() * 2); pos _start len; } iterator end _finish - 1; while (end pos) { *(end 1) *end; --end; } *pos x; _finish; return pos; } void erase(iterator pos) { assert(pos _start); assert(pos _finish); iterator it pos 1; while (it ! end()) { *(it - 1) *it; it; } --_finish; } T operator[](size_t i) { assert(i size()); return _start[i]; } const T operator[](size_t i) const { assert(i size()); return _start[i]; } private: iterator _start nullptr; iterator _finish nullptr; iterator _end_of_storage nullptr; }; templateclass T void print_vector(const vectorT v) { //规定, 没有实例化的类模板里面取东西, 编译器不能区分这里const_iterator //是类型还是静态成员变量 //typename vectorT::const_iterator it v.begin(); auto it v.begin(); while (it ! v.end()) { cout *it ; it; } cout endl; for (auto e : v) { cout e ; } cout endl; } templateclass Container void print_container(const Container v) { //auto it v.begin(); //while (it ! v.end()) //{ // cout *it ; // it; //} //cout endl; for (auto e : v) { cout e ; } cout endl; } void test_vector1() { vectorint v; v.push_back(1); v.push_back(2); v.push_back(3); v.push_back(4); v.push_back(5); for (size_t i 0;i v.size();i) { cout v[i] ; } cout endl; vectorint::iterator it v.begin(); while (it ! v.end()) { cout *it ; it; } cout endl; for (auto e : v) { cout e ; } cout endl; print_vector(v); vectordouble vd; vd.push_back(1.1); vd.push_back(2.1); vd.push_back(3.1); vd.push_back(4.1); vd.push_back(5.1); print_vector(vd); } void test_vector2() { std::vectorint v; v.push_back(1); v.push_back(2); v.push_back(3); v.push_back(4); v.push_back(5); print_container(v); //v.insert(v.begin() 2, 30); //print_container(v); int x; cin x; auto p find(v.begin(), v.end(), x); if (p ! v.end()) { //insert以后p就是失效了不要访问 //v.insert(p, 20); //(*p) * 10; p v.insert(p, 40); (*(p 1)) * 10; } print_container(v); } void test_vector3() { std::vectorint v; v.push_back(1); v.push_back(2); v.push_back(3); v.push_back(4); v.push_back(5); print_container(v); //删除所有的偶数 auto it v.begin(); while (it ! v.end()) { if(*it% 2 0) { itv.erase(it); } else { it; } } print_container(v); } void test_vector4() { int i int(); int j int(1); int k(2); vectorint v; v.resize(10, 1); v.reserve(20); print_container(v); cout v.size() endl; cout v.capacity() endl; v.resize(15, 2); print_container(v); } void test_vector5() { vectorint v1; v1.push_back(1); v1.push_back(2); v1.push_back(3); v1.push_back(4); print_container(v1); vectorintv2 v1;//拷贝构造 print_container(v2); vectorint v3; v3.push_back(10); v3.push_back(20); v3.push_back(30); v1 v3; print_container(v1); print_container(v3); } void test_vector6() { vectorint v1; v1.push_back(1); v1.push_back(2); v1.push_back(3); v1.push_back(4); v1.push_back(4); v1.push_back(5); //vectorint v2(v1.begin(), --v1.end());//不想要第一个数据也不想要最后一个数据 vectorint v2(v1.begin(), v1.begin() 3);//只想要前三个 print_container(v1); print_container(v2); listint lt; lt.push_back(10); lt.push_back(10); lt.push_back(10); lt.push_back(10); vectorint v3(lt.begin(), lt.begin()); print_container(lt); print_container(v2); vectorstring v4(10, 11111111111); print_container(v4); vectorint v5(10); print_container(v5); vectorint v6(10, 1); print_container(v6); } void test_vector7() { vectorstring v; v.push_back(11111111111111111); v.push_back(11111111111111111); v.push_back(11111111111111111); v.push_back(11111111111111111); print_container(v); v.push_back(11111111111111111); print_container(v); } }test.cpp#includevector.h int main() { //bit::test_vector1(); //bit::test_vector2(); //bit::test_vector3(); //bit::test_vector4(); //bit::test_vector5(); //bit::test_vector6(); bit::test_vector7(); return 0; }今天vector的模拟实现就到此结束期待我们下次再见