冠军资讯
青衫落拓在 C++ 开发中，手动管理内存是一项令人头疼的任务。稍有不慎，就会导致内存泄漏，程序崩溃等问题。尤其在高并发的服务器程序中，例如使用 C++ 开发的 Nginx 模块，内存管理至关重要。如果 Nginx 模块因为内存泄漏导致工作进程频繁重启，那将会严重影响反向代理和负载均衡的稳定性，最终降低 QPS 和用户的访问体验。而 C++ 智能指针的出现，正是为了解决这个问题。它可以自动管理动态分配的内存，在对象不再需要时自动释放，从而大大简化了内存管理，提高了代码的可靠性和安全性。
智能指针的种类与选择
C++11 引入了三种主要的智能指针：
std::unique_ptr：独占式指针，同一时间只能有一个unique_ptr指向给定的对象，对象的所有权完全属于该指针。适用于需要明确所有权转移的场景。std::shared_ptr：共享式指针，多个shared_ptr可以指向同一个对象，使用引用计数来跟踪对象的生命周期。当最后一个shared_ptr销毁时，对象才会被释放。适用于多个对象共享同一资源的场景。std::weak_ptr：弱引用指针，指向由shared_ptr管理的对象，但不增加引用计数。它可以用来检测对象是否仍然存在，避免循环引用。
选择哪种智能指针取决于你的具体需求。如果确定只有一个指针需要拥有对象的所有权，那么 unique_ptr 是最佳选择。如果多个指针需要共享对象的所有权，那么 shared_ptr 是更好的选择。weak_ptr 则主要用于解决 shared_ptr 循环引用问题。
std::unique_ptr：独占所有权
unique_ptr 保证了同一时间只有一个指针指向对象，因此它不支持拷贝构造和赋值操作。但它支持移动构造和移动赋值，可以将所有权从一个 unique_ptr 转移到另一个。
#include <iostream>
#include <memory>
class MyClass {
public:
MyClass() { std::cout << "MyClass created" << std::endl; }
~MyClass() { std::cout << "MyClass destroyed" << std::endl; }
void doSomething() { std::cout << "Doing something" << std::endl; }
};
int main() {
// 使用 make_unique 创建 unique_ptr，推荐方式
std::unique_ptr<MyClass> ptr = std::make_unique<MyClass>();
ptr->doSomething(); // 使用 -> 访问对象成员
// 所有权转移
std::unique_ptr<MyClass> ptr2 = std::move(ptr);
if (ptr2) {
ptr2->doSomething();
}
// ptr 现在为空，不能再使用
// if (ptr) { ptr->doSomething(); } // 错误：ptr 为空
return 0; // ptr2 销毁时，MyClass 对象会被自动释放
}
std::make_unique 是 C++14 引入的函数，用于创建 unique_ptr，它避免了直接使用 new 带来的潜在异常安全问题。
std::shared_ptr：共享所有权
shared_ptr 允许多个指针指向同一个对象，使用引用计数来跟踪对象的生命周期。当引用计数降为 0 时，对象才会被释放。
#include <iostream>
#include <memory>
class MyClass {
public:
MyClass() { std::cout << "MyClass created" << std::endl; }
~MyClass() { std::cout << "MyClass destroyed" << std::endl; }
void doSomething() { std::cout << "Doing something" << std::endl; }
};
int main() {
// 使用 make_shared 创建 shared_ptr，推荐方式
std::shared_ptr<MyClass> ptr1 = std::make_shared<MyClass>();
std::shared_ptr<MyClass> ptr2 = ptr1; // 共享所有权，引用计数增加
ptr1->doSomething();
ptr2->doSomething();
std::cout << "Reference count: " << ptr1.use_count() << std::endl; // 输出引用计数
ptr1.reset(); // 释放 ptr1 的所有权，引用计数减少
std::cout << "Reference count: " << ptr2.use_count() << std::endl;
// ptr2 仍然有效
ptr2->doSomething();
return 0; // ptr2 销毁时，MyClass 对象会被自动释放
}
std::make_shared 与 std::make_unique 类似，用于创建 shared_ptr，同样避免了直接使用 new 带来的潜在异常安全问题。 强烈建议使用 make_shared 创建 shared_ptr，因为它可以在一次内存分配中同时创建对象和控制块，提高了效率。
std::weak_ptr：解决循环引用
weak_ptr 是一种弱引用，它指向由 shared_ptr 管理的对象，但不增加引用计数。它可以用来检测对象是否仍然存在，避免循环引用。
循环引用是指两个或多个对象相互持有 shared_ptr，导致引用计数永远不为 0，对象无法被释放，造成内存泄漏。
#include <iostream>
#include <memory>
class B;
class A {
public:
std::shared_ptr<B> b_ptr;
~A() { std::cout << "A destroyed" << std::endl; }
};
class B {
public:
std::shared_ptr<A> a_ptr;
~B() { std::cout << "B destroyed" << std::endl; }
};
int main() {
std::shared_ptr<A> a = std::make_shared<A>();
std::shared_ptr<B> b = std::make_shared<B>();
a->b_ptr = b; // A 持有 B
b->a_ptr = a; // B 持有 A
// 循环引用导致 A 和 B 都无法被释放
return 0; // A 和 B 的析构函数不会被调用
}
要解决循环引用，可以将其中一个 shared_ptr 改为 weak_ptr。
#include <iostream>
#include <memory>
class B;
class A {
public:
std::shared_ptr<B> b_ptr;
~A() { std::cout << "A destroyed" << std::endl; }
};
class B {
public:
std::weak_ptr<A> a_ptr; // 使用 weak_ptr 避免循环引用
~B() { std::cout << "B destroyed" << std::endl; }
};
int main() {
std::shared_ptr<A> a = std::make_shared<A>();
std::shared_ptr<B> b = std::make_shared<B>();
a->b_ptr = b; // A 持有 B
b->a_ptr = a; // B 持有 A
// 循环引用被打破，A 和 B 都可以被释放
return 0; // A 和 B 的析构函数会被调用
}
实战避坑经验总结
- 优先使用
make_unique和make_shared：它们可以避免异常安全问题，提高效率。 - 避免循环引用：使用
weak_ptr打破循环引用。 - 不要将原始指针赋值给多个智能指针：这会导致重复释放。
- 理解所有权语义：根据需求选择合适的智能指针类型。
- 在多线程环境下使用
shared_ptr时，注意线程安全问题：可以使用原子操作来保证引用计数的线程安全。
总结
C++ 智能指针是现代 C++ 开发中不可或缺的工具，可以帮助我们更好地管理内存，避免内存泄漏，提高程序的可靠性和安全性。掌握智能指针的使用，可以让你写出更加健壮、高效的 C++ 代码。在处理高负载、高并发的场景，例如 Web 服务器开发，使用智能指针可以极大降低因为内存管理不当导致服务雪崩的风险。 例如在开发基于 Boost.Asio 的网络库时，大量的连接对象和回调函数都可以通过智能指针管理，确保资源在使用完毕后能够及时释放，避免内存泄露。
