C++ 学习笔记之——STL 库 vector

vector 是一种顺序容器，可以看作是可以改变大小的数组。

就像数组一样，vector 占用连续的内存地址来存储元素，因此可以像数组一样用偏移量来随机访问，但是它的大小可以动态改变，容器会自动处理内存分配问题。

在内部，vector 使用动态分配的数组来存储元素，当新元素插入时，如果现有的存储空间已经占满，则需要重新再分配一个新的数组，并且将之前的元素都移动到新的内存上。这个过程是非常耗时的，因此，vector 并不会在每次插入新元素时都重新分配内存。

相反，vector 容器可能会分配一些额外的内存来适应其大小的增长，因此，其真实容量可能比存储这些元素实际需要的内存要大。库通过不同的策略来平衡内存占用和空间再分配，但无论如何，空间分配只应在 vector 大小以对数增长的时候发生，以便在向量末尾插入单个元素可以做到均摊情况下是常数级的时间复杂度。

因此，相对于数组，vector 会消耗更多的内存来换取更有效地对内存进行管理并且动态增长。

相对于其他动态容器，vector 支持随机访问，并且能相对高效地在末尾插入或者删除元素，但如果要在其他位置插入或者删除元素，vector 就会表现得很差，而且迭代器和引用也不是那么方便。

构造函数

• explicit vector (const allocator_type& alloc = allocator_type()); 默认构造函数，构造出一个不包含任何元素的空的 vector；

• explicit vector (size_type n); 构造出一个包含 \(n\) 个元素的 vector，默认会初始化为 0；

• explicit vector (size_type n, const value_type& val, const allocator_type& alloc = allocator_type()); 构造出一个包含 \(n\) 个值为 \(val\) 的 vector；

• vector (InputIterator first, InputIterator last, const allocator_type& alloc = allocator_type()); 构造出一个包含迭代器 \([first, end)\) 范围内元素的 vector，注意左闭右开；

• vector (const vector& x); 复制构造函数，构造出一个和 \(x\) 相同的 vector；

#include <iostream>
#include <vector>

using namespace std;

int main ()
{
    vector<int> first;                                 // 空的 vector
    vector<int> second (4, 100);                       // 包含 4 个值为 100 元素的 vector，[100, 100, 100, 100]
    vector<int> third (second.begin(), second.end()); // 包含 second 起始迭代器到终止迭代器区间元素的 vector，[100, 100, 100, 100]
    vector<int> fourth (third);                       // 对 third 的复制，[100, 100, 100, 100]

    // 数组也可以用来作为迭代器初始化 vector
    int myints[] = {16, 2, 77, 29};
    vector<int> fifth (myints, myints + sizeof(myints) / sizeof(int) ); //[16, 2, 77, 29]
    vector<int> sixth (4); // [0, 0, 0, 0]

    cout << "The contents of fifth are:";
    for (vector<int>::iterator it = fifth.begin(); it != fifth.end(); ++it)
        cout << ' ' << *it;
    cout << '\n';

    return 0;
}

赋值运算

赋值运算会给容器赋予新的内容，替换掉旧的内容，同时改变其大小。

#include <iostream>
#include <vector>

using namespace std;

int main ()
{
    vector<int> foo (3,0);
    vector<int> bar (5,0);

    bar = foo;
    foo = vector<int>();

    cout << "Size of foo: " << int(foo.size()) << '\n'; // 0
    cout << "Size of bar: " << int(bar.size()) << '\n'; // 3
    return 0;
}

迭代器

• iterator begin(); 返回指向 vector 中第一个元素的迭代器；
• iterator end(); 返回一个迭代器，引用向量容器中的 past-the-end 元素，也即最后一个元素之后的理论元素；
• reverse_iterator rbegin(); 返回指向 vector 中最后一个元素的反向迭代器，增加反向迭代器会使它们向前移动；
• reverse_iterator rend(); 返回一个反向迭代器，指向向量中第一个元素之前的理论元素；

#include <iostream>
#include <vector>

using namespace std;

int main ()
{
    vector<int> myvector;
    for(int i = 0; i < 5; i++)
    {
      myvector.push_back(i);
    }

    vector<int>::iterator it = myvector.begin();

    for (; it != myvector.end(); it++)
    {
      cout << *it << '\t';
    }
    cout << endl;

    vector<int>::reverse_iterator rit = myvector.rbegin();

    for (; rit != myvector.rend(); rit++)
    {
      cout << *rit << '\t';
    }
    cout << endl;

    return 0;
}
// 0    1   2   3   4
// 4    3   2   1   0

也可以对向量建立指针，然后通过指针来访问成员函数。或者建立引用。

#include <iostream>
#include <vector>

using namespace std;

int main ()
{
    vector<int> myvector;
    for(int i = 0; i < 5; i++)
    {
      myvector.push_back(i);
    }

    vector<int> *p = &myvector;
    p->push_back(5);

    vector<int>::reverse_iterator rit = p->rbegin();
    //   vector<int>::reverse_iterator rit = (*p).rbegin();

    for (; rit != p->rend(); rit++)
    {
      cout << *rit << '\t';
    }
    cout << endl;

    vector<int> &ref_myvector = myvector;
    ref_myvector.push_back(6);

    vector<int>::iterator it = ref_myvector.begin();

    for (; it != ref_myvector.end(); it++)
    {
      cout << *it << '\t';
    }
    cout << endl;

    return 0;
}
// 5    4    3   2   1   0
// 0    1   2   3   4   5   6

容量

• size_type size() const; 返回向量中元素的个数；
• size_type max_size() const; 返回向量中最大可能包含的元素个数，但这只是理论上的；
• void resize (size_type n, value_type val = value_type()); 重新设置向量的大小使之包含 \(n\) 个元素；如果 \(n\) 小于现有向量大小，则只保留前 \(n\) 个元素；如果 \(n\) 大于现有向量大小，那么在末尾插入元素来使向量大小达到 \(n\) ；如果 \(n\) 大于现有向量容量，那么会自动重新分配内存；
• size_type capacity() const; 返回向量当前分配的内存可以包含多少个元素；
• bool empty() const; 返回当前向量是否为空，也就是大小是否为零；
• void reserve (size_type n); 让向量当前分配的内存至少可以包含 \(n\) 个元素；

#include <iostream>
#include <vector>

using namespace std;

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

    // 添加元素的过程中容量会不断增大
    for(int i = 0; i < 10; i++)
    {
        myvector.push_back(i);
        cout << "size: " << myvector.size() << '\t';
        cout << "capacity: " << myvector.capacity() << endl;
    }

    vector<int> othervector;
    othervector.reserve(100);
    // 添加元素的过程中大小不超过 100 就不会增大
    for(int i = 0; i < 10; i++)
    {
        othervector.push_back(i);
        cout << "size: " << othervector.size() << '\t';
        cout << "capacity: " << othervector.capacity() << endl;
    }

    return 0;
}

元素访问

• reference operator[] (size_type n); 像数组一样访问位置 \(n\) 处的元素，但不会进行边界检测；
• reference at (size_type n); 访问位置 \(n\) 处的元素，但会进行边界检测；
• reference front(); 返回向量中第一个元素的引用；
• reference back(); 返回向量中最后一个元素的引用；

#include <iostream>
#include <vector>

using namespace std;

int main ()
{
    vector<int> myvector;

    for(int i = 0; i < 10; i++)
    {
        myvector.push_back(i);

    }

    cout << myvector.front() << endl;
    cout << myvector.back() << endl;

    // 此处越界访问向量，不会提示
    for(int i = 0; i <= myvector.size(); i++)
    {
        cout << myvector[i] << '\t';
    }
    cout << endl;

    // 此处越界访问向量，会抛出一个 out_of_range 异常
    for(int i = 0; i <= myvector.size(); i++)
    {
        cout << myvector.at(i) << '\t';
    }
    cout << endl;

    return 0;
}

向量修改

• void assign (InputIterator first, InputIterator last); 给向量重新分配迭代器 \([first, end)\) 范围内的元素，注意左闭右开；
• void assign (size_type n, const value_type& val); 给向量重新分配 \(n\) 个值 \(val\) 的元素；
• void push_back (const value_type& val); 在向量末尾添加一个元素；
• void pop_back(); 从向量末尾删除一个元素；
• iterator insert (iterator position, const value_type& val); 在迭代器位置前面插入一个元素，返回指向第一个新插入元素的迭代器；
• void insert (iterator position, size_type n, const value_type& val); 在迭代器位置前面插入 \(n\) 个值 \(val\) 的元素；
• void insert (iterator position, InputIterator first, InputIterator last); 在迭代器位置前面插入迭代器 \([first, end)\) 范围内的元素；
• iterator erase (iterator position); 删除迭代器位置的元素，返回最后一个被删除元素的后面一个元素的迭代器；
• iterator erase (iterator first, iterator last); 删除迭代器 \([first, end)\) 范围内的元素，返回最后一个被删除元素的后面一个元素的迭代器；
• void swap (vector& x); 和向量 \(x\) 进行交换，两个向量元素类型相同，但大小可能不同；
• void clear(); 清空向量；

#include <iostream>
#include <vector>

using namespace std;

int main ()
{
    vector<int> first;
    vector<int> second;
    vector<int> third;

    first.assign(7, 100);             // [100, 100, 100, 100, 100, 100, 100]

    vector<int>::iterator it;
    it = first.begin() + 1;

    second.assign(it, first.end() - 1); // [100, 100, 100, 100, 100]

    int myints[] = {1776, 7, 4};
    third.assign(myints, myints + 3);   // [1776, 7, 4]

    cout << "Size of first: " << int (first.size()) << '\n';
    cout << "Size of second: " << int (second.size()) << '\n';
    cout << "Size of third: " << int (third.size()) << '\n';

    vector<int> myvector (3, 100); // [100, 100, 100]

    it = myvector.begin() + 1;
    it = myvector.insert(it, 200); // [100, 200, 100, 100]，此时 it 指向新插入的元素 200

    myvector.insert(it, 2, 300); // [100, 300, 300, 200, 100, 100]，此时 it 无效了

    it = myvector.begin();

    vector<int> anothervector (2, 400);  // [400, 400]

    myvector.insert(it + 2, anothervector.begin(), anothervector.end());
    // [100, 300, 400, 400, 300, 200, 100, 100]

    int myarray [] = {501, 502, 503};
    myvector.insert (myvector.begin(), myarray, myarray + 3);
    // [501, 502, 503, 100, 300, 400, 400, 300, 200, 100, 100]

    cout << "myvector contains:";
    for (it = myvector.begin(); it < myvector.end(); it++)
        cout << ' ' << *it;
    cout << '\n';

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

    it = myvector.erase(myvector.begin() + 5);
    // [1, 2, 3, 4, 5, 7, 8, 9, 10]，此时 it 指向 6 后面的元素 7

    it = myvector.erase(myvector.begin(), myvector.begin() + 3);
    // [4, 5, 7, 8, 9, 10]，此时 it 指向 3 后面的元素 4

    cout << "myvector contains:";
    for (unsigned i = 0; i < myvector.size(); ++i)
        cout << ' ' << myvector[i];
    cout << '\n';

    return 0;
}

参考资料 [http://www.cplusplus.com]

获取更多精彩，请关注「seniusen」!