C++如何在函数中传递复合类型对象

陌敏同学_3713

发布时间：2025-09-06 09:28:01

347人浏览过

来源于php中文网

原创

C++中操作复合类型对象主要采用值传递、引用传递和指针传递。值传递会复制对象，安全但性能开销大，适用于小型对象或需独立副本的场景；引用传递通过别名直接操作原对象，避免拷贝，const引用是只读访问的首选，兼具性能与安全；指针传递传递地址，可表示可选参数（nullptr），但需防范空指针解引用。对于大型对象，优先使用const引用以避免不必要的拷贝，提升效率并保障数据安全。智能指针传递需根据所有权语义选择：unique_ptr通过std::move转移所有权，shared_ptr值传递共享所有权，观察者场景使用const引用或原始指针以避免影响生命周期。动态数组如std::vector推荐const引用只读，非const引用修改，返回新数据时利用移动语义。引用不可为空，指针需显式检查null，值传递存在切片风险。正确选择传递方式需权衡性能、安全与语义清晰性。

c++如何在函数中传递复合类型对象

C++中，要在函数里操作复合类型对象，比如结构体、类实例或者数组，我们主要有三种手段：值传递、引用传递和指针传递。这三种方式各有各的脾气和用武之地，理解它们对原始对象的影响以及潜在的性能开销，是写出高效、健壮C++代码的关键。

解决方案

简单来说，当你把一个复合类型对象传给函数时，你得决定是让函数拿到这个对象的一个“副本”（值传递），还是让它直接“看到”并可能“修改”到原始对象（引用或指针传递）。

值传递 (Pass-by-value) 这是最直观的方式，函数会收到你传入对象的一个完整拷贝。这意味着函数内部对这个副本的任何操作，都不会影响到函数外部的原始对象。听起来很安全对吧？确实如此。但问题是，如果你的复合类型对象很大，比如一个包含几百个元素的
```
std::vector
```
，或者一个复杂的类实例，那么每次函数调用都进行一次完整的拷贝，这个开销可不小。这不仅消耗CPU时间（复制构造函数被调用），还可能占用额外的内存。所以，除非对象很小，或者你真的需要一个独立副本在函数内部随意折腾，否则通常不推荐对大型复合类型使用值传递。
```
struct MyData {
    int id;
    std::string name;
    // 假设还有很多其他数据...
};

void processDataByValue(MyData data) {
    data.id = 999; // 仅修改副本
    std::cout << "Inside (value): " << data.id << std::endl;
}

// 调用示例
// MyData original = {1, "Test"};
// processDataByValue(original);
// std::cout << "Outside: " << original.id << std::endl; // 仍然是 1
```
引用传递 (Pass-by-reference) 引用传递就聪明多了。它不是把对象复制一份，而是给原始对象起了一个“别名”。函数通过这个别名直接操作原始对象。这样一来，就没有了拷贝的开销，性能自然提升。而且，函数内部对引用的修改，会直接反映到函数外部的原始对象上。

如果你希望函数能够修改原始对象，就用普通的引用（
```
MyData&
```
）。如果你只是想让函数读取原始对象，但不允许它修改，那就用
```
const
```
引用（
```
const MyData&
```
）。
```
const
```
引用是C++中处理大型复合类型参数的“黄金法则”，它既避免了拷贝开销，又保证了数据的安全性，是一种非常优雅的解决方案。
```
void processDataByReference(MyData& data) {
    data.id = 999; // 直接修改原始对象
    std::cout << "Inside (reference): " << data.id << std::endl;
}

void printDataByConstReference(const MyData& data) {
    // data.id = 999; // 编译错误！const引用不能修改
    std::cout << "Inside (const reference): " << data.name << std::endl;
}

// 调用示例
// MyData original = {1, "Test"};
// processDataByReference(original);
// std::cout << "Outside after ref: " << original.id << std::endl; // 变成 999
// printDataByConstReference(original);
```
指针传递 (Pass-by-pointer) 指针传递和引用传递有点像，都是直接操作原始对象，避免了拷贝。函数接收的是对象的内存地址，通过解引用（
```
*
```
操作符或
```
->
```
操作符）来访问和修改对象。指针传递的一个显著特点是，它可以接受
```
nullptr
```
，这意味着你可以用它来表示一个可选的参数——“也许有这个对象，也许没有”。这在某些C风格的API或者需要明确表示“没有对象”的场景下非常有用。但缺点是，你必须在函数内部进行
```
nullptr
```
检查，否则解引用一个空指针会导致程序崩溃。
```
void processDataByPointer(MyData* data) {
    if (data) { // 必须检查空指针
        data->id = 999; // 直接修改原始对象
        std::cout << "Inside (pointer): " << data->id << std::endl;
    } else {
        std::cout << "Inside (pointer): Received nullptr." << std::endl;
    }
}

// 调用示例
// MyData original = {1, "Test"};
// processDataByPointer(&original);
// std::cout << "Outside after ptr: " << original.id << std::endl; // 变成 999
// processDataByPointer(nullptr); // 传递空指针
```

C++函数参数传递时，为什么我们常说优先考虑使用

const

引用？

这几乎是C++编程的一个黄金法则了，尤其是在处理复合类型对象时。我个人在写代码时，如果一个函数只是需要读取一个对象，而不需要修改它，那么

const

引用几乎是我的第一选择，因为它兼顾了性能和安全性。

首先，性能优势显而易见。对于大型对象，值传递会触发昂贵的拷贝构造函数和析构函数调用。想象一下，一个函数被频繁调用，每次都复制一个几MB的数据结构，那程序的性能瓶颈很快就会出现在这里。

const

引用避免了这一切，它只是传递了一个指向原始对象的“轻量级”引用，几乎没有额外的开销。

立即学习“C++免费学习笔记（深入）”；

其次，它提供了强大的类型安全保障。

const

关键字告诉编译器和开发者，这个函数承诺不会修改它所引用的对象。如果我在函数内部不小心尝试修改了

const

引用的对象，编译器会立即报错，这能有效地预防许多难以追踪的bug。这种“只读”的保证，让代码的意图更加清晰，也降低了代码的维护成本。

此外，它让接口更具表达力。当一个函数参数声明为

const MyClass&

时，调用者一眼就能明白，传入的对象在这个函数里是安全的，不会被意外改动。这是一种非常好的契约，增强了代码的可读性和可靠性。

当然，凡事无绝对。如果你的函数确实需要修改传入的对象，那么就应该使用非

const

引用（

MyClass&

）。而如果你的函数需要获得一个完全独立的副本进行操作，且这个对象足够小，或者复制的语义本身就是设计的一部分（比如工厂函数返回一个新对象），那么值传递也是可以考虑的。但对于大多数场景，尤其是那些只需要读取数据的函数，

const

引用无疑是最佳实践。

值传递、引用传递和指针传递，各自有哪些使用场景和潜在陷阱？

这三者就像工具箱里的不同扳手，各自有最趁手的活计，也有可能让你拧崩螺丝的风险。

值传递 (Pass-by-value)

使用场景：

C++14
C++14 对 C++11 的修正与增强版本，适合旧系统维护和较老工具链兼容。

下载
- 小型、内置类型或简单结构体： 比如
```
int
```
  、
```
double
```
  、
```
std::pair<int, int>
```
  。这些类型复制的开销极小，甚至可能比传递引用或指针更高效（因为避免了间接寻址）。
- 函数需要独立副本： 当函数内部需要对传入对象进行修改，但又不想影响外部原始对象时。比如，一个函数接收一个
```
std::string
```
  ，然后对它进行一些格式化操作，最终返回一个新的
```
std::string
```
  。如果函数内部的修改不应该影响外部，值传递是合理的。
- 移动语义（C++11及以后）： 对于一些支持移动语义的类型（如
```
std::vector
```
  、
```
std::string
```
  、
```
std::unique_ptr
```
  ），值传递配合
```
std::move
```
  可以实现高效的资源转移，避免不必要的深拷贝。
潜在陷阱：
- 性能开销： 对于大型复合类型，频繁的值传递会导致大量的拷贝构造和析构，严重影响程序性能。
- 对象切片（Slicing）： 当通过基类类型的值传递派生类对象时，派生类特有的数据部分会被“切掉”，只剩下基类部分。这会丢失多态性，通常是设计上的错误。
- 无法修改原对象： 如果函数本意是修改原对象，值传递就达不到目的。

引用传递 (Pass-by-reference)

使用场景：
- 大型复合类型的首选： 无论是需要修改还是只读访问，引用传递都避免了拷贝开销。
- 需要修改原对象： 非
```
const
```
  引用是函数修改外部变量的唯一“安全”且惯用的方式（指针也可以，但引用更C++风格）。
- 避免空值： 引用必须绑定到一个有效的对象，它不能是
```
nullptr
```
  。这在某些情况下是一种优势，因为你无需进行空检查。
潜在陷阱：
- 意外修改： 非
```
const
```
  引用允许函数修改原始对象，如果设计不当或误用，可能导致外部数据被意外篡改，产生难以调试的bug。
- 悬空引用： 如果引用绑定到一个局部变量，而这个局部变量在函数返回后被销毁，那么返回的引用就会变成“悬空引用”，再次使用会导致未定义行为。
- 无法表示“可选参数”： 引用不能为
```
nullptr
```
  ，所以不能用来表示一个参数是可选的。

指针传递 (Pass-by-pointer)

使用场景：
- 可选参数： 当函数参数可能是
```
nullptr
```
  时，指针传递是唯一直接的表示方式。例如，
```
int find(const std::string* key, Result* outResult)
```
  ，
```
outResult
```
  可能是可选的。
- C风格接口： 许多C语言或与C兼容的库函数都使用指针作为参数，以实现修改或可选性。
- 需要动态内存管理： 当函数需要分配或释放堆上的内存时，通常会通过指针来操作。
- 多态性： 指针（和引用）可以用于实现多态，基类指针可以指向派生类对象。
潜在陷阱：
- 空指针解引用： 这是指针最常见的陷阱。如果在使用前不进行
```
nullptr
```
  检查，解引用空指针会导致程序崩溃（段错误）。
- 内存管理问题： 如果函数接收一个原始指针并负责其生命周期（例如，
```
delete
```
  它），那么内存所有权模型就会变得复杂，容易出现内存泄漏或二次释放。智能指针的出现就是为了解决这个问题。
- 可读性稍差： 相比引用，指针操作（
```
*
```
  和
```
->
```
  ）在某些情况下会使代码看起来更复杂一些，尤其是多级指针。

面对复杂的复合类型，例如动态数组或智能指针，传递策略有何不同？

当复合类型本身就带有复杂的内存管理或所有权语义时，传递策略的选择就更需要深思熟虑了。

对于动态数组（如

std::vector

）

std::vector

是C++中非常常用的动态数组，它内部管理着一块连续的内存。

只读访问： 几乎总是使用
```
const std::vector<T>&
```
。这是最高效且安全的做法，避免了整个数组内容的复制。
需要修改内容： 使用
```
std::vector<T>&
```
。函数可以直接修改数组的元素，或者调用
```
push_back
```
、
```
pop_back
```
等方法。
函数需要返回新数组或深拷贝： 如果函数需要基于传入数组创建一个新的数组并返回，或者需要对传入数组进行深拷贝以供独立使用，那么可以考虑：
- 函数内部创建并返回
```
std::vector<T>
```
  （利用RVO/NRVO或移动语义）。
- 如果函数需要一个完全独立的副本进行内部操作，并且这个副本不会被返回，那么值传递（
```
std::vector<T> vec
```
  ）也可以，但要警惕性能。如果传入的是右值，可以利用移动构造函数避免深拷贝。

对于智能指针（如

std::unique_ptr

,
std::shared_ptr
）

智能指针的核心在于管理对象的所有权和生命周期。传递智能指针时，关键在于你希望如何处理这种所有权。

std::unique_ptr

(独占所有权)

unique_ptr

表示独占所有权，它所指向的对象只能有一个

unique_ptr

拥有。

转移所有权： 如果函数需要接管

unique_ptr

所指向对象的所有权，那么应该通过值传递

std::unique_ptr<T>

，并使用

std::move

来调用。

void takeOwnership(std::unique_ptr<MyObject> obj) {
    // obj 现在拥有 MyObject，当 obj 离开作用域时，MyObject 会被删除
}
// 调用: std::unique_ptr<MyObject> p = make_unique<MyObject>(); takeOwnership(std::move(p));

作为观察者（不改变所有权）： 如果函数只是想使用

unique_ptr

指向的对象，但不想改变其所有权，那么应该传递原始指针

MyObject*

或引用

MyObject&

。这避免了所有权语义的混淆。

void observeObject(MyObject* obj) {
    if (obj) obj->doSomething();
}
// 调用: std::unique_ptr<MyObject> p = make_unique<MyObject>(); observeObject(p.get());

或者

void observeObjectRef(MyObject& obj) {
    obj.doSomething();
}
// 调用: std::unique_ptr<MyObject> p = make_unique<MyObject>(); observeObjectRef(*p);

修改
unique_ptr
指向的对象内容：同样通过原始指针或引用。

```
std::shared_ptr
```
(共享所有权)
```
shared_ptr
```
表示共享所有权，多个
```
shared_ptr
```
可以共同管理同一个对象，当最后一个
```
shared_ptr
```
被销毁时，对象才会被释放。
- 共享所有权（增加引用计数）： 如果函数需要成为对象的另一个所有者，并延长其生命周期，那么就通过值传递
```
std::shared_ptr<T>
```
  。这会增加引用计数。
```
void shareOwnership(std::shared_ptr<MyObject> obj) {
    // obj 成为 MyObject 的另一个所有者
}
// 调用: std::shared_ptr<MyObject> p = make_shared<MyObject>(); shareOwnership(p);
```
- 作为观察者（不增加引用计数）： 这是最常见的传递方式。如果函数只是想使用
```
shared_ptr
```
  指向的对象，但不想影响其生命周期（不增加引用计数），那么应该传递
```
const std::shared_ptr<T>&
```
  。
```
void observeSharedObject(const std::shared_ptr<MyObject>& obj) {
    if (obj) obj->doSomething();
}
// 调用: std::shared_ptr<MyObject> p = make_shared<MyObject>(); observeSharedObject(p);
```
- 修改
  shared_ptr
  指向的对象内容：通常通过
```
const std::shared_ptr<T>&
```
  ，然后通过
```
obj.get()
```
  获取原始指针进行修改，或者直接通过
```
obj->
```
  操作符。如果需要修改
```
shared_ptr
```
  本身（比如让它指向另一个对象），则需要传递非
```
const
```
  引用
```
std::shared_ptr<T>&
```
  。