C++ vector容器的介绍与使用

一、vector简介

std::vector 是 C++ 标准模板库 (STL) 中的一个动态数组容器。允许存储元素（可以使用任何数据类型作为其元素类型）集合，并能够动态调整其大小。

特点：

1. 动态大小：与常规数组不同，vector 可以在运行时改变大小。

2. 连续存储：vector 保证其元素在内存中是连续存储的，可以使用指针或迭代器遍历其元素。

3. 访问：可以使用索引运算符 [] 快速访问 vector 中的元素，与常规数组类似，此外还有 at() 方法提供带边界检查的访问。

4. 性能：向 vector 的末尾添加/删除元素（使用 push_back 或 pop_back）通常是快速的。但在 vector 的中间或开始位置插入/删除元素需要移动多个元素，相对较慢。

5. 内存：随着元素的添加，在当前分配的内存不足以容纳更多的元素时，vector 会重新分配内存（这可能导致之前的迭代器、指针和引用失效）

6. 函数：vector 提供了一系列函数来管理其元素。

本文主要参考：https://cplusplus.com/reference/vector/vector/

关于代码的相关解释也可以在该网站中查询。

本文主要以示例代码为演示，结合函数说明来对vector的相关用法进行阐述。

二、初始化

1. 代码示例

#include 
#include 
using namespace std;
 
int main() {
    vector v1;
    v1.push_back("hello");
    v1.push_back("world");
    for(int i=0; isize(); i++)cout<" "; cout<
    // 输出为：hello world 
 
    vector<int> v2(5,99);
    for(int i=0; isize(); i++)cout<" "; cout<
    // 输出为：99 99 99 99 99
 
    vector<int> v3({0, 1, 2});
    vector<int> v4 = {3, 4, 5};
    for(int i=0; isize(); i++)cout<" "; cout<
    // 输出为：0 1 2
    for(int i=0; isize(); i++)cout<" "; cout<
    // 输出为：3 4 5
 
    int arr[] = {1, 2, 3, 4, 5, 6};
    vector<int> v5(arr,arr+5);
    for(int i=0; isize(); i++)cout<" "; cout<
    // 输出为：1 2 3 4 5
 
    vector<int> v6(v5.begin(),v5.end()-2);
    for(int i=0; isize(); i++)cout<" "; cout<
    // 输出为：1 2 3
 
    vector<int> v7(v5);
    for(int i=0; isize(); i++)cout<" "; cout<
    // 输出为：1 2 3 4 5
 
    vector<int> v8;
    v8 = v7;
    for(int i=0; isize(); i++)cout<" "; cout<
    // 输出为：1 2 3 4 5
 
    cout << &v5 << endl << &v7 << endl << &v8 << endl;
    // 输出三个地址，可以发现地址并不相同
    // 说明v5、v7、v8虽然内容相同，但却是两个不同的对象，位于内存中的不同位置。
 
    return 0;
}

注：

v.begin()指向 vector 中 第一个元素 的迭代器
v.end()  指向 vector 中 最后一个元素之后的位置 的迭代器（并不指向 vector 中的任何元素）

2.函数说明

vector();
// 默认构造函数：创建一个空的 vector。
// 如上述代码 vector v1;
 
vector(size_type n); 
// 创建一个包含 n 个元素的 vector
 
vector(size_type n, const value_type& value);
// 创建一个包含 n 个元素，每个元素的值 value 的 vector。
// vector v2(5,99);
 
vector(initializer_list il);
// 使用初始化列表il 来初始化 vector
// vector v3({0, 1, 2});
    
vector(InputIterator first, InputIterator last);
// 使用初始化列表创建
// vector v5(arr,arr+5);
// vector v6(v5.begin(),v5.end()-2);
 
vector(vector& x);
// 复制 vector
// vector v7(v5);
// 上面这句代码的效果等价于 vector v7 = v5;

2. 容量

1. 代码示例

#include 
#include 
using namespace std;
 
int main() {
    vector<int> v1(2,7);
    for(auto t : v1)cout<< t <<" "; cout << endl;
    // 输出为：7 7
    cout<< "size:" << v1.size() << endl;
    cout << "capacity:" << v1.capacity() << endl;
    // 输出为：size:2
    // 输出为：capacity:2
 
 
    v1.push_back(8);
    cout<< "size:" << v1.size() << endl;
    cout << "capacity:" << v1.capacity() << endl;
    // 输出为：size:3
    // 输出为：capacity:4
 
 
    cout<< "max_size:" << v1.max_size() << endl;
    // 输出视情况而定，本机此处输出为：max_size:2305843009213693951
 
 
    v1.resize(1);
    for(auto t : v1)cout<< t <<" "; cout << endl;
    // 输出为：7
    cout<< "size:" << v1.size() << endl;
    cout << "capacity:" << v1.capacity() << endl;
    // 输出为：size:1
    // 输出为：capacity:4
 
 
    v1.resize(5,99);
    for(auto t : v1)cout<< t <<" "; cout << endl;
    // 输出为：7 99 99 99 99
    cout<< "size:" << v1.size() << endl;
    cout << "capacity:" << v1.capacity() << endl;
    // 输出为：size:5
    // 输出为：capacity:5
 
 
    v1.reserve(9);
    for(auto t : v1)cout<< t <<" "; cout << endl;
    // 输出为：7 99 99 99 99
    cout<< "size:" << v1.size() << endl;
    cout << "capacity:" << v1.capacity() << endl;
    // 输出为：size:5
    // 输出为：capacity:9
 
 
    v1.shrink_to_fit();
    for(auto t : v1)cout<< t <<" "; cout << endl;
    // 输出为：7 99 99 99 99
    cout<< "size:" << v1.size() << endl;
    cout << "capacity:" << v1.capacity() << endl;
    // 输出为：size:5
    // 输出为：capacity:5
 
 
    cout<< v1.empty() << endl;
    // 输出为：0
    cout<< "size:" << v1.size() << endl;
    cout << "capacity:" << v1.capacity() << endl;
    // 输出为：size:5
    // 输出为：capacity:5
 
 
    v1.resize(0);
    cout<< v1.empty() << endl;
    // 输出为：1
    cout<< "size:" << v1.size() << endl;
    cout << "capacity:" << v1.capacity() << endl;
    // 输出为：size:0
    // 输出为：capacity:5
 
    return 0;
}

2.函数说明

size_type size(); 
// vector中包含元素的数量。
// size_type is an unsigned integral type。
 
size_type capacity();
// 返回vector已分配存储空间的大小，该值大于等于 size()。当此容量耗尽并且需要更多容量时，容器会自动扩展它（重新分配其存储空间）。
 
size_type max_size();
// vector可以容纳的最大元素数量,由系统或库的限制决定，是非常大的值。
 
void resize(n);
void resize(n, value);
// 改变vector的大小，使其包含 n 个元素。当 n 大于当前大小时，添加 n - size() 个新元素，值为 value ；如果 n 小于当前大小，则将删除最后的 size() - n 个元素。resize 可能会导致 vector 的内存重新分配（但不一定，我测试了一下，没有看到capacity()的变化）。
 
bool empty();
// 判断vector的size()是否为0
 
void reserve(n);
// 请求更改capacity,如果 n 大于当前矢量容量，则该函数会导致容器重新分配其存储，将其容量增加到 n（或更大）。如果 n 小于或等于当前容量，则该函数不会产生任何效果。使用 reserve 可以提高效率，特别是知道最终需要存储多少元素时。
 
void shrink_to_fit();
// 请求容器减小其capacity以适应其size。

3. 元素访问

1. 代码示例

#include 
#include 
#include 
using namespace std;
 
int main() {
    vector<int> v1;
    v1.push_back(100);
    v1.push_back(99);
 
    cout<< v1[0] << endl;
    // 输出为：100    
 
    cout<< v1.at(1) << endl;
    // 输出为：99
 
    v1.resize(6,1);
    for(auto t : v1) cout << t <<" "; cout << endl;
    // 输出为：100 99 1 1 1 1
 
    cout << v1.front() << " " << v1.back() << endl;
    // 输出为：100 1
    
    v1.front() = 88;
    v1.back() = 123;
    cout << v1.front() << " " << v1.back() << endl;
    // 输出为：88 123
 
    vector<int>::iterator it;
    for (it = v1.begin(); it != v1.end(); it++)
        cout << *it <<" "; 
    cout << endl;
    // 输出为：88 99 1 1 1 123
 
    int* p = v1.data();
    for(int i=0; isize(); i++, p++) cout << *p <<" ";  cout << endl;
    // 输出为：88 99 1 1 1 123
 
    int* q = v1.data();
    memset(q, 0, v1.size() * sizeof(int));
    for(auto t : v1) cout << t <<" "; cout << endl;
    // 输出为：0 0 0 0 0 0
    return 0;
}

2.函数说明

//——————以vector v为例——————
 
[] 运算符
// 访问下标为n的元素可以使用v[n]访问
 
reference at(n);
// 访问下标为n的元素
// 返回值类型 reference 是容器元素的引用类型，此处的reference类型为int
 
reference front();
// 返回对vector中第一个元素的引用
 
reference back();
// 返回对vector中最后一个元素的引用
 
value_type* data();
// 该函数返回一个指向容器中第一个元素的指针。这是一种直接访问底层数组的方法。
// 此处的返回值类型 value_type* 为 int* 类型。
 
 
// for (vector::iterator it = v.begin(); it != v.end(); ++it)
// 使用迭代器输出每个元素

4. 修改

1. 代码示例

#include 
#include 
using namespace std;
 
class P {
private:
    string name;
    int age;
public:
    P(string str, int n){
        name = str;
        age = n;
    }
    void print()
    {
        cout << name << " " << age << endl;
    }
};
 
int main() {
    vector<int> v1;
    v1.resize(5,99);
    for(auto t : v1) cout << t <<" "; cout << endl;
    // 输出为：99 99 99 99 99
 
    v1.pop_back();
    v1.pop_back();
    for(auto t : v1) cout << t <<" "; cout << endl;
    // 输出为：99 99 99 
 
    v1.assign({1,2,3,4,5});
    for(auto t : v1) cout << t <<" "; cout << endl;
    // 输出为：1 2 3 4 5
 
    vector<int> v2(v1.begin(), v1.begin() + 3);
    for(auto t : v2) cout << t <<" "; cout << endl;
    // 输出为：1 2 3
 
    v1.swap(v2);
    for(auto t : v1) cout << t <<" "; cout << endl;
    // 输出为：1 2 3
    for(auto t : v2) cout << t <<" "; cout << endl;
    // 输出为：1 2 3 4 5
 
 
 
    //------------以下使用class P ------------
    vector
 v;
    v.emplace_back("ubuntu", 66);
    v.push_back(P("windows", 99));
    for(auto temp : v) temp.print();
    // 输出为：
    // ubuntu 66
    // windows 99
 
 
    v.emplace(v.begin()+1, "computer", 100);
    for(auto temp : v) temp.print();
    // 输出为：
    // ubuntu 66
    // computer 100
    // windows 99
 
 
    v.insert(v.begin()+2, {P("aaa", 1),P("bbb", 2)});
    v.insert(v.begin()+4, P("ccc", 3));
    for(auto temp : v) temp.print();
    // 输出为：
    // ubuntu 66
    // computer 100
    // aaa 1
    // bbb 2
    // ccc 3
    // windows 99
 
 
    v.insert(v.begin(), v.begin()+2,v.begin() + 5);
    for(auto temp : v) temp.print();
    // 输出为：
    // aaa 1
    // bbb 2
    // ccc 3
    // ubuntu 66
    // computer 100
    // aaa 1
    // bbb 2
    // ccc 3
    // windows 99
 
 
    v.erase(v.begin(), v.begin() + 4);
    for(auto temp : v) temp.print();
    // 输出为：
    // computer 100
    // aaa 1
    // bbb 2
    // ccc 3
    // windows 99
 
 
    vector
::iterator it;
    it = v.begin();
    v.erase(it + 3);
    for(auto temp : v) temp.print();
    // 输出为：
    // computer 100
    // aaa 1
    // bbb 2
    // windows 99
 
 
    v.clear();
    cout << "size:" << v.size() << " capacity:" << v.capacity() << endl;
    // 输出为：size:0 capacity:12
 
    return 0;
}

2.函数说明

void push_back(value_type&& val);
// 在 vector 的末尾添加一个新元素，（当新的 vector 大小超过当前 vector 的 capacity 时，会自动重新分配存储空间）
// 与其功能类似的还有emplace_back()函数
// 比如向vector末尾插入一个整数100：
//     v.push_back(100);
 
void emplace_back(Args&&... args);
// 在 vector 末尾插入一个新元素，类似于push_back()
// Args&&... args 为 基本数据类型参数，或者类的构造函数参数
// emplace_back 是直接在 vector 的末尾就地构造一个元素，而不是先创建一个元素然后复制或移动它到 vector 中。
// push_back 是用于添加已经创建的对象或临时对象到 vector 的末尾。
// emplace_back 的效率会更高一些。
 
void pop_back();
// 删除 vector 的最后一个元素，将 size 减小 1。
// pop_back()用于删除最后一个元素，注意与back()区别，back()用来访问最后一个元素。
 
void clear();
// 删除所有元素,使size为0;
 
void swap (vector& x);
// 交换两个 vector 对象的内容.
// 这是一个非常高效的操作，不涉及实际数据的复制，只是交换内部指针、大小和容量。
// std::vector vec1 = {1, 2, 3};
// std::vector vec2 = {4, 5, 6, 7};
// vec1.swap(vec2); //vec1: {4, 5, 6, 7},  vec2: {1, 2, 3}
 
 
iterator erase (const_iterator position);
// 从vector中删除某个元素
iterator erase (const_iterator first, const_iterator last);
// 从vector中删除[first,last)元素
// 函数返回值为一个指向被函数调用擦除的 最后一个元素之后的元素的新位置 
// vector vec = {1, 2, 3, 4, 5};
// vec.erase(vec.begin() + 2);  // 删除第三个元素，vec现在是{1, 2, 4, 5}
// vector vec1 = {1, 2, 3, 4, 5};
// vec1.erase(vec1.begin() + 1, vec1.begin() + 4);  // 删除第二个到第四个元素，vec现在是{1, 5}
 
 
 
 
void assign(size_type n, const value_type& val);
// assign会清除容器的当前内容，并将其替换为指定的新内容。
// 清除vector，并使用 n 个值为 value 的元素 替换。
// 比如使用 10 个 0 填充，v.assign(10, 0);
 
void assign (InputIterator first, InputIterator last);
// 从另一个容器或数组的给定范围中的元素替换 vector 的内容。
// vector source = {1, 2, 3, 4, 5};
// vector dest1，dest2;
// dest1.assign(source.begin(), source.begin() + 3);  // dest1: {1, 2, 3}
// dest2.assign(source.begin(), source.end() - 3);  // dest2: {1, 2}
 
void assign (initializer_list il);
// std::vector vec;
// vec.assign({7, 8, 9, 10});  // vec: {7, 8, 9, 10}
 
 
 
 
iterator insert(const_iterator position, const T& value);
iterator insert(const_iterator position, size_type n, const T& value);
// 当 n 缺省时：在指定位置插入一个元素，返回值为指向插入元素的迭代器类型 iterator
// vector vec = {1, 2, 4};
// vec.insert(vec.begin() + 2, 3);  // vec: {1, 2, 3, 4}
// 当 插入元素数量 n 指定时：在指定位置插入 n 个元素，返回值为指向插入的第一个元素的迭代器类型 iterator
// vector vec = {1, 2, 4};
// vec.insert(vec.begin() + 1, 2, 999);  // vec: {1, 999, 999, 2, 4}
// 插入操作需要从插入位置开始，向后移动所有元素，所以其时间复杂度为O(n)。
 
iterator insert(const_iterator position, InputIterator first, InputIterator last);
// 从范围插入元素：从另一个容器或数组的指定范围插入元素。
// vector vec = {1, 2, 4};
// int arr[] = {101, 102, 103};
// vec.insert(vec.begin() + 1, arr, arr + 3);  // vec1: {1, 101, 102, 103, 2, 4}
 
iterator insert(const_iterator position, std::initializer_list il);
// 从初始化列表插入元素。
// vector vec = {1, 2, 4};
// vec.insert(vec.begin() + 1, {101, 102, 103});  // vec: {1, 101, 102, 103, 2, 4}
 
 
 
 
iterator emplace (const_iterator position, Args&&... args);
// position 指定了插入元素的位置
// Args&&... args 为 基本数据类型参数，或者类的构造函数参数
// emplace() 和 insert()类似，都是在指定位置插入元素，但emplace()效率会更高一些
// vector vec = {1, 2, 4};
// vec.emplace(vec.begin() + 2, 3);  // 在第三个位置插入3，vec: {1, 2, 3, 4}
 
// vector> matrix;
// matrix.emplace(matrix.begin(), vector {1, 2, 3});  // 在matrix的开始处插入一个vector

如有不当或错误之处，恳请您的指正，谢谢！！！