【笔记】C++的vector容器

发表于 更新于 分类于 阅读次数：

前言

C++的vector容器学习笔记
vector的数据结构是单端数组
vector类似于数组，但与数组不同的是，可以动态扩展
vector的数据结构是尾部插入，尾部弹出

引入头文件

1
#include <vector>

构造

空构造

1
vector<T> v;

拷贝构造

1
vector<T> v(v);

拷贝部分元素

  • 将[<iterator_start>, <iterator_end>)区间内的元素拷贝

<iterator_start>：开始位置迭代器
<iterator_end>：结束位置迭代器

1
vector<T> v(<iterator_start>, <iterator_end>);

将多个相同元素赋值

<num>：元素的个数
<element>：需要存放的元素

1
vector<T> v(<num>, <element>);

迭代器

定义迭代器

第一个元素的前一个位置

1
verctor<T>::iterator it = v.rend();

第一个元素的位置

1
verctor<T>::iterator it = v.begin();

最后一个元素的位置

1
verctor<T>::iterator it = v.rbegin();

最后一个元素的后一个位置

1
verctor<T>::iterator it = v.end();

迭代器递增

<step>：访问的步数

1
2
3
4
5
it += <step>;
it -= <step>;

it++;
it--;

通过迭代器遍历

1
2
3
4
for (vector<T>::iterator it = v.begin(); it != v.end(); it++)
{
    cout << *it << endl;
}

使迭代器只读

  • 当一个函数传递的vector是常量时，需要将iterator改为const_iterator
1
2
3
4
5
6
7
void print(const vector<T> & v)
{
    for (vector<T>::const_iterator it = v.begin(); it != v.end(); it++)
    {
        cout << *it << endl;
    }
}

赋值

利用运算符重载赋值

1
v = v;

利用assign函数赋值

利用区间的方式赋值

<iterator_start>：开始位置迭代器
<iterator_end>：结束位置迭代器

1
v.assign(<iterator_start>, <iterator_end>);

将多个相同元素赋值

<num>：元素的个数
<element>：需要存放的元素

1
v.assign(<num>, <element>);

容量和大小的操作

判断容器是否为空

1
v.empty();

获取容器的容量

1
v.capacity();

获取元素的个数

1
v.size();

重新指定容量

  • 如果扩容，会以默认值填充新的位置
  • 如果缩容，末尾的数据会被删除

<num>：新的容量

1
v.resize(<num>);

以指定元素填充新的位置

<element>：填充的元素

1
v.resize(<num>, <element>);

增

向尾部添加元素

<element>：元素

1
v.push_back(<element>);

在迭代器指向的位置添加元素

<iterator>：迭代器
<element>：元素

1
v.insert(<iterator>, <element>);

添加多个相同的元素

<iterator>：迭代器
<num>：插入元素的个数
<element>：元素

1
v.insert(<iterator>, <num>, <element>);

删

删除尾部的元素

1
v.pop_back();

删除迭代器指向的元素

  • 返回下一个元素的位置

<iterator>：迭代器

1
v.erase(<iterator>);

删除一组元素

  • 返回下一个元素的位置

<iterator_start>：开始位置迭代器
<iterator_end>：结束位置迭代器

1
v.erase(<iterator_start>, <iterator_end>);

删除容器中所有的元素

1
v.clear();

改

通过迭代器

<value>：修改后的值

1
*it = <value>;

通过运算符修改指定下标的元素

<index>：需要读写的元素下标
<value>：修改后的值

1
v[<index>] = <value>;

通过at函数修改指定下标的元素

<index>：需要读写的元素下标
<value>：修改后的值

1
v.at(<index>) = <value>;

查

通过迭代器

1
*it;

获取容器中第一个元素

1
v.front();

获取容器中最后一个元素

1
v.back();

查询指定位置的元素

通过运算符重载

<index>：需要读写的元素下标

1
v[<index>];

通过at函数

1
v.at(<index>);

排序

利用内置算法

  • 利用内置算法，实现升序排序

<iterator_start>：开始位置迭代器
<iterator_end>：结束位置迭代器

1
2
3
#include <algorithm>

sort(<iterator_start>, <iterator_end>);

利用自定义算法

1
2
3
4
5
6
7
8
9
10
class Cla
{
public:
    bool operator()(T t1, T t2)
    {
        return t1 > t2;
    }
};

sort(v.begin(), v.end(), Cla());

交换

  • 容器内数据的互换
1
v.swap(v);

利用swap函数实现收缩容器的空间

1
vector<T>(v).swap(v);

预留空间

  • 当自动扩容的操作过多时，如果提前知道容器应该分配的容量，可以通过预留空间节省扩容的次数，从而节省资源

<num>：开辟的空间大小

1
v.reserve(<num>);

查找

查找指定元素是否存在

  • 利用一元谓词查找指定条件的元素是否存在。如果存在，就返回找到的元素的迭代器；如果不存在，就返回尾部迭代器
1
2
3
4
5
6
7
8
9
10
class Cla
{
public:
    bool operator()(T t)
    {
        return false;
    }
};

vector<T t>::iterator it = find_if(v.begin(), v.end(), Cla());

完成

参考文献

哔哩哔哩——黑马程序员