C++STL容器之vector

类型:序列式容器

底层数据结构:数组array

查询速度:O(1), 随机存取,常数时间

插入速度:O(n)

能否扩容:能

扩容方式:定义时在堆上申请一定大小内存空间, 当容器未满时, ,插入和删除不会申请空间和释放空间, 当容器已满时, 会申请当前容器容量两倍的内存空间作为,将原容器内存拷贝到新容器中 导致容器和元素地址发生改变, 对vector的操作如果引起空间重新配置, 指向该vector的所有容器都会失效

适用情形: 保存需要频繁进行访问的内容但是不经常在除尾部外的其他位置插入或删除新元素

特别的该容器重载了[]运算符

 

C++对vector的部分接口支持:

C++对vector的部分接口支持
1 vector();
默认构造函数, 创建一个长度为0的向量
2 vector(const T &V);
复制构造函数, 创建一个V的副本
3 vector(size_type n, const T &val = T());
构造函数, 创建一个长度为n的向量, 每一个元素初始化为val
4 vector(size_type n, const T &val = T());
构造函数, 创建一个长度为n的向量, 每一个元素初始化为val
5 ~vector();
析构函数, 释放向量的动态内存
6 reference at(int i);
如果i是有效索引, 返回第i个元素的引用, 否则报错
7 reference back();
返回向量中的最后一个元素的引用
8 iterator begin();
返回向量中第一个元素的迭代
9 void clear();
删除向量的所有元素
10 bool empty() cosnt;
如果向量中没有元素, 返回true, 否则返回false
11 iterator end();
返回向量最后一个元素的迭代, 不指向任何有实际意义的元素, 只作为没有下一个元素的标志
12iterator erase(iterator pos);
删除向量中pos位置的元素, 返回指向被删除的元素后面的元素的迭代器, 如果被删除的元素是尾元素,
则返回指向尾后元素的迭代器, 等同于iterator end();的返回值
13 reference front();
返回向量中的第一个元素的引用
14 iterator insert(iterator pos, const T &V = T());
在向量pos位置插入val的副本, 返回插入位置的迭代器
15vector<T> &operator=(const vector<T> &V);
把V值赋值给向量, 返回修改后的向量
16 reference operator[](size_type i);
返回向量第i个元素的引用
17void pop_back();
删除向量的最后一个元素
18void push_back(const T &val);
在向量的最后一个元素之后插入val副本
19 reverse_iterator rBegin();
返回向量中反向第一个元素的迭代, 指向正向第一个元素
20 reverse_iterator rend();
返回向量中反向最后一个元素(无效元素, 不能通过*访问元素, 只作为遍历完容器的标志用)的迭代, 指向正向最后一个元素
21 size_type size() const;
返回向量中的元素个数
22 void swap(vector<T> &V);
当前向量与向量V交换
23 void resize(size_type s, T val=T());
重置向量长度, 若s小于当前长度, 释放多出部分的内存, 若s 大于当前长度, 以第二个参数构造元素值并插入到向量中(缺多少插入多少

 

代码示例:

#include <iostream>
#include <vector>
using namespace std;

//声明一个编译vector<char>的函数
void transverVec(std::vector<char>::iterator &itC1, std::vector<char> &v5); 

//C++对vector的部分接口支持
//1 vector();
//默认构造函数, 创建一个长度为0的向量
//2 vector(const T &V);
//复制构造函数, 创建一个V的副本
//3 vector(size_type n, const T &val = T());
//构造函数, 创建一个长度为n的向量, 每一个元素初始化为val
//4 vector(size_type n, const T &val = T());
//构造函数, 创建一个长度为n的向量, 每一个元素初始化为val
//5 ~vector();
//析构函数, 释放向量的动态内存
//6 reference at(int i);
//如果i是有效索引, 返回第i个元素的引用, 否则报错
//7 reference back();
//返回向量中的最后一个元素的引用
//8 iterator begin();
//返回向量中第一个元素的迭代
//9 void clear();
//删除向量的所有元素
//10 bool empty() cosnt;
//如果向量中没有元素, 返回true, 否则返回false
//11 iterator end();
//返回向量最后一个元素的迭代, 不指向任何有实际意义的元素, 只作为没有下一个元素的标志
//12iterator erase(iterator pos);
//删除向量中pos位置的元素, 返回指向被删除的元素后面的元素的迭代器, 如果被删除的元素是尾元素,
//则返回指向尾后元素的迭代器, 等同于iterator end();的返回值
//13 reference front();
//返回向量中的第一个元素的引用
//14 iterator insert(iterator pos, const T &V = T());
//在向量pos位置插入val的副本, 返回插入位置的迭代器
//15vector<T> &operator=(const vector<T> &V);
//把V值赋值给向量, 返回修改后的向量
//16 reference operator[](size_type i);
//返回向量第i个元素的引用
//17void pop_back();
//删除向量的最后一个元素
//18void push_back(const T &val);
//在向量的最后一个元素之后插入val副本
//19 reverse_iterator rBegin();
//返回向量中反向第一个元素的迭代, 指向正向第一个元素
//20 reverse_iterator rend();
//返回向量中反向最后一个元素(无效元素, 不能通过*访问元素, 只作为遍历完容器的标志用)的迭代, 指向正向最后一个元素
//21 size_type size() const;
//返回向量中的元素个数
//22 void swap(vector<T> &V);
//当前向量与向量V交换
//23 void resize(size_type s, T val=T());
//重置向量长度, 若s小于当前长度, 释放多出部分的内存, 若s 大于当前长度, 以第二个参数构造元素值并插入到向量中(缺多少插入多少

class A60
{
public:
    ~A60()
    {
        cout << "~A60()" << endl;
    }
};

int main()
{
    //vector();
    //默认构造函数, 创建一个长度为0的向量
    vector<int> v1;

    //vector(const T &V);
    //复制构造函数, 创建一个V的副本
    vector<int> v2(v1);

    //vector(size_type n, const T &val = T());
    //构造函数, 创建一个长度为n的向量, 每一个元素初始化为val
    vector<A60> v3(10, A60());

    //~vector();
    //析构函数, 释放向量的动态内存
    v3.~vector();
    

    //reference at(int i);
    //如果i是有效索引, 返回第i个元素的引用, 否则报错
    vector<int> v4(5, 2);
    //v4: 2 2 2 2 2
    cout << v4.at(3) << endl;
    //2
    int &tempI1 = v4.at(3);
    tempI1 = 4;
    //v4: 2 2 2 4 2
    cout << v4.at(3) << endl;
    //4

    //reference back();
    //返回向量中的最后一个元素的引用
    int &tempI2 = v4.back();
    tempI2 = 8;
    //v4: 2 2 2 4 8
    cout << v4.at(4) << endl;
    // 8

    //iterator begin();
    //返回向量中第一个元素的迭代
    vector<int>::iterator itI1 = v4.begin();
    cout << *itI1 << endl;
    //2
    itI1++;
    *itI1 = 1;
    //v4: 2 1 2 4 8
    cout << v4.at(1) << endl;
    //1

    //void clear();
    //删除向量的所有元素
    v4.clear();
    //v4:

    //bool empty() cosnt;
    //如果向量中没有元素, 返回true, 否则返回false
    cout << (v4.empty() ? "true" : "false") << endl;
    //true

    //iterator end();
    //返回向量最后一个元素的迭代, 不指向任何有实际意义的元素, 只作为没有下一个元素的标志
    vector<char> v5(10, 'a');
    //v5:"aaaaaaaaaa"
    vector<char>::iterator itC1 = v5.end();
    *(--itC1) = 'b';
    //v5:"aaaaaaaaab"
    cout << v5.at(9) << endl;
    //b

    //iterator erase(iterator pos);
    //删除向量中pos位置的元素, 返回指向被删除的元素后面的元素的迭代器, 如果被删除的元素是尾元素,
    //则返回指向尾后元素的迭代器, 等同于iterator end();的返回值
    int i = 0;
    for (itC1 = v5.begin(); itC1 != v5.end(); itC1++)
    {
        *itC1 = 'a' + i;
        i++;
    }
    transverVec(itC1, v5);
    //abcdefghij
    //v5:"abcdefghij"
    vector<char>::iterator itC2 = ++v5.begin();
    cout << *itC2 << endl;
    //b
    vector<char>::iterator itC3 = v5.erase(itC2);
    //v5:"acdefghij"
    cout << *itC3 << endl;
    //c
    transverVec(itC2, v5);
    //acdefghij
    cout << v5.at(1) << endl;
    //c
    cout << *++v5.begin() << endl;
    //c
    itC3 = v5.end();
    itC3--;
    itC2 = v5.erase(itC3);
    ////v5:"acdefghi"
    if (itC2 == v5.end())
    {
        cout << "delete the last element, the function 'erase' return vector.end() " << endl;
    }
    //delete the last element, the function 'erase' return vector.end() 

    //reference front();
    //返回向量中的第一个元素的引用
    v5.front() = 'b';
    //v5:"bcdefghi"
    transverVec(itC1, v5);
    //bcdefghi


    //iterator insert(iterator pos, const T &V = T());
    //在向量pos位置插入val的副本, 返回插入位置的迭代器
    itC1 = v5.begin();
    itC1 = v5.insert(itC1, 'z');
    //v5:"zbcdefghi"
    transverVec(itC2, v5);
    //zbcdefghi
    cout << *itC1 << endl;
    //z
    //vector<T> &operator=(const vector<T> &V);
    //把V值赋值给向量, 返回修改后的向量
    vector<char> v6(5, 'z');
    transverVec(itC2, v6);
    //v6:"zzzzz"
    v6 = v5;
    transverVec(itC1, v6);
    //v6:"zbcdefghi"

    //reference operator[](size_type i);
    //返回向量第i个元素的引用
    char &c = v6[3];
    cout << c << endl;
    //d
    c = 'y';
    //v6:"zbcyefghi"
    transverVec(itC1, v6);
    //zbcyefghi

    //void pop_back();
    //删除向量的最后一个元素
    v6.pop_back();
    //v6:"zbcyefgh"
    v6.pop_back();
    //v6:"zbcyefg"
    transverVec(itC1, v6);
    //zbcyefg

    //void push_back(const T &val);
    //在向量的最后一个元素之后插入val副本
    v6.push_back('*');
    //v6:"zbcyefg*"
    v6.push_back('*');
    //v6:"zbcyefg**"
    transverVec(itC1, v6);
    //zbcyefg**

    //reverse_iterator rBegin();
    //返回向量中反向第一个元素的迭代, 指向正向第一个元素
    //reverse_iterator rend();
    //返回向量中反向最后一个元素(无效元素, 不能通过*访问元素, 只作为遍历完容器的标志用)的迭代, 指向正向最后一个元素
    vector<char>::reverse_iterator itC4 = v6.rbegin();
    cout << *itC4 << endl;
    //*
    while (itC4 != v6.rend())
    {
        cout << *itC4 ;
        itC4++;
    }
    cout << endl;
    //**gfeycbz

    //size_type size() const;
    //返回向量中的元素个数
    cout << "size of v6 is " << v6.size() << endl;

    //void swap(vector<T> &V);
    //当前向量与向量V交换
    cout << "before swap, v5 is ";
    transverVec(itC1, v5);
    cout << "v6 is ";
    transverVec(itC1, v6);
    v6.swap(v5);
    cout << "after swap ,v5 is ";
    transverVec(itC1, v5);
    cout << "v6 is ";
    transverVec(itC1, v6);

    //void resize(size_type s, T val=T());
    //重置向量长度, 若s小于当前长度, 释放多出部分的内存, 若s 大于当前长度, 以第二个参数构造元素值并插入到向量中(缺多少插入多少
    v6.resize(5);
    transverVec(itC1, v6);
    v6.resize(6, 'z');
    transverVec(itC1, v6);
    //v6:"zbcdez"
    v6.resize(8,'?');
    transverVec(itC1, v6);


    system("pause");
}

void transverVec(std::vector<char>::iterator &itC1, std::vector<char> &v5)
{
    for (itC1 = v5.begin(); itC1 != v5.end(); itC1++)
    {
        cout << *itC1;
    }
    cout << endl;
}