手写share_ptr

share_ptr:c++11引入的智能指针。是模板类，允许多个指针指向同一个对象。通过判断引用计数的值，来决定何时释放动态内存。

1.用nullptr构造时，引用计数为0；

2.用非nullptr构造时，引用计数为1；

3.拷贝一个share_ptr，引用计数会加1：如拷贝构造，share_ptr作为参数传递给函数，作为函数的返回值。

4.引用计数减1的情况：给share_ptr赋予新值，share_ptr被销毁时如离开作用域时。

当引用计数为0时，析构函数会销毁对象，释放内存。

#include <iostream>
//手写share_ptr

using namespace std;

template<typename T>
class MyShare_ptr{
private:
    int* count;
    T * ptr;
    //引用计数减一，释放资源
    void remove(){
        --(*count);
        if(count == 0){
            //delete一个指针，只会释放指针所指向的内存空间，
            //指针本身仍然存在，是一个空悬指针，指向随机的地方，所以所需要赋值nullptr让指针变成空指针。
            //野指针：指没有被初始化的指针，无地址。

            delete ptr;
            delete count;
            count = nullptr;
            ptr = nullptr;
        }
    }

public:
    //空参构造，引用计数为0。
    MyShare_ptr():count(new int(0)),ptr(nullptr){};
    //含参构造，引用计数为1.
    MyShare_ptr(T* _ptr):count(new int(1)),ptr(_ptr){};
    //拷贝构造函数，对象为另一个对象的副本，拷贝构造函数拷贝指针并增加与之相应的引用计数；
    MyShare_ptr(const MyShare_ptr<T> & other){
        this->count = other.count;
        this->ptr = other.ptr;
        (*(this->count))++;
    }
    //赋值构造函数
    MyShare_ptr<T> & operator= ( const MyShare_ptr<T>  & other){
        //本来就是所指一个地址,引用计数也不用改变。
        if(this->ptr == other.ptr) return *this;
        //指向不同地址
        else{
            //如果左操作数的引用计数>0，说明已经有ptr了,对左操作数减引用计数。
            if(*count > 0){
                remove();
            }
            this->ptr = other.ptr;
            this->count = other.count;
            //共同的计数加1。这里就体现出int *count的必要性了。而不是int。
            (*(this->count))++;
            return *this;
        }
    }
    //析构函数
    ~MyShare_ptr(){
        //减少引用计数，如果为0 就delete;
        remove();
    }
};
int main() {
    MyShare_ptr<int> p1(new int(1));
    MyShare_ptr<int> p2(p1);
    MyShare_ptr<int> p3(new int (2));
    p3 = p1;
    return 0;
}

 程序需要在多个对象之间共享数据时，可以采用share_ptr<vector<string>>的方式。详见 《c++ primer》P456