C++中对象传参的几种方式

在 C++ 中传递对象作为函数参数有多种方式，每种方式都有不同的语义、性能特点和适用场景。以下是全面的分析和最佳实践指南：

1. 按值传递 (Pass by Value)

void processObject(MyClass obj) {
    // 操作 obj 的副本
}

MyClass original;
processObject(original);  // 复制构造新对象

特点：

• 创建对象的完整副本
• 函数内修改不影响原始对象
• 调用时发生复制构造（可能昂贵）

适用场景：

• 小型对象（基本类型、小结构体）
• 需要修改参数但不影响原对象
• 需要获取参数的拷贝

性能考虑：

• C++11 后可通过移动语义优化：

  processObject(std::move(original));  // 移动构造代替复制
  

2. 按常量引用传递 (Pass by const Reference)

void readObject(const MyClass& obj) {
    // 只读访问 obj，无法修改
}

MyClass original;
readObject(original);  // 无拷贝，零开销

特点：

• 无对象拷贝（仅传递引用）
• 函数内无法修改对象
• 最安全的访问方式

适用场景：

• 大型对象（避免复制开销）
• 只读访问对象内容
• 多态对象访问（基类引用）

最佳实践：

• 默认选择方式（除非需要修改）
• 配合 const 确保不变性

3. 按非常量引用传递 (Pass by Non-const Reference)

void modifyObject(MyClass& obj) {
    obj.changeState();  // 修改原始对象
}

MyClass original;
modifyObject(original);  // 原始对象被修改

特点：

• 直接操作原始对象
• 无对象拷贝
• 函数内修改影响调用者

适用场景：

• 需要修改原始对象
• 实现输出参数（替代指针）
• 避免复制大型对象

注意事项：

• 明确函数可能修改对象
• 避免误用导致意外修改

4. 按指针传递 (Pass by Pointer)

void processPointer(MyClass* ptr) {
    if (ptr) {  // 必须检查空指针
        ptr->doSomething();
    }
}

MyClass obj;
processPointer(&obj);  // 传递地址

MyClass* heapObj = new MyClass();
processPointer(heapObj);  // 堆对象
delete heapObj;

特点：

• 显式传递对象地址
• 可表示可选参数（nullptr）
• 需要手动检查空指针

适用场景：

• 需要重新绑定对象
• 可选参数（可能为空）
• C 风格接口兼容

现代替代：

• 优先使用引用（除非需要空值语义）
• 智能指针传递所有权

5. 按右值引用传递 (Pass by Rvalue Reference)

void consumeObject(MyClass&& obj) {
    // 获取资源所有权
    MyClass newOwner(std::move(obj));
}

MyClass original;
consumeObject(std::move(original));  // 转移所有权
// original 不再拥有资源（有效但未定义状态）

特点：

• C++11 引入的移动语义
• 显式所有权转移
• 高性能资源接管

适用场景：

• 转移大型对象所有权
• 实现移动构造函数/赋值
• 工厂函数返回对象

关键应用：

// 完美转发
template<typename T>
void forwardObject(T&& arg) {
    // std::forward 保持值类别
    otherFunction(std::forward<T>(arg));
}

6. 智能指针传递 (Pass by Smart Pointer)

独占所有权 (unique_ptr)

void takeOwnership(std::unique_ptr<MyClass> ptr) {
    // 获得对象唯一所有权
}

auto obj = std::make_unique<MyClass>();
takeOwnership(std::move(obj));  // 所有权转移

共享所有权 (shared_ptr)

void shareObject(std::shared_ptr<MyClass> ptr) {
    // 共享所有权（引用计数+1）
}

auto sharedObj = std::make_shared<MyClass>();
shareObject(sharedObj);  // 引用计数增加

观察访问 (weak_ptr)

void checkObject(std::weak_ptr<MyClass> weak) {
    if (auto ptr = weak.lock()) {
        // 临时获取共享指针
    }
}

特点：

• 明确表达所有权语义
• 自动内存管理
• 避免内存泄漏

适用场景：

• 跨函数/作用域所有权管理
• 共享访问资源
• 对象生命周期不确定

7. 使用 std::reference_wrapper

#include 
#include 

void modifyWrapped(std::reference_wrapper<MyClass> ref) {
    ref.get().modify();  // 修改原始对象
}

MyClass obj1, obj2;
std::vector<std::reference_wrapper<MyClass>> objects{obj1, obj2};

for (auto& ref : objects) {
    modifyWrapped(ref);  // 传递引用包装
}

特点：

• 允许在容器中存储引用
• 可重新绑定
• 比指针更安全的引用访问

适用场景：

• 需要引用语义的容器
• 需要重新绑定的引用
• 模板元编程

参数传递决策树

graph TD
    A[需要传递对象] --> B{需要修改原始对象？}
    B -->|Yes| C{需要表达所有权？}
    B -->|No| D{对象很大？}
    C -->|转移所有权| E[右值引用/unique_ptr]
    C -->|共享所有权| F[shared_ptr]
    C -->|仅观察| G[原始指针/weak_ptr]
    D -->|Yes| H[const引用]
    D -->|No| I{需要内部副本？}
    I -->|Yes| J[值传递]
    I -->|No| K[const引用]

性能对比表（假设 MyClass 大小为 1KB）

传递方式	拷贝开销	修改原始对象	空值支持	所有权语义
按值传递	完整拷贝	❌	❌	独立副本
const引用	零拷贝	❌	❌	无
非const引用	零拷贝	✅	❌	无
指针	零拷贝	✅	✅	无
右值引用	移动构造	✅	❌	转移
unique_ptr	移动指针	✅	✅	独占
shared_ptr	引用计数	✅	✅	共享
reference_wrapper	零拷贝	✅	❌	无

最佳实践指南

1. 默认选择 const 引用：

   void process(const LargeObject& obj); // 90% 场景的最佳选择
   

2. 需要修改时用非 const 引用：

   void updateConfig(Config& config); // 明确表示修改意图
   

3. 小型对象考虑值传递：

   void addPoint(Point pt); // Point 是小型结构体
   

4. 所有权转移用右值引用：

   void sinkObject(Resource&& res); // 获取资源所有权
   

5. 可选参数用指针：

   bool tryParse(const char* input, Result* output = nullptr);
   

6. 共享资源用智能指针：

   void registerObject(std::shared_ptr<Observable> obj);
   

7. 避免以下反模式：

   // 错误1：不必要的值传递大型对象
   void processBigObject(BigObject obj);
   
   // 错误2：非const引用但未修改对象
   void readData(Data& data); // 应改为 const Data&
   
   // 错误3：智能指针值传递导致额外计数
   void useShared(std::shared_ptr<Res> ptr); // 应改为 const shared_ptr&
   

高级技巧

完美转发

template<typename T>
void forwardExample(T&& arg) {
    // 保持值类别（左值/右值）
    targetFunction(std::forward<T>(arg));
}

类型擦除

void processAny(std::any arg) {
    if (arg.type() == typeid(MyClass)) {
        auto& obj = std::any_cast<MyClass&>(arg);
    }
}

参数多态

void draw(const Drawable& obj) {
    obj.render(); // 多态调用
}

class Shape : public Drawable { /*...*/ };
class Text : public Drawable { /*...*/ };

Shape s;
Text t;
draw(s); // 调用 Shape::render()
draw(t); // 调用 Text::render()

结论

选择正确的参数传递方式需要综合考虑：

• 对象大小：大型对象避免复制
• 修改需求：是否需要修改原始对象
• 所有权语义：是否需要转移或共享所有权
• 空值可能性：参数是否可选
• 性能要求：避免不必要的拷贝/移动

现代 C++ 的最佳实践：

1. 优先按 const 引用传递
2. 需要修改时用非 const 引用
3. 小型对象或需要副本时按值传递
4. 所有权转移用右值引用或 unique_ptr
5. 共享所有权用 shared_ptr
6. 可选参数用指针（或 std::optional）

理解这些传递方式的细微差别，可以写出更高效、更安全、语义更清晰的 C++ 代码。