C++ 函数与 std::vector：引用传递的绝对统治

HAPPY酷

704人浏览 · 2026-03-09 11:45:00

HAPPY酷 · 2026-03-09 11:45:00 发布

C++ 函数与 std::vector：引用传递的绝对统治

摘要：
在 C++ 中处理动态数组（std::vector）时，“按值传递”是隐形的性能杀手。

核心原则：除非你确实需要一份独立的拷贝，否则永远通过引用 (&) 传递 vector。

只读场景：使用 const std::vector<T>&。

修改场景：使用 std::vector<T>&。

所有权转移：使用移动语义 (std::move) 或 std::unique_ptr。

本文将对比不同传参方式的性能差异，解析常见陷阱（如迭代器失效），并展示如何编写高效、安全的 vector 处理函数。

📉 第一部分：为什么不能“按值传递”？

1. 昂贵的深拷贝 (Deep Copy)

std::vector 内部管理着一块堆内存。当你按值传递它时，会触发拷贝构造函数，执行以下昂贵操作：

分配一块新的堆内存。
逐个拷贝原 vector 中的所有元素到新内存。
函数返回时，析构并释放这块临时内存。

如果 vector 有 100 万个元素，每次调用都要进行百万次内存操作，性能直接崩塌。

❌ 灾难现场 vs ✅ 最佳实践

#include <vector>
#include <chrono>
#include <iostream>

// ❌ 灾难现场：按值传递
// 每次调用都会触发一次完整的深拷贝！
long long processByValue(std::vector<int> data) {
    long long sum = 0;
    for (int x : data) sum += x;
    return sum;
}

// ✅ 最佳实践：按常量引用传递
// 无拷贝，直接访问原内存，仅传递一个指针大小的地址
long long processByRef(const std::vector<int>& data) {
    long long sum = 0;
    for (int x : data) sum += x;
    return sum;
}

int main() {
    std::vector<int> hugeVec(1000000, 1); // 100 万元素

    auto t1 = std::chrono::high_resolution_clock::now();
    processByValue(hugeVec); 
    auto t2 = std::chrono::high_resolution_clock::now();

    processByRef(hugeVec);
    auto t3 = std::chrono::high_resolution_clock::now();

    std::cout << "By Value Time: " 
              << std::chrono::duration_cast<std::chrono::microseconds>(t2 - t1).count() 
              << " μs\n";
    std::cout << "By Ref Time:   " 
              << std::chrono::duration_cast<std::chrono::microseconds>(t3 - t2).count() 
              << " μs\n";
              
    // 典型结果：By Value 耗时几百到几千微秒，By Ref 几乎为 0 (<1 μs)
}

🛠️ 第二部分：三种传参模式详解

模式 A：只读访问 (Read-Only) -> `const std::vector<T>&`

场景：遍历、查找、统计，不修改数据。
优点：零拷贝，且防止函数内部意外修改数据。
语法：

void printData(const std::vector<int>& vec) {
    // 内部循环也建议用 const auto&，避免二次拷贝
    for (const auto& val : vec) { 
        std::cout << val << " ";
    }
    // vec.push_back(1); // ❌ 编译错误：安全保护
}

模式 B：修改内容 (Modify In-Place) -> `std::vector<T>&`

场景：排序、过滤、追加元素、就地变换。
优点：零拷贝，直接修改原容器。
注意：调用者需明确知道数据会被修改。
语法：

void sortAndDouble(std::vector<int>& vec) {
    std::sort(vec.begin(), vec.end());
    for (auto& val : vec) {
        val *= 2;
    }
}

模式 C：可选参数或可能为空 -> `std::vector<T>*`

场景：函数逻辑允许“没有数据”的情况（类似 nullptr）。
缺点：需要手动判空，语法繁琐 (->)。
替代方案：C++17 推荐使用 std::optional<std::reference_wrapper<std::vector<T>>>，或者直接重载函数。
语法：

void processData(std::vector<int>* vec) {
    if (!vec) return; // 必须判空
    // ...
}

⚠️ 第三部分：常见陷阱与误区

陷阱 1：迭代器失效 (Iterator Invalidation)

当通过引用传递 vector 并在函数内修改其大小（如 push_back, erase）时，外部持有的迭代器、指针或引用可能会失效。

void addElement(std::vector<int>& vec) {
    vec.push_back(99); // 可能导致扩容，使旧迭代器失效
}

int main() {
    std::vector<int> v = {1, 2, 3};
    auto it = v.begin(); 
    
    addElement(v); 
    
    // ❌ 危险：如果发生了扩容，it 已经失效，解引用会导致未定义行为 (Crash!)
    // std::cout << *it; 
}

对策：如果函数会改变 vector 容量，调用后不要继续使用旧的迭代器，需要重新获取。

陷阱 2：误以为引用会重新绑定

和所有引用一样，你不能在函数内部让引用指向另一个 vector。

void switchVector(std::vector<int>& vec, std::vector<int>& other) {
    vec = other; // ❌ 这不是让 vec 引用 other！
                 // ✅ 这是把 other 的内容【拷贝赋值】给 vec 原来的对象！
                 // 原 vec 的内存可能被释放，内容被替换（发生拷贝）。
}

如果你想交换两个 vector 的内容而不拷贝，请使用 swap：

void swapVectors(std::vector<int>& a, std::vector<int>& b) {
    a.swap(b); // O(1) 操作，仅交换内部指针，极快且无拷贝
}

陷阱 3：返回局部 vector 的引用

// ❌ 致命错误
const std::vector<int>& getBadVec() {
    std::vector<int> temp = {1, 2, 3};
    return temp; // 💥 temp 销毁，返回悬空引用
}

修正：
直接返回值。现代编译器会应用 RVO/NRVO (返回值优化) 或 移动语义，效率极高且安全。

// ✅ 正确做法
std::vector<int> getGoodVec() {
    return {1, 2, 3}; // 高效，无拷贝
}

🚀 第四部分：进阶技巧

1. 移动语义 (Move Semantics) —— 避免拷贝的终极手段

如果你需要将一个 vector 的所有权转移给函数，或者函数生成一个大 vector 返回，使用 std::move。

场景 A：消耗型参数 (Consuming Argument)
函数需要接管 vector 的所有权（例如存入全局列表），不再需要原数据。

// 接受右值引用，表示“我要拿走这个 vector”
void storeData(std::vector<int>&& data) {
    globalList.push_back(std::move(data)); 
    // data 现在处于“有效但未指定”状态，原调用者的 vector 变空
}

std::vector<int> myData = {1, 2, 3};
storeData(std::move(myData)); // 显式移动，零拷贝
// 此时 myData 已空，不能再使用

场景 B：工厂函数返回

std::vector<int> createHugeData() {
    std::vector<int> data(1000000);
    // ... 填充 ...
    return data; // C++11/14/17/20 都会自动应用移动语义或 RVO，无拷贝
}

2. `std::span` (C++20) —— 更轻量的视图

如果你只需要访问 vector 的一部分，或者不想依赖 <vector> 头文件，C++20 引入了 std::span。

它只是一个 指针 + 长度，不拥有内存。
比引用更灵活，可以表示子数组，兼容 C 数组和 std::vector。

#include <span>

void processSpan(std::span<int> s) {
    // s.size() 可用
    // 可以接受 vector, 数组, 指针+长度
    for (int x : s) { /*...*/ }
}

std::vector<int> v = {1, 2, 3, 4, 5};
processSpan(v);            // OK: 整个 vector
processSpan({v.data(), 3}); // OK: 只处理前 3 个元素 (切片)

📊 总结决策表

需求	推荐签名	理由
只读查看	`void f(const std::vector<T>& v)`	首选。零拷贝，安全，语义清晰。
修改内容	`void f(std::vector<T>& v)`	零拷贝，直接修改原数据。
可选参数	`void f(std::vector<T>* v)`	允许传 `nullptr` 表示无数据。
转移所有权	`void f(std::vector<T>&& v)`	接收临时对象或通过 `std::move` 传入的对象，避免拷贝。
返回新数据	`std::vector<T> f()`	直接返回值，依靠 RVO/移动语义，高效且安全。
部分视图	`void f(std::span<T> s)` (C++20)	轻量级，可切片，不依赖具体容器类型。
❌ 绝对禁止	`void f(std::vector<T> v)`	除非你确实需要一份独立的拷贝，否则这是性能自杀。