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

时间  2019-11-09
标签 c++ 学习 笔记 stl vector 栏目 C&C++ 繁體版
原文   原文链接

vector 是一种顺序容器，能够看做是能够改变大小的数组。ios

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

在内部，vector 使用动态分配的数组来存储元素，当新元素插入时，若是现有的存储空间已经占满，则须要从新再分配一个新的数组，而且将以前的元素都移动到新的内存上。这个过程是很是耗时的，所以，vector 并不会在每次插入新元素时都从新分配内存。函数

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

所以，相对于数组，vector 会消耗更多的内存来换取更有效地对内存进行管理而且动态增加。spa

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

构造函数

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

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

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

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

  • 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」!

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程