当前位置：首页 > news >正文

C++智能指针`shared_ptr`详解

news 2025/3/11 9:05:54

在C++编程中，内存管理是一个核心问题。传统的裸指针（如int*）使用灵活，但容易导致内存泄漏或野指针问题。C++11引入的智能指针shared_ptr通过自动管理内存生命周期，极大降低了这些风险。

一、`shared_ptr`是什么？内部结构如何？

1. 定义与特点

shared_ptr是C++标准库（<memory> 头文件）中的一种智能指针，用于管理动态分配的内存。它通过引用计数机制，跟踪有多少个shared_ptr实例共享同一块内存。当最后一个shared_ptr被销毁或重置时，引用计数变为0，内存自动释放。这种“共享所有权”的特性使其非常适合多人共用资源的场景。

2. 内部结构

shared_ptr的内存占用通常是裸指针的两倍（例如，在32位系统中，裸指针占4字节，shared_ptr占8字节）。其内部包含以下部分：

资源指针：指向被管理对象。
控制块指针：
- 强引用计数：有多少个shared_ptr指向当前对象。
- 弱引用计数：有多少个weak_ptr指向当前对象。
- 附加信息：如自定义删除器等。

引用计数的增减操作是线程安全的原子操作，这保证了shared_ptr在多线程环境下的可靠性。

二、`shared_ptr`的创建方式

1. 通过裸指针创建

std::shared_ptr<int> sp(new int(10));   //将动态内存交给shared_ptr管理

内存分配：分配了两次内存：一次是对象内存，一次是shared_ptr内存
注意：避免用同一原始指针初始化多个 shared_ptr，否则会导致双重释放。

2. 通过另一个`shared_ptr`复制

std::shared_ptr<int> sp1(new int(10));
std::shared_ptr<int> sp2 = sp1; // 引用计数增至2

特点：利用shared_ptr的复制语义，基于现有实例创建新实例：

3. 使用`make_shared`工厂函数创建（推荐）

auto sp = std::make_shared<int>(10);

内存分配：只分配一次（创建一块足够大的内存，同时存储被管理的对象和shared_ptr）
适用场景：大多数情况下推荐使用。

三、常用操作与解引用方法

1. 常用操作

use_count()：获取当前引用计数：

std::shared_ptr<int> sp1(new int(10));
std::shared_ptr<int> sp2 = sp1;
std::cout << sp1.use_count(); // 输出2

reset()：重置管理的对象或清空：

std::shared_ptr<int> sp(new int(10));
// 将指针设置为nullptr，引用计数减一
sp.reset();              // 原对象的引用计数减一， 将指针设置为新的对象地址，新对象引用计数加一
sp.reset(new int(20));

判空：检查指针是否有效：

if (sp) {  // 或者通过sp.get()返回裸指针来判断 （不推荐）std::cout << "指针非空\n";
}

2. 解引用

访问shared_ptr管理的对象与裸指针类似：

使用*获取值：

std::shared_ptr<int> sp = std::make_shared<int>(10);
std::cout << *sp; // 输出10

使用->访问成员：

class Test { public: void print() { std::cout << "Hello\n"; } };
auto sp = std::make_shared<Test>();
sp->print(); // 输出Hello

四、常见应用场景

shared_ptr在多种场景下都能发挥作用，以下是几个典型案例：

1. 多个对象共享资源

当多个对象需要访问同一资源时，shared_ptr确保资源安全管理：

auto data = std::make_shared<int>(100);
std::vector<std::shared_ptr<int>> vec{data, data}; // 两个元素共享data
std::cout << *vec[0] << " " << *vec[1]; // 输出100 100

2. 容器存储指针

在容器中存储动态对象时，使用shared_ptr避免手动管理内存：

std::vector<std::shared_ptr<int>> numbers;
numbers.push_back(std::make_shared<int>(1));
numbers.push_back(std::make_shared<int>(2));
for (const auto& num : numbers) { std::cout << *num << " "; } // 输出1 2

3. 函数参数传递

传递大对象时，使用shared_ptr避免拷贝开销，同时保证内存安全：

void process(std::shared_ptr<int> p) { std::cout << *p; }
int main() {auto sp = std::make_shared<int>(42);process(sp); // 输出42return 0;
}

五、常见误区与解决方法

尽管shared_ptr功能强大，但使用不当会导致问题。以下是三个常见误区及解决方案：

1. 通过同一裸指针创建多个`shared_ptr`

    {int* p = new int(10);std::shared_ptr<int> sp1(p);std::shared_ptr<int> sp2(p);}// 这个作用域结束后，sp1和sp2的引用计数变为0，都尝试取释放内存。

问题原因：每个shared_ptr独立创建控制块，引用计数互不关联。sp1和sp2销毁时会分别尝试释放p，造成双重释放，程序崩溃。

解决方法：通过复制创建新实例：

    {std::shared_ptr<int> sp1(new int(10));std::shared_ptr<int> sp2 = sp1; // 正确，共享计数}

2. 通过`this`创建`shared_ptr`

在类中直接用this构造shared_ptr可能引发问题。例如：

class Cat {
public:std::shared_ptr<Cat> getPtr() {return std::shared_ptr<Cat>(this); // 错误！}
};
int main() {auto c = std::make_shared<Cat>();auto c2 = c->getPtr(); // 独立计数，可能崩溃return 0;
}

问题原因：c和c2分别管理this，但引用计数不共享，导致内存被重复释放。

解决方法：继承enable_shared_from_this：

class Cat : public std::enable_shared_from_this<Cat> {
public:std::shared_ptr<Cat> getPtr() {return shared_from_this(); // 正确，共享计数}
};
int main() {auto c = std::make_shared<Cat>(); // 必须先被shared_ptr管理auto c2 = c->getPtr();return 0;
}

shared_from_this()确保新实例与现有实例共享计数，避免问题。

3. 循环引用问题

对象间相互持有shared_ptr会导致内存泄漏：

class Node {
public:std::shared_ptr<Node> next;
};
int main() {auto n1 = std::make_shared<Node>();auto n2 = std::make_shared<Node>();n1->next = n2;n2->next = n1; // 循环引用，内存不释放return 0;
}

问题原因：n1和n2互相引用，引用计数无法归零（二者都是1），内存无法释放。

解决方法：使用weak_ptr打破循环：

class Node {
public:std::weak_ptr<Node> next; // 弱引用，不增计数
};
int main() {auto n1 = std::make_shared<Node>();auto n2 = std::make_shared<Node>();n1->next = n2;n2->next = n1; // 无循环问题return 0;
}