【C++】STL——vector模拟实现

目录
实现框架
一、基本的结构雏形 
二、默认成员函数
1.构造函数 
1.无参构造 
2.迭代器区间构造 
2.拷贝构造
1.传统写法 
2.现代写法 
3.赋值运算符重载函数 
1.传统写法 
2.现代写法 
4.析构函数
5.操作符重载函数 
三、迭代器相关的函数
四、容量相关的函数
1.size和capacity
2.reserve
3.resize 
五、增删查改相关的函数
1.push_back
2.pop_back
3.insert
4.erase
5.swap
六、完成代码 

---

实现框架


一、基本的结构雏形 

   首先我们将所需的成员变量一一罗列出来

1. //为了避免和库里的vector产生冲突，在自己的命名空间内实现vector
2. namespace vec
3. {
4.     template<class T>//通过模板能够实现不同类型的数据存储
5.         class vector
6.         {
7.         public:
8.             typedef        T* iterator;
10.         /*
11.             各类函数功能实现
12.         */
14.         private:
15.                 iterator _start;          //指向容器中的起始位置
16.                 iterator _finish;         //指向容器中最后一个有效数据的下一个位置
17.                 iterator _end_of_storage; //指向容器中现有容量的位置
18.         };
19. }

复制代码

二、默认成员函数

1.构造函数 

1.无参构造 

   对于vector的无参构造，我们只需要将三个成员变量置为空指针即可。

1. //构造函数 --- 无参构造
2. vector()
3.     //初始化成员列表
4.         :_start(nullptr)
5.         , _finish(nullptr)
6.         , _end_of_storage(nullptr)
7. {}

复制代码

2.迭代器区间构造 

   当我们想要以某个对象的区间来进行初始化时，就需要用到模板了。它既可以是类模板，也可以是函数模板。
  例如：
  用一个常量字符串来构造vector

1. const char* p = "hello";
2. vector<char>v(p, p + 2);

复制代码

用一个数组来构造vector

1. int a[5] = { 1,2,3,4,5 };
2. vector<int>v1(a, a + sizeof(a) / sizeof(a[0]));

复制代码

用一个string类来构造vector

1. string s1("hello");
2. vector<char>v2(s1.begin(), s1.end());

复制代码

1. //构造函数 --- 迭代器区间构造
2. template <class InputIterator>//既是一个类模板的成员函数，又可以是一个函数模板
3. vector(InputIterator first, InputIterator last)
4.         :_start(nullptr)
5.         , _finish(nullptr)
6.         , _end_of_storage(nullptr)
7. {
8.         while (first != last)
9.         {
10.                 push_back(*first);//尾插
11.                 ++first;
12.         }
13. }

复制代码

2.拷贝构造

   对于拷贝构造函数，因为涉及到深浅拷贝的问题，我们这里提供传统写法与现代写法。
  1.传统写法 

1.                               /*用v1去拷贝构造v2*/
2. //v2(v1)
3. //传统写法1
4. vector(const vector<T>& v)
5. {
6.         _start = new T[v.capacity()]; //让v2开辟一块和v1一样大小的空间
7.         _finish = _start + v.size();
8.         _end_of_storage = _start + v.capacity();
9.        
10.         memcpy(_start, v._start, v.size() * sizeof(T));
11. }
13. //v2(v1)
14. //传统写法2
15. vector(const vector<T>& v)
16. {
17.         _start = new T[v.capacity()]; //让v2开辟一块和v1一样大小的空间
18.     for (size_t i = 0; i < v.size(); i++)
19.     {
20.         _start[i] = v[i];//通过循环进行赋值
21.     }
22.     //最后调整_finish和_end_of_storage的大小
23.     _finish = _start + v.size();
24.     _end_of_storage = _start + v.capacity();
25. }

复制代码

  以上两种写法存在样的区别呢？ 
  写法1：依然存在浅拷贝的问题；写法2彻底完成了深拷贝的问题；
          从代码上来看，两者的区别在于写法1对于数据的拷贝采用的是memcpy函数，写法2对于数据的拷贝采用的是for循环进行赋值拷贝；两者在拷贝数据的方式上对于内置类型或不需要进行深拷贝的自定义类型，完全是满足要求的；但是当vector存储的是string时，一定存在问题。
  
          vectorv1存储了5个数据，每个数据都是string类，vectorv2(v1),v2也开辟了5个空间，并且在memcpy下完成拷贝，但是它们却指向了同一块空间，在调用析构函数时，就会导致同一块空间释放多次，最终内存泄露。
  对于写法2，它会去调用string类的赋值重载函数进行一个深拷贝
  2.现代写法 

1. //v2(v)
2. //现代写法
3. vector(const vector<T>& v)//也支持vector(const vector& v)
4.         :_start(nullptr)
5.         , _finish(nullptr)
6.         , _end_of_storage(nullptr)
7. {
8.         vector<T> tmp(v.begin(), v.end()); //通过迭代器区间对tmp进行拷贝
9.         swap(tmp); //交换v2和tmp的数据
10.         //this->swap(tmp);
11. }

复制代码

3.赋值运算符重载函数 

   和拷贝构造一样，使用memcpy时存在浅拷贝的问题 
  1.传统写法 

1. //v1 = v2
2. //传统写法
3. vector<T>& operator=(const vector<T>& v)
4. {
5.         if (this != &v) //防止自己给自己赋值
6.         {
7.                 delete[] _start; //先将v1的空间释放掉
8.                 _start = new T[v.capacity()]; //再开辟一块和v2一样大小的空间
9.                 for (size_t i = 0; i < v.size(); i++)
10.                 {
11.                         _start[i] = v[i];//通过循环进行赋值
12.                 }
13.         //最后调整_finish和_end_of_storage的大小
14.                 _finish = _start + v.size();
15.                 _end_of_storage = _start + v.capacity();
16.         }
17.         return *this;
18. }

复制代码

2.现代写法 

1. //v1 = v2
2. //现代写法
3. vector<T>& operator=(vector<T> v)//v2传给v，实际上拷贝构造一个和v2一样的v
4. {
5.         swap(v); //然后直接交换数据即可
6.         return *this;
7. }

复制代码

4.析构函数

1. //析构函数
2. ~vector()
3. {
4.         if (_start)//防止对空指针进行释放
5.         {
6.                 delete[] _start;
7.                 _start = _finish = _end_of_storage = nullptr;
8.         }
9. }

复制代码

5.操作符重载函数 

1. const T& operator[](size_t i) const
2. {
3.         assert(i < size());
4.         return _start[i];
5. }
7. T& operator[](size_t i)
8. {
9.         assert(i < size());
10.         return _start[i];
11. }

复制代码

三、迭代器相关的函数

1. typedef        T* iterator;
2. typedef        const T* const_iterator;
3. iterator begin()
4. {
5.         return _start; //返回的是容器的首地址
6. }
8. iterator end()
9. {
10.         return _finish; //返回的是容器最后一个数据的下一个位置
11. }
13. const_iterator begin() const
14. {
15.         return _start; //返回的是容器的首地址
16. }
18. const_iterator end() const
19. {
20.         return _finish; //返回的是容器最后一个数据的下一个位置
21. }

复制代码

四、容量相关的函数

1.size和capacity

1. size_t size() const
2. {
3.         return _finish - _start;//返回的是容器中有效数据的个数
4. }
6. size_t capacity() const
7. {
8.         return _end_of_storage - _start;//返回的是容器的实际有效容量
9. }

复制代码

2.reserve

   reserve增容：
          1.当 n > capacity 时，将capacity扩大到n；
          2.当 n < capacity 时，不进行任何操作；

1. void reserve(size_t n)
2. {
3.         if (n > capacity())//判断是否需要扩容
4.         {
5.                 //扩容
6.                 size_t sz = size(); //提前算好增容前的数据个数
7.                 T* tmp = new T[n];  //开辟n个空间
8.                 if (_start)
9.                 {
10.             //数据拷贝，也不能去使用memcpy函数
11.                         for (size_t i = 0; i < sz; i++)
12.                         {
13.                                 tmp[i] = _start[i];
14.                         }
15.                         delete[]_start; //释放旧空间
16.                 }
17.                 _start = tmp; //指向新空间
18.                 _finish = _start + sz;
19.                 _end_of_storage = _start + n;
20.         }
21. }

复制代码

  对于reserve，我还需要注意两个问题：  
  1.对增容前的数据个数进行记录 

    如果不提前算好增容前的数据个数，而是在增容完后更新_start，对于_finish和_end_of_storage都会出现问题，因为增容完后，就需要释放旧空间。
   2.增容前后的数据拷贝不能使用memcpy

   如果使用memcpy进行数据的拷贝后，随着_start的释放，tmp作为新的_start后，当进行访问操作时，就存在非法访问
  3.resize 

   当nsize时，我们还需要判断n是否大于capacity，是否增容
  在resize函数中的第二个参数val，采用的是缺省（匿名对象），因为我们并不知道T是什么类型，如果是int/int*给val = 0是可以的，但是T还有可能是vector，我们给到匿名对象作为缺省值的好处在于，对于内置类型它也有自己的默认构造函数

1. 例如:
2. int i = int();  // i = 0
3. int j = int(10);// j = 10

复制代码

当我们不给val传任何参数时，它会去调用自己的默认构造函数给val

1. void resize(size_t n, const T& val = T())
2. //T()是匿名对象，它的生命周期本来只是存在于当前行，但是被const修饰以后，可以延长它的生命周期
3. {
4.         if (n < size())
5.         {
6.                 _finish = _start + n;
7.         }
8.         else
9.         {
10.                 if (n > capacity())
11.                 {
12.                         reserve(n);
13.                 }
14.                 while (_finish != _start + n)
15.                 {
16.                         *_finish = val;
17.                         ++_finish;
18.                 }
19.         }
20. }

复制代码

五、增删查改相关的函数

1.push_back

   尾插数据时，首先需要判断容器是否已满，若满则去调用reserve 

1. void push_back(const T& x)
2. {
3.         if (_finish == _end_of_storage)
4.         {
5.                 reserve(capacity() == 0 ? 4 : capacity() * 2);
6.         }
7.         *_finish = x;
8.         ++_finish;
9. }

复制代码

2.pop_back

           在进行尾删时，需要判断容器是否为空，我们这里并没有实现vector的判空操作，可以利用_finish和_start之间的关系进行判断。

1. void pop_back(const T& x)
2. {
3.         assert(_finish > _start);
4.         --_finish;
5. }

复制代码

3.insert

   insert是在某个位置插入数据，插入数据就存在是否扩容，如果不需要扩容，插入数据时不会存在然后的问题；如果需要扩容，但未调整pos，会存在pos失效；

1. iterator insert(iterator pos, const T& x)
2. {
3.         assert(pos >= _start);
4.         assert(pos <= _finish);
5.         if (_finish == _end_of_storage)
6.         {
7.                 //扩容会导致pos失效，需要更新一下pos
8.                 size_t len = pos - +_start;
9.                 reserve(capacity() == 0 ? 4 : capacity() * 2);
10.                 pos = _start + len;
11.         }
12.         iterator end = _finish - 1;
13.         while (end >= pos)
14.         {
15.                 *(end + 1) = *end;
16.                 --end;
17.         }
18.         *pos = x;
19.         ++_finish;
21.         return pos;
22. }
23. void test_vector4()
24. {
25.         vector<int> v1;
26.         v1.push_back(1);
27.         v1.push_back(2);
28.         v1.push_back(3);
29.         v1.push_back(4);
30.         vector<int>::iterator it = find(v1.begin(), v1.end(), 2);
31.         if (it != v1.end())
32.         {
33.                 //如果insert中发生了扩容，那么会导致it指向的空间被释放
34.                 //it本质就是一个野指针，这种问题，我们叫做迭代器失效
35.                 v1.insert(it, 30);
36.         }
38.         for (auto e : v1)
39.         {
40.                 cout << e << " ";
41.         }
42.         cout << endl;
43. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！