40 C++ STL模板库9-容器2-vector

C++ STL模板库9-容器2-vector

文章目录

  • C++ STL模板库9-容器2-vector
    • 一、基础概念
      • 1. 类型成员（Type Members）
      • 2. 模板参数
    • 二、构造函数
      • 1. 语法
      • 2. 示例
    • 三、元素访问
      • 1. 函数说明
      • 2. 示例代码
    • 四、容量操作
      • 1. 函数说明
      • 2. 关键点说明
      • 3. 关键操作解析
      • 4. 操作示例
    • 五、修改
      • 1. 函数说明
      • 2. 关键操作解析
      • 3. 操作示例
      • 4. 操作技巧
    • 六、迭代器操作
      • 1. 函数说明
      • 2. 关键操作解析
      • 3. 操作示例
      • 4. 注意事项
    • 七、高效操作（C++11+）
      • 1. 函数说明
      • 2. 关键操作解析
      • 3. 常见错误规避
      • 4. 优先选择原则
    • 八、非成员函数
      • 1. 函数说明
      • 2. 示例代码
      • 3. 操作对比总结
    • 九、完整应用示例
      • 1. 类对象的向量
      • 2. 通过数组初始化向量
    • 十、关键特性
    • 十一、应用注意事项⚖️
      • 1. 完美转发陷阱
      • 2. 高性能尾部操作
      • 3. 内存释放替代方案
      • 4. 函数选择指南
      • 5. 避免裸指针操作

vector- 动态数组，也叫向量，内存连续，动态管理内存，下标访问，尾部增删效率高。是最常用的容器。

一、基础概念

1. 类型成员（Type Members）

类型说明
value_type元素类型（如 int）
allocator_type分配器类型（默认 std::allocator<T>）
size_type大小类型（通常 size_t）
reference元素引用（value_type&）
const_reference常量引用（const value_type&）
iterator随机访问迭代器
const_iterator常量迭代器

2. 模板参数

  • std::vector<T>(...) v; // T:元素类型, ...:参数

  • 示例：

    #include <vector>vector<int> vn;
vector<string> vs;// 元素的预分配和初始化
vector<int> vn (10); // 用0初始化10个元素
vector<int> vn (10, 5); // 用5初始化10个元素

二、构造函数

1. 语法

vector();                        // 默认构造 
vector(size_type count, T value); // 填充构造 
vector(iterator first, iterator last); // 范围构造 
vector(initializer_list<T> init);      // 初始化列表构造

2. 示例

#include <iostream>
#include <vector>
#include <array>int main() {// ========== 1. 默认构造 ==========std::vector<int> v1;  // 创建空vector std::cout << "v1大小: " << v1.size()  << "\n";  // 输出 0// ========== 2. 填充构造 ==========std::vector<char> v2(5, 'A');  // 5个'A'std::cout << "v2内容: ";for (char c : v2) std::cout << c;               // 输出 AAAAA// ========== 3. 范围构造 ==========std::array<int, 3> arr{10, 20, 30};std::vector<int> v3(arr.begin(),  arr.end());   // 复制数组元素 std::cout << "\nv3内容: ";for (int n : v3) std::cout << n << " ";          // 输出 10 20 30 // ========== 4. 初始化列表构造 ==========std::vector<std::string> v4 = {"Apple", "Banana", "Cherry"};std::cout << "\nv4内容: ";for (auto& s : v4) std::cout << s << " ";          // 输出 Apple Banana Cherry// ========== 组合验证 ==========std::vector<int> v5{ v3.begin(),  // 复用v3的范围构造 v3.begin()  + 2 };std::cout << "\nv5内容: ";for (int n : v5) std::cout << n << " ";          // 输出 10 20 return 0;
}

  • 初始化列表的等价操作

    // 以下两种写法等价
std::vector<int> a = {1,2,3};
std::vector<int> b({1,2,3});  // 显式构造函数

  • 显式类型转换

    // 避免整数类型混淆 
std::vector<int> v1(5, 2.5);    // 输出 {2,2,2,2,2}（截断）
std::vector<double> v2{5, 2.5}; // 输出 {5.0, 2.5}（保留精度）

三、元素访问

1. 函数说明

函数说明
at(size_type pos)边界检查访问（越界抛异常）
operator[](size_type pos)无检查直接访问
front()首元素引用
back()末元素引用
data()底层数组指针

2. 示例代码

#include <iostream>
#include <vector>
#include <stdexcept> // 异常处理int main() {std::vector<int> nums{10, 20, 30, 40, 50};// ===== 1. at() std::cout << "at(2): " << nums.at(2) << '\n';     // ✅ 输出 30 // ===== 2. operator[] 无检查访问 ===== std::cout << "operator[3]: " << nums[3] << '\n';  // ✅ 输出 40 // nums[10] = 100; // ❌ 未定义行为（可能崩溃或数据污染）// ===== 3. front() & back() 端点访问 =====std::cout << "front(): " << nums.front() << '\n';  // ✅ 输出 10（首元素）std::cout << "back(): " << nums.back() << '\n';    // ✅ 输出 50（尾元素）// ===== 4. data() 底层指针访问 =====int* ptr = nums.data();std::cout << "data()[1]: " << ptr[1] << '\n';  // ✅ 输出 20 *ptr = 100;  // 修改首元素std::cout << "front()修改后: " << nums.front() << '\n';  // 输出 100return 0;
}
  • 优先选择原则：
    • 用户输入索引必须用at()安全
    • 内部循环索引访问用 operator[]高效
    • 和C兼容用data()兼容

四、容量操作

1. 函数说明

函数作用描述时间复杂度内存影响
empty()判断容器是否为空O(1)无
size()获取当前元素数量O(1)无
max_size()系统支持的最大元素数O(1)无
capacity()当前预分配内存容量O(1)无
reserve(new_cap)预扩容至指定容量O(n)可能重新分配内存
shrink_to_fit()释放多余内存（非强制）O(n)可能缩小容量

2. 关键点说明

  • 大小可增可减，引起大小变化的函数包括resize()/push_back()/pop_back()/insert()/erase()。
  • 容量只增不减，直接引起容量变化的函数只有reserve()一个。
  • 大小的增加可能导致容量的增加，容量的变化不会引起大小的变化。
  • 通过resize()增加大小，新增部分会被初始化，但是通过reserve()增加容量，新增部分不做初始化。
  • 位于容量范围内但在大小范围外的元素，可以通过下标或迭代器访问，但其值不确定。
  • 无论是大小还是容量，它们的变化永远发生在向量容器的尾部。

3. 关键操作解析

  • 基础状态检测（empty()/size()）

    std::vector<int> v;
std::cout << "初始状态: " << "empty=" << v.empty()   // 输出 true << ", size=" << v.size()   // 输出 0 << "\n";v.push_back(10);
std::cout << "添加元素后: "<< "empty=" << v.empty()   // 输出 false << ", size=" << v.size()   // 输出 1 << "\n";

  • 容量动态增长（capacity()/reserve()）

    std::vector<std::string> words;
// 初始容量（实现相关，通常0）
std::cout << "初始容量: " << words.capacity() << "\n";  // 输出 0 words.reserve(3);  // 预分配3元素空间 
std::cout << "reserve(3)后容量: " << words.capacity() << "\n";  // 输出 3 words = {"A", "B", "C", "D"};  // 可能触发扩容（容量可能变6）
std::cout << "超容添加后容量: " << words.capacity() << "\n";  // 输出 4

  • 极限容量检测（max_size()）

    std::vector<double> data;
std::cout << "系统支持最大元素数: " << data.max_size() / 1e9 << " 亿"  // 示例输出 2.30584e+09 亿<< "\n（实际受限于内存和系统架构）\n";

  • 内存回收操作（shrink_to_fit()）

    std::vector<char> buffer(1000);
buffer.erase(buffer.begin()+100, buffer.end());  // 删除900元素 std::cout << "删除后: size=" << buffer.size()        // 输出 100 << ", capacity=" << buffer.capacity()     // 输出 1000 << "\n";buffer.shrink_to_fit();  // 请求释放内存 
std::cout << "shrink后: capacity=" << buffer.capacity()  // 输出 100（可能）<< "\n（实际效果依赖编译器实现）\n";

  • size() vs capacity() 关系
    在这里插入图片描述

  • 扩容策略优化（以GCC为例）

    // GCC扩容规则：new_cap = max(2*old_cap, required_size)
std::vector<int> v;
v.reserve(1);  // capacity=1 
v.push_back(1);
v.push_back(2);  // 触发扩容 → capacity=2 
v.push_back(3);  // 再次扩容 → capacity=4

  • shrink_to_fit() 的底层实现

    // 典型实现流程 
if (size() < capacity()) {vector tmp(*this);        // 拷贝构造新vector（按size分配）swap(tmp);                // 交换数据指针 
}

4. 操作示例

// 向量的大小和容量
#include <iostream>
#include <vector>
#include <algorithm>using namespace std;
void print (vector<int>& vn) {std::cout << "大小：" << vn.size ()     << "   ";std::cout << "容量：" << vn.capacity () << std::endl;for (vector<int>::iterator it = vn.begin ();it != vn.end (); it++)cout << *it << ' ';cout << endl;
}int main (void) {vector<int> v1 (10);print (v1);                 //大小：10   容量：10 //0 0 0 0 0 0 0 0 0 0v1.push_back (23);print (v1);                 //大小：11   容量：20 //0 0 0 0 0 0 0 0 0 0 23v1.resize (5);print (v1);                 //大小：5   容量：20 //0 0 0 0 0v1.resize (30);print (v1);                 //大小：30   容量：30 //0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 for (int i = 0; i < 10; i++)//大小：20   容量：30v1.pop_back ();print (v1);                 //0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0v1.reserve (40);            //大小：20   容量：40print (v1);                 //0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0v1.reserve (10);            //大小：20   容量：40print (v1);                 //0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0v1.insert (v1.begin () + 4, 55);//大小：21   容量：40print (v1);                 //0 0 0 0 55 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0v1.erase (v1.begin () + 4);//大小：20   容量：40print (v1);                //0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0v1.insert (v1.begin () + 4, 66);//大小：21   容量：40print (v1);                //0 0 0 0 66 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0vector<int>::iterator it =find (v1.begin (), v1.end (), /*66*/88);if (it == v1.end ())cout << "没找到！" << endl;//没找到！elsecout << *it << endl;   //66 int arr[] = {12, 56, 77, 45, 98, 100, 2};int *p = find (arr, arr + sizeof (arr) / sizeof (arr[0]), 45);cout << *p << endl;        // 45return 0;
}

五、修改

1. 函数说明

函数说明内存影响
clear()清空所有元素元素销毁，容量保留
push_back(const T& value)尾部插入元素可能触发扩容
pop_back()删除尾部元素尾部元素销毁（容量不变）
insert(iterator pos, const T& value)指定位置插入插入节点后元素后移
erase(iterator pos)删除指定元素删除节点后元素前移
resize(size_type count)调整元素数量增删默认构造元素
swap(vector& other)交换两个容器内容仅交换指针
assign()完全替换 vector 内容原元素全销毁

2. 关键操作解析

  • clear() vs resize(0)

    std::vector<int> v{1,2,3};
v.clear();       // 内存状态: [  ] 容量=3
v.resize(0);     // 效果相同（但依赖实现）

  • 插入删除的性能陷阱，头部插入和尾部插入都会使元素向后移动

    // 连续头部插入：O(n²) 性能灾难！
for (int i = 0; i < 1000; ++i) v.insert(v.begin(), i);  // 每次插入全体后移 // 优化方案：尾部插入后反转
for (int i = 0; i < 1000; ++i) v.push_back(i);
std::reverse(v.begin(), v.end());

  • swap 的原子性优势

    current_data.swap(new_data); // 原子指针交换

  • assign 的隐蔽风险

    std::vector<std::string> names{"Alice", "Bob"};
std::vector<std::string> temp = names; // 深拷贝备份 names.assign(1000, "Unknown"); // 原元素"Alice","Bob"被销毁 
// 若异常抛出：原数据丢失且无恢复！

3. 操作示例

#include <iostream>
#include <vector>void print(const std::vector<int>& v, const char* msg) {std::cout << msg << ": [";for (int n : v) std::cout << n << " ";std::cout << "]  容量: " << v.capacity()  << "\n\n";
}int main() {// === 1. 初始状态 === std::vector<int> nums{10, 20, 30};print(nums, "初始状态");  // [10 20 30] 容量:3 // === 2. push_back：尾部插入 ===nums.push_back(40); print(nums, "push_back(40)");  // [10 20 30 40] 容量:6（触发扩容）// === 3. pop_back：尾部删除 === nums.pop_back(); print(nums, "pop_back()");  // [10 20 30] 容量:6 // === 4. insert：指定位置插入 === nums.insert(nums.begin()  + 1, 99);print(nums, "insert(pos1,99)");  // [10 99 20 30] 容量:6// === 5. erase：指定位置删除 ===nums.erase(nums.begin()  + 2);print(nums, "erase(pos2)");  // [10 99 30] 容量:6// === 6. resize：调整元素数量 === nums.resize(5);  // 新增2个默认0 print(nums, "resize(5)");  // [10 99 30 0 0] 容量:6 nums.resize(2);  // 删除尾部3个print(nums, "resize(2)");  // [10 99] 容量:6 // === 7. assign：完全替换内容 ===nums.assign({7,  8, 9, 10});print(nums, "assign({7,8,9,10})");  // [7 8 9 10] 容量:6 // === 8. swap：容器交换 === std::vector<int> other{100, 200};nums.swap(other); print(nums, "swap后nums");  // [100 200] 容量:2 print(other, "swap后other"); // [7 8 9 10] 容量:6// === 9. clear：清空元素 === nums.clear(); print(nums, "clear()后");  // [] 容量:2（容量保留！）return 0;
}

4. 操作技巧

  • 容量预分配规则 ，提前把容量分配好，避免在循环里使用push_back()时扩容造成时间开销

    std::vector<int> data;
data.reserve(1000);   // 预分配避免多次扩容
for (int i=0; i<1000; ++i) data.push_back(i); // 无扩容开销

  • 安全删除模式

    // 删除特定条件元素（避免迭代器失效）
auto it = data.begin();
while (it != data.end()) 
{if (*it % 2 == 0) it = data.erase(it); // erase返回下一有效迭代器 else ++it;
}

  • 移动语义优化

    // 在 words 尾部插入字符串变量 huge_str 使用移动语义而非拷贝
std::vector<std::string> words;
std::string huge_str = get_large_string();
words.push_back(std::move(huge_str)); // 移动而非拷贝

六、迭代器操作

1. 函数说明

begin() / end();       // 正向迭代器
rbegin() / rend();     // 反向迭代器
cbegin() / cend();     // 常量正向迭代器 
crbegin() / crend();   // 常量反向迭代器

2. 关键操作解析

  • 随机访问：下标、迭代器

    vn[1] = 40;
*(vn.begin () + 1) = 40;

  • 基础正向迭代（可读写）

    std::vector<int> nums{10, 20, 30};
// 修改第二个元素 
auto it = nums.begin() + 1;
*it = 200;  // ✅ 允许修改 
for (auto i = nums.begin(); i != nums.end(); ++i) std::cout << *i << " ";  // 输出：10 200 30

  • 反向迭代（镜像操作）

    std::vector<char> letters{'A','B','C'};
// 逆序输出并修改首元素 
auto rit = letters.rbegin();
*rit = 'Z';  // ✅ 修改最后一个元素 
for (auto r = letters.rbegin(); r != letters.rend(); ++r)std::cout << *r << " ";  // 输出：Z B A

  • 常量反向迭代（安全遍历）

    const std::string str = "HELLO";
// 逆序输出且无法修改 
for (auto cr = str.crbegin(); cr != str.crend(); ++cr)std::cout << *cr;  // 输出：OLLEH

  • 迭代器类型转换关系

    std::vector<int>::iterator          // begin()返回类型 
std::vector<int>::const_iterator    // cbegin()返回类型 
std::vector<int>::reverse_iterator  // rbegin()返回类型 
std::vector<int>::const_reverse_iterator // crbegin()返回类型

  • 与C风格数组的互操作

    int arr[] = {100, 200, 300};
// 用标准库函数获取迭代器 
auto arr_begin = std::begin(arr);  // ✅ 等效 &arr[0]
auto arr_end = std::end(arr);      // ✅ 等效 &arr[3]

3. 操作示例

#include <iostream>
#include <vector>using namespace std;void print (vector<int>& vn) 
{vector<int>::size_type size = vn.size ();cout << "元素个数：" << size << " -> ";for (vector<int>::size_type i = 0; i < size; i++)cout << vn[i] << ' ';cout << endl;
}
void show (vector<int>& vn) 
{for (vector<int>::iterator it = vn.begin (); it != vn.end (); it++)cout << *it << ' ';cout << endl;
}int main (void) 
{vector<int> vn;vn.push_back (10);vn.push_back (20);vn.push_back (30);print (vn);        // 元素个数：3 -> 10 20 30show (vn);        // 10 20 30vn.pop_back ();print (vn);        // 元素个数：2 -> 10 20vn[1] = 40;print (vn);        // 元素个数：2 -> 10 40vector<int>::const_iterator it = vn.begin ();it++;//    (*it)++; // it的目标不可修改，如同常量指针// const xxx *或xxx const *// 而const vector<int>::iterator it 表示迭代器本身不可修改，如同指针常量// xxx * constvector<int> v1 (10);print (v1);        // 元素个数：10 -> 0 0 0 0 0 0 0 0 0 0vector<int> v2 (10, 5);print (v2);        // 元素个数：10 -> 5 5 5 5 5 5 5 5 5 5v1[0] = 100;v1[9] = 200;cout << v1.front () << ' ' << v1.back() << endl;//100 200return 0;
}

4. 注意事项

  • 类型推导陷阱

    auto it1 = nums.begin();   // 推导为iterator（可修改）
auto it2 = nums.cbegin();  // 推导为const_iterator（安全）

  • 范围循环本质

    for (int n : nums) { /*...*/ } 
// 等价于：
for (auto it = nums.begin(); it != nums.end(); ++it)

  • 迭代器失效场景

    std::vector<int> data{1,2,3};
auto it = data.begin();
data.push_back(4);  // 可能触发扩容 
*it = 5;  // ❌ 迭代器已失效（未定义行为）

七、高效操作（C++11+）

1. 函数说明

函数说明
emplace_back(Args&&... args)直接构造尾部元素
emplace(iterator pos, Args&&... args)直接构造指定位置元素

2. 关键操作解析

// 直接构造对象（避免拷贝）
struct Point { int x, y; };
std::vector<Point> points;
points.emplace_back(3,  4);  // 直接调用构造函数 

// ✅ 推荐使用emplace的情况 
v.emplace_back("text",  100);  // 构造参数简单 
v.emplace(v.begin(),  1, 2, 3); // 插入位置敏感 // ⚠️ 不推荐使用的情况 
v.emplace_back(existing_obj);   // 已有对象直接push_back更清晰 

// 简单类型（int/double等）
v.push_back(42);           // ✅ 清晰简洁 // 多参数构造的复杂类型 
v.emplace_back("ID007",  9.8, Vector3D());  // ✅ 避免临时对象 // 在迭代器中间插入 
v.emplace(v.begin()  + 2, config);  // ✅ 减少元素移动次数 // 对象已存在时 
auto obj = HeavyObject(...);
v.push_back(std::move(obj));   // ✅ 明确所有权转移

3. 常见错误规避

错误案例后果修正方案
emplace_back({1,2,3})编译错误（初始化列表歧义）emplace_back(std::initializer_list{1,2,3})
emplace(pos, arg) 后使用旧迭代器迭代器失效接收返回的新迭代器 it = emplace(...)
忽略移动语义类型意外拷贝操作对移动类型显式使用 std::move

4. 优先选择原则

// 简单类型（int/double等）
v.push_back(42);          // ✅ 清晰简洁 // 多参数构造的复杂类型 
v.emplace_back("ID007", 9.8, Vector3D());  // ✅ 避免临时对象 // 在迭代器中间插入 
v.emplace(v.begin() + 2, config);  // ✅ 减少元素移动次数 // 对象已存在时 
auto obj = HeavyObject(...);
v.push_back(std::move(obj));  // ✅ 明确所有权转移

八、非成员函数

1. 函数说明

函数说明
operator==, !=, <, >容器比较
std::swap(vector<T>& lhs, rhs)特化交换
erase(vector<T>& c, const T& value)删除匹配值（C++20）
erase_if(vector<T>& c, Predicate pred)条件删除（C++20）

2. 示例代码

  • 容器比较运算符

    std::vector a{1,2,3}, b{1,2,3}, c{9};// 等值比较（需元素数量和值相同）
bool eq = (a == b);  // ✅ true（深层次比较）// 字典序比较（常用于排序）
bool lt = (c < a);   // ✅ true（9<1）

  • 特化交换函数

    std::vector v1{10,20}, v2{30};// 高性能交换（无拷贝，仅交换指针）
std::swap(v1, v2);  // v1: [30]｜v2: [10,20]（容量同步交换）

  • 值匹配删除 erase() (C++20)

    std::vector nums{5,2,5,8};// 删除所有值为5的元素 
std::erase(nums, 5);  // 结果：[2,8]（返回删除数量）

  • 条件删除 erase_if() (C++20)

    std::vector data{-3,7,-1,0};// 删除所有负数（λ表达式）
std::erase_if(data, [](int x){return x<0;});  // 结果：[7,0]（支持复杂逻辑）

3. 操作对比总结

函数典型场景优势
operator==配置比对/结果验证深度比较容器内容
std::swap(vector&, vector&)线程安全数据交换零拷贝原子操作
erase(vector&, value)批量删除特定值比循环+erase高效
erase_if(vector&, pred)复杂条件删除（如负/奇数）避免手写易出错的迭代器逻辑

九、完整应用示例

1. 类对象的向量

  • 如果一个类类型的对象需要被存储在向量中，那么这个类至少应该支持无参构造，以确保为这个向量所分配的内存能够被正确的初始化。
  • 该类可能还需要支持拷贝构造函数和拷贝赋值操作符重载函数。
  • 如有必要可能还需要支持“==”和“<“操作符。
// 类对象的向量
#include <iostream>
#include <vector>using namespace std;class Integer {
public:Integer (void) : m_data (0) {cout << "无参构造：" << this << endl;}Integer (int data) : m_data (data) {cout << "有参构造：" << this << endl;}~Integer (void) {cout << "析构函数：" << this << endl;}Integer (const Integer& that) :m_data (that.m_data) {cout << "拷贝构造：" << &that << " -> " <<this << endl;}Integer& operator= (const Integer& that) {cout << "拷贝赋值：" << &that << " -> " <<this << endl;if (&that != this)m_data = that.m_data;return *this;}bool operator== (const Integer& that) const {return m_data == that.m_data;}bool operator< (const Integer& that) const {return m_data > that.m_data;}int m_data;
};int main (void) {cout << "-------- 1 --------" << endl;vector<Integer> vi (5, Integer (100));//1次有参构造 5次拷贝构造   6次析构cout << "-------- 2 --------" << endl;vi.erase (vi.begin ());               //删除节点后元素前移 //4次拷贝赋值 5次析构  cout << "-------- 3 --------" << endl;vi.insert (vi.begin (), Integer (200));//插入节点后元素后移 //1次有参构造 1次拷贝构造 4次拷贝赋值 6次析构  cout << "-------- 4 --------" << endl;vi.resize (1);                         //调整容器大小为1   //5 次析构  cout << "-------- 5 --------" << endl;vi.resize (5);                         //调整容器大小为5   //5 次析构  cout << vi.capacity() << endl;         //5cout << "-------- 6 --------" << endl;vi.reserve (10);                       //调整容器大小为 10  //5次拷贝构造 添加5个初始化的0元素cout << "-------- X --------" << endl;vi[0] = 12;                            //分别调用5次 有参构造 拷贝赋值 析构函数：vi[1] = 23;vi[2] = 47;vi[3] = 33;vi[4] = 47;return 0;
}

2. 通过数组初始化向量

  • 核心代码：vector<int> v1(&arr[0], &arr[5]); 

    int arr[5] = {1, 2, 3, 4, 5};
vector<int> v1 (&arr[0], &arr[5]);

  • 迭代器范围原理：

    • &arr[0] 指向首元素（包含）

    • &arr[5] 是尾后指针（不包含）

    • 实际构造范围：[arr[0], arr[5]) → 等价于 arr[0]到arr[4]

      // 用容器初始化容器
#include <iostream>
#include <vector>
using namespace std;
int main (void) {int arr[5] = {1, 2, 3, 4, 5};vector<int> v1 (&arr[0], &arr[5]);//实际构造范围：[arr[0], arr[5]) → 等价于 arr[0]到arr[4]for (int i = 0; i < v1.size (); i++)cout << v1[i] << ' ';cout << endl;               // 1 2 3 4 5vector<int> v2 (v1.begin () + 1, v1.end () - 1);for (int i = 0; i < v2.size (); i++)cout << v2[i] << ' ';cout << endl;               // 2 3 4for (vector<int>::reverse_iterator it = v1.rbegin (); it != v1.rend (); it++)cout << *it << ' ';         // 5 4 3 2 1cout << endl;return 0;
}

十、关键特性

  1. 动态内存管理：自动扩容（通常按2倍扩容）
  2. 连续存储：支持指针算术操作
  3. 异常安全：强异常保证（部分操作）
  4. 时间复杂度：
    • 随机访问：O(1)
    • 尾部插入/删除：均摊O(1)
    • 中间插入/删除：O(n)

十一、应用注意事项⚖️

1. 完美转发陷阱

std::vector<std::unique_ptr<Device>> devices;
// 错误：尝试复制 unique_ptr 
// devices.emplace_back(new Device()); // 正确：显式移动 
devices.emplace_back(std::make_unique<Device>());

2. 高性能尾部操作

vector<int> data;
data.reserve(1000);  // 预分配避免多次扩容
for(int i=0; i<1000; ++i) 
data.emplace_back(i);// C++20 安全删除
erase_if(data, [](int x){ return x%2==0; });

3. 内存释放替代方案

// 强制释放内存的可靠方法 
std::vector<int> huge_data = get_data();
std::vector<int>(huge_data).swap(huge_data);  // 通过临时对象交换

4. 函数选择指南

场景推荐操作理论依据
容器状态检测empty()替代size()==0语义更清晰
高性能批量插入reserve()预分配避免多次扩容开销
内存敏感型系统shrink_to_fit()减少内存占用（可能有效）
跨平台开发避免依赖max_size()不同系统差异过大
实时系统慎用动态扩容防止不可预测的内存分配延迟

5. 避免裸指针操作

// 改用data()获取首元素指针 
vector<int> v{1,2,3};
int* p = v.data();   // 等效&v[0]但更安全

实际开发中，优先使用 emplace_back() 替代 push_back() 避免拷贝，结合 reserve() 可显著提升性能。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如若转载，请注明出处：http://www.pswp.cn/pingmian/93236.shtml
繁体地址，请注明出处：http://hk.pswp.cn/pingmian/93236.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

GPT-5系列文章2——新功能、测试与性能基准全解析

GPT-5系列文章2——新功能、测试与性能基准全解析

引言 2025年8月&#xff0c;OpenAI正式发布了其新一代旗舰模型GPT-5。与业界此前期待的AGI(人工通用智能)突破不同&#xff0c;GPT-5更像是OpenAI对现有技术的一次深度整合与用户体验优化。本文将全面解析GPT-5的新特性、实际测试表现以及官方发布的基准数据&#xff0c;帮助开…
阅读更多...
利用cursor+MCP实现浏览器自动化释放双手

利用cursor+MCP实现浏览器自动化释放双手

小伙伴们&#xff0c;我们今天利用cursorMCP实现浏览器自动化&#xff0c;释放双手&#xff0c;工作效率嘎嘎提升&#xff01;前期准备&#xff1a;安装node.js网址&#xff1a;https://nodejs.org/zh-cn下载下来安装即可。 下载browser-tools-mcp扩展程序&#xff1a;下载扩展…
阅读更多...
指针/边界索引混淆梳理

指针/边界索引混淆梳理

在处理数组/链表等数据结构时&#xff0c;时常混淆长度和指针序号。处理技巧&#xff1a;使用0-base索引。则区间长度 rightIndex - LeftIndex 1总长度 lastIndex - firstIndex 1链表创建一个dummy节点&#xff0c;添加到head前&#xff0c;则可认为从索引0开始。末尾指针判…
阅读更多...
LeetCode 刷题【43. 字符串相乘】

LeetCode 刷题【43. 字符串相乘】

43. 字符串相乘 自己做 解1&#xff1a;矩阵计数 class Solution { public:string multiply(string num1, string num2) {int len1 num1.size();int len2 num2.size();if (num1[0] 0 || num2[0] 0) //结果为0的情况return "0";//存储计算过程的矩阵vector…
阅读更多...
NLP数据增强方法及实现-A

NLP数据增强方法及实现-A

目录 词替换 主要参考&#xff1a;paddlenlp/data_aug模块 词替换数据增强策略也即将句子中的词随机替换为其他单词进行数据增强&#xff0c;这里我们将介绍如何使用paddlenlp.dataaug.WordSubstitute进行词级别替换的数据增强。 WordSubstitute 参数介绍&#xff1a;aug_ty…
阅读更多...
EhViewer安卓ios全版本类下载安装工具的完整路径解析

EhViewer安卓ios全版本类下载安装工具的完整路径解析

开发一款类似EhViewer的下载安装工具&#xff08;集下载管理、应用部署等功能于一体&#xff09;&#xff0c;需要经历从需求锚定到落地发布的系统性流程。以下从需求拆解到技术落地的全维度指南&#xff0c;将帮你理清开发脉络&#xff0c;避开常见陷阱。安装 GitHub - huangy…
阅读更多...
MySQL 主键详解：作用与使用方法

MySQL 主键详解：作用与使用方法

在 MySQL 数据库中&#xff0c;主键&#xff08;Primary Key&#xff09; 是表结构设计中最重要的约束之一。它不仅是数据唯一性的保障&#xff0c;也是多表关联、查询优化的核心工具。本文将从 主键的作用 和 主键的用法 两个方面进行讲解&#xff0c;并配合代码示例帮助理解一…
阅读更多...
lib.dom.d.ts

lib.dom.d.ts

lib.dom.d.ts 是一个 TypeScript 类型声明文件&#xff0c;它是 TypeScript 标准库的一部分&#xff0c;用于定义浏览器 DOM&#xff08;文档对象模型&#xff09;相关的类型和接口。这个文件为开发者提供了浏览器中所有内置的 DOM 类型的定义&#xff0c;包括 localStorage、d…
阅读更多...
Spring 工具类：StopWatch

Spring 工具类：StopWatch

StopWatch 是 Spring 框架提供的一个简单而强大的计时工具类&#xff0c;用于测量代码块的执行时间。它特别适合在开发阶段进行性能分析、调试和优化。 基本使用方法 // 创建 StopWatch 实例&#xff08;可指定 ID&#xff09; StopWatch stopWatch new StopWatch("性能分…
阅读更多...
解决 VSCode 运行 Python 时 ModuleNotFoundError: No module named ‘open_webui‘ 问题

解决 VSCode 运行 Python 时 ModuleNotFoundError: No module named ‘open_webui‘ 问题

目录 1. 问题原因分析 2. 解决思路 3. 解决步骤 3.1 打开或创建 .vscode/launch.json 3.2 添加调试配置 3.3 配置说明 3.4 运行测试 4. 总结 在使用 VSCode 调试 Python 项目时&#xff0c;我们经常会遇到类似下面的错误&#xff1a; Exception has occurred: ModuleN…
阅读更多...
Python基础-数据结构

Python基础-数据结构

数据结构 Python提供了四种主要的内置数据结构&#xff1a;列表&#xff08;List&#xff09;、元组&#xff08;Tuple&#xff09;、字典&#xff08;Dictionary&#xff09;和集合&#xff08;Set&#xff09;。每种数据结构都有其特定的用途和特性。 Python数据结构概览&…
阅读更多...
NLP学习之Transformer（1）

NLP学习之Transformer（1）

初识 Transformer &#xff08;1&#xff09; 1.简介 1.1主要特点&#xff1a; self-attention&#xff1a; 自注意力机制&#xff0c;Transformer的核心是自注意力机制&#xff0c;它允许模型在处理某个位置的输入时&#xff0c;能够直接与其他位置的输入交互&#xff0c;而不…
阅读更多...
C语言笔记6：C高级 part1

C语言笔记6：C高级 part1

1.gcc 编译器 编译流程 预处理-》编译》汇编》链接》 E 预处理的命令 S 编译汇编代码 -c汇编阶段命令 -o 输出对应的文件GDB调试工具2.作用域存储分类// C高级部分知识多&#xff0c; 加上这周 我学的知识量有点爆炸。家里又有事情&#xff0c;这周末要回老家 争取下周补齐吧。…
阅读更多...
A12预装app

A12预装app

在A12上预装应用&#xff0c;出现了一个异常。在此记录问题描述&#xff1a;在A12上预装应用按照A13的预装方案报错&#xff0c;mk文件如下&#xff1a;LOCAL_PATH : $(call my-dir) include $(CLEAR_VARS) LOCAL_MODULE_TAGS : optional LOCAL_MODULE : Tideen_PTT LOCAL_MODU…
阅读更多...
termios 线程 poll epoll进化 二叉AVL红黑树

termios 线程 poll epoll进化 二叉AVL红黑树

struct termios tio 是什么 #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <fcntl.h> #include <termios.h>#define SERIAL_PORT "/dev/ttyS0" #define BUF_SIZE 256int main(v…
阅读更多...
C++设计模式：类间关系

C++设计模式：类间关系

类封装了数据和行为&#xff0c;是面向对象的重要组成部分&#xff0c;它是具有相同属性、操作、关系的对象集合的总称。在系统中&#xff0c;每个类都具有一定的职责&#xff0c;职责指的是类要完成什么样子的功能&#xff0c;要承担什么样子的义务。一个类可以有多种职责&…
阅读更多...
MSYS2+CMake配置C/C++开发环境

MSYS2+CMake配置C/C++开发环境

目录一、MSYS2是什么1.1 核心架构与组件​​1.1.1 背景介绍1.1.1.1 Cygwin1.1.1.2 MinGW和Mingw-w641.1.1.3MSYS和MSYS21.1.2 技术基础​​1.1.3 多环境支持​​1.2 核心功能​​1.2.1 类Unix开发环境​​1.2.2 开发工具链​​1.2.3 软件仓库与包管理​​二、安装和配置2.1 配置…
阅读更多...
Vue 3 + TypeScript：package.json 示例 / 详细注释说明

Vue 3 + TypeScript：package.json 示例 / 详细注释说明

一、示例 / 详细注释说明 {// 项目基础信息"name": "vite-project", // 项目名称&#xff08;建议使用 kebab-case 格式&#xff09;"private": true, // 标记为私有项目&#xff0c;避免意外发布到 npm"version": "1.0.…
阅读更多...
SpatialVLM和SpatialRGPT论文解读

SpatialVLM和SpatialRGPT论文解读

目录 一、SpatialVLM 1、概述 2、方法 3、实验 二、SpatialRGPT 1、概述 2、方法 3、训练方法 4、实验 一、SpatialVLM 1、概述 SpatialVLM是最早的依赖传统VLMs实现3D空间推理能力的论文&#xff0c;在24年1月由DeepMind团队提出&#xff0c;当时对比的还是GPT4v&am…
阅读更多...
理解GPU架构：基础与关键概念

理解GPU架构：基础与关键概念

GPU 基础概述&#xff1a;从图形渲染到 AI 与高性能计算的核心 Graphics Processing Units&#xff08;GPU&#xff09;已从专用的图形渲染硬件演进为 AI、科学计算与高性能任务的中坚力量。本文将介绍 GPU 架构的基础知识&#xff0c;包括其组成部分、内存层次结构&#xff0c…
阅读更多...
最新文章

Copyright @ 2022~2023