C++中操作复合类型对象主要采用值传递、引用传递和指针传递。值传递会复制对象，安全但性能开销大，适用于小型对象或需独立副本的场景；引用传递通过别名直接操作原对象，避免拷贝，const引用是只读访问的首选，兼具性能与安全；指针传递传递地址，可表示可选参数（nullptr），但需防范空指针解引用。对于大型对象，优先使用const引用以避免不必要的拷贝，提升效率并保障数据安全。智能指针传递需根据所有权语义选择：unique_ptr通过std::move转移所有权，shared_ptr值传递共享所有权，观察者场景使用const引用或原始指针以避免影响生命周期。动态数组如std::vector推荐const引用只读，非const引用修改，返回新数据时利用移动语义。引用不可为空，指针需显式检查null，值传递存在切片风险。正确选择传递方式需权衡性能、安全与语义清晰性。
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): " <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
const
引用？
这几乎是C++编程的一个黄金法则了，尤其是在处理复合类型对象时。我个人在写代码时，如果一个函数只是需要读取一个对象，而不需要修改它，那么
const
引用几乎是我的第一选择，因为它兼顾了性能和安全性。
首先，性能优势显而易见。对于大型对象，值传递会触发昂贵的拷贝构造函数和析构函数调用。想象一下，一个函数被频繁调用，每次都复制一个几MB的数据结构，那程序的性能瓶颈很快就会出现在这里。
const
引用避免了这一切，它只是传递了一个指向原始对象的“轻量级”引用，几乎没有额外的开销。
立即学习“C++免费学习笔记（深入）”；
其次，它提供了强大的类型安全保障。
const
关键字告诉编译器和开发者，这个函数承诺不会修改它所引用的对象。如果我在函数内部不小心尝试修改了
const
引用的对象，编译器会立即报错，这能有效地预防许多难以追踪的bug。这种“只读”的保证，让代码的意图更加清晰，也降低了代码的维护成本。
此外，它让接口更具表达力。当一个函数参数声明为
const MyClass&
时，调用者一眼就能明白，传入的对象在这个函数里是安全的，不会被意外改动。这是一种非常好的契约，增强了代码的可读性和可靠性。
当然，凡事无绝对。如果你的函数确实需要修改传入的对象，那么就应该使用非
const
引用（
MyClass&
）。而如果你的函数需要获得一个完全独立的副本进行操作，且这个对象足够小，或者复制的语义本身就是设计的一部分（比如工厂函数返回一个新对象），那么值传递也是可以考虑的。但对于大多数场景，尤其是那些只需要读取数据的函数，
const
引用无疑是最佳实践。
值传递、引用传递和指针传递，各自有哪些使用场景和潜在陷阱？
这三者就像工具箱里的不同扳手，各自有最趁手的活计，也有可能让你拧崩螺丝的风险。
值传递 (Pass-by-value)
使用场景：
小型、内置类型或简单结构体： 比如
int
、
double
、
std::pair
。这些类型复制的开销极小，甚至可能比传递引用或指针更高效（因为避免了间接寻址）。函数需要独立副本： 当函数内部需要对传入对象进行修改，但又不想影响外部原始对象时。比如，一个函数接收一个
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&
。这是最高效且安全的做法，避免了整个数组内容的复制。需要修改内容： 使用
std::vector&
。函数可以直接修改数组的元素，或者调用
push_back
、
pop_back
等方法。函数需要返回新数组或深拷贝： 如果函数需要基于传入数组创建一个新的数组并返回，或者需要对传入数组进行深拷贝以供独立使用，那么可以考虑：函数内部创建并返回
std::vector
（利用RVO/NRVO或移动语义）。如果函数需要一个完全独立的副本进行内部操作，并且这个副本不会被返回，那么值传递（
std::vector vec
）也可以，但要警惕性能。如果传入的是右值，可以利用移动构造函数避免深拷贝。
对于智能指针（如
std::unique_ptr
,
std::shared_ptr
）
智能指针的核心在于管理对象的所有权和生命周期。传递智能指针时，关键在于你希望如何处理这种所有权。
std::unique_ptr
(独占所有权)
unique_ptr
表示独占所有权，它所指向的对象只能有一个
unique_ptr
拥有。
转移所有权： 如果函数需要接管
unique_ptr
所指向对象的所有权，那么应该通过值传递
std::unique_ptr
，并使用
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 p = make_unique(); observeObject(p.get());
或者
void observeObjectRef(MyObject& obj) { obj.doSomething();}// 调用: std::unique_ptr p = make_unique(); observeObjectRef(*p);
修改
unique_ptr
指向的对象内容： 同样通过原始指针或引用。
std::shared_ptr
(共享所有权)
shared_ptr
表示共享所有权，多个
shared_ptr
可以共同管理同一个对象，当最后一个
shared_ptr
被销毁时，对象才会被释放。
共享所有权（增加引用计数）： 如果函数需要成为对象的另一个所有者，并延长其生命周期，那么就通过值传递
std::shared_ptr
。这会增加引用计数。
void shareOwnership(std::shared_ptr obj) { // obj 成为 MyObject 的另一个所有者}// 调用: std::shared_ptr p = make_shared(); shareOwnership(p);
作为观察者（不增加引用计数）： 这是最常见的传递方式。如果函数只是想使用
shared_ptr
指向的对象，但不想影响其生命周期（不增加引用计数），那么应该传递
const std::shared_ptr&
。
void observeSharedObject(const std::shared_ptr& obj) { if (obj) obj->doSomething();}// 调用: std::shared_ptr p = make_shared(); observeSharedObject(p);
修改
shared_ptr
指向的对象内容： 通常通过
const std::shared_ptr&
，然后通过
obj.get()
获取原始指针进行修改，或者直接通过
obj->
操作符。如果需要修改
shared_ptr
本身（比如让它指向另一个对象），则需要传递非
const
引用
std::shared_ptr&
。
总而言之，对于智能指针，传递策略的选择取决于你希望如何处理对象的所有权语义：是转移、共享，还是仅仅作为观察者。理解这些语义是正确使用智能指针的关键。
以上就是C++如何在函数中传递复合类型对象的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/1474708.html
微信扫一扫 
支付宝扫一扫 
