C++ | 智能指针

在 C++ 编程中，内存管理一直是一个重要且复杂的问题。手动管理内存容易引发如内存泄漏、悬空指针等一系列问题，不仅增加了程序的调试难度，还可能影响程序的稳定性和性能。为了解决这些问题，C++11 引入了智能指针（Smart Pointers）这一强大工具。本文将深入探讨 C++ 智能指针的原理、优势及其常见使用场景。

一、智能指针的原理

智能指针本质上是一个类模板，它利用了 RAII（Resource Acquisition Is Initialization，资源获取即初始化）技术对普通指针进行封装，使其行为类似指针，却又具备自动内存管理的能力。简单来说，智能指针在构造时获取资源（如分配内存），在析构时释放资源，从而确保资源在不再需要时能被正确释放。

C++ 标准库提供了三种主要的智能指针类型：std::unique_ptr、std::shared_ptr 和 std::weak_ptr ，它们各自有着不同的特性和适用场景。

1.1 std::unique_ptr

std::unique_ptr 代表着对动态分配对象的独占所有权，即同一时刻只能有一个 std::unique_ptr 指向一个对象。当 std::unique_ptr 离开其作用域或被显式重置时，它会自动删除关联的对象。这一过程通过禁止拷贝语义，仅提供移动语义来实现。例如：

#include <iostream>

#include <memory>

int main() {

std::unique_ptr<int> uniquePtr(new int(10));

std::cout << *uniquePtr << std::endl; // 输出10

// uniquePtr离开作用域，自动释放内存

return 0;

}

在这个例子中，uniquePtr 离开 main 函数作用域时，其所指向的内存会被自动释放，无需手动调用 delete 。

使用场景：

函数内部临时对象管理：在函数内部创建一个动态分配的对象，且该对象只在函数内部使用，不需要在函数外部共享时，std::unique_ptr 是很好的选择。例如：

void processData() {

std::unique_ptr<int> data(new int(100));

// 处理data

// data离开作用域自动释放

}

对象所有权转移：当需要将一个对象的所有权从一个函数转移到另一个函数时，std::unique_ptr 可以通过移动语义实现高效的转移。

std::unique_ptr<int> createObject() {

return std::unique_ptr<int>(new int(40));

}

void processObject(std::unique_ptr<int> obj) {

// 处理obj

}

int main() {

auto obj = createObject();

processObject(std::move(obj));

// obj离开作用域，自动释放内存

return 0;

}

1.2 std::shared_ptr

std::shared_ptr 实现了对动态分配对象的共享所有权，多个 std::shared_ptr 可以指向同一个对象。它使用引用计数（reference counting）来跟踪指向对象的引用数量。当一个 std::shared_ptr 被创建或拷贝时，引用计数增加；当一个 std::shared_ptr 被销毁或赋值给其他对象时，引用计数减少。当引用计数减为 0 时，对象被自动删除。例如：

#include <iostream>

#include <memory>

int main() {

std::shared_ptr<int> sharedPtr1(new int(20));

std::shared_ptr<int> sharedPtr2 = sharedPtr1; // 引用计数增加

std::cout << *sharedPtr1 << " " << *sharedPtr2 << std::endl; // 输出20 20

// sharedPtr1和sharedPtr2离开作用域，引用计数减为0，对象被删除

return 0;

}

引用计数增加的时机：

初始化：当通过构造函数创建一个新的std::shared_ptr ，并指向一个新分配的对象时，引用计数初始化为 1 。例如std::shared_ptr<int> ptr(new int(5)); 。
拷贝构造：当使用一个已有的std::shared_ptr 来拷贝构造一个新的std::shared_ptr 时，引用计数增加。如std::shared_ptr<int> ptr2 = ptr; 。
赋值：当将一个std::shared_ptr 赋值给另一个std::shared_ptr ，且这两个std::shared_ptr 指向同一个对象时，引用计数增加。例如：

引用计数减少的时机：

析构：当std::shared_ptr 离开其作用域被销毁时，引用计数减少。例如在上述代码中，ptr和temp离开作用域时，引用计数会分别减少。
赋值：当一个std::shared_ptr 被赋值为另一个指向不同对象的std::shared_ptr 时，原对象的引用计数减少，新对象的引用计数增加（如果新对象不是第一次被引用）。如ptr = std::shared_ptr<int>(new int(20)); ，此时原来指向的对象引用计数减 1 ，新对象引用计数初始化为 1 。
reset：调用std::shared_ptr 的reset 成员函数时，引用计数减少。如果reset 时传入新的指针，那么新对象引用计数增加。例如ptr.reset(new int(30)); ，原对象引用计数减 1 ，新对象引用计数初始化为 1 。

使用场景：

对象需要在多个地方共享：当一个对象需要在不同的函数、模块甚至不同的线程之间共享时，std::shared_ptr 非常适用。例如实现一个全局的配置对象，多个模块都需要访问和修改这个配置对象：

std::shared_ptr<Config> globalConfig(new Config());

void module1() {

auto config = globalConfig;

// 使用config

}

void module2() {

auto config = globalConfig;

// 使用config

}

动态数组管理：当需要动态分配一个数组，并且希望在多个地方共享这个数组时，可以使用std::shared_ptr ，结合std::make_shared 来创建数组：

std::shared_ptr<int[]> sharedArray = std::make_shared<int[]>(10);

1.3 std::weak_ptr

std::weak_ptr 通常与 std::shared_ptr 一起使用，用于解决可能出现的循环引用问题，避免内存泄漏。std::weak_ptr 不参与引用计数，它提供了一个非拥有性、观察性的引用，指向由 std::shared_ptr 管理的对象。可以通过 lock() 方法尝试获取一个有效的 std::shared_ptr ，如果对象已被销毁，lock() 将返回一个空的 std::shared_ptr 。例如：

#include <iostream>

#include <memory>

int main() {

std::shared_ptr<int> sharedPtr(new int(30));

std::weak_ptr<int> weakPtr = sharedPtr;

if (auto temp = weakPtr.lock()) {

std::cout << *temp << std::endl; // 输出30

}

// sharedPtr离开作用域，对象被删除

// 此时weakPtr指向的对象已不存在

return 0;

}

使用场景：

解决循环引用：在对象之间存在循环引用时，使用std::weak_ptr 可以打破循环，避免内存泄漏。例如在一个双向链表的实现中，节点之间相互引用，如果都使用std::shared_ptr 会导致循环引用，使用std::weak_ptr 可以解决这个问题：

class Node;

using SharedNode = std::shared_ptr<Node>;

using WeakNode = std::weak_ptr<Node>;

class Node {

public:

int data;

SharedNode next;

WeakNode prev;

Node(int value) : data(value) {}

};

监控对象生命周期：当需要监控一个由std::shared_ptr 管理的对象是否还存在，但又不想增加其引用计数时，可以使用std::weak_ptr 。例如在一个缓存系统中，缓存对象由std::shared_ptr 管理，其他模块可以通过std::weak_ptr 来检查缓存对象是否还在缓存中：

std::shared_ptr<CacheObject> cacheObject(new CacheObject());

std::weak_ptr<CacheObject> weakCache = cacheObject;

// 其他地方检查缓存对象是否存在

if (auto temp = weakCache.lock()) {

// 缓存对象存在

} else {

// 缓存对象已被释放

}