vector 容器封装了动态数组。
包含头文件: #include<vector>
vector 类模板的声明:
template<class T, class Alloc = allocator<T>>
class vector{
private:
T *start_;
T *finish_;
T *end_;
......
};
分配器
各种 STL 容器模板都接受一个可选的模板参数,该参数指定使用哪个分配器对象来管理内存
如果省略该模板参数的值,将默认使用 allocator<T>,用 new 和 delete 分配和释放内存。
1)vector(); // 创建一个空的 vector 容器。
2)vector(initializer_list<T> il); // 使用统一初始化列表。
3)vector(const vector<T>& v); // 拷贝构造函数。
4)vector(Iterator first, Iterator last); // 用迭代器创建 vector 容器。
5)vector(vector<T>&& v); // 移动构造函数(C++11 标准)。
不重要的已省略。
析构函数~vector()释放内存空间。
1)size_t max_size() const; // 返回容器的最大长度,此函数意义不大。
2)size_t capacity() const; // 返回容器的容量。
3)size_t size() const; // 返回容器的实际大小(已使用的空间)。
4)bool empty() const; // 判断容器是否为空。
5)void clear(); // 清空容器。
6)void reserve(size_t size); // 将容器的容量设置为至少 size。
7)void shrink_to_fit(); // 将容器的容量降到实际大小(需要重新分配内存)。
8)void resize(size_t size); // 把容器的实际大小置为 size。
1)T &operator[](size_t n);
2)const T &operator[](size_t n) const; // 只读。
3)T &at(size_t n);
4)const T &at(size_t n) const; // 只读。
以上均为返回第n个元素
5)T *data(); // 返回容器中动态数组的首地址。
6)const T *data() const; // 返回容器中动态数组的首地址。
7)T &front(); // 第一个元素。
8)const T &front(); // 第一个元素,只读。
9)const T &back(); // 最后一个元素,只读。
10)T &back(); // 最后一个元素。
给已存在的容器赋值,将覆盖容器中原有的内容。
1)vector &operator=(const vector<T> &v); // 把容器 v 赋值给当前容器。
2)vector &operator=(initializer_list<T> il); // 用统一初始化列表给当前容器赋值。
3)void assign(initializer_list<T> il); // 使用统一初始化列表赋值。
4)void assign(Iterator first, Iterator last); // 用迭代器赋值。
5)void assign(const size_t n, const T& value); // 把 n 个 value 给容器赋值
vector<int> v1;
v1 = { 1,2,3,4,5 }; // 使用统一初始化列表赋值。
for (int ii = 0; ii < v1.size(); ii++) cout << v1[ii] << " ";
cout << endl;
vector<int> v2;
v2 = v1; // 把容器 v1 赋值给当前容器。
for (int ii = 0; ii < v2.size(); ii++) cout << v2[ii] << " ";
cout << endl;
vector<int> v3;
v3.assign({ 1,2,3,4,5 }); // 用 assign()函数给当前容器赋值,参数是统一初始化列表。
for (int ii = 0; ii < v3.size(); ii++) cout << v3[ii] << " ";
cout << endl;
void swap(vector<T> &v); // 把当前容器与 v 交换。
交换的是动态数组的地址。
bool operator == (const vector<T> & v) const;
bool operator != (const vector<T> & v) const;
1)void push_back(const T& value); // 在容器的尾部追加一个元素。
2)void emplace_back(...); // 在容器的尾部追加一个元素,...用于构造元素。C++11
3)iterator insert(iterator pos, const T& value); // 在指定位置插入一个元素,返回指向插入元
素的迭代器。
4)iterator emplace (iterator pos, ...); // 在指定位置插入一个元素,...用于构造元素,返回指向
插入元素的迭代器。C++11
5)iterator insert(iterator pos, iterator first, iterator last); // 在指定位置插入一个区间的元素,
返回指向第一个插入元素的迭代器。
6)void pop_back(); // 从容器尾部删除一个元素。
7)iterator erase(iterator pos); // 删除指定位置的元素,返回下一个有效的迭代器。
8)iterator erase(iterator first, iterator last); // 删除指定区间的元素,返回下一个有效的迭代器。
强烈建议使用emplace.
vector<vector<int>> vv; // 创建一个 vector 容器 vv,元素的数据类型是 vector<int>。
vector<int> v; // 创建一个容器 v,它将作为容器 vv 的元素。
resize()、reserve()、assign()、push_back()、pop_back()、insert()、erase()等函数会引起 vector
容器的动态数组发生变化,可能导致 vector 迭代器失效。
迭代器是访问容器中元素的通用方法。
如果使用迭代器,不同的容器,访问元素的方法是相同的。
迭代器支持的基本操作:赋值(=)、解引用(*)、比较(==和!=)、从左向右遍历(++)。
一般情况下,迭代器是指针和移动指针的方法。
迭代器一般有五种:
1)正向迭代器
只能使用++运算符从左向右遍历容器,每次沿容器向右移动一个元素。
容器名<元素类型>::iterator 迭代器名; // 正向迭代器。
容器名<元素类型>::const_iterator 迭代器名; // 常正向迭代器。
相关的成员函数:
iterator begin();
const_iterator begin();
const_iterator cbegin(); // 配合 auto 使用。
iterator end();
const_iterator end();
const_iterator cend();
2)双向迭代器
具备正向迭代器的功能,还可以反向(从右到左)遍历容器(也是用++),不管是正向还是反向遍历,都可以用--让迭代器后退一个元素。
容器名<元素类型>:: reverse_iterator 迭代器名; // 反向迭代器。
容器名<元素类型>:: const_reverse_iterator 迭代器名; // 常反向迭代器。
相关的成员函数:
reverse_iterator rbegin();
const_reverse_iterator crbegin();
reverse_iterator rend();
const_reverse_iterator crend();
3)随机访问迭代器
具备双向迭代器的功能,还支持以下操作:
? 用于比较两个迭代器相对位置的关系运算(<、<=、>、>=)。
? 迭代器和一个整数值的加减法运算(+、+=、-、-=)。
? 支持下标运算(iter[n])。
数组的指针是纯天然的随机访问迭代器。
4)输入和输出迭代器
这两种迭代器比较特殊,它们不是把容器当做操作对象,而是把输入/输出流作为操作对象。
#include <iostream>
#include <vector>
#include <list>
using namespace std;
struct Node // 单链表的结点。
{
int item;
Node* next;
};
int* find_(int* arr, int n, const int& val) // 在整型数组 arr 中查找值为 val 的元素。
{
for (int ii = 0; ii < n; ii++) // 遍历数组。
if (arr[ii] == val) return &arr[ii]; // 如果找到了,返回数组中元素的地址。
return nullptr;
}
int* find_(int* begin, int* end, const int& val) // 在整型数组的区间中查找值为 val 的元素。
{
for (int* iter = begin; iter != end; iter++) // 遍历查找区间。
if (*iter == val) return iter; // 如果找到了元素,返回区间中的
位置。
return nullptr;
}
Node* find_(Node* begin, Node* end, const Node& val) // 在单链表中查找值为 val
的元素。
{
for (Node * iter = begin; iter != end; iter = iter->next) // 遍历链表。
if (iter->item == val.item) return iter; // 如果找到了,返回链表中结点的地址。
return nullptr;
}
// 查找元素的算法。
template<typename T1, typename T2>
// begin-查找区间开始的位置;end-查找区间结束的位置;val-待查找的值。
T1 find_(T1 begin, T1 end, const T2 &val)
{
for (T1 iter = begin; iter != end; iter++) // 遍历查找区间。
if (*iter == val) return iter; // 如果找到了元素,返回区间中的位
置。
return end;
}
int main()
{
// 在 vector 容器中查找元素。
vector<int> vv = { 1,2,3,4,5 }; // 初始化 vector 容器。
vector<int>::iterator it2 = find_(vv.begin(), vv.end(), 3);
if (it2 != vv.end()) cout << "查找成功。\n";
else cout << "查找失败。\n";
// 在 list 容器中查找元素。
list<int> ll = {1,2,3,4,5}; // 初始化 vector 容器。
list<int>::iterator it3 = find_(ll.begin(), ll.end(), 3);
if (it3 != ll.end()) cout << "查找成功。\n";
else cout << "查找失败。\n";
}
对于一个有范围的集合来说,在程序代码中指定循环的范围有时候是多余的,还可能犯错误。
C++11 中引入了基于范围的 for 循环。
语法:
for (迭代的变量 : 迭代的范围)
{
// 循环体。
}
vector<int> vv = { 1,2,3,4,5,6,7,8,9,10 };
//for (auto it = vv.begin(); it != vv.end(); it++) // 用迭代器遍历容器 vv。
//{
// cout << *it << " ";
//}
//cout << endl;
for (auto &val : vv) // 用基于范围的 for 循环遍历数组 vv。
{
cout << val << " ";
vv.push_back(10);
}
cout << endl;
注意:
1)迭代的范围可以是数组名、容器名、初始化列表或者可迭代的对象(支持 begin()、end()、++、
==)。
2)数组名传入函数后,已退化成指针,不能作为容器名。
3)如果容器中的元素是结构体和类,迭代器变量应该申明为引用,加 const 约束表示只读。
4)注意迭代器失效的问题。
强烈建议加引用。