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

原创于 2025-06-25 09:05:10 发布 · 590 阅读

10 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

标签

#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 <functional>
#include <vector>

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	零拷贝	✅	❌	无

最佳实践指南

默认选择 const 引用：

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

需要修改时用非 const 引用：

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

小型对象考虑值传递：

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

所有权转移用右值引用：

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

可选参数用指针：

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

共享资源用智能指针：

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

避免以下反模式：

// 错误1：不必要的值传递大型对象
void processBigObject(BigObject obj);

// 错误2：非const引用但未修改对象
void readData(Data& data); // 应改为 const Data&

// 错误3：智能指针值传递导致额外计数
void useShared(std::shared_ptr<Res> ptr); // 应改为 const shared_ptr<Res>&

高级技巧

完美转发

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()