共计 2577 个字符，预计需要花费 7 分钟才能阅读完成。

1. 背景痛点：新手常见传参错误

刚接触 C ++ 的函数参数传递时，最容易踩的坑往往集中在三个方面：

• 不必要的拷贝 ：盲目使用值传递导致大对象被复制，例如直接传递std::vector 或自定义结构体
• 悬空引用 / 指针：函数内使用外部变量的引用或指针，但该变量生命周期已结束
• 意外修改 ：未使用const 修饰导致传入参数被意外修改，破坏原始数据

// 典型错误示例：大对象值传递
void processVector(std::vector<int> data) {/*...*/} // 每次调用都会复制整个 vector

// 正确做法：常量引用传递
void processVector(const std::vector<int>& data) {/*...*/}

2. 技术对比：三种传递方式详解

2.1 值传递 (Pass by Value)

• 工作原理：创建参数的完整副本
• 优点：
• 函数内修改不影响原始数据
• 适合基本类型和小型结构体
• 缺点：
• 大对象复制成本高
• 可能触发多次构造 / 析构

2.2 引用传递 (Pass by Reference)

• 工作原理：传递变量的别名
• 优点：
• 零拷贝开销
• 可以直接修改原始数据（非常量引用）
• 缺点：
• 需注意生命周期问题
• 可能被意外修改（需配合 const）

2.3 指针传递 (Pass by Pointer)

• 工作原理：传递内存地址
• 优点：
• 明确表达参数可被修改
• 可以传递 nullptr 表示可选参数
• 缺点：
• 需要检查空指针
• 语法较引用更复杂

3. 核心实现：代码示例对比

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

// 1. 值传递示例
void valuePass(std::vector<int> vec) {vec[0] = 100; // 只修改副本
}

// 2. 常量引用传递
void constRefPass(const std::vector<int>& vec) {// vec[0] = 100; // 编译错误：不能修改 const 引用
    std::cout << "First element:" << vec[0] << '\n';
}

// 3. 非常量引用传递
void refPass(std::vector<int>& vec) {vec[0] = 200; // 修改原始数据
}

// 4. 指针传递
void pointerPass(std::vector<int>* vec) {if (vec) { // 必须检查空指针
        (*vec)[0] = 300;
    }
}

int main() {std::vector<int> data = {1, 2, 3};

    // 测试值传递
    auto start = std::chrono::high_resolution_clock::now();
    valuePass(data); // 触发拷贝构造
    auto end = std::chrono::high_resolution_clock::now();
    std::cout << "值传递耗时:" 
              << std::chrono::duration_cast<std::chrono::microseconds>(end - start).count() 
              << "微秒 \n";

    // 测试引用传递（无拷贝）start = std::chrono::high_resolution_clock::now();
    constRefPass(data);
    end = std::chrono::high_resolution_clock::now();
    std::cout << "引用传递耗时:" 
              << std::chrono::duration_cast<std::chrono::microseconds>(end - start).count() 
              << "微秒 \n";

    return 0;
}

4. 性能考量：大对象传递优化

通过基准测试对比传递 1MB 数据的不同方式：

优化建议：
– 对于只读大对象：使用const &
– 需要转移所有权时：使用移动语义(std::move)
– 需要修改原始对象：使用 & 或指针

5. 避坑指南：5 大常见陷阱

1. 悬空引用问题

   int& createRef() {
       int x = 10;
       return x; // 返回局部变量的引用！}

   解决方案：确保引用指向的对象生命周期足够长

2. 意外的 const 转换

   void print(const std::string& s);
   print("hello"); // 隐式创建临时 string 对象

   解决方案：明确使用std::string_view(C++17)

3. 指针参数忘记检查 nullptr
   解决方案：使用 assert 或改为引用参数

4. 误用移动语义导致数据失效

   void process(std::string&& s);
   std::string str = "data";
   process(std::move(str));
   // str 现在处于有效但未定义状态！

   解决方案：移动后不再使用原对象

5. 多态对象切片问题

   class Base {/*...*/};
   class Derived : public Base {/*...*/};
   
   void func(Base b); // 值传递会导致切片
   Derived d;
   func(d); // 丢失 Derived 特有信息

   解决方案：使用引用或指针传递

6. 进阶技巧

6.1 const 正确性

// 明确函数不会修改参数
void analyze(const BigObject& obj);

// 成员函数承诺不修改对象状态
class Logger {
public:
    void log() const; // const 成员函数};

6.2 移动语义(C++11)

class Buffer {Buffer(Buffer&& other) { // 移动构造
        data_ = other.data_;
        other.data_ = nullptr;
    }
};

void store(Buffer&& buf); // 只接受右值

6.3 完美转发(C++11)

template<typename T>
void relay(T&& arg) { // 通用引用
    process(std::forward<T>(arg)); // 保持值类别
}

总结

选择参数传递方式时需考虑：
1. 是否需要修改原始对象
2. 参数的数据大小
3. 对象的生命周期管理
4. 是否需要支持多态
5. 性能敏感度

现代 C ++ 的最佳实践：
– 优先使用 const & 传递只读大对象
– 需要修改时使用 & 或指针
– 转移所有权时使用移动语义
– 模板代码考虑完美转发