C++ 智能指针详解：原理、实现与内存安全

这个智能指针也是基于 RAII 思想搞出来的，但它有很大的弊端：如果管理权被转移了，之前那个指针就会变成空指针，这容易导致未定义行为。因此很多公司都是明令禁止使用的，C++11 后也已被标记为 deprecated。

auto_ptr 的模拟实现

template<class T>
class auto_ptr {
public:
    auto_ptr(T* ptr) : _ptr(ptr) {}
    ~auto_ptr() { delete _ptr; }
    
    T& operator*() { return *_ptr; }
    T* operator->() { return _ptr; }
    
    // 拷贝构造函数：转移所有权
    auto_ptr(auto_ptr<T>& ap) : _ptr(ap._ptr) { 
        ap._ptr = nullptr; 
    }
    
private:
    T* _ptr;
};
// 使用示例：A 是一个类
// auto_ptr<A> ap1(new A(5));

std::unique_ptr

unique_ptr, shared_ptr 和 weak_ptr 是 Boost 库先实现的（底层和名字稍有不同），后来 C++11 也支持这几个智能指针的使用了。

unique_ptr 直接让智能指针不能拷贝和赋值 + 管理权转移。这个智能指针也是基于 RAII 思想实现的。

unique_ptr 的模拟实现

template<class T>
class unique_ptr {
public:
    unique_ptr(T* ptr) : _ptr(ptr) {}
    ~unique_ptr() { delete _ptr; }
    
    T& operator*() { return *_ptr; }
    T* operator->() { return _ptr; }
    
    // 禁止拷贝构造和拷贝赋值
    unique_ptr(unique_ptr<T>& ap) = delete;
    unique_ptr<T>& operator=(unique_ptr<T>& ap) = delete;
    
private:
    T* _ptr;
};
// 使用：unique_ptr<A> up1(new A(5));

引申一下：一般拷贝不让实现的话，赋值也不能实现，就像上面禁止就一起禁止了。实际标准库中 unique_ptr 支持移动语义（move semantics），这里为了简化演示只展示了禁止拷贝的逻辑。

std::shared_ptr

这个智能指针是最全面的，一般都是用的这个，然后有循环引用的时候搭配 weak_ptr 用。也是 RAII 思想实现的。

原理：通过引用计数的方式来实现多个 shared_ptr 对象之间共享资源。

shared_ptr 的模拟实现

template<class T>
class shared_ptr {
public:
    shared_ptr(T* ptr = nullptr) : _ptr(ptr), _pcount(new int(1)) {}
    
    template<class D>
    shared_ptr(T* ptr, D del) : _ptr(ptr), _pcount(new int(1)), _del(del) {}
    
    ~shared_ptr() {
        if (--(*_pcount) == 0) { // 注意理解这里
            _del(_ptr);
            delete _pcount;
        }
    }
    
    T& operator*() { return *_ptr; }
    T* operator->() { return _ptr; }
    
    shared_ptr(const shared_ptr<T>& sp) : _ptr(sp._ptr), _pcount(sp._pcount) {
        ++(*_pcount);
    }
    
    shared_ptr<T>& operator=(const shared_ptr<T>& sp) {
        if (_ptr == sp._ptr) return *this; // 注意自己给自己赋值这个场景
        
        if (--(*_pcount) == 0) {
            delete _ptr;
            delete _pcount;
        }
        
        _ptr = sp._ptr;
        _pcount = sp._pcount;
        ++(*_pcount);
        return *this;
    }
    
    T* get() const { return _ptr; }

private:
    T* _ptr;
    int* _pcount; // 这里的计数 用静态的 static int count 是不行的
    function<void(T*)> _del = [](T* ptr){ delete ptr; }; // 这个_del 的类型很巧妙
};
// 用法：shared_ptr<A> sp1(new A(1));
// 注意：shared_ptr<A> 跟 A 可不是一个类型

引申：编译器对越界访问的检查一般不是很彻底的，所以要注意边界。

shared_ptr 的一个弊端

shared_ptr 在遇到循环引用的时候也是会内存泄漏的。比如两个对象互相持有对方的 shared_ptr，引用计数永远无法归零。

std::weak_ptr

weak_ptr 这个智能指针不是 RAII 思想的，它的唯一作用就是解决 shared_ptr 的循环引用问题的。

这个智能指针可以访问资源，但是不参与资源释放的解决。weak_ptr 不能管理资源！！！

注意：weak_ptr 库里面实现了让它可以和 shared_ptr 相互转换。

weak_ptr 的模拟实现

template<class T>
class weak_ptr {
public:
    weak_ptr() : _ptr(nullptr) {}
    weak_ptr(const shared_ptr<T>& sp) : _ptr(sp.get()) {}
    
    weak_ptr<T>& operator=(const shared_ptr<T>& sp) {
        _ptr = sp.get();
        return *this;
    }
    
    T& operator*() { return *_ptr; }
    T* operator->() { return _ptr; }

private:
    T* _ptr;
};
// weak_ptr 其实也是可以转换成 shared_ptr 的，只是自己没有实现罢了

删除定制器

在智能指针使用过程中，可能会有 new[] 或者 malloc 出来的空间，这些空间用 delete 根本不行——此时就需要删除定制器了。

库里面的话，是给 unique_ptr 和 shared_ptr 配备了删除定制器的。这里的话，自己模拟实现一下 shared_ptr 的删除定制器（在上面的模拟实现里面自己写了的）。

课后练习

建议结合上述原理，尝试编写一个简单的测试程序，验证 shared_ptr 的引用计数变化以及 weak_ptr 如何解决循环引用问题。