STL-vector的使用 详细说明

vector

vector是一个动态数组，是基本数组的类模板，内部定义了很多接口。
现在我创建一个vector对象
首先需要包头文件：

#include "Vector"
std::list<int> v1;

例如这个例子，我实例化出了一个对象。

接下来我参考cpulscpuls.com，介绍接口的用法：

一.数据操作：

1.assign:

    ①：void assign (size_type n, const value_type& val);

    ②：template <class InputIterator>
       void assign (InputIterator first, InputIterator last);

①：

    std::vector<int> first;
    first.assign(7, 100);

则此时first里就会有7个100。

②：

    std::vector<int> first;
    std::vector<int> second;
    first.assign(7, 100);//first里有7个100
    std::vector<int>::iterator it = first.begin() + 1;//迭代器it指在first的第二个100
    second.assign(it, first.end() - 1); //区间是it到first的最后一个（左闭右开）

则此时second里有5个100。

    std::vector<int> third;
    int myints[] = { 1776, 7, 4 };//数组里存1776 7 4
    third.assign(myints, myints + 3);那么现在third里就会存这三个数

2.push_back：尾插

void push_back (const value_type& val);

void push_back (const value_type& val);
    std::vector<int> first;
    first.push_back(1);
    first.push_back(2);
    first.push_back(3);
    first.push_back(4);

那么通过尾插，现在first里就会有1 2 3 4四个数据。

3.pop_back：尾删

void pop_back();

比较容易，就是直接删除尾上的数据。

4.insert：

①： iterator insert (iterator position, const value_type& val);  
②： void insert (iterator position, size_type n, const value_type& val); 
③： template <class InputIterator>
    void insert (iterator position, InputIterator first, InputIterator last);

①：

`   std::vector<int> myvector(3, 100);//myvector里有3个100
    std::vector<int>::iterator it = myvector.begin();//迭代器it等于第一个数据
    it = myvector.insert(it, 200);`//在it前插入200并返回迭代器

现在myvector里存的是200 100 100 100
②：

    myvector.insert(it, 2, 300);//在it前插入2个300，可以指定数量

那么现在myvector里就有300 300 200 100 100 100
③：

    it = myvector.begin();//300 300 200 100 100 100

    std::vector<int> anothervector(2, 400);//anothervector里存了2个400
    myvector.insert(it + 2, anothervector.begin(), anothervector.end());
    //从it+2开始存指定的区间（以anothervector的begin开始，到end结束的区间）

那么myvector现在存了300 300 400 400 200 100 100 100

5.erase:注意，删完数据返回下一个

①：iterator erase (iterator position);
②：iterator erase (iterator first, iterator last);

①：

    std::vector<int> myvector;
    for (int i = 1; i <= 10; i++)
    {
        myvector.push_back(i);
    }//此时myvector里存有 1 2 3 4 5 6 7 8 9 10
    myvector.erase(myvector.begin() + 5);//删除第六个

此时myvector里存有 1 2 3 4 5 7 8 9 10（6已经删除）
②：

    myvector.erase(myvector.begin(), myvector.begin() + 3);
    //删除了从myvector的begin开始到begin+3的区间

此时myvector里存有4 5 7 8 9 10。
6.swap:交换

void swap (vector& x);

    std::vector<int> v1(5, 10)//;10 10 10 10 10
    std::vector<int> v2(6,6);//6 6 6 6 6 6
    v1.swap(v2);

交换完后，v1: 6 6 6 6 6 6
v2:10 10 10 10 10
7.clear:

void clear();

    std::vector<int> v1(5, 10);//10 10 10 10 10
    v1.clear();

清空后，v1里不存数据。

二：迭代器：

1.begin和end:返回迭代器的开始，结束

首先我需要介绍一下迭代器，先来看用法：

    std::vector<int> v1(5,10);//10 10 10 10 10
    std::vector<int>::iterator it = v1.begin();//it现在指向了第一个数据10

所谓迭代器，它就是一个类，可以理解它为指针，可以进行解引用，->，++，–，等操作，比如上面的例子，可以理解为it指向了v1的第一个数据，可以让代码更灵活。

iterator begin();
const_iterator begin() const;

iterator end();
const_iterator end() const;

    std::vector<int> myvector;
    for (int i = 1; i <= 5; i++)
    {
        myvector.push_back(i);
    }//此时myvector里存有1 2 3 4 5

    //迭代器it从开始一直到结束
    for (std::vector<int>::iterator it = myvector.begin(); it != myvector.end(); ++it)
    {
        std::cout << ' ' << *it;
    }
    std::cout << endl;

输出1 2 3 4 5

2.rbegin和rend：返回反向迭代器的开始，结束
所谓反向迭代器，只是和普通迭代器的方向不同。

reverse_iterator rbegin();
const_reverse_iterator rbegin() const;

reverse_iterator rend();
const_reverse_iterator rend() const;

    std::vector<int> myvector(5);//0 0 0 0 0
    int i = 0;

    std::vector<int>::reverse_iterator rit = myvector.rbegin();//反向迭代器，等于myvector的rbegin（也就是end）
    for (; rit != myvector.rend(); ++rit)
    {
        *rit = ++i;//那么会从最后依次赋值分别为5 4 3 2 1
    }

可以看到，begin/end,rbegin/rend都分别有一个重载的const成员函数，this指针被const修饰，表示指向的内容是常量，所以当const对象调用begin/end,rbegin/rend这些函数时，会调到重载的const成员函数，返回的也是const迭代器。

三：容量

1.size:

size_type size() const;//const成员函数

    std::vector<int> myints;
    std::cout << "0. size: " << myints.size() << endl;//此时myints无数据，调用size()

    for (int i = 0; i < 5; i++)
    {
        myints.push_back(i);
    }
    std::cout << "1. size: " << myints.size() << endl;//1 2 3 4 5再次调用size()

输出：0. size: 0
1. size: 5

2.max_size：

size_type max_size() const

    std::vector<char> myvector0;
    std::cout << "max_size: " << myvector0.max_size() << endl;

    std::vector<int> myvector;
    std::cout << "max_size: " << myvector.max_size() << endl;

    std::vector<double> myvector1;
    std::cout << "max_size: " << myvector1.max_size() << endl;

不同类型创建的对象分别调用max_size,分别输出为：
char: 4294967295
int: 1073741823
double: 536870911
max_size返回的是整形最大值4294967295除以类型的大小。
3.resize:
resize是改变size的函数，并且还具有初始化的能力：

void resize (size_type n, value_type val = value_type());

    std::vector<int> myvector;

    for (int i = 1; i<10; i++) myvector.push_back(i);//1 2 3 4 5 6 7 8 9

    myvector.resize(5);//1 2 3 4 5
    myvector.resize(8, 100);//1 2 3 4 5 100 100 100
    myvector.resize(12);//1 2 3 4 5 100 100 100 0 0 0 0

.当n<size，直接删除后面的数据
.当n>size,多出来的值会初始化：
    （1）：当写死了类型的值val，那么就会补val
    （2）：若没有写，那么就调用该类型默认构造函数补。

4.capacity:返回容量

size_type capacity() const

    std::vector<int> myvector;
    for (int i = 0; i < 100; i++)
    {
        myvector.push_back(i);//此时插入了100个数据，size应该是100
    }
    std::cout << "capacity: " << (int)myvector.capacity() << '\n';

输出:capacity: 141

5.empty：判断是否为空，为空返回1，不为空返回0

bool empty() const;

    std::vector<int> myvector;
    cout << myvector.empty() << endl;//输出1
    myvector.push_back(1);
    cout << myvector.empty() << endl;//输出0

6.reserve：改变容量

void reserve (size_type n);

    std::vector<int> myvector;
    cout << myvector.capacity() << endl;//0
    myvector.reserve(100);//将容量变为100
    cout << myvector.capacity() << endl;//100

四：元素访问

1.operator[]：返回指向vector容器中n位置的元素的引用。

reference operator[] (size_type n);

const_reference operator[] (size_type n) const;//重载

    std::vector<int> myvector(10); //0 0 0 0 0 0 0 0 0 0
    std::vector<int>::size_type sz = myvector.size();//sz == 10;
    for (unsigned i = 0; i<sz; i++)
    {
        myvector[i] = i;//依次取
    }

那么现在myvector里存有0 1 2 3 4 5 6 7 8 9
2.at:返回位置n中的元素的引用。

reference at (size_type n);
const_reference at (size_type n) const;

    std::vector<int> myvector(10);//10个0
    for (unsigned i = 0; i < myvector.size(); i++)
    {
        myvector.at(i) = i;//依次赋值

    }

此时：myvector里存有0 1 2 3 4 5 6 7 8 9
3.front和back：
front：对vector容器中第一个元素的引用。如果vector对象是const，函数返回一个const_reference。否则，它返回一个引用
back：对向量中最后一个元素的引用。如果vector对象是const，函数返回一个const_reference。否则，它返回一个引用。

reference front();
const_reference front() const;

reference back();
const_reference back() const;

    std::vector<int> myvector;
    myvector.push_back(78);
    myvector.push_back(16);//78 16
    std::cout << "myvector.front() is now " << myvector.front() << '\n';//此时front()是78
    std::cout << "myvector.back()  is now " << myvector.front() << '\n';//此时back()是16

    myvector.front() -= myvector.back();
    std::cout << "myvector.front() is now " << myvector.front() << '\n';

输出:
myvector.front() is now 78
myvector.back() is now 16
myvector.front() is now 62