C++11引入了智能指针机制，通过RAII思想自动管理动态分配的内存，大幅降低了手动管理内存带来的风险。三种核心智能指针shared_ptr、unique_ptr、weak_ptr各有不同的设计目标和适用场景，理解它们的差异是正确使用智能指针的前提。
三种智能指针核心特性对比
三种智能指针的基础特性差异如下表所示：
| 指针类型 | 所有权模式 | 引用计数 | 是否可拷贝 | 是否可转移所有权 |
|---|---|---|---|---|
unique_ptr | 独占所有权 | 无 | 否 | 是（通过std::move） |
shared_ptr | 共享所有权 | 有 | 是 | 是（拷贝即共享） |
weak_ptr | 弱引用 | 无（不增加计数） | 是 | 否 |
unique_ptr使用场景
unique_ptr是独占所有权的智能指针，同一时间只能有一个unique_ptr指向某个对象，当指针销毁时对象会被自动释放。它适合以下场景：
- 管理生命周期明确的单个对象，不需要多个持有者共享该对象
- 作为函数的返回值，返回动态分配的对象，避免调用方手动释放
- 管理动态数组，替代原生数组指针
下面是unique_ptr的基础使用示例：
#include <memory>
#include <iostream>
class Test {
public:
Test() { std::cout << "Test构造" << std::endl; }
~Test() { std::cout << "Test析构" << std::endl; }
void print() { std::cout << "Test方法调用" << std::endl; }
};
int main() {
// 创建独占智能指针
std::unique_ptr<Test> ptr1(new Test());
ptr1->print();
// 转移所有权，ptr1变为空
std::unique_ptr<Test> ptr2 = std::move(ptr1);
if (ptr1 == nullptr) {
std::cout << "ptr1已为空" << std::endl;
}
ptr2->print();
// 函数返回unique_ptr示例
auto createTest = []() -> std::unique_ptr<Test> {
return std::make_unique<Test>();
};
auto ptr3 = createTest();
ptr3->print();
return 0;
}
shared_ptr使用场景
shared_ptr采用共享所有权模式，多个shared_ptr可以指向同一个对象，内部通过引用计数记录指向该对象的指针数量，当最后一个shared_ptr销毁时，对象才会被释放。它适合以下场景：
- 多个模块需要共享同一个对象，无法确定哪个模块最后释放对象
- 对象需要被存储在容器中，且容器外也有引用该对象的情况
- 需要跨函数传递对象，且传递后原持有者也需要保留对象引用
下面是shared_ptr的使用示例：
#include <memory>
#include <iostream>
#include <vector>
class Data {
public:
int value;
Data(int v) : value(v) { std::cout << "Data构造，值：" << v << std::endl; }
~Data() { std::cout << "Data析构，值：" << value << std::endl; }
};
int main() {
// 创建共享智能指针
std::shared_ptr<Data> ptr1 = std::make_shared<Data>(10);
std::cout << "ptr1引用计数：" << ptr1.use_count() << std::endl;
// 拷贝共享指针，引用计数增加
std::shared_ptr<Data> ptr2 = ptr1;
std::cout << "拷贝后引用计数：" << ptr1.use_count() << std::endl;
// 存入容器
std::vector<std::shared_ptr<Data>> vec;
vec.push_back(ptr1);
std::cout << "存入容器后引用计数：" << ptr1.use_count() << std::endl;
// 离开作用域，ptr2销毁，引用计数减少
{
std::shared_ptr<Data> ptr3 = ptr1;
std::cout << "作用域内引用计数：" << ptr1.use_count() << std::endl;
}
std::cout << "作用域外引用计数：" << ptr1.use_count() << std::endl;
return 0;
}
weak_ptr使用场景
weak_ptr是弱引用指针，它指向shared_ptr管理的对象，但不会增加引用计数，主要用于解决shared_ptr的循环引用问题，也适合需要临时访问对象但不想影响对象生命周期的场景。它适合以下场景：
- 解决两个对象互相持有
shared_ptr导致的循环引用内存泄漏问题 - 缓存场景，缓存的对象不影响原对象的生命周期
- 观察者模式中，观察者持有被观察者的弱引用，避免影响被观察者释放
下面是weak_ptr解决循环引用的示例：
#include <memory>
#include <iostream>
class B; // 前向声明
class A {
public:
// 如果是std::shared_ptr<B> member; 会导致循环引用
std::weak_ptr<B> member;
~A() { std::cout << "A析构" << std::endl; }
};
class B {
public:
std::weak_ptr<A> member;
~B() { std::cout << "B析构" << std::endl; }
};
int main() {
auto a = std::make_shared<A>();
auto b = std::make_shared<B>();
// 互相持有弱引用，不会增加引用计数
a->member = b;
b->member = a;
std::cout << "a引用计数：" << a.use_count() << std::endl;
std::cout << "b引用计数：" << b.use_count() << std::endl;
// 访问weak_ptr指向的对象需要先转换为shared_ptr
if (auto b_ptr = a->member.lock()) {
std::cout << "成功访问B对象" << std::endl;
} else {
std::cout << "B对象已释放" << std::endl;
}
return 0;
}
选择建议总结
实际开发中可以按照以下优先级选择智能指针：
- 优先使用
unique_ptr，如果对象不需要共享，独占所有权性能更高，开销更小 - 如果需要多个持有者共享对象，再选择
shared_ptr - 如果需要在
shared_ptr的场景中避免循环引用，或者临时访问对象不影响生命周期，搭配使用weak_ptr
注意：尽量使用std::make_unique和std::make_shared创建智能指针，比直接new更安全，也能减少内存分配次数。
掌握三种智能指针的特性后，就能根据实际的业务场景选择最合适的指针类型，既保证内存安全，也能兼顾程序的性能。
shared_ptrunique_ptrweak_ptr智能指针修改时间：2026-07-20 15:33:44