C++ 中的参数传递

在C++中，参数传递是函数调用时数据传递的机制，直接影响函数内外数据的交互方式和性能。C++提供了多种参数传递方式，理解它们的区别和适用场景是编写高效、安全代码的关键。以下是详细介绍：

一、参数传递的三种基本方式

1. 值传递（Pass by Value）

• 机制：函数接收的是实参的副本，函数内对参数的修改不影响原始数据。
• 语法：

  void increment(int x) {
      x++;  // 修改副本，不影响原始值
  }
  
  int main() {
      int a = 5;
      increment(a);  // a 仍为 5
      return 0;
  }
  

• 特点：
  • 安全性高：避免函数意外修改外部数据。
  • 开销大：对大型对象（如结构体、类）复制成本高。

2. 引用传递（Pass by Reference）

• 机制：函数接收的是实参的引用（别名），函数内修改直接影响原始数据。
• 语法：

  void increment(int& x) {
      x++;  // 直接修改原始值
  }
  
  int main() {
      int a = 5;
      increment(a);  // a 变为 6
      return 0;
  }
  

• 特点：
  • 效率高：无需复制对象，适合传递大型对象。
  • 可修改性：函数可直接操作原始数据（需谨慎使用）。

3. 指针传递（Pass by Pointer）

• 机制：函数接收的是实参的地址，通过解引用操作原始数据。
• 语法：

  void increment(int* ptr) {
      (*ptr)++;  // 解引用修改原始值
  }
  
  int main() {
      int a = 5;
      increment(&a);  // a 变为 6
      return 0;
  }
  

• 特点：
  • 显式性：通过指针语法（* 和 &）明确表示可能修改外部数据。
  • 空指针风险：需检查指针是否为 nullptr 避免崩溃。

二、常量引用与常量指针

1. 常量引用（const T&）

• 作用：避免复制开销的同时禁止修改原始数据，常用于传递大型对象。
• 示例：

  void printString(const std::string& str) {
      cout << str;  // 只读访问，无法修改 str
  }
  

• 优势：
  • 支持临时对象作为参数（如 printString("hello");）。
  • 编译器可优化，避免不必要的复制。

2. 常量指针（const T*）

• 作用：禁止通过指针修改指向的数据。
• 示例：

  void printValue(const int* ptr) {
      cout << *ptr;  // 只读访问，无法修改 *ptr
  }
  

三、右值引用与移动语义（C++11起）

1. 右值引用（T&&）

• 作用：绑定到临时对象（右值），用于实现移动语义。
• 示例：

  void processValue(int&& value) {
      // 接收临时值（如字面量或函数返回值）
  }
  
  processValue(10);  // 合法：10 是右值
  int x = 5;
  // processValue(x);  // 非法：x 是左值
  

2. 移动构造函数与移动赋值

• 作用：高效转移资源所有权（如动态内存），避免深拷贝。
• 示例：

  class MyString {
  public:
      // 移动构造函数
      MyString(MyString&& other) noexcept {
          data = other.data;
          other.data = nullptr;  // 防止 other 析构时释放资源
      }
      // ...
  private:
      char* data;
  };
  

四、参数传递的性能对比

五、数组与函数参数

1. 数组作为参数

• 退化规则：数组作为函数参数时会退化为指针，丢失数组大小信息。
• 示例：

  void printArray(int arr[]) {  // 等价于 int* arr
      // sizeof(arr) 返回指针大小（如 8 字节），非数组大小
  }
  

• 改进方案：

  // 方案1：显式传递数组大小
  void printArray(int arr[], int size) { ... }
  
  // 方案2：使用引用（保留数组大小信息）
  void printArray(int (&arr)[5]) { ... }  // 仅接受长度为5的数组
  
  // 方案3：使用 std::array 或 std::vector
  void printArray(const std::array<int, 5>& arr) { ... }
  

2. 函数指针作为参数

• 作用：实现回调机制。
• 示例：

  void process(int a, int b, int (*op)(int, int)) {
      int result = op(a, b);  // 调用传入的函数
  }
  
  int add(int a, int b) { return a + b; }
  
  // 调用
  process(3, 5, add);  // 传递函数指针
  

六、可变参数函数

1. C风格可变参数（stdarg.h）

• 语法：使用 ... 和 va_list 宏。
• 示例：计算平均值：

  #include <cstdarg>
  
  double average(int count, ...) {
      va_list args;
      va_start(args, count);
      double sum = 0;
      for (int i = 0; i < count; ++i) {
          sum += va_arg(args, int);
      }
      va_end(args);
      return sum / count;
  }
  

2. C++11 可变参数模板

• 作用：类型安全的可变参数处理。
• 示例：递归展开参数包：

  template<typename T>
  T sum(T value) {
      return value;
  }
  
  template<typename T, typename... Args>
  T sum(T first, Args... args) {
      return first + sum(args...);
  }
  
  // 调用
  int result = sum(1, 2, 3, 4);  // 结果：10
  

七、常见陷阱与最佳实践

1. 悬空引用/指针

• 问题：函数返回局部变量的引用或指针。
• 示例：

  int& getValue() {
      int x = 10;
      return x;  // 错误：返回局部变量的引用
  }  // x 已销毁，引用无效
  

2. 过度使用指针

• 建议：优先使用引用替代指针，减少空指针风险。

  // 不良设计
  void process(int* ptr) {
      if (ptr) (*ptr)++;  // 需检查空指针
  }
  
  // 改进
  void process(int& ref) {
      ref++;  // 无需检查，引用必须绑定有效对象
  }
  

3. 大型对象值传递

• 问题：复制开销高。
• 解决方案：使用 const T& 或 T&&：

  void process(const std::vector<int>& data);  // 避免复制
  

通过合理选择参数传递方式，能在安全性、效率和代码可读性之间取得平衡。