优先使用智能指针传递动态分配对象，std::unique_ptr通过std::move转移独占所有权，确保资源安全释放；std::shared_ptr通过引用计数实现共享所有权，适合多部分共享对象的场景；避免原始指针以防止内存泄漏和悬空指针。
在C++函数中传递动态分配的对象，核心考量在于如何清晰地管理对象的所有权和生命周期。简单来说，最佳实践是优先使用智能指针，特别是
std::unique_ptr
和
std::shared_ptr
，它们能有效避免传统原始指针带来的内存泄漏、悬空指针和双重释放等问题，让代码更健壮、更易维护。
解决方案
要安全、高效地在C++函数中传递动态分配的对象，我们主要有以下几种策略，每种都对应着不同的所有权语义：
传递独占所有权（
std::unique_ptr
）当你希望一个函数获得一个动态分配对象的唯一所有权，并且在函数结束后（或将所有权转移到其他地方后）负责其生命周期管理时，
std::unique_ptr
是理想选择。你通常会通过值传递
std::unique_ptr
，并使用
std::move
来显式转移所有权。这意味着原始的
unique_ptr
在调用后将变为空，不再拥有该对象。
#include #include class MyResource {public: MyResource(int id) : id_(id) { std::cout << "MyResource " << id_ << " created.n"; } ~MyResource() { std::cout << "MyResource " << id_ << " destroyed.n"; } void use() const { std::cout << "Using MyResource " << id_ << ".n"; }private: int id_;};// 函数接收独占所有权void processUniqueResource(std::unique_ptr res) { if (res) { res->use(); } // res 在这里超出作用域时会自动销毁其指向的对象}// 示例用法// int main() {// std::unique_ptr r1 = std::make_unique(1);// processUniqueResource(std::move(r1)); // 所有权转移// // r1 现在是空的，不能再访问// // if (r1) { /* 这段代码不会执行 */ }// return 0;// }
传递共享所有权（
std::shared_ptr
）当一个动态分配的对象需要被多个部分共享，并且其生命周期应该由所有共享者共同决定时，
std::shared_ptr
就派上用场了。它通过引用计数机制来管理对象的生命周期，只有当所有
shared_ptr
实例都销毁后，对象才会被释放。你可以通过值传递
std::shared_ptr
来增加引用计数，或者通过常量引用传递
const std::shared_ptr&
来观察智能指针本身而不影响引用计数。
#include #include class SharedResource {public: SharedResource(int id) : id_(id) { std::cout << "SharedResource " << id_ << " created.n"; } ~SharedResource() { std::cout << "SharedResource " << id_ << " destroyed.n"; } void report() const { std::cout << "Reporting from SharedResource " << id_ << ".n"; }private: int id_;};// 函数接收共享所有权void processSharedResource(std::shared_ptr res) { if (res) { res->report(); std::cout << " Inside processSharedResource, use_count: " << res.use_count() << "n"; } // res 离开作用域时，引用计数减一}// 函数仅观察 shared_ptr 本身，不影响所有权void inspectSharedPtr(const std::shared_ptr& resPtr) { if (resPtr) { std::cout << " Inspecting shared_ptr, use_count: " << resPtr.use_count() << "n"; }}// 示例用法// int main() {// std::shared_ptr s1 = std::make_shared(10);// std::cout << "Initial use_count: " << s1.use_count() << "n"; // 1// processSharedResource(s1); // 传递值，引用计数增加// std::cout << "After processSharedResource, use_count: " << s1.use_count() << "n"; // 1// inspectSharedPtr(s1); // 传递常量引用，引用计数不变// std::cout << "After inspectSharedPtr, use_count: " << s1.use_count() << "n"; // 1// {// std::shared_ptr s2 = s1; // 复制，引用计数增加// std::cout << "Inside block, use_count: " << s1.use_count() << "n"; // 2// } // s2 销毁，引用计数减一// std::cout << "After block, use_count: " << s1.use_count() << "n"; // 1// return 0;// }
传递非所有权（原始指针或引用）有时候，一个函数仅仅需要访问动态分配的对象，而不需要参与其所有权管理。在这种情况下，你可以从智能指针中获取原始指针（
get()
方法）或引用（
*
解引用），然后将它们传递给函数。但这要求调用者保证在函数执行期间，对象仍然存活。这种方式适用于观察者模式或那些不关心对象生命周期的辅助函数。
// 函数仅使用对象，不关心所有权void useResourceDirectly(MyResource* res) { if (res) { res->use(); }}void useResourceByRef(MyResource& res) { res.use();}// 示例用法// int main() {// std::unique_ptr r2 = std::make_unique(2);// useResourceDirectly(r2.get()); // 传递原始指针// useResourceByRef(*r2); // 传递引用// return 0;// }
为什么直接传递原始指针（Raw Pointer）是个坏主意？
说实话，在现代C++中，直接通过原始指针（
T*
）来传递动态分配的对象，尤其是当函数可能需要管理其生命周期时，简直是自找麻烦。我个人觉得，这玩意儿就是一堆潜在问题的温床，特别容易导致：
所有权不明确：这是最大的痛点。当一个函数接收
T*
时，它到底应该负责
delete
这个对象，还是仅仅使用它？如果它
delete
了，那么调用者还能不能访问？如果调用者也
delete
，那不就双重释放了吗？这种模糊性是导致内存泄漏和程序崩溃的根本原因。悬空指针（Dangling Pointers）：如果一个对象被提前释放了，而其他地方的原始指针还在引用它，那么这些指针就成了悬空指针。一旦通过它们访问内存，轻则程序崩溃，重则数据损坏，而且这种错误往往难以追踪。双重释放（Double Free）：如果多个原始指针指向同一个动态分配的对象，并且它们都尝试去
delete
它，那就会发生双重释放。这通常会导致未定义行为，程序直接就崩给你看。异常安全问题：在复杂的代码流中，如果函数内部发生异常，原始指针可能无法在正确的时间被
delete
，从而导致内存泄漏。智能指针在这方面表现得好得多，它们利用RAII（资源获取即初始化）原则，确保在任何情况下都能正确释放资源。缺乏语义表达：原始指针仅仅是一个内存地址，它无法表达任何关于对象生命周期的意图。而智能指针，比如
unique_ptr
和
shared_ptr
，其类型本身就清晰地传达了所有权语义，让代码意图一目了然。
所以，除非你明确知道对象的所有权由别处严格管理，并且你的函数只是一个临时的“观察者”，否则，尽量远离直接传递原始指针来管理动态对象。这不仅仅是编码规范的问题，更是为了代码的健壮性和可维护性。
立即学习“C++免费学习笔记（深入）”；
std::unique_ptr
std::unique_ptr
如何实现独占所有权传递？
std::unique_ptr
实现独占所有权传递的核心在于它的移动语义（Move Semantics）。顾名思义，它强调的是“移动”而非“复制”。一个
unique_ptr
实例是它所管理对象的唯一所有者，你不能简单地复制它，因为那样就会有两个指针指向同一个对象，这与“独占”的理念相悖。
当你把一个
std::unique_ptr
作为函数参数通过值传递时，你需要显式地使用
std::move
。这个
std::move
操作并不会复制对象，而是将原
unique_ptr
的所有权“转移”给函数参数。一旦所有权被转移，原来的
unique_ptr
就变成了一个空指针（不再指向任何对象），而函数参数现在则拥有了该对象。当函数执行完毕，这个函数参数
unique_ptr
超出作用域时，它会自动调用其析构函数，从而安全地删除所管理的对象。
这种机制完美地解决了原始指针的所有权模糊问题：谁接收了
unique_ptr
，谁就负责它的生命周期。这就像你把一件独一无二的宝物交给了另一个人，宝物现在是他的了，你手上就没有了。
#include #include class Gadget {public: Gadget(int id) : id_(id) { std::cout << "Gadget " << id_ << " created.n"; } ~Gadget() { std::cout << "Gadget " << id_ << " destroyed.n"; } void operate() const { std::cout << "Operating Gadget " << id_ << ".n"; }private: int id_;};// 接收独占所有权，处理后销毁void processAndDispose(std::unique_ptr g) { if (g) { g->operate(); std::cout << " Gadget " <id_ << " processed.n"; } // g 在这里离开作用域，自动调用 ~Gadget()}// 仅仅观察 Gadget，不获取所有权void inspectGadget(const Gadget& g) { g.operate(); std::cout << " Gadget " << g.id_ << " inspected by reference.n";}int main() { std::unique_ptr myGadget = std::make_unique(101); std::cout << "Main scope: myGadget created.n"; // 传递原始指针或引用给不获取所有权的函数 inspectGadget(*myGadget); // 转移所有权给 processAndDispose processAndDispose(std::move(myGadget)); std::cout << "Main scope: After processAndDispose call.n"; // 此时 myGadget 已经为空，访问会是未定义行为 if (!myGadget) { std::cout << "Main scope: myGadget is now empty.n"; } // 如果想在函数内部修改 unique_ptr 本身（比如让它指向新的对象）， // 可以传递 unique_ptr 的引用，但这种情况不常见，且需要小心所有权管理 // void modifyUniquePtr(std::unique_ptr& ptr) { // ptr = std::make_unique(202); // } // modifyUniquePtr(myGadget); // 此时 myGadget 又指向新对象了 return 0;}
通过这个例子，我们能清楚看到
std::move
如何将
myGadget
的所有权转移给
processAndDispose
函数内部的
g
，而
myGadget
本身则失去了对对象的控制。这种模式在工厂函数、资源管理对象需要被传递给消费者等场景下非常有用。
std::shared_ptr
std::shared_ptr
在共享所有权场景下的应用
std::shared_ptr
是C++中处理共享所有权的利器。它内部通过一个引用计数器来追踪有多少个
shared_ptr
实例正在共享同一个动态分配的对象。每当一个新的
shared_ptr
实例被创建并指向同一个对象时，引用计数就加一；每当一个
shared_ptr
实例被销毁或重新指向其他对象时，引用计数就减一。只有当引用计数归零时，
shared_ptr
才会自动删除它所管理的对象。
这种机制特别适合那些对象生命周期不确定，或者需要被多个不相关的模块共同持有和访问的场景，比如：
缓存系统：缓存中的对象可能被多个客户端访问，只有当所有客户端都不再需要时才将其从内存中移除。回调函数：当一个异步操作完成后，需要访问一个特定的对象，但你不知道这个对象在回调触发时是否还存活。
shared_ptr
可以确保对象在回调期间一直有效。图结构或循环引用：虽然
shared_ptr
本身可能导致循环引用（需要
std::weak_ptr
来打破），但在没有循环引用的情况下，它能很好地管理共享对象。
在函数中传递`std::shared
以上就是C++如何在函数中传递动态分配对象的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/1475316.html
微信扫一扫 
支付宝扫一扫 
