std::vector是动态数组，支持自动内存管理、随机访问和动态扩容，相比C数组更安全高效。1. 可通过声明初始化创建；2. 用push_back或emplace_back添加元素，后者原地构造更高效；3. 支持下标、at()和迭代器访问，at()具备边界检查；4. 提供pop_back、erase和clear删除元素；5. size表示元素数量，capacity为已分配内存容量，可用reserve预分配、shrink_to_fit释放多余空间。emplace_back适用于直接构造对象，push_back适合已有对象；合理使用reserve可减少内存重分配开销，避免迭代器失效问题。
C++中，STL的
std::vector
是存储同类型数据序列的利器，本质上它是一个动态数组，能够自动管理内存，让我们在编程时省去不少麻烦。它将数据连续地存储在内存中，这使得它在随机访问（通过索引访问元素）时效率极高，同时，由于其动态特性，我们不必在编译时就确定其大小，可以根据程序运行的需要灵活增减元素。
解决方案
使用
std::vector
存储数据，核心在于理解其声明、添加/访问/删除元素以及容量管理。
1. 声明与初始化：
你可以直接声明一个空的
vector
：
立即学习“C++免费学习笔记（深入）”；
std::vector myNumbers; // 存储整数的vectorstd::vector names; // 存储字符串的vector
或者在声明时进行初始化：
std::vector initialNumbers = {10, 20, 30, 40}; // 使用初始化列表std::vector fixedSizeVector(5); // 创建一个包含5个double类型元素，默认值为0.0的vectorstd::vector filledVector(3, 'A'); // 创建一个包含3个'A'的vector
2. 添加元素：
最常用的方式是
push_back()
，它会在
vector
的末尾添加一个元素。
myNumbers.push_back(50); // myNumbers现在是 {10, 20, 30, 40, 50}myNumbers.push_back(60); // myNumbers现在是 {10, 20, 30, 40, 50, 60}
对于自定义对象，
emplace_back()
通常更高效，因为它直接在
vector
内部构造对象，避免了额外的拷贝或移动。
struct Point { int x, y; Point(int _x, int _y) : x(_x), y(_y) {}};std::vector points;points.emplace_back(1, 2); // 直接构造Point(1, 2)points.push_back(Point(3, 4)); // 先构造Point(3, 4)，再拷贝或移动到vector
3. 访问元素：
你可以像访问数组一样使用
[]
操作符，或者使用
at()
方法。
int firstNum = myNumbers[0]; // 访问第一个元素，不进行边界检查int lastNum = myNumbers.back(); // 访问最后一个元素int safeNum = myNumbers.at(1); // 访问第二个元素，会进行边界检查，越界会抛出std::out_of_range异常
迭代器也是访问元素的强大工具：
for (int num : myNumbers) { // C++11 范围for循环 std::cout << num << " ";}std::cout << std::endl;for (auto it = myNumbers.begin(); it != myNumbers.end(); ++it) { // 传统迭代器循环 std::cout << *it << " ";}std::cout << std::endl;
4. 删除元素：
pop_back()
：删除最后一个元素。
myNumbers.pop_back(); // 删除了60
erase()
：删除指定位置或范围的元素。
myNumbers.erase(myNumbers.begin() + 1); // 删除第二个元素 (20)myNumbers.erase(myNumbers.begin(), myNumbers.begin() + 2); // 删除前两个元素
clear()
：删除所有元素。
myNumbers.clear(); // vector变为空
5. 大小与容量：
size()
：返回
vector
中实际元素的数量。
capacity()
：返回
vector
当前分配的内存能容纳的元素数量。
reserve(n)
：预留至少能容纳
n
个元素的内存空间，可以减少后续的内存重新分配。
shrink_to_fit()
：请求
vector
减少其容量以适应其当前大小。
std::vector data;data.reserve(100); // 预留100个元素的空间for (int i = 0; i < 50; ++i) { data.push_back(i);}std::cout << "Size: " << data.size() << ", Capacity: " << data.capacity() << std::endl;data.shrink_to_fit(); // 尝试将容量调整到50std::cout << "After shrink_to_fit, Size: " << data.size() << ", Capacity: " << data.capacity() << std::endl;
std::vector
std::vector
vector
而不是数组？
在我看来，
std::vector
和C风格的普通数组（如
int arr[10];
或动态分配的
int* arr = new int[10];
）最大的本质区别在于它们的内存管理方式和安全性。普通数组在声明时大小就固定了，或者动态分配后也需要手动
delete[]
来释放内存，这种固定大小和手动管理内存的模式，说实话，挺容易出问题的，比如缓冲区溢出、内存泄漏等。
std::vector
则完全不同。它是一个“智能”的动态数组，它的核心优势在于：
动态大小与自动内存管理： 这是最关键的一点。
vector
可以根据需要自动增长或缩小，你不需要担心内存分配和释放。当你
push_back
一个元素时，如果当前容量不足，
vector
会自动分配一块更大的内存，将现有元素移动过去，然后释放旧内存。这个过程完全由
vector
自己处理，遵循RAII（资源获取即初始化）原则，即便发生异常，内存也能得到妥善释放。这极大地减少了内存泄漏和悬挂指针的风险。安全性：
vector
提供了
at()
方法进行边界检查。当你尝试访问一个越界的索引时，
at()
会抛出
std::out_of_range
异常，这比C风格数组的未定义行为（可能导致程序崩溃或更隐蔽的错误）要安全得多。虽然
[]
操作符不进行边界检查，但至少你有了选择。功能丰富： 作为STL的一部分，
vector
拥有丰富的成员函数（
size()
,
empty()
,
clear()
,
insert()
,
erase()
等），并且可以无缝地与STL的其他算法（如
std::sort
,
std::std::find
等）配合使用。这些都是普通数组所不具备的。迭代器支持：
vector
提供了迭代器，这让遍历和操作元素变得更加通用和灵活，也方便与STL算法集成。类型安全：
vector
是模板类，它能确保只存储你指定类型的数据，提供了编译时的类型检查。
我个人觉得，除非在极度追求极致性能且内存分配模式非常固定、或是在与C语言库接口时，否则几乎所有情况下都应该优先选择
std::vector
。它的便利性、安全性和功能性，远超普通数组带来的那一点点可能的“裸金属”性能优势。毕竟，现代C++编程更注重效率和安全性，而不是徒增出错的概率。
push_back
push_back
和
emplace_back
在性能和使用场景上有什么不同？我什么时候该用哪个？
这俩兄弟都是往
vector
末尾添加元素，但它们在幕后做的事情，尤其是在处理复杂对象时，差异还是挺大的。说白了，区别就在于对象是如何被创建和放置到
vector
内部的。
push_back
的工作方式是：
你传入一个已经存在的对象，或者一个临时对象。
push_back
会拷贝（如果传入的是左值）或移动（如果传入的是右值，比如一个临时对象或
std::move
过的对象）这个对象到
vector
内部。这意味着，如果你传入的是一个左值，会涉及到一次拷贝构造；如果你传入的是一个右值，会涉及到一次移动构造。在这之前，对象可能已经在别的地方构造了一次。
emplace_back
的工作方式是：
你传入的是构造目标对象所需的参数。
emplace_back
会直接在
vector
内部的内存空间上，原地构造这个对象。它避免了额外的拷贝或移动操作，因为对象从一开始就直接在它最终应该在的位置被构造出来。
性能差异：
对于基本数据类型（如
int
,
double
），或者那些拷贝/移动成本极低的轻量级对象，
push_back
和
emplace_back
的性能差异微乎其微，几乎可以忽略不计。对于复杂对象（比如有大量成员变量、需要分配内存、或者拷贝/移动构造函数开销很大的对象），
emplace_back
通常会带来显著的性能提升。因为它省去了至少一次拷贝或移动构造的开销。
使用场景：
使用
push_back
：
当你已经有一个现成的对象，想把它放到
vector
里时。
MyObject obj("data");myVector.push_back(obj); // 拷贝myVector.push_back(std::move(obj)); // 移动
当你需要将一个临时对象放入
vector
时，
push_back
也能很好地利用移动语义。
myVector.push_back(MyObject("temp_data")); // 移动
代码可读性可能略高，因为你直接看到了一个完整的对象被传入。
使用
emplace_back
：
首选当你需要将一个新创建的对象放入
vector
时。
emplace_back
能直接将构造函数的参数传递过去，在
vector
内部完成对象的构造，这是最有效率的方式。
// 假设MyObject有一个构造函数MyObject(const std::string& name, int id)myVector.emplace_back("new_item", 123); // 直接在vector内部构造MyObject
当对象构造开销大，或者拷贝/移动语义复杂时，
emplace_back
能避免不必要的中间对象创建和资源操作。
总的来说，我的建议是：如果能用
emplace_back
，就优先使用它。它代表了更现代、更高效的C++编程范式。只有当你确实需要将一个已经存在的对象（左值）放入
vector
，或者出于某些特殊原因（比如为了代码清晰度，或者构造函数参数过多导致
emplace_back
的参数列表过长），才考虑
push_back
。即使是
push_back
，如果传入的是右值，编译器也会优化为移动语义，但
emplace_back
是直接在目标位置构造，理论上是最优的。
std::vector
std::vector
的内存管理机制是怎样的？我应该如何理解它的容量（capacity）和大小（size）？
std::vector
的内存管理机制，说白了就是它背后有一套策略来动态地分配和释放内存，以适应元素数量的变化。这套机制是其强大和灵活的基石，但理解它对于写出高效的C++代码至关重要。
核心机制：内存重新分配 (Reallocation)
当
vector
需要添加新元素，而当前分配的内存空间（即容量）不足时，它会进行一次“重新分配”操作：
它会申请一块更大的内存空间（通常是当前容量的1.5倍或2倍，具体取决于STL实现）。将当前所有元素从旧内存移动（或拷贝，如果元素不支持移动语义）到新内存。释放旧的内存空间。
这个过程，尤其是当元素数量很多时，开销是相当大的。频繁的重新分配会导致性能下降，因为涉及到内存申请、数据移动和内存释放。
容量 (Capacity) 与 大小 (Size) 的理解：
这两个概念是
vector
内存管理的关键：
大小 (Size)：这是
vector
中实际存储的元素数量。
vector::size()
方法返回的就是这个值。它代表了你当前能访问到的有效元素的个数。比如，你
push_back
了5个元素，
size()
就是5。容量 (Capacity)：这是
vector
当前已经分配的内存可以容纳的元素总数。
vector::capacity()
方法返回的就是这个值。它总是大于或等于
size()
。当
size()
达到
capacity()
时，下一次添加元素就会触发重新分配。
举个例子：
std::vector v; // size = 0, capacity = 0 (或某个很小的初始值)v.push_back(1); // size = 1, capacity 可能变为 1v.push_back(2); // size = 2, capacity 可能变为 2 (如果之前是1) 或 4 (如果之前是2，增长2倍)v.push_back(3); // size = 3, capacity 可能保持 4v.push_back(4); // size = 4, capacity 保持 4v.push_back(5); // size = 5, capacity 触发重新分配，可能变为 8
你会发现，
capacity
的增长不是线性的，而是几何级的。这是为了摊平重新分配的成本，使得在平均情况下，
push_back
操作的复杂度是常数时间O(1)。
优化策略：
reserve(n)
： 如果你预先知道
vector
大概会存储多少元素，或者至少知道一个上限，那么在开始添加元素之前调用
reserve(n)
是一个非常好的习惯。它会一次性分配足够的内存，避免了后续多次重新分配的开销。这对于性能敏感的场景尤其重要。
shrink_to_fit()
： 当你从
vector
中删除了大量元素，导致
size
远小于
capacity
时，
vector
并不会自动释放多余的内存。如果你希望
vector
释放这些未使用的内存，让
capacity
尽可能接近
size
，可以调用
shrink_to_fit()
。但要注意，这个操作不保证一定会减少容量，标准只是说“请求”减少。而且，这个操作本身也可能涉及到一次重新分配（将数据移动到更小的内存块）。所以，只在确实需要释放大量内存，且不打算再添加大量元素时才考虑使用。迭代器失效： 这是一个非常重要的副作用。任何导致
vector
重新分配内存的操作（例如
push_back
当容量不足时，
insert
，
erase
，
clear
等）都会使指向
vector
内部元素的迭代器、指针和引用失效。这意味着你不能在修改
vector
的同时，继续使用之前获取的迭代器、指针或引用，否则会导致未定义行为。
理解
capacity
和
size
，并合理利用
reserve
，能让你更好地掌控
vector
的内存使用，避免不必要的性能损耗，写出更健壮、更高效的代码。在我看来，这是使用
std::vector
时一个常常被忽视但又极其重要的细节。
以上就是C++如何使用STL向量vector存储数据的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/1475689.html
微信扫一扫 
支付宝扫一扫 
