vector的讲解及模拟实现(c++)

为了方便大家理解我们边模拟实现vector容器的常用操作,然后根据代码讲解如何使用vector的这些功能,这样的话相信可以帮助大家更好的理解vector.

目录

一.vector的介绍

二.vector模拟实现的讲解

1.vector的模块分类

 2.模拟实现时vector的定义及成员变量.

三.vector的迭代器

1.T*和const  T*

2.begin()和end()

3.cbegin()和cend()

四.vector构造函数

1.无参的构造函数

2.以n个value为成员的构造函数

3.以区间来初始化对象的构造函数

4.拷贝构造函数

5.赋值运算符重载

6.析构函数

五.vector的容量管理

1.返回有效元素个数.

2.返回容器的容量.

3.对容器进行扩容

4.改变有效元素的个数

六.vector中元素的访问.

1.以[ ]的方式访问容器当中的元素

七.vector中元素的修改

1.尾插和尾删

2.自定义的swap

3.任意位置的元素插入

4.任意位置元素的删除

八.vector中的迭代器失效问题

1.什么是迭代器失效?

2.对于vector可能会导致其迭代器失效的操作有

3.扩展

---

一.vector的介绍

什么是vector以及同其他容器相比的优缺点:

1. vector是表示可变大小数组的序列容器.(因此其空间存在于堆上)

2. 就像数组一样,vector也采用的连续存储空间来存储元素,也就是意味着可以采用下标对vector的元素进行访问,和数组一样高效,但是又不像数组,它的大小是可以动态改变的,而且它的大小会被容器自动处理.(在我们向vector中插入元素的时候,该容器会在代码中判断容器的空间是否够用,不够则要进行扩容)

3. 本质讲,vector使用动态分配数组来存储它的元素,当新元素插入时候,这个数组需要被重新分配大小为了增加存储空间,其做法是,分配一个新的数组,然后将全部元素移到这个数组,就时间而言,这是一个相对代价高的任务,因此每当一个新的元素加入到容器的时候,vector并不会每次都重新分配大小.

4. vector分配空间策略:  vector会分配一些额外的空间以适应可能的增长,因为存储空间比实际需要的存储空间更大,不同的库采用不同的策略权衡空间的使用和重新分配,但是无论如何,重新分配都应该是对数增长的间隔大小,以至于在末尾插入一个元素的时候是在常数时间的复杂度完成的.

5. 因此,vector占用了更多的存储空间,为了获得管理存储空间的能力,以一种有效的方式动态增长.

6. 与其它动态序列容器相比  (deques, lists and forward_lists) vector在访问元素的时候更加高效,在末尾添加和删除元素相对高效,对于其它不在末尾的删除和插入操作,效率更低,比起lists和forward_lists统一的迭代器和引用更好.

7.使用时主要包含头文件: #include

上面这几点没看懂也没关系,我们接下来会对其进行一一讲解.

二.vector模拟实现的讲解

1.vector的模块分类

c++底层在实现vector的时候是将其分成5个模块进行实现(而我们也是针对这5个模块中常用的内容进行实现和讲解):

分别为:

1.构造函数.(主要实现我们使用vector如何创建时初始化数组和结束时销毁数组)

在c++98的文档中的相关声明:

 2.迭代器.(STL中的迭代器主要就是为了方便我们对容器进行遍历和操作才出现的,切记不同的容器都拥有自己的迭代器,不同的容器迭代器也不同,而对于vector的迭代器我们可以将其看做一个原生态的指针,指向vector所创建出来的数组的不同位置.)

在c++98的文档中的相关声明:

 3.容量相关操作.(主要有获取数组的容量大小,数组的有效元素个数,判断数组是否为空,对数组进行手动扩容,改变数组的有效元素个数等等操作)

在c++98的文档中的相关声明:

 4.访问数组元素.(对[ ]进行重载,让我们在使用vector的时候可以很方便的访问数组元素).

在c++98的文档中的相关声明:

 5.数组中元素的修改.(主要包括了增删改查等方面的操作,查在上面模块已经出现,这里就不进行讲解了)

在c++98的文档中的相关声明:

 2.模拟实现时vector的定义及成员变量.

我们得先了解一下vector模拟实现时的框架,这样才可以帮助我们更好的理解下面的内容.

1.在其中我们针对vector的5个模块的相关操作函数进行了声明,之后则会进行分别实现和讲解.

2.因为vector是一个可以针对于各个类型数据存储的容器,因此我们采用模板类的方式进行编写.(将数据的类型作为模板参数)

3.我们所实现的vector的类名是和c++系统中的vector冲突的,因此我们将其放到自己的命名空间中进行实现.

namespace lz {

    template
    class vector {

    public:

        // Vector的迭代器是一个原生指针
        typedef T* iterator;

        typedef const T* const_iterator;

		iterator begin();

		iterator end();

		const_iterator cbegin() const;

		const_iterator cend() const;

        // construct and destroy

		vector();

		vector(int n, const T& value = T());

        template
        vector(InputIterator first, InputIterator last);

        vector(const vector& v);

        vector& operator= (vector v);

        ~vector();

        // capacity

        size_t size() const;

        size_t capacity() const;

        void reserve(size_t n);

        void resize(size_t n, const T& value = T());

        ///access///

        T& operator[](size_t pos);

        const T& operator[](size_t pos)const;

        ///modify/

        void push_back(const T& x);

        void pop_back();

        void swap(vector& v);

        iterator insert(iterator pos, const T& x);

        iterator erase(iterator pos);

        void output();
    private:

        iterator _start; // 指向数据块的开始

        iterator _finish; // 指向有效数据的尾

        iterator _endOfStorage; // 指向存储容量的尾

    };

}

三.vector的迭代器

1.T*和const  T*

对T*和const T*这两个原生态指针类型我们就可以将其看做迭代器类型(在存储空间连续的容器中大都如此),首先将这两个重命名方便我们后续的使用,并与c++系统的vector保持一致.

   typedef T* iterator;

   typedef const T* const_iterator;

2.begin()和end()

我们使用begin()函数会返回一个指向容器首元素的迭代器,而使用end()则会返回一个指向容器最后一个元素后一位的迭代器.(因为vector中的迭代器等同于原生态的指针,因此迭代器指向某个元素则意味着其存储着这个元素的地址)

        iterator begin() {
            return _start;
        }

        iterator end() {
            return _finish;
        }

3.cbegin()和cend()

这里的cbegin()和cend()和我们前面看到的begin()和end()相同,区别在于其返回值类型,前面的是普通类型,而这里返回的则是const类型,只允许访问,不能修改.

        const_iterator cbegin() const {
            return _start;
        }

        const_iterator cend() const {
            return _finish;
        }

注意:

我们使用迭代器进行容器的相关操作虽然很方便,但是必须要注意迭代器失效的问题,在后面我们会根据实例,对vector中的迭代器失效问题进行一一讲解.

四.vector构造函数

1.无参的构造函数

a.说明:

我们使用vector  a; 创建一个对象a时,编译器会调用其构造函数对该对象进行初始化,三个指针都指向同一块空间,此时空间中没有元素,因为我们要求的是_start指向第一个元素,_finish指向最后一个元素的后一位,而这里_start和_finish在同一个位置,那我们就认为容器中元素个数为0.(_endOfStorage指向空间的最后一位)

b.测试:

代码: lz::vector a1;

c.运行结果:

我们可以看到此时: a1中三个指针的值相同,说明其都指向同一块空间.

        vector()
            :_start(nullptr)
            ,_finish(nullptr)
            ,_endOfStorage(nullptr)
        {
            _start = new T[1];
            _finish = _start;
            _endOfStorage = _start;
        }

2.以n个value为成员的构造函数

a.说明: 

我们使用vector  a(5,1);这就意味着,我们创建了一个对象,该对象中有5个有效元素都为1,再来看代码,首先使用new申请一块空间按照n的长度来申请(多出来的一个空间用来存放_endOfStorage指针),意味着参数中我们传入的n也就是初始化对象时空间的大小.并用temp来接收这段空间的地址,然后就是让对象中的_start指向这段空间,使用循环来让value填充空间,我们可以看到填充的循环次数是n,这便验证我们所说的n为有效元素个数,value为填充元素的值. 最后再对_finish和_endOfStorage进行赋值即可.

b.测试:

vector  a(5,1);

c.运行结果:(output是我们自己实现的一个打印容器成员变量的函数)

 ​​​

        vector(int n, const T& value = T()) 
            :_start(nullptr)
            , _finish(nullptr)
            , _endOfStorage(nullptr)
        {
            iterator temp = new T[n+1];
            _start = temp;
            for (int i = 0; i < n; i++) {
                *temp = value;
                temp++;
            }
            _finish = _start + n;
            _endOfStorage = _finish;
        }

3.以区间来初始化对象的构造函数

a.说明:(连续或非连续的空间都可以)

我们在创建的时候传入参数为一段空间的前闭后开的区间,因为我们无法知道这段空间是以什么类型存在的,所以使用函数模板的方式进行定义,当该构造函数被调用的时候,first就会变成实际对应的类型了,再看代码---->第一个while循环我们遍历这个区间,计算出该区间总共有多少个元素,这样我们才能进行下面的空间的申请,申请好的空间直接用_start接收,然后再遍历空间将空间中的元素一一拷贝到我们的_start对应的空间中去. 最后在调整_finish和_endOfStorage的值即可.

b.测试:

int  array[ ] = {1,2,3,4,5,6,7,8,9};

vector  a(array, array+sizeof(array)/sizeof(array[0]));

c.运行结果:

        template
        vector(InputIterator first, InputIterator last) 
            :_start(nullptr)
            , _finish(nullptr)
            , _endOfStorage(nullptr)
        {
            int newsize = 0;
            while (last != first) {
                newsize++;
                last--;
            }
            _start = new T[newsize + 1];
            int i;
            for (i = 0; i < newsize; i++) {
                *(_start + i) = *first;
                first++;
            }
            _finish = _start + newsize;
            _endOfStorage = _start + newsize;
        }

4.拷贝构造函数

a.说明:

拷贝构造函数针对的是相同类型对象之间的拷贝,具体实现过程大致和前面相同, 申请空间----->拷贝元素----->设置_finish和_endOfStorage,要注意我们拷贝元素的这个循环针对的是v这个对象,将其中的元素使用循环拷贝到我们新申请的空间中. 另外一点与前面不同,因为该函数是拷贝构造函数,所以在执行算法前我们必须判断是不是自己给自己拷贝,如果不是再执行算法,如果是直接退出即可.

b.测试:

    int array[] = { 1,2,3,4,5,6,7,8,9 };
    lz::vector a1(array,array+sizeof(array)/sizeof(array[0]));
    lz::vector a(a1);
    a.output();

c.运行结果:

        vector(const vector& v) 
            :_start(nullptr)
            , _finish(nullptr)
            , _endOfStorage(nullptr)
        {
            if (this != &v) {
                iterator temp = new T[v.capacity() + 1];
                _start = temp;
                for (size_t i = 0; i < v.size(); i++) {
                    *temp = *(v._start + i);
                    temp++;
                }
                _finish = _start + v.size();
                _endOfStorage = _start + v.capacity();
            }
        }

5.赋值运算符重载

a.说明:

该函数的调用只针对于两个已经创建好的对象, 我们再来看该函数的参数,是以传值的方式进行传递的,因此说明调用该函数的时候,实参向形参的转换过程中已经调用拷贝构造函数创建了一个临时对象v,此时v中的元素和我们用来进行赋值的那个对象中的元素是相同的,因此只用将我们所要赋值的对象中_start,_finish,_endOfStorage,的值和v中的_start,_finish,_endOfStorage,的值进行交换即可,调用自身的swap函数就能进行交换,我们后续可以看见swap的实现方式.

b.测试:

    int array[] = { 1,2,3,4,5,6,7,8,9 };
    lz::vector a1(array,array+sizeof(array)/sizeof(array[0]));
    lz::vector a;
    a = a1;
    a.output();

c.运行结果:

        vector& operator= (vector v) {
            swap(v);
            return *this;
        }

6.析构函数

a.说明:

析构函数是在类对象生命周期结束时系统自动调用的, 因此我们需要在该函数中将类中申请的空间资源全部释放掉.

b.代码:

        ~vector() {
            if (_start != nullptr) {//释放掉我们申请的空间, 并让指针都指向空.
                delete[] _start;
                _start = nullptr;
                _finish = nullptr;
                _endOfStorage = nullptr;
            }
        }

五.vector的容量管理

1.返回有效元素个数.

a.说明:

该函数的作用就跟它的名字一样, 需要返回容器中有效元素的个数, 因为我们在容器内部申请的空间是连续的, 所以直接用_finish减去_start就能算出有效元素的个数.

b.测试:

    int array[] = { 1,2,3,4,5,6,7,8,9 };
    lz::vector a1(array,array+sizeof(array)/sizeof(array[0]));
    cout << a1.size() << endl;

c.运行结果:

 

        size_t size() const {
            return _finish - _start;
        }

2.返回容器的容量.

a.说明:

该函数跟上面的大致相同, 我们要返回容器的容量, 因为我们申请的空间是连续的, 所以使用__endOfStorage减去_start就能算出容器容量了.

b.测试:

    int array[] = { 1,2,3,4,5,6,7,8,9 };
    lz::vector a1(array,array+sizeof(array)/sizeof(array[0]));
    cout << a1.capacity() << endl;
 

c.运行结果:

 

        size_t capacity() const {
            return _endOfStorage - _start;
        }

3.对容器进行扩容

a.说明:

我们要创建一个函数, 来供使用者对容器空间进行扩容, 因为vector容器要进行扩容是比较耗费资源的, 要经过四步, 申请新空间, 拷贝元素, 使用新空间, 释放旧空间, 因此如果我们用户直接知道, 要使用的容器需要多大的容量的话, 可以直接使用该函数进行扩容, 也就避免了后续需要频繁扩容的现象发生了.

b.测试:

    int array[] = { 1,2,3,4,5,6,7,8,9 };
    lz::vector a1(array,array+sizeof(array)/sizeof(array[0]));
    cout << a1.capacity() << endl;
    a1.reserve(20);
    cout << a1.capacity() << endl;

c.运行结果:

 

代码说明:

首先我们要记录一下原先空间中元素的个数, 方便我们后续进行元素迁移, 然后判断我们所要扩容到的容量是否比当前的容器容量大, 如果没有的话则不用操作直接返回即可, 接着就是执行上面说到的四步操作, 1.申请新空间, 容量为n+1, 多加一个用来存放_endOfStorage指针, 2.使用循环将旧空间中的元素拷贝到新空间中, 这里之所以不使用memcpy是因为memcpy中进行的拷贝是浅拷贝, 而我们vector中的元素是自定义类型(其中有使用到空间资源)的话, 使用memcpy进行拷贝就会出错, 造成一个空间多个对象使用的现象, 因此我们使用循环和=进行元素迁移, 只要自定义类型的元素中有进行赋值运算符重载的话, 使用这种方式就可以进行元素的拷贝. 3.释放旧空间, 4.使用新空间, 并对_finish和_endOfStorage进行重新赋值.

        void reserve(size_t n) {
            int oldsize = size();
            if (n > capacity()) {
                iterator temp = new T[n + 1];
                //memcpy(temp, _start, sizeof(T) * oldsize);//注意: 无法用来创建二维数组
                if (_start != nullptr) {
                    int i;
                    for (i = 0; i < oldsize; i++) {
                        temp[i] = _start[i];
                    }
                    delete[] _start;                                                    
                }
                _start = temp;
                _finish = _start + oldsize;
                _endOfStorage = _start + n;
            }
        }

4.改变有效元素的个数

a.说明:

使用该函数可以改变数组中有效元素的个数, 如果要使有效元素的个数减少, 直接改变_finish的位置就行, 如果要使有效元素的个数增多, 则要考虑空间的容量问题, 还有新的有效元素的值, 因此我们在该函数的第二个位置, 传递的参数可以对新增的有效元素初始化.

b.测试:

    int array[] = { 1,2,3,4,5,6,7,8,9 };
    lz::vector a1(array,array+sizeof(array)/sizeof(array[0]));
    a1.resize(20, 1);
    a1.output();

c.运行结果:

 

代码说明:

首先判断新的有效元素的个数是增多了, 还是减少了, 如果是减少了, 直接将_finish向前移动就行, 如果是增多了, 先看是否需要扩容, 然后调用push_back()向容器中插入新的有效元素就行.

        void resize(size_t n, const T& value = T()) {
            if (n > size()) {
                if (n > capacity()) {
                    reserve(n);
                }
                int i, length = n - size();
                for (i = 0; i < length; i++) {
                    push_back(value);
                }
            }
            else {
                int i, length = size() - n;
                for (i = 0; i < length; i++) {
                    _finish--;
                }
            }
        }

六.vector中元素的访问.

1.以[ ]的方式访问容器当中的元素

a.说明:

因为容器当中的空间是连续的, 所以我们可以使用下标的方式访问容器当中的元素, 这里需要注意的就是at和[ ]的区别, 使用方式是一样的都是按下标进行访问, 区别在于访问出错的时候的处理方式不一样, at在访问出错时抛出异常, 而[ ]在访问出错的时候直接报错使程序崩溃.

b.测试:

    int array[] = { 1,2,3,4,5,6,7,8,9 };
    lz::vector a1(array,array+sizeof(array)/sizeof(array[0]));
    a1.resize(20, 1);
    for (int i = 0; i < a1.size(); i++) {
        cout << a1[i];
    }
    cout << endl;

c.运行结果:

 

代码说明:

判断传入的下标是否合法, 然后返回以空间的首地址加下标解引用即可, 这里给出了两种类型的分别为普通类型和const类型为了应对于各种情况.

        T& operator[](size_t pos) {//普通类型
            if (pos < 0 || pos >= size()) {
                assert(false);
            }
            return *(_start + pos);
        }

        const T& operator[](size_t pos)const {//const类型
            if (pos < 0 || pos >= size()) {
                assert(false);
            }
            return *(_start + pos);
        }

七.vector中元素的修改

1.尾插和尾删

a.说明:

在平时使用数组的时候, 总会有这种在数组尾部插入元素, 删除元素的操作, 因此c++在实现vector时也增加这两种功能方便用户使用, 在这里直接调用insert和erase两个函数, 后面会对这两个函数进行实现讲解.

b.测试:

    int array[] = { 1,2,3,4,5,6,7,8,9 };
    lz::vector a1(array,array+sizeof(array)/sizeof(array[0]));
    a1.push_back(11);
    a1.output();
    a1.pop_back();
    a1.output();

c.运行结果:

 

        void push_back(const T& x) {
            insert(_finish, x);
        }

        void pop_back() {
            erase(_finish - 1);
        }

2.自定义的swap

a.说明:

这里的swap是针对于vector对象的, 用于交换两个vector对象中的元素, 既然要交换那我们先来看对象中都有哪些元素, _start,_finish,_endOfStorage,这三个指针, 因此我们只用将两个对象中各自指针的内容交换即可.

b.测试:

    int array_1[] = { 1,2,3,4,5,6,7,8,9 };
    int array_2[] = { 1,1,1,1,1,1,1,1,1,1,1 };
    lz::vector a1(array_1,array_1+sizeof(array_1)/sizeof(array_1[0]));
    lz::vector a2(array_2, array_2 + sizeof(array_2) / sizeof(array_2[0]));
    a1.swap(a2);
    a1.output();
    a2.output();

c.运行结果:

        void swap(vector& v) {
            std::swap(_start, v._start);
            std::swap(_finish, v._finish);
            std::swap(_endOfStorage, v._endOfStorage);
        }

3.任意位置的元素插入

a.说明:

我们可以使用insert函数, 在容器中的任意位置插入元素, 那么如何传递位置呢? 我们使用迭代器的方式传递位置, 并在该迭代器所指向的位置, 插入元素, 要注意的是, insert函数中应对传入位置的合法性进行判断, 另外因为容器底层使用的空间是连续的, 因此不论在那个位置插入元素, 该位置后的所有元素都需要后移一位, 以供新元素的插入.

b.测试:

    int array_1[] = { 1,2,3,4,5,6,7,8,9 };
    lz::vector a1(array_1,array_1+sizeof(array_1)/sizeof(array_1[0]));
    auto i = a1.begin();
    i = a1.insert(i + 2, 11);
    i = a1.insert(i, 12);
    a1.insert(i, 13);
    a1.output();

c.运行结果:

 

代码说明:

第一步判断传入位置的合法性, 不合法直接报错, 然后是对容器的容量进行判断, 判断该空间是否还能插入新元素, 是否需要扩容, 然后就是把该插入位置之后的元素全部后移一位, 然后在该位置插入新元素, 最后再修改_finish的位置, 这里之所以返回值为terator类型, 是因为在元素个数改变的情况下有迭代器失效的问题, 我们需要返回一个新的迭代器来供用户使用. (关于vector中迭代器失效的问题在最后会进行详细讲解)

        iterator insert(iterator pos, const T& x) {
            if (pos >= _start && pos <= _finish) {
                if (size() + 1 > capacity()) {
                    int newsize = pos - _start;
                    reserve(capacity() * 2 + 1);
                    pos = _start + newsize;
                }
                iterator i = end();
                while (i > pos) {
                    *i = *(i - 1);
                    i--;
                }
                *pos = x;
                _finish++;
            }
            else {
                assert(false);
            }
            return pos;
        }

4.任意位置元素的删除

a.说明:

和上面任意位置元素的插入相似, 需要注意传入位置的合法性, 还有就是因为使用的是连续空间的原因, 我们需要将要删除位置后的所有元素全部向前移一位.

b.测试:

    int array_1[] = { 1,2,3,4,5,6,7,8,9 };
    lz::vector a1(array_1,array_1+sizeof(array_1)/sizeof(array_1[0]));
    auto i = a1.begin();
    i = a1.erase(i + 2);
    i = a1.erase(i);
    a1.erase(i);
    a1.output();

c.运行结果:

 

代码说明:

第一步判断传入位置的合法性, 如果不合法直接报错, 合法则将该位置后的所有元素全部向前移一位, 最后再更改_finish的值即可, 这里之所以以iterator为返回值类型, 是因为在涉及元素数量改变的操作中, 可能会出现迭代器失效的问题, 所以我们需要返回一个新的迭代器供用户使用.(关于vector中迭代器失效的问题在最后会进行详细讲解)

        iterator erase(iterator pos) {
            if (pos >= _start && pos < _finish) {
                iterator i = pos;
                while (i < end() - 1) {
                    *i = *(i + 1);
                    i++;
                }
                _finish--;
            }
            else {
                assert(false);
            }
            return pos;
        }

八.vector中的迭代器失效问题

1.什么是迭代器失效?

迭代器的主要作用就是让算法能够不用关心底层数据结构, 其底层实际就是一个指针, 或者是对指针进行了封装, 比如:  vector的迭代器就是原生态指针T*. 因此迭代器失效, 实际就是迭代器底层对应指针所指向的空间被销毁了, 而使用一块已经被释放的空间, 造成的后果是程序崩溃(即如果继续使用已经失效的迭代器, 程序可能会崩溃).

2.对于vector可能会导致其迭代器失效的操作有

①. 会引起其底层空间改变的操作, 都有可能是迭代器失效, 比如:  resize、reserve、insert、assign、push_back等.

出错原因:

以上操作, 都有可能会导致vector扩容, 也就是说vector底层原来旧空间被释放掉, 而在打印时, it还使用的是释放之间的旧空间, 在对it迭代器操作时, 实际操作的是一块已经被释放的空间, 而引起代码运行时崩溃.

②. 指定位置元素的删除操作--erase.

出错原因:

erase删除pos位置元素后, pos位置之后的元素会往前搬移, 没有导致底层空间的改变, 理论上讲迭代器不应该会失效, 但是: 如果pos刚好是最后一个元素, 删完之后pos刚好是end的位置, 而end位置是没有元素的, 那么pos就失效了. 因此删除vector中任意位置上元素时, vs就认为该位置迭代器失效了.(vector的删除操作不光会导致指向被删除元素的迭代器失效，删除元素后面的迭代器也会失效)

③. 当我们使用swap时也有可能会导致迭代器失效.

出错原因:

当我们创建两个vector对象时, 分别创建两个对象的begin()迭代器it_1,it_2, 我们使用swap对两个对象进行交换,交换完之后,it_1指向第二个对象, it_2指向第一个对象,这时如果你再使用it_1去操作第一个对象或者使用it_2去操作第二个对象就会发生错误.

迭代器失效的解决办法?

在使用前, 对迭代器重新赋值即可.

3.扩展

使用vector创建二维数组.

注意我们使用的vector是一个模板类,因此要想使用必须先将其实例化,那么我们如果使用一个已经实例化过的vector 来作为这个vector的实例化类型,那么最终创建出来的那个实例化对象就是一个动态的线性表,表中的每一个元素都是vector类型的成员,此时二维数组就创建好了.