一、智能指针的前世今生
在C++的世界里，内存管理就像是在玩杂耍，稍有不慎就会摔得粉身碎骨。传统的裸指针(new/delete)就像是走钢丝不带安全绳，而智能指针的出现，则给我们系上了安全带。
智能指针主要有三种：unique_ptr、shared_ptr和weak_ptr。它们各自有不同的性格特点：
- unique_ptr是个独行侠，坚持独占所有权原则
- shared_ptr是个社交达人，喜欢共享所有权
- weak_ptr是个观察者，默默关注但不插手
// 技术栈：C++17
#include <memory>
#include <iostream>
class Person {
public:
Person(const std::string& name) : name(name) {
std::cout << name << "诞生了\n";
}
~Person() {
std::cout << name << "离开了\n";
}
std::string name;
};
void demo_unique_ptr() {
// unique_ptr独占所有权，无法复制只能移动
auto alice = std::make_unique<Person>("Alice");
// auto bob = alice; // 错误！无法复制
auto bob = std::move(alice); // 正确，所有权转移
if (!alice) {
std::cout << "Alice的所有权已经转移\n";
}
} // bob离开作用域，自动释放资源
二、循环引用的致命诱惑
shared_ptr虽然好用，但它有个致命弱点——循环引用。就像两个好朋友互相拉着对方的手不肯放开，结果谁都走不了。
让我们看个典型的循环引用场景：
// 技术栈：C++17
#include <memory>
#include <iostream>
class Boy;
class Girl;
class Boy {
public:
std::shared_ptr<Girl> girlfriend;
~Boy() { std::cout << "Boy被销毁\n"; }
};
class Girl {
public:
std::shared_ptr<Boy> boyfriend;
~Girl() { std::cout << "Girl被销毁\n"; }
};
void circular_reference_demo() {
auto bob = std::make_shared<Boy>();
auto alice = std::make_shared<Girl>();
bob->girlfriend = alice; // bob引用alice
alice->boyfriend = bob; // alice引用bob
// 离开作用域后，引用计数不会归零
// bob和alice都不会被销毁！
}
运行这段代码你会发现，析构函数永远不会被调用，内存泄漏就这么发生了。这是因为：
- bob的引用计数：alice持有bob的shared_ptr → 计数=1
- alice的引用计数：bob持有alice的shared_ptr → 计数=1
- 离开作用域时，两个shared_ptr的计数都减1，但不会归零
三、weak_ptr的正确打开方式
要解决循环引用问题，我们需要引入weak_ptr这位"旁观者"。weak_ptr可以观察shared_ptr管理的对象，但不会增加引用计数。
让我们改造上面的例子：
// 技术栈：C++17
#include <memory>
#include <iostream>
class Boy;
class Girl;
class Boy {
public:
std::shared_ptr<Girl> girlfriend;
~Boy() { std::cout << "Boy被销毁\n"; }
};
class Girl {
public:
// 使用weak_ptr替代shared_ptr
std::weak_ptr<Boy> boyfriend;
~Girl() { std::cout << "Girl被销毁\n"; }
void checkRelationship() {
if (auto sp = boyfriend.lock()) {
std::cout << "男朋友是：" << sp->name << "\n";
} else {
std::cout << "单身中\n";
}
}
};
void weak_ptr_solution() {
auto bob = std::make_shared<Boy>();
auto alice = std::make_shared<Girl>();
bob->girlfriend = alice;
alice->boyfriend = bob; // 这里使用weak_ptr
alice->checkRelationship();
// 离开作用域后，bob和alice都会被正确销毁
}
weak_ptr有几个关键特点：
- 不增加引用计数，不会阻止对象销毁
- 通过lock()方法可以获取一个shared_ptr(如果对象还存在)
- 可以检测被观察对象是否已被销毁
四、智能指针的进阶技巧
除了解决循环引用，智能指针还有一些高级用法值得掌握。
4.1 自定义删除器
shared_ptr允许我们自定义删除器，这在管理特殊资源时非常有用：
// 技术栈：C++17
#include <memory>
#include <iostream>
#include <cstdio>
void file_deleter(FILE* fp) {
if (fp) {
std::cout << "关闭文件\n";
fclose(fp);
}
}
void custom_deleter_demo() {
// 使用自定义删除器管理文件资源
std::shared_ptr<FILE> file(
fopen("test.txt", "w"),
file_deleter
);
if (file) {
fprintf(file.get(), "Hello, World!");
}
// 离开作用域时自动调用file_deleter
}
4.2 enable_shared_from_this
当我们需要在类的成员函数中获取当前对象的shared_ptr时，可以使用enable_shared_from_this：
// 技术栈：C++17
#include <memory>
#include <iostream>
class Session : public std::enable_shared_from_this<Session> {
public:
void start() {
// 获取当前对象的shared_ptr
auto self = shared_from_this();
// 可以安全地传递self给其他函数
}
};
void enable_shared_demo() {
auto session = std::make_shared<Session>();
session->start();
}
注意：必须在对象已经被shared_ptr管理的情况下才能使用shared_from_this()。
五、智能指针的性能考量
虽然智能指针带来了便利，但也要注意它的性能开销：
- shared_ptr的引用计数是原子操作，有同步开销
- 控制块(存储引用计数等)需要额外内存
- weak_ptr的lock()操作也有一定开销
在性能敏感的场景，可以考虑：
- 使用unique_ptr替代shared_ptr
- 避免频繁创建/销毁shared_ptr
- 对于短暂的生命周期，使用栈对象可能更高效
六、最佳实践总结
经过上面的探讨，我们总结出以下智能指针使用指南：
- 优先使用unique_ptr，它几乎没有额外开销
- 需要共享所有权时才使用shared_ptr
- 存在循环引用可能时，使用weak_ptr打破循环
- 避免从裸指针创建多个shared_ptr
- 使用make_shared/make_unique替代直接new
- 注意线程安全问题，特别是shared_ptr的引用计数
记住，智能指针是工具而不是银弹。理解它们的原理和限制，才能在C++的内存管理中游刃有余。
评论