智能指针的作用

c++程序在书写的时候难免会有很多对内存的使用，其中对于在栈空间中的内存，在程序结束后，自动释放，但是对于堆内存来说，如果不及时释放，这会对内存造成一定的灾难，对于堆内存的使用来说，对堆得申请和释放，都需要我们自己来动手（在c++11之前），但是在c++11之后，引出了智能指针的概念，对于一个在堆内存的使用上，有了极大的简洁。使用一般的指针，对于一个刚入门的程序员而言，很容易乱用，忘记释放，二次释放等。但使用智能指针之后，便能更好的管理堆内存。当然在如今，计算机行业发展甚好的今天，早就有人开发出了对于堆内存管理的堆管理器，它能很好的帮助程序员检测内存泄漏的地方，在程序调试期便能够检测出内存泄漏的地方。（向偶像致敬）

对于智能指针内部原理的理解

智能指针利用了一种机制（RAII）,资源获取即初始化，对于检验一个是否合格的c++工程师，就要看他是否真实理解RAII机制。RAII机制，对一般的指针进行封装，实际上智能指针就是一个实例化的对象而已，但是其行为表现，显得是一个指针。当然，它也是线程安全的。

shared_ptr的使用

1，初始化。智能指针是一个类，而且是一个模板类，可以指定类型，传入指针，通过其内部constructor初始化。不能讲一个指针赋值给一个智能指针，记住，智能指针是一个类，而不是一个指针，其行为表现是指针而已。
2，拷贝和赋值
拷贝，引用计数器加1，赋值，引用计数器减一。当引用计数器为0时，自动释放内存。
3，实现：

#include<mutex>
#include<thread>
#include<iostream>
using namespace std;

template<class T>
class share_pointer
{
    public:
        share_pointer(T* ptr):_ptr(ptr),reference(new int(1)),pmuxte(new mutex){}

        ~share_pointer()
        {  
            relese();
        }

        share_pointer(const share_pointer<T>&sp):_ptr(sp._ptr),reference(sp.reference),pmuxte(sp.pmutex)
        { 
            addcount();
        }

        share_pointer<T>& operator= (const share_pointer<T>&sp)
        {
            if (this->_ptr != sp._ptr)
            { 
                relese();
                this->_ptr = sp._ptr;
                this->reference = sp.reference;
                this->pmutex = sp.pmutex;
                this->addcount();
            }
            return *this;
        }

        T& operator* ()
        {
            return *(this->_ptr);
        }

        T& operator-> ()
        {
            return this->_ptr;
        }
        
        int usecount()
        {
            return *(this->reference);
        }

        T* get()
        {
            return this->_ptr;
        }

        void addcount()
        {
            this->pmutex->lock();
            ++(*this->reference));
            this->pmutex->unlock();
        }
  private:
        int* reference;
        T* _ptr;
        mutex* pmutex;
        
        void relese()
        {
            bool deleteflage = false;
            this->pmutex->lock();
            if ( 0 == (--(*(this->reference))) )
            {
                delete this->_ptr;
                delete this->reference;
                deleteflag = true;
            }
            this->pmutex->unlock();
            if ( deleteflag == true)
            {
                delete this->pmutex;
            }
        }
};

int mian()
{
    share_pointer<int>t1(new int(10));
    share_pointer<int>t2(t1);
    *t2 = 20;
    cout<<t1.usecount()<<endl;
    cout<<t2.usecount()<<endl;
    share_pointer<int>t3(new int(200));
    t2 = t3;
    cout<<t1.usecount()<<endl;
    cout<<t2.usecount()<<endl;
    cout<<t3.usecount()<<endl;
    t1 =t3;
    cout<<t1.usecount()<<endl;
    cout<<t2.usecount()<<endl;
    cout<<t3.usecount()<<endl;
    return 0;
}