怎样实现类似智能指针的类手写简化版智能指针教学示例

P粉602998670

发布时间：2025-08-05 10:15:01

310人浏览过

来源于php中文网

原创

实现一个类似智能指针的类核心在于利用raii原则绑定资源与对象生命周期，通过封装原始指针确保资源自动释放，解决内存泄漏和悬空指针等问题。1. 使用模板类包装原始指针并重载解引用与成员访问运算符；2. 在析构函数中释放资源以实现自动管理；3. 禁用拷贝构造与赋值操作确保独占所有权；4. 实现移动构造与赋值转移所有权；5. 提供get、release、reset等接口用于资源获取与替换；6. 通过operator bool支持空指针检查。相比标准库unique_ptr，该简化版本缺少自定义删除器、数组特化、make_unique支持及多态转换等功能，但已体现raii与移动语义的核心机制。

怎样实现类似智能指针的类手写简化版智能指针教学示例

实现一个类似智能指针的类，核心在于利用C++的RAII（Resource Acquisition Is Initialization）原则，将资源的生命周期管理与对象的生命周期绑定。简单来说，就是用一个类来包装原始指针，确保当这个包装类对象被销毁时，它所持有的资源（比如动态分配的内存）也能被自动释放，从而避免内存泄漏和悬空指针等问题。

我一直觉得，理解智能指针，光看概念是远远不够的，得自己上手写一个，哪怕是简化版。你会发现，那些平时觉得有点玄乎的RAII原则，一下就变得具体起来了。

#include  // 仅用于示例中的输出

// 示例：一个简单的资源类，用于观察构造和析构
struct MyResource {
    int value;
    MyResource(int v) : value(v) {
        std::cout << "MyResource(" << value << ") constructed.\n";
    }
    ~MyResource() {
        std::cout << "MyResource(" << value << ") destroyed.\n";
    }
    void do_something() {
        std::cout << "MyResource(" << value << ") doing something.\n";
    }
};

// 简化版智能指针：MyUniquePtr
// 模仿std::unique_ptr，实现独占所有权
template 
class MyUniquePtr {
private:
    T* ptr; // 持有的原始指针

public:
    // 构造函数：接受一个原始指针
    // explicit关键字避免隐式类型转换
    explicit MyUniquePtr(T* p = nullptr) : ptr(p) {
        // std::cout << "MyUniquePtr constructed with ptr: " << ptr << "\n";
    }

    // 析构函数：确保在MyUniquePtr对象销毁时，其管理的资源也被释放
    ~MyUniquePtr() noexcept { // 析构函数应为noexcept
        // std::cout << "MyUniquePtr destructed, deleting ptr: " << ptr << "\n";
        delete ptr;
    }

    // 禁用拷贝构造函数和拷贝赋值运算符
    // 独占所有权意味着不能复制，只能移动
    MyUniquePtr(const MyUniquePtr&) = delete;
    MyUniquePtr& operator=(const MyUniquePtr&) = delete;

    // 移动构造函数：从另一个MyUniquePtr对象“窃取”所有权
    MyUniquePtr(MyUniquePtr&& other) noexcept : ptr(other.ptr) {
        other.ptr = nullptr; // 将原对象置空，防止其析构时误删资源
        // std::cout << "MyUniquePtr move constructed.\n";
    }

    // 移动赋值运算符：同理，转移所有权
    MyUniquePtr& operator=(MyUniquePtr&& other) noexcept {
        if (this != &other) { // 避免自我赋值
            delete ptr; // 先释放当前持有的资源
            ptr = other.ptr;
            other.ptr = nullptr;
        }
        // std::cout << "MyUniquePtr move assigned.\n";
        return *this;
    }

    // 解引用运算符：允许像操作原始指针一样操作对象
    T& operator*() const {
        // 实际使用时，这里应该检查ptr是否为nullptr，避免空指针解引用
        // 但为了简化，这里暂时省略
        return *ptr;
    }

    // 成员访问运算符：允许通过->访问成员
    T* operator->() const {
        return ptr;
    }

    // 获取原始指针：通常不建议直接使用，除非必要
    T* get() const noexcept {
        return ptr;
    }

    // 释放所有权：返回原始指针，并将MyUniquePtr置空
    // 调用者现在负责管理返回的原始指针
    T* release() noexcept {
        T* oldPtr = ptr;
        ptr = nullptr;
        return oldPtr;
    }

    // 重置：释放当前资源，并管理新的原始指针
    void reset(T* p = nullptr) noexcept {
        if (ptr != p) { // 避免删除自身（如果p就是当前ptr）
            delete ptr;
            ptr = p;
        }
    }

    // 转换为bool：判断是否持有有效指针
    explicit operator bool() const noexcept {
        return ptr != nullptr;
    }
};

// 示例用法
// int main() {
//     std::cout << "--- Creating p1 ---\n";
//     MyUniquePtr p1(new MyResource(10)); // 独占MyResource(10)
//     p1->do_something();
//     std::cout << "p1 value: " << (*p1).value << "\n";

//     std::cout << "--- Attempting copy (will fail to compile) ---\n";
//     // MyUniquePtr p2 = p1; // 编译错误：拷贝构造函数被禁用

//     std::cout << "--- Moving p1 to p3 ---\n";
//     MyUniquePtr p3 = std::move(p1); // 移动所有权，p1变空
//     if (p1) {
//         std::cout << "p1 is still valid (should not happen).\n";
//     } else {
//         std::cout << "p1 is now empty.\n";
//     }
//     p3->do_something();
//     std::cout << "p3 value: " << p3->value << "\n";

//     std::cout << "--- Resetting p3 ---\n";
//     p3.reset(new MyResource(20)); // MyResource(10)被销毁，p3现在管理MyResource(20)
//     p3->do_something();

//     std::cout << "--- Releasing p3's ownership ---\n";
//     MyResource* rawPtr = p3.release(); // p3放弃所有权，MyResource(20)未被销毁
//     if (!p3) {
//         std::cout << "p3 is now empty after release.\n";
//     }
//     std::cout << "Manually deleting released rawPtr...\n";
//     delete rawPtr; // 必须手动删除，否则MyResource(20)会泄漏

//     std::cout << "--- End of main ---\n";
//     return 0;
// }

为什么我们需要智能指针？它解决了哪些传统C++内存管理痛点？

说实话，刚开始写C++那会儿，内存泄漏简直是家常便饭。每次程序崩溃，都得花大量时间去排查是不是哪个

new

没配对

delete

。智能指针简直就是救星，它把这种繁琐、易错的活儿自动化了。

传统C++内存管理中，我们经常会遇到几个让人头疼的问题。最常见的就是内存泄漏，当你

new

了一块内存，却因为各种原因（比如忘记

delete

、提前返回、异常抛出）没有释放它，这块内存就永远被占用了，直到程序结束。想象一下一个长时间运行的服务，如果频繁发生内存泄漏，最终会导致系统资源耗尽。

另一个痛点是悬空指针和重复释放。当你

delete

了一块内存后，如果原始指针没有被置空，它就成了悬空指针。之后如果再通过这个悬空指针去访问内存，或者再次

delete

它，就会导致程序崩溃或者未定义行为。这在复杂的程序中，尤其是有多个指针指向同一块内存时，更是噩梦。

此外，异常安全也是个大问题。如果在函数内部

new

了内存，然后因为某些操作抛出了异常，而

delete

语句在异常点之后，那么内存就永远不会被释放了。智能指针通过将资源管理封装在类的析构函数中，确保了无论函数如何退出（正常返回还是抛出异常），析构函数都会被调用，从而保证了资源被正确释放，这就是C++中非常重要的RAII（Resource Acquisition Is Initialization）原则。它不仅仅限于内存，文件句柄、网络连接、锁等任何需要在特定时刻获取和释放的资源，都可以通过RAII原则来管理。

实现一个简化的智能指针时，有哪些关键设计考量？

设计这东西，很多时候都是在权衡。比如，我们这个简化版，为了突出核心的RAII和所有权，就没去考虑多线程下的引用计数（那是

shared_ptr

的范畴），也没去搞自定义删除器。但即便是这样，里面的移动语义，还有对拷贝的禁用，都是缺一不可的。

实现一个简化版智能指针，主要有以下几个关键设计考量：

所有权语义（Ownership Semantics）：这是智能指针的核心。我们选择实现的是独占所有权（
```
unique_ptr
```
风格），这意味着任何时候，只有一个智能指针实例拥有对特定资源的控制权。为了强制这种独占性，我们必须禁用拷贝构造函数和拷贝赋值运算符。如果允许拷贝，就会出现多个智能指针管理同一块内存的情况，导致重复释放。

Clickable
用AI在几秒钟内生成广告

下载
RAII原则的体现：这是自动管理资源的关键。智能指针的构造函数负责获取资源（接收一个原始指针），而析构函数则负责释放资源（调用
```
delete
```
）。当智能指针对象超出作用域或被销毁时，其析构函数会自动被调用，从而保证资源被及时、安全地释放。
操作符重载：为了让智能指针的行为尽可能接近原始指针，我们需要重载
```
*
```
（解引用运算符）和
```
->
```
（成员访问运算符）。这样，用户就可以像使用原始指针一样，通过智能指针来访问所指向对象的值或成员。
移动语义（Move Semantics）：虽然我们禁用了拷贝，但为了实现所有权的转移（比如从一个函数返回智能指针，或者将智能指针放入容器），移动构造函数和移动赋值运算符是必不可少的。移动操作会将资源的所有权从一个智能指针转移到另一个，同时将原智能指针置空，避免资源被多次管理。
空指针处理：智能指针应该能够安全地处理空指针。例如，当智能指针不持有任何资源时（即内部的
```
ptr
```
为
```
nullptr
```
），对其进行
```
reset()
```
操作或析构时，不应该导致问题。同时，提供一个
```
operator bool()
```
重载可以方便地检查智能指针是否持有有效资源。
```
release()
```
和
reset()
方法：
```
release()
```
允许智能指针放弃对资源的控制权，并返回原始指针，这在某些需要手动管理资源或将资源传递给C风格API的场景下非常有用。
```
reset()
```
则允许智能指针释放当前持有的资源，并开始管理一个新的资源。

我们的简化版智能指针与标准库中的

std::unique_ptr

有何异同？

写完这个简化版，你会发现，标准库里的

std::unique_ptr

真的考虑得太周全了。我们这个版本，就像是个“毛坯房”，能住人，但很多细节功能还没完善。比如自定义删除器，那真是个特别实用的功能，能让智能指针管理各种非内存资源。但话说回来，能搭起这个“毛坯房”，就已经很能说明问题了。

我们的

MyUniquePtr

与C++标准库中的

std::unique_ptr

在核心思想和功能上是相似的，都实现了独占所有权和RAII原则，并支持移动语义。然而，标准库的版本经过了大量的工程实践和优化，拥有更多高级特性和健壮性：

相同点：

独占所有权： 两者都确保了资源在任何时候只被一个智能指针实例拥有。
RAII原则： 都通过构造函数获取资源，通过析构函数释放资源，保证了资源管理的自动化和异常安全。
移动语义： 都支持通过移动操作来转移所有权，而非复制。
操作符重载： 都重载了
```
*
```
和
```
->
```
，使得它们可以像原始指针一样使用。
get()
、
release()
、
reset()
：这些核心接口功能基本一致。

不同点（

MyUniquePtr

的局限性）：

自定义删除器（Custom Deleters）：
```
std::unique_ptr
```
允许你指定一个自定义的删除器（可以是函数对象、lambda表达式等），来处理资源的释放。这使得
```
unique_ptr
```
不仅可以管理堆内存，还能管理文件句柄（
```
FILE*
```
）、网络套接字等需要特定释放操作的资源。我们的
```
MyUniquePtr
```
目前只能使用
```
delete
```
操作符。
数组支持：
```
std::unique_ptr
```
有针对数组的特化版本（
```
std::unique_ptr
```
），它的析构函数会调用
```
delete[]
```
来正确释放数组内存。而我们的
```
MyUniquePtr
```
只调用
```
delete ptr;
```
，如果用于管理数组，会导致未定义行为。
make_unique
函数：标准库提供了
```
std::make_unique
```
辅助函数，用于创建
```
unique_ptr
```
对象。它不仅语法更简洁，还能提供异常安全保证（避免在
```
new
```
和
```
unique_ptr
```
构造之间发生异常）。
类型转换和多态：
```
std::unique_ptr
```
支持从派生类指针到基类指针的安全转换，这在多态场景下非常有用。我们的简化版可能没有完全实现这一点。
noexcept
保证：
```
std::unique_ptr
```
的许多成员函数都带有
```
noexcept
```
关键字，表明它们不会抛出异常，这对于编写异常安全的代码非常重要。我在
```
MyUniquePtr
```
中也尝试添加了，但在实际的生产级代码中，这需要更细致的