C++的智能指针

智能指针(Smart Pointer)
     
     传统指针存在的问题
     需要手动管理内存
     容易发生内存泄漏(忘记释放,出现异常等)
     释放之后可能会产生野指针.
     
     智能指针就是为了解决传统指针存在的问题
     auto_ptr:属于C++9.8标准,在C++11中已经不推荐使用(有缺陷,比如不能用于数组)
     shared_ptr:属于C++11标准,多个shared_ptr可以指向同一个对象,当最后一个shared_ptr在作用域范围内结束时,对象才会被自动释放
     针对数组的用法:
     shared_ptr<Person> ptr1(new Person[5]{},[](Person *p){delete[] p;});
     shared_ptr<Person[]> persons(new Person[5]{});
     shared_ptr的原理:
     一个shared_ptr会对一个对象产生强引用(strong reference)
     每个对象都有一个与之对应的强引用计数,记录着当前对象被多少个shared_ptr强引用着
     可以通过shared_ptr的use_count函数获得强引用计数
     当有一个新的shared_ptr指向对象时,对象的强引用计数就会+1
     当一个对象的强引用计数为0时(没有任何shared_ptr指向对象时),对象就会自动销毁(析构)
     shared_ptr的注意点:
     不要使用裸指针来初始化智能指针
     weak_ptr弱引用
     unique_ptr:属于C++11标准
     unique_ptr也会对一个对象产生强引用,它可以确保同一时间只有1个指针指向对象.
     当unique_ptr销毁时(作用域结束时),其指向的对象也就自动销毁了
     可以使用std::move函数转移unique_ptr的所有权
     unique_ptr<Person> ptr1(new Person());//ptr1强引用着Person对象
     unique_ptr<Person> ptr2 = std::move(ptr1);// 转移之后,ptr2强引用着Person对象
     
     
     
     class Person () {
         public:
         Person();
         ~Person();
     };
     
     // 自己创建智能指针
     template <class T>
     class SmartPointer {
         T *m_pointer;
         public:
         SmartPointer(T *m_pointer):m_pointer(pointer) {}
         ~SmartPointer(){
             if (m_pointer == nullptr) return;
             delete m_pointer;
         }
     };
    
     int main() {
     
     
         {
            SmartPointer<Person> p(new Person());
         }
         int *p = new int();
         delete p;
         p = nullptr;
     
     
         {
             shared_ptr<Person> p1(new Person());
             shared_ptr<Person> p2(p1);
         }
     
     
         {
             shared_ptr<Person> p1(new Person[5]{},[](Person *p){delete[] p;})
             //或者 shared_ptr<Person[]> persons(new Person[5]{});
         }
     
     
     
         {
             shared_ptr<Person[]> p1(new Person[5]{});
             shared_ptr<Person[]> p2 = p1;
             shared_ptr<Person[]> p3 = p1;
             shared_ptr<Person[]> p4 = p1;
             cout << p1.use_count() << endl; // 4
     
         }
     
     
     // 通过裸指针初始化智能指针,析构了两次显然不对
     {
     
     
         Person *p = new Person();
         {
            shared_ptr<Person> p1(p);
         }
         {
            shared_ptr<Person> p2(p);
         }
    
     }
     
     // 可以通过一个已存在的智能指针初始化一个新的智能指针
     {
         shared_ptr<Person> p1(new Person());
         shared_ptr<Person> p2(p1);
     }
     
     
     
     
     
         getchar();
         return 0;
     }