【C++11】深度剖析 C++11 智能指针：告别内存泄漏

在C++编程中，内存管理一直是一个重要且复杂的话题。不正确的内存管理可能导致内存泄漏、悬空指针等问题，给程序带来潜在的风险。C++11引入了智能指针（Smart Pointers）这一强大的工具，为开发者提供了一种更安全、更便捷的内存管理方式。
本文将深入探讨C++11中的智能指针，包括其概念、类型、用法以及优势，同时还会介绍智能指针的一些高级用法，并梳理C++14/17/20中对智能指针的增强。

一、为什么需要智能指针

在传统的C++中，动态内存的分配和释放需要手动进行。使用new关键字分配内存后，必须确保在适当的时候使用delete关键字释放内存，否则就会导致内存泄漏。例如：

void someFunction() {int* ptr = new int(5);// 一些操作// 忘记释放ptr指向的内存
}

上述代码中，如果在函数结束时没有调用delete ptr，那么ptr所指向的内存将永远无法被释放，从而造成内存泄漏。随着程序规模的增大，手动管理内存的复杂性也会急剧增加，很容易出现遗漏或错误。

智能指针的出现就是为了解决这些问题。它利用RAII（Resource Acquisition Is Initialization）机制，将动态内存的管理与对象的生命周期绑定在一起。当智能指针对象超出其作用域时，会自动释放其所指向的内存，从而避免了内存泄漏的风险。

二、智能指针的类型

C++11标准库提供了三种主要的智能指针类型：std::unique_ptr、std::shared_ptr和std::weak_ptr。下面分别对它们进行介绍。

1. std::unique_ptr

std::unique_ptr是一种独占式智能指针，它拥有对其所指向对象的唯一所有权。在同一时间，只能有一个std::unique_ptr指向一个给定的对象。当std::unique_ptr对象被销毁时，它所指向的对象也会被自动销毁。

创建std::unique_ptr的方式如下：

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

std::unique_ptr不支持拷贝构造和拷贝赋值操作，因为这会违背其独占所有权的特性。但是，它支持移动构造和移动赋值操作，这使得我们可以将所有权从一个std::unique_ptr转移到另一个std::unique_ptr。例如：

std::unique_ptr<int> ptr1(new int(10));
std::unique_ptr<int> ptr2 = std::move(ptr1); // ptr1的所有权转移到ptr2

std::unique_ptr适用于需要独占资源的场景，比如在函数内部动态分配一个对象，并希望在函数结束时自动释放该对象。

2. std::shared_ptr

std::shared_ptr是一种共享式智能指针，多个std::shared_ptr可以同时指向同一个对象，通过引用计数机制来管理对象的生命周期。当最后一个指向对象的std::shared_ptr被销毁时，对象才会被释放。

创建std::shared_ptr的方式有多种，最常见的是使用std::make_shared函数：

std::shared_ptr<int> ptr = std::make_shared<int>(10);

std::shared_ptr支持拷贝构造和拷贝赋值操作，每次拷贝或赋值都会增加引用计数。例如：

std::shared_ptr<int> ptr1 = std::make_shared<int>(10);
std::shared_ptr<int> ptr2 = ptr1; // ptr2和ptr1指向同一个对象，引用计数增加

std::shared_ptr适用于需要在多个地方共享对象所有权的场景，比如在多线程环境中共享资源。

3. std::weak_ptr

std::weak_ptr是一种弱引用智能指针，它指向一个由std::shared_ptr管理的对象，但不会增加对象的引用计数。std::weak_ptr主要用于解决std::shared_ptr之间的循环引用问题。

创建std::weak_ptr通常是通过std::shared_ptr来初始化：

std::shared_ptr<int> sharedPtr = std::make_shared<int>(10);
std::weak_ptr<int> weakPtr = sharedPtr;

std::weak_ptr不能直接访问其所指向的对象，需要通过lock函数将其转换为std::shared_ptr后才能访问。例如：

std::shared_ptr<int> lockedPtr = weakPtr.lock();
if (lockedPtr) {// 可以安全地访问对象
}

std::weak_ptr适用于需要观察对象的生命周期，但又不想影响对象生命周期的场景。

三、智能指针的使用场景

1. 自动释放内存

智能指针最基本的用途就是自动释放内存，避免内存泄漏。无论是std::unique_ptr、std::shared_ptr还是std::weak_ptr，在其生命周期结束时都会自动处理其所指向的内存，无需手动调用delete。

2. 函数返回动态分配的对象

在函数中动态分配对象并返回时，使用智能指针可以确保对象在不再需要时被正确释放。例如：

std::unique_ptr<int> createInt() {return std::unique_ptr<int>(new int(10));
}

或者使用std::shared_ptr：

std::shared_ptr<int> createInt() {return std::make_shared<int>(10);
}

3. 容器中存储动态对象

在容器（如std::vector、std::list等）中存储动态对象时，智能指针可以很好地管理对象的生命周期。例如：

std::vector<std::shared_ptr<int>> vec;
vec.push_back(std::make_shared<int>(10));
vec.push_back(std::make_shared<int>(20));

当vec超出作用域时，其中存储的所有std::shared_ptr对象都会被销毁，相应的动态分配的int对象也会被释放。

4. 解决循环引用问题

循环引用是使用std::shared_ptr时可能遇到的一个问题。例如：

class B;
class A {
public:std::shared_ptr<B> ptrB;~A() {std::cout << "~A()" << endl;}
};
class B {
public:std::shared_ptr<A> ptrA;~B() {std::cout << "~B()" << endl;}
};

在上述代码中，如果A和B对象相互引用，就会导致循环引用，使得对象无法被正确释放。此时，可以使用std::weak_ptr来打破循环引用：

class B;
class A {
public:std::weak_ptr<B> ptrB;~A() {std::cout << "~A()" << endl;}
};
class B {
public:std::shared_ptr<A> ptrA;~B() {std::cout << "~B()" << endl;}
};

通过将A中的ptrB改为std::weak_ptr，可以避免循环引用导致的内存泄漏问题。

四、智能指针的高级用法

1. 自定义删除器

默认情况下，std::unique_ptr和std::shared_ptr使用delete操作符来释放对象。但在某些场景下，我们可能需要自定义释放资源的方式。比如，当我们使用std::unique_ptr管理通过malloc分配的内存时，就需要使用free来释放。

// 自定义删除器函数
void customDeleter(void* ptr) {free(ptr);
}
// 使用自定义删除器的std::unique_ptr
std::unique_ptr<void, decltype(&customDeleter)> ptr(malloc(1024), customDeleter);

对于std::shared_ptr，也可以采用类似的方式，自定义删除器使得智能指针能够管理更复杂的资源释放逻辑。

2. 管理数组

std::unique_ptr原生支持管理动态数组，使用[]语法进行对象创建和销毁。

std::unique_ptr<int[]> arr(new int[5]{1, 2, 3, 4, 5});
for (size_t i = 0; i < 5; ++i) {std::cout << arr[i] << " ";
}

std::shared_ptr管理数组时，需要自定义删除器，因为默认的删除器使用delete而非delete[]。

// 用于数组的自定义删除器
struct ArrayDeleter {template <typename T>void operator()(T* ptr) const {delete[] ptr;}
};
std::shared_ptr<int> arrShared(new int[5]{1, 2, 3, 4, 5}, ArrayDeleter());

3. 智能指针与多态

智能指针在多态场景下表现出色。通过使用基类的智能指针，可以指向派生类对象，并且在对象销毁时会调用正确的析构函数。

class Base {
public:virtual ~Base() = default;
};
class Derived : public Base {
public:~Derived() override {std::cout << "~Derived()" << endl;}
};
std::unique_ptr<Base> basePtr = std::make_unique<Derived>();

这里basePtr是std::unique_ptr<Base>类型，但指向Derived对象，当basePtr超出作用域时，Derived类的析构函数会被正确调用。

六、总结

C++11的智能指针为内存管理提供了强大而安全的工具：
unique_ptr：轻量级独占所有权指针，无额外开销，，与裸指针相当
shared_ptr：共享所有权指针，使用引用计数，有一定开销
weak_ptr：弱引用指针，解决循环引用问题。与shared_ptr配合使用，额外开销较小