C++_vector

2019-09-25 0 条评论 60 次阅读 0 人点赞

vector文档

  1. vector是表示可变大小数组的序列容器。

  2. 就像数组一样,vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问,和数组一样高效。但是又不像数组,它的大小是可以动态改变的,而且它的大小会被容器自动处理。

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

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

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

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

1. vector接口

1.1 构造函数

(constructor)构造函数声明 接口说明
vector() (重点) 无参构造
vector(size_type n, const value_type& val = value_type()) 构造并初始化n个val
vector (const vector& x); (重点) 拷贝构造
vector (InputIterator first, InputIterator last); 使用迭代器进行初始化构造

1.2 vector iterator

iterator的使用 接口说明
begin + end(重点) 获取第一个数据位置的iterator/const_iterator, 获取最后一个数据的下一个位置 的iterator/const_iterator
rbegin + rend 获取最后一个数据位置的reverse_iterator,获取第一个数据前一个位置的 reverse_iterator

1.3 vector 空间相关

容量空间 接口说明
size 获取数据个数
capacity 获取容量大小
empty 判断是否为空
resize(重点) 改变vector的size
reserve (重点) 改变vector放入capacity
  • capacity的代码在vs和g++下分别运行会发现,vs下capacity是按1.5倍增长的,g++是按2倍增长的。不要固化的认为,顺序表增容都是2倍,具体增长多少是根据具体的需求定义的。vs是PJ版本STL,g++是SGI版本STL。
  • reserve只负责开辟空间,如果确定知道需要用多少空间,reserve可以缓解vector增容的代价缺陷问题。
  • resize在开空间的同时还会进行初始化,影响size。

1.4 增删查改

vector增删查改 接口说明
push_back(重点) 尾插
pop_back (重点) 尾删
find 查找(注意这个是算法模块实现,不是vector的成员接口
insert 在position之前插入val
erase 删除position位置的数据
swap 交换两个vector的数据空间
operator[] (重点) 像数组一样访问vector中的元素

1.5 迭代器失效问题

// insert/erase导致的迭代器失效
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

int main(){
    int a[] = { 1, 2, 3, 4 };
    vector<int> v(a, a + sizeof(a) / sizeof(int));

    // 使用find查找3所在位置的iterator
    vector<int>::iterator pos = find(v.begin(), v.end(), 3);

    // 删除pos位置的数据,导致pos迭代器失效。
    v.erase(pos);
    cout << *pos << endl; // 此处会导致非法访问

    // 在pos位置插入数据,导致pos迭代器失效。
    // insert会导致迭代器失效,是因为insert可
    // 能会导致增容,增容后pos还指向原来的空间,而原来的空间已经释放了。
    pos = find(v.begin(), v.end(), 3);
    v.insert(pos, 30);
    cout << *pos << endl; // 此处会导致非法访问

    return 0;
}

// 常见的迭代器失效的场景
int main1(){
    int a[] = { 1, 2, 3, 4 };
    vector<int> v(a, a + sizeof(a) / sizeof(int));
    // 实现删除v中的所有偶数
    // 下面的程序会崩溃掉,如果是偶数,erase导致it失效
    // 对失效的迭代器进行++it,会导致程序崩溃
    vector<int>::iterator it = v.begin();
    while (it != v.end()){
        if (*it % 2 == 0)
        v.erase(it);

        ++it;
    }

// 以上程序要改成下面这样,erase会返回删除位置的下一个位置
    vector<int>::iterator it = v.begin();
    while (it != v.end()){
        if (*it % 2 == 0)
            it = v.erase(it);
        else
            ++it;
    }

    return 0;
}

2. 模拟实现vector

#ifndef CPLUSPLUS_MYVECTOR_H
#define CPLUSPLUS_MYVECTOR_H

#include <iostream>
#include <iterator>

namespace km {
    template<class T>
    class Vector {
        T *m_start;
        T *m_finish;
        T *m_endOfStorage;
    public:
        typedef T *iterator;
        typedef const T *const_iterator;

        Vector():
        m_start(nullptr),
        m_finish(nullptr),
        m_endOfStorage(nullptr){
        }

        Vector(int n, const T &val = T()):
                m_start(nullptr),
                m_finish(nullptr),
                m_endOfStorage(nullptr){
            Reserve(n);

            for (int i = 0; i < n; i++) {
                m_start[i] = val;
            }
            m_finish = m_start + n;
        }

        Vector(T* start, T* end):
                m_start(nullptr),
                m_finish(nullptr),
                m_endOfStorage(nullptr){
            int _size = end - start;
            Reserve(_size);

            for (int i = 0; i < _size; ++i) {
                m_start[i] = start[i];
            }
            m_finish = m_start + _size;
        }

        iterator Begin(){
            return m_start;
        }

        iterator End(){
            return m_finish;
        }

        size_t Size(){
            return m_finish - m_start;
        }

        size_t Capacity(){
            return m_endOfStorage - m_start;
        }

        // 实现[]访问元素操作
        T& operator[](int i){
            return m_start[i];
        }

        const T& operator[](int i)const{
            return m_start[i];
        }

        void Reserve(size_t _size){
           int _capacity = Capacity();
           if(_capacity < _size){
               if(_capacity == 0){
                   _capacity = 1;
               }
               while(_capacity < _size){
                   _size *= 2;
               }
           }

           T* tmp = new T[_capacity];
           m_endOfStorage = tmp + _capacity;
           int oldSize = Size();// 出错更改位置
           m_finish = tmp + oldSize;
           if(m_start != nullptr){
               for(int i = 0; i < oldSize; i++){
                   tmp[i] = m_start[i];
               }
               delete[] m_start;
           }
           m_start = tmp;
        }

        void Resize(size_t _size, const T &val = T()){
            Reserve(_size);// 增容

            for(int i = Size(); i < _size; i++){
                m_start[i] = val;
            }
            m_finish = m_start + _size;// 填元素
        }

        iterator Insert(iterator pos, const T& val ){
            int tmp = pos - m_start;
            Reserve(Size() + 1);
            pos = m_start + tmp;

            int i;
            for(i = Size() - 1; i >= pos - m_start; i--){
                m_start[i + 1] = m_start[i];// 平移覆盖值
            }
            *pos = val;
            m_finish++;
            return pos;
        }
        iterator Insert(iterator pos, int n, const T& val ){
            int tmp = pos - m_start;
            Reserve(Size() + n);
            pos = m_start + tmp;

            int i;
            for(i = Size() - 1; i >= pos - m_start; i--){
                m_start[i + n] = m_start[i];
            }
            for(i = 0; i < n; i++){
                pos[i] = val;
            }
            m_finish += n;
            return pos;
        }

        iterator Insert(iterator pos, const T* start, const T* end){
            int tmp = pos - m_start;
            int exitSize = (end - start);
            Reserve(Size() + exitSize);
            pos = m_start + tmp;

            int i;
            for(i = Size() - 1; i >= pos - m_start; i--){
                m_start[i + exitSize] = m_start[i];
            }
            for(i = 0; i < exitSize; i++){
                pos[i] = start[i];
            }
            m_finish += exitSize;
            return pos;
        }

        iterator Erase(iterator pos){
            int i;
            for(i = pos - m_start; i < Size(); i++){
                m_start[i] = m_start[i + 1];
            }
            m_finish--;
            return pos;
        }

        iterator Erase(iterator start, iterator end){
            int i;
            int exitSize = end - start;

            for(i = start - m_start; i < Size() - exitSize; i++){
                m_start[i] = m_start[i + exitSize];
            }
            m_finish -= exitSize;
            return start;
        }

        void Push_back(const T &val){
            Reserve(Size() + 1);
            *m_finish = val;
            m_finish++;
        }

        void Pop_back(){
            m_finish--;
        }
    };
}

#endif //CPLUSPLUS_MYVECTOR_H

L_KingMing

这个人太懒什么东西都没留下

文章评论(0)