C++智能指针简单实现

女爷i 2022-06-10 03:06 185阅读 0赞

#include <iostream>
    #include <string>
    #include <vector>
    #include <list>
    
    namespace smart_pointer {
    
    // RAII（Resource Acquisition Is Initialization）:资源分配即初始化，是管理资源、避免内存泄露的方法。
    // 方法是：定义一个类来封装资源的分配和释放，在构造函数完成资源的分配和初始化，在析构函数完成资源的的清理，可以保证资源的正确初始化和释放。
    
    // 参考 http://blog.csdn.net/ER_Plough/article/details/48206439?ref=myread
    // http://blog.csdn.net/daniel_ustc/article/details/23096229
    // 循环引用
    // 循环引用”简单来说就是：两个对象互相使用一个shared_ptr成员变量指向对方的会造成循环引用。
    // 即A内部有指向B，B内部有指向A，这样对于A，B必定是在A析构后B才析构，对于B，A必定是在B析构后才析构A，这就是循环引用问题，违反常规，导致内存泄露。
    
    // 解决循环引用方法：
    // 1. 当只剩下最后一个引用的时候需要手动打破循环引用释放对象。
    // 2. 当A的生存期超过B的生存期的时候，B改为使用一个普通指针指向A。
    // 3. 使用weak_ptr打破这种循环引用，因为weak_ptr不会修改计数器的大小，所以就不会产生两个对象互相使用一个shared_ptr成员变量指向对方的问题，从而不会引起引用循环。
    
    // 强引用和弱引用
    // 一个强引用当被引用的对象活着的话，这个引用也存在（就是说，当至少有一个强引用，那么这个对象就不能被释放）。
    // share_ptr就是强引用。相对而言，弱引用当引用的对象活着的时候不一定存在。仅仅是当它存在的时候的一个引用。弱引用并不修改该对象的引用计数，
    // 这意味这弱引用它并不对对象的内存进行管理，在功能上类似于普通指针，然而一个比较大的区别是，弱引用能检测到所管理的对象是否已经被释放，从而避免访问非法内存。
    
    // 1.AutoPtr-----管理权转移
    // 2.ScopedPtr------防拷贝
    // 3.SharePtr------引用计数
    
    //-----------------------------------------------------------------------------------
    // 1.AutoPtr
    
    template<class T>
    class AutoPtr {
    public:
      explicit AutoPtr(T* ptr);
    
      ~AutoPtr();
    
      AutoPtr(AutoPtr<T>& auto_ptr);
    
      T* get() const {
        return ptr_;
      }
    
      void reset(T* ptr);
    
      T& operator*() const {
        return *ptr_;
      }
    
      T* operator->() const {
        return ptr_;
      }
    
      bool operator!() const {
        return ptr_ == NULL;
      }
    
      explicit operator bool() const {
        return ptr_ != NULL;
      }
    
      AutoPtr& operator=(AutoPtr<T>& auto_ptr);
    
    private:
      T* ptr_;
    };
    
    template<class T>
    AutoPtr<T>::AutoPtr(T* ptr)
        : ptr_(ptr) {
    }
    
    template<class T>
    AutoPtr<T>::~AutoPtr() {
      if (ptr_ != NULL) {
        delete ptr_;
        ptr_ = NULL;
      }
    }
    
    template<class T>
    AutoPtr<T>::AutoPtr(AutoPtr<T>& auto_ptr) {
      ptr_ = auto_ptr.ptr_;
      auto_ptr.ptr_ = NULL;
    }
    
    template<class T>
    AutoPtr<T>& AutoPtr<T>::operator=(AutoPtr<T>& auto_ptr) {
      if (&auto_ptr == this) {
        return *this;
      }
    
      if (ptr_ != NULL) {
        delete ptr_;
      }
    
      ptr_ = auto_ptr.ptr_;
      auto_ptr.ptr_ = NULL;
    
      return *this;
    }
    
    template<class T>
    void AutoPtr<T>::reset(T* ptr) {
      if (ptr_ != NULL) {
        delete ptr_;
      }
    
      ptr_ = ptr;
    }
    
    template<class T, class D>
    bool operator==(const AutoPtr<T>& lhs, const AutoPtr<D>& rhs) {
      return lhs.get() == rhs.get();
    }
    
    template<class T, class D>
    bool operator!=(const AutoPtr<T>& lhs, const AutoPtr<D>& rhs) {
      return lhs.get() != rhs.get();
    }
    
    
    //-----------------------------------------------------------------------------------
    // ScopedPtr
    
    template<class T>
    class ScopedPtr {
    public:
      explicit ScopedPtr(T* ptr)
        : ptr_(ptr) {
      }
    
      ~ScopedPtr() {
        if (ptr_ != NULL) {
          delete ptr_;
          ptr_ = NULL;
        }
      }
    
      T* operator->() const {
        return ptr_;
      }
    
    private:
      ScopedPtr(const ScopedPtr<T>& scoped_ptr);
      ScopedPtr& operator=(const ScopedPtr<T>& scoped_ptr);
    
    private:
      T* ptr_;
    };
    
    //-----------------------------------------------------------------------------------
    // ScopedPtr
    
    template<class T>
    class SharedPtr {
    public:
      explicit SharedPtr(T* ptr)
        : ptr_(ptr) {
        count_ = new int(1);
      }
    
      SharedPtr()
        : ptr_(NULL)
        , count_(NULL) {
      }
    
      ~SharedPtr() {
        Release();
      }
    
      SharedPtr(const SharedPtr<T>& shared_ptr)
        : ptr_(shared_ptr.ptr_)
        , count_(shared_ptr.count_) {
        ++(*count_);
      }
    
      SharedPtr<T>& operator=(const SharedPtr<T>& shared_ptr) {
        if (&shared_ptr != this) {
          Release();
    
          ptr_ = shared_ptr.ptr_;
          count_ = shared_ptr.count_;
          ++(*count_);
        }
    
        return *this;
      }
    
      T* operator->() const {
        return ptr_;
      }
    
    private:
      void Release() {
        if (ptr_ == NULL) {
          return;
        }
    
        --(*count_);
    
        if (*count_ == 0) {
          delete ptr_;
          delete count_;
        }
      }
    
    private:
      T* ptr_;
    
      int* count_;
    };
    
    //-----------------------------------------------------------------------------------
    // Test
    
    class String1 {
    public:
      explicit String1(const std::string& name)
        : name_(name) {
        std::cout << "Construct String1 : " << name_ << "!" << std::endl;
      }
    
      ~String1() {
        std::cout << "Destruct String1! : " << name_ << "!" << std::endl;
      }
    
      void Print() {
        std::cout << "I am " << name_ << "!" << std::endl;
      }
    
    private:
      std::string name_;
    };
    
    class B;
    
    class A {
    public:
      SharedPtr<B> b;
    
      ~A() {
        std::cout << "Destruct A!" << std::endl;
      }
    };
    
    class B {
    public:
      SharedPtr<A> a;
    
      ~B() {
        std::cout << "Destruct B!" << std::endl;
      }
    };
    
    static void TestAutoPtr() {
      AutoPtr<String1> ptr1(new String1("N1"));
      AutoPtr<String1> ptr2(ptr1);
      if (ptr1.get() == NULL) {
        std::cout << "true" << std::endl;
      }
    
      AutoPtr<String1> ptr3(new String1("N2"));
      ptr3 = ptr2;
      if (ptr2.get() == NULL) {
        std::cout << "true" << std::endl;
      }
    
      ptr3.reset(new String1("N4"));
      (*ptr3).Print();
      ptr3->Print();
    
      AutoPtr<int> ptr4(NULL);
      if (!ptr4) {
        std::cout << "true" << std::endl;
      }
    
      if (ptr3) {
        std::cout << "true" << std::endl;
      }
    
      if (ptr3 == ptr1) {
        std::cout << "true" << std::endl;
      }
    
      if (ptr3 != ptr1) {
        std::cout << "true" << std::endl;
      }
    }
    
    static void TestScopedPtr() {
      ScopedPtr<String1> ptr1(new String1("M1"));
      //ScopedPtr<String1> ptr2(ptr1);  // error
      ScopedPtr<String1> ptr3(new String1("M3"));
      //ptr3 = ptr1;  // error
    
      ptr1->Print();
    }
    
    static void TestSharedPtr() {
      SharedPtr<String1> ptr1(new String1("Z1"));
      SharedPtr<String1> ptr2(new String1("Z2"));
      SharedPtr<String1> ptr3(ptr1);
      ptr2 = ptr3;
    
      ptr1->Print();
      ptr2->Print();
      ptr3->Print();
    }
    
    static void TestCircularReference() {
      SharedPtr<A> a(new A);
      SharedPtr<B> b(new B);
    
      a->b = b;
      b->a = a;
    
    }
    
    static void TestDestructOrder() {
      String1 a("a");
      String1 b("b");
    }
    
    }  // smart_pointer
    
    int main_smart() {
      using namespace smart_pointer;
    
      //TestDestructOrder();
    
      //TestAutoPtr();
      //TestScopedPtr();
      //TestSharedPtr();
    
      //TestCircularReference();
    
      return 0;
    }