当前位置：首页 > news >正文

C++动态数组vector的使用小结

news 2026/5/25 11:39:45

vector的基本概念

vector是C++标准模板库(STL)中最重要且最常用的容器之一，它本质上是一个封装了动态数组的类模板，提供了一系列便捷的方法来操作和管理数组数据。作为序列式容器的一种，vector支持在尾部高效地添加或删除元素，同时保持元素的线性存储顺序。

vector的实现原理是基于动态数组，它在内部使用连续的内存空间来存储元素。当现有容量不足时，vector会自动重新分配更大的内存空间（通常是当前容量的2倍），并将原有元素复制到新的内存区域。这个特性使得vector具有以下特点：

随机访问效率高：通过下标运算符[]或at()方法可以在O(1)时间内访问任意元素
尾部操作高效：push_back()和pop_back()操作的时间复杂度为O(1)
插入删除效率低：在中间位置插入或删除元素需要移动后续元素，时间复杂度为O(n)

vector的典型使用场景包括：

需要频繁随机访问元素的场合
数据量变化不大或主要在尾部增删的场合
需要兼容C风格数组的场合

基本操作示例：

#include <vector>

usingnamespacestd;

vector<int> v;// 创建空vector

v.push_back(10);// 尾部添加元素

v.insert(v.begin(), 5);// 在头部插入元素

intval = v[0];// 随机访问

v.pop_back();// 删除尾部元素

vector还提供了许多有用的成员函数，如size()获取元素数量，capacity()获取当前容量，reserve()预分配内存等，这些函数使得vector比原始数组更安全、更易于使用。

与传统静态数组的比较

与传统的静态数组相比，vector具有以下显著优势：

动态扩容能力：
- 当元素数量超过当前容量时，vector会自动分配更大的内存空间(通常是当前容量的1.5-2倍)并将原有元素拷贝到新空间
- 扩容策略可以通过reserve()方法预先指定，减少频繁扩容带来的性能开销
- 示例：vector<int> v; v.reserve(100);预先分配100个元素的空间
自动内存管理：
- 用户无需手动分配和释放内存，vector会在析构时自动释放所有内存
- 遵循RAII(资源获取即初始化)原则，避免内存泄漏
- 示例：{ vector<int> temp; /*...*/ }作用域结束时自动释放内存
丰富的成员函数：
- 提供了push_back()、pop_back()、insert()、erase()等方法来方便地增删元素
- 支持size()、capacity()、empty()等状态查询方法
- 提供front()、back()快速访问首尾元素的方法
随机访问支持：
- 通过[]运算符或at()方法可以像普通数组一样快速访问任意位置的元素
- 时间复杂度为O(1)，与静态数组相同
- 示例：v[10] = 42;或int x = v.at(5);

常用操作示例

#include <vector>

#include <iostream>

intmain() {

// 创建vector

std::vector<int> numbers;

// 尾部添加元素

numbers.push_back(10);

numbers.push_back(20);

numbers.push_back(30);

// 访问元素

std::cout <<"第一个元素: "<< numbers[0] << std::endl;

// 遍历元素

for(intnum : numbers) {

std::cout << num <<" ";

}

// 删除尾部元素

numbers.pop_back();

return0;

}

实际应用场景

在实际应用中，vector常用于以下场景：

需要频繁在尾部添加/删除元素的场合：
- 日志记录系统
- 数据采集缓冲
- 动态生成的结果集存储
需要随机访问元素的场合：
- 图像像素处理
- 数学向量/矩阵运算
- 游戏对象管理
无法预先确定元素数量的情况：
- 读取未知长度的用户输入
- 解析动态数据文件
- 数据库查询结果存储
需要将数据作为参数传递给函数时：
- 避免数组退化为指针
- 保持完整的容器信息(size/capacity等)
- 示例：void process(const std::vector<int>& data);

例如：

#include <vector>

#include <iostream>

intmain() {

std::vector<int> nums;// 创建一个空的int型vector

// 添加元素

nums.push_back(10);

nums.push_back(20);

nums.push_back(30);

// 访问元素

std::cout <<"第一个元素："<< nums[0] << std::endl;

std::cout <<"当前容量："<< nums.capacity() << std::endl;

// 遍历元素

for(auto num : nums) {

std::cout << num <<" ";

}

return0;

}

需要注意的是，虽然vector提供了诸多便利，但在中间位置插入/删除元素时效率较低(O(n)复杂度)，这种情况下可以考虑使用list等其他容器。此外，频繁的扩容操作也可能带来性能开销，可以通过reserve()方法预先分配足够空间来优化。

基本特性

动态扩容机制

当vector的size达到capacity时，会自动进行扩容：

扩容策略：大多数实现采用1.5倍或2倍扩容策略（如VS通常1.5倍，g++通常2倍）
扩容过程：分配新内存→拷贝元素→释放旧内存
时间复杂度：均摊O(1)，但单次扩容可能达到O(n)

vector<int> v;

for(inti=0; i<100; i++){

v.push_back(i);// 自动扩容约7-8次(取决于实现)

}

内存布局

连续存储：所有元素在内存中连续排列，与普通数组一致
随机访问：支持通过下标直接访问，效率与数组相同
迭代器：提供随机访问迭代器，支持各种STL算法

类型安全

通过模板实现，可存储任意类型：

vector<string> names;

vector<pair<int,double>> measurements;

vector<vector<int>> matrix;// 二维数组

常用操作详解

初始化方式

// 1. 默认构造

vector<int> v1;

// 2. 指定大小和初始值

vector<int> v2(10, 0);// 10个0

// 3. 通过迭代器范围初始化

intarr[] = {1,2,3};

vector<int> v3(arr, arr+3);

// 4. 列表初始化(C++11)

vector<int> v4 = {1,2,3};

// 5. 拷贝构造

vector<int> v5(v4);

元素添加

vector<int> v;

// 尾部添加

v.push_back(10);

v.push_back(20);

// 高效构造(C++11)

v.emplace_back(30);// 直接在容器内构造，避免拷贝

// 任意位置插入

v.insert(v.begin(), 5);// 头部插入

v.insert(v.begin()+1, 2, 8);// 插入2个8

元素访问

// 下标访问(不检查边界)

inta = v[0];

// 安全访问(检查边界)

try{

intb = v.at(100);// 抛出out_of_range异常

}catch(out_of_range& e) {

cerr << e.what() << endl;

}

// 迭代器访问

for(auto it = v.begin(); it != v.end(); ++it) {

cout << *it <<" ";

}

// 反向迭代器

for(auto rit = v.rbegin(); rit != v.rend(); ++rit) {

cout << *rit <<" ";

}

// C++11范围for

for(intnum : v) {

cout << num <<" ";

}

元素删除

// 删除末尾元素

v.pop_back();

// 删除指定位置

v.erase(v.begin());

// 删除范围

v.erase(v.begin(), v.begin()+2);

// 条件删除(C++11)

v.erase(remove_if(v.begin(), v.end(),

[](intx){returnx%2==0;}), v.end());

// 清空容器

v.clear();

容量管理

// 当前元素数量

size_tcount = v.size();

// 当前容量

size_tcap = v.capacity();

// 是否为空

if(v.empty()) {

cout <<"Vector is empty"<< endl;

}

// 预分配空间(避免多次扩容)

v.reserve(100);

// 释放多余空间

v.shrink_to_fit();

// 调整大小

v.resize(50);// 不足补0，多余删除

v.resize(100, -1);// 不足补-1

性能优化建议

预分配空间：已知元素数量时先reserve，避免多次扩容
1
2
3
4
5
vector<int> v;
v.reserve(1000);// 预先分配
for(inti=0; i<1000; i++) {
v.push_back(i);// 不会触发扩容
}
选择合适的添加方法：
- 优先使用emplace_back而非push_back（避免临时对象）
- 批量插入时使用insert范围版本
避免不必要的拷贝：
1
2
3
4
5
6
// 返回vector的函数
vector<int> getData() {
vector<int> data;
// ...填充data
returndata;// 移动语义优化，无拷贝
}
元素类型选择：
- 存储大型对象时考虑存储指针
- 频繁插入删除时考虑list或deque

典型应用场景

动态数组需求
1
2
3
4
5
6
// 读取未知数量的输入
vector<int> inputs;
intnum;
while(cin >> num) {
inputs.push_back(num);
}
实现栈结构
1
2
3
4
vector<int> stack;
stack.push_back(1);// push
inttop = stack.back();// top
stack.pop_back();// pop
矩阵运算
1
2
vector<vector<double>> matrix(m, vector<double>(n));
// 矩阵操作...
算法容器
1
2
3
vector<int> data = {5,3,8,1,9};
sort(data.begin(), data.end());
auto it = find(data.begin(), data.end(), 8);
缓存数据
1
2
vector<CacheEntry> cache;
cache.reserve(MAX_CACHE_SIZE);