C++ 定制 `std::unique_ptr`：深入其资源管理机制

好的，各位观众老爷们，欢迎来到今天的C++资源管理讲座！今天我们要聊聊std::unique_ptr，这玩意儿听起来高大上，但其实就是个负责任的“管家”，专门帮你管理资源，防止你辛辛苦苦申请的内存变成无人认领的“孤儿”。

开场白：资源管理的重要性

在C++的世界里，资源管理是个大问题。想象一下，你向操作系统申请了一块内存，用完了却忘了还回去，时间一长，你的程序就会变得越来越慢，最终崩溃。这就是所谓的“内存泄漏”，简直是程序员的噩梦。

为了解决这个问题，C++引入了智能指针，std::unique_ptr就是其中一位得力干将。它确保资源在不再需要时自动释放，避免手动管理内存的痛苦。

std::unique_ptr：独一无二的管家

std::unique_ptr是一个独占所有权的智能指针，也就是说，一个资源只能由一个std::unique_ptr来管理。这就好比你买了一辆车，车钥匙只有一把，只能你一个人开。

基本用法：声明、初始化和使用

先来看看std::unique_ptr的基本用法：

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass() { std::cout << "MyClass constructor calledn"; }
    ~MyClass() { std::cout << "MyClass destructor calledn"; }
    void doSomething() { std::cout << "Doing something!n"; }
};

int main() {
    // 1. 声明并初始化一个 unique_ptr，指向一个 MyClass 对象
    std::unique_ptr<MyClass> ptr(new MyClass());

    // 2. 使用 -> 运算符访问 MyClass 对象的方法
    ptr->doSomething();

    // 3. unique_ptr 在超出作用域时，会自动调用 MyClass 的析构函数，释放内存
    return 0;
}

解释：

std::unique_ptr<MyClass> ptr(new MyClass());：这行代码创建了一个std::unique_ptr，名为ptr，它指向一个新创建的MyClass对象。注意，我们使用了new来分配内存，但不用担心手动释放，std::unique_ptr会搞定一切。
ptr->doSomething();：通过->运算符，我们可以像使用普通指针一样访问MyClass对象的方法。
当ptr超出作用域（例如，main函数结束）时，std::unique_ptr会自动调用MyClass的析构函数，释放new分配的内存。

为什么不用裸指针？

你可能会问，为什么我们要用std::unique_ptr，而不是直接用裸指针呢？

// 不推荐的写法
MyClass* ptr = new MyClass();
ptr->doSomething();
delete ptr; // 必须手动释放内存！

原因很简单：

容易忘记释放内存： 如果你在代码中忘记了delete ptr;，就会造成内存泄漏。
异常安全问题： 如果在ptr->doSomething();中抛出了异常，delete ptr;就不会被执行，同样会导致内存泄漏。

std::unique_ptr则可以避免这些问题，它保证资源在任何情况下都会被释放，即使发生了异常。

移动语义：所有权的转移

由于std::unique_ptr是独占所有权的，所以不能进行拷贝构造和赋值操作。

std::unique_ptr<MyClass> ptr1(new MyClass());
// std::unique_ptr<MyClass> ptr2 = ptr1; // 错误！不能拷贝构造
// ptr2 = ptr1; // 错误！不能赋值

但是，我们可以使用移动语义来转移所有权：

std::unique_ptr<MyClass> ptr1(new MyClass());
std::unique_ptr<MyClass> ptr2 = std::move(ptr1); // 所有权转移到 ptr2
// 现在 ptr1 为空，不能再使用 ptr1->doSomething() 了

if (ptr2) {
    ptr2->doSomething(); // ptr2 可以正常使用
}

解释：

std::move(ptr1)：这会将ptr1的所有权转移到ptr2。移动后，ptr1会变成一个空指针。
if (ptr2)：在使用ptr2之前，最好检查一下它是否为空，以避免空指针解引用。

使用 std::move 的场景

函数返回值: 当函数返回一个动态分配的对象时，使用std::unique_ptr并用std::move转移所有权非常方便.

std::unique_ptr<MyClass> createMyClass() {
    return std::unique_ptr<MyClass>(new MyClass());
}

int main() {
    std::unique_ptr<MyClass> myPtr = createMyClass(); // 通过返回值转移所有权
    if (myPtr) {
        myPtr->doSomething();
    }
    return 0;
}

容器操作: 当需要将一个unique_ptr从一个容器移动到另一个容器时.

#include <vector>
#include <algorithm>

int main() {
    std::vector<std::unique_ptr<MyClass>> vec1;
    vec1.push_back(std::unique_ptr<MyClass>(new MyClass()));

    std::vector<std::unique_ptr<MyClass>> vec2;
    std::move(vec1.begin(), vec1.end(), std::back_inserter(vec2));
    vec1.clear(); // vec1 现在是空的

    if (!vec2.empty() && vec2[0]) {
        vec2[0]->doSomething();
    }
    return 0;
}

自定义删除器：更灵活的资源管理

std::unique_ptr默认使用delete运算符来释放资源。但是，在某些情况下，我们需要使用自定义的删除器，例如：

使用 new[] 分配的数组： 必须使用 delete[] 来释放内存。
使用 C 风格的 API： 必须使用特定的函数来释放资源。
需要执行额外的清理操作： 例如，关闭文件句柄。

使用 delete[] 删除数组

#include <iostream>
#include <memory>

int main() {
    // 使用 delete[] 删除数组
    std::unique_ptr<int[], std::default_delete<int[]>> arrayPtr(new int[10]);

    for (int i = 0; i < 10; ++i) {
        arrayPtr[i] = i;
    }

    // 当 arrayPtr 超出作用域时，会自动调用 delete[] 释放内存

    return 0;
}

自定义删除器函数对象

#include <iostream>
#include <memory>

// 自定义删除器函数对象
struct FileDeleter {
    void operator()(FILE* file) const {
        if (file) {
            fclose(file);
            std::cout << "File closed.n";
        }
    }
};

int main() {
    // 使用自定义删除器
    std::unique_ptr<FILE, FileDeleter> filePtr(fopen("test.txt", "w"), FileDeleter());

    if (filePtr) {
        fprintf(filePtr.get(), "Hello, world!n");
    }

    // 当 filePtr 超出作用域时，会自动调用 FileDeleter 关闭文件

    return 0;
}

自定义删除器 Lambda 表达式

#include <iostream>
#include <memory>

int main() {
    // 使用 Lambda 表达式作为删除器
    std::unique_ptr<FILE, void(*)(FILE*)> filePtr(fopen("test.txt", "w"), [](FILE* file) {
        if (file) {
            fclose(file);
            std::cout << "File closed (lambda).n";
        }
    });

    if (filePtr) {
        fprintf(filePtr.get(), "Hello, world!n");
    }

    // 当 filePtr 超出作用域时，会自动调用 Lambda 表达式关闭文件

    return 0;
}

解释：

std::unique_ptr<FILE, FileDeleter>： 指定了std::unique_ptr管理的资源类型为FILE*，删除器类型为FileDeleter。
FileDeleter()： 创建FileDeleter对象，用于在std::unique_ptr析构时调用。
fopen("test.txt", "w")： 打开文件，并将返回的FILE*指针交给std::unique_ptr管理。
filePtr.get()： 获取std::unique_ptr管理的原始指针，用于fprintf函数。
当filePtr超出作用域时，FileDeleter的operator()会被调用，关闭文件。

自定义删除器的选择

选择自定义删除器类型取决于具体需求：

函数对象： 如果删除逻辑比较复杂，或者需要在多个地方使用，可以使用函数对象。
Lambda 表达式： 如果删除逻辑比较简单，且只在一个地方使用，可以使用 Lambda 表达式。
函数指针： C-style API，或者需要在C++和C之间传递.

std::unique_ptr 和数组

前面我们已经看到了如何使用 std::unique_ptr 和自定义删除器来管理动态分配的数组。 std::unique_ptr<T[]> 是一个特化版本，专门用于管理动态数组。它会自动使用 delete[] 释放内存。

#include <iostream>
#include <memory>

int main() {
    // 使用 unique_ptr 管理动态数组
    std::unique_ptr<int[]> arrayPtr(new int[10]);

    for (int i = 0; i < 10; ++i) {
        arrayPtr[i] = i * 2;
    }

    for (int i = 0; i < 10; ++i) {
        std::cout << arrayPtr[i] << " ";
    }
    std::cout << std::endl;

    // 当 arrayPtr 超出作用域时，会自动调用 delete[] 释放内存

    return 0;
}

解释：

std::unique_ptr<int[]> arrayPtr(new int[10]);： 创建了一个std::unique_ptr，用于管理一个包含10个int元素的动态数组。
*`arrayPtr[i] = i 2;：** 可以使用下标运算符[]`访问数组元素，就像使用普通数组一样。
当arrayPtr超出作用域时，会自动调用delete[]释放内存。

注意事项：

std::unique_ptr<T[]> 只能管理使用 new T[] 分配的数组。
不能使用 std::unique_ptr<T[]> 管理单个对象，否则会导致未定义行为。

std::unique_ptr 的优势总结

自动资源管理： 避免手动释放内存，防止内存泄漏。
异常安全： 即使发生异常，也能保证资源被释放。
独占所有权： 确保只有一个指针指向资源，避免多个指针同时修改资源的问题。
移动语义： 可以高效地转移资源的所有权。
自定义删除器： 可以灵活地管理各种类型的资源。

表格：std::unique_ptr 的关键特性

特性	描述
所有权	独占所有权，一个资源只能由一个 `std::unique_ptr` 管理。
拷贝构造	禁止拷贝构造，防止多个 `std::unique_ptr` 指向同一个资源。
赋值	禁止赋值，防止多个 `std::unique_ptr` 指向同一个资源。
移动	支持移动语义，可以将资源的所有权从一个 `std::unique_ptr` 转移到另一个 `std::unique_ptr`。
删除器	默认使用 `delete` 释放资源，但可以自定义删除器，例如使用 `delete[]` 释放数组，或者使用特定的函数释放资源。
异常安全	保证在任何情况下，包括发生异常时，资源都会被释放。
应用场景	管理动态分配的内存，管理文件句柄，管理网络连接，管理互斥锁等。

高级技巧：与工厂函数配合使用

工厂函数是一种创建对象的常用模式，它可以隐藏对象的创建细节，并提供更灵活的创建方式。std::unique_ptr 可以很好地与工厂函数配合使用。

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass() { std::cout << "MyClass constructor calledn"; }
    ~MyClass() { std::cout << "MyClass destructor calledn"; }
    void doSomething() { std::cout << "Doing something!n"; }

private:
    // 私有构造函数，防止外部直接创建对象
    MyClass(int value) : data(value) {}
    int data;

public:
    // 工厂函数，创建 MyClass 对象
    static std::unique_ptr<MyClass> create(int value) {
        return std::unique_ptr<MyClass>(new MyClass(value));
    }

    void printData() {
        std::cout << "Data: " << data << std::endl;
    }
};

int main() {
    // 使用工厂函数创建 MyClass 对象
    std::unique_ptr<MyClass> ptr = MyClass::create(42);

    if (ptr) {
        ptr->doSomething();
        ptr->printData();
    }

    return 0;
}

解释：

MyClass(int value) : data(value) {}： 私有构造函数，防止外部直接使用 new 创建 MyClass 对象。
static std::unique_ptr<MyClass> create(int value)： 静态工厂函数，用于创建 MyClass 对象，并返回一个 std::unique_ptr。
在 main 函数中，我们使用 MyClass::create(42) 创建 MyClass 对象，并将返回的 std::unique_ptr 赋值给 ptr。

总结：std::unique_ptr，你的资源管理好帮手

std::unique_ptr 是C++中管理动态分配资源的首选工具。它简单易用，功能强大，可以帮助你编写更安全、更可靠的代码。掌握 std::unique_ptr 的用法，你就能告别内存泄漏的困扰，成为一名真正的C++大师！

今天就到这里，感谢各位观众老爷的观看！记得点赞收藏加关注，下次再见！

发表回复 取消回复

发表回复取消回复