C++智能指针的使用与实现

1.什么是智能指针

 C++的智能指针其实就是对普通指针的封装（即封装成一个类），通过重载 * 和 ->两个运算符，使得智能指针表现的就像普通指针一样。

2.智能指针的作用
           C++程序设计中使用堆内存是非常频繁的操作，堆内存的申请和释放都由程序员自己管理。程序员自己管理堆内存可以提高 了程序的效率，但是整体来说堆内存的管理是麻烦的，C++11中引入了智能指针的概念，方便管理堆内存。使用普通指针，容易   造成堆内存泄露（忘记释放），二次释放，程序发生异常时内存泄露等问题等，使用智能指针能更好的管理堆内存。

3.智能指针实现原理

           智能指针(smart pointer)的通用实现技术是使用引用计数(reference count)。智能指针类将一个计数器与类指向的对象相关联，引用计数跟踪该类有多少个对象的指针指向同一对象。每次创建类的新对象时，初始化指针就将引用计数置为1；当对象作为另一对象的副本而创建时，拷贝构造函数拷贝指针并增加与之相应的引用计数；对一个对象进行赋值时，赋值操作符减少左操作数所指对象的引用计数（如果引用计数为减至0，则删除对象），并增加右操作数所指对象的引用计数；调用析构函数时，析构函数减少引用计数（如果引用计数减至0，则删除基础对象）。

4.使用C++标准库中的智能指针

智能指针在C++11版本之后提供，包含在头文件中，shared_ptr、unique_ptr、weak_ptr

shared_ptr

            利用引用计数->每有一个指针指向相同的一片内存时，引用计数+1，每当一个指针取消指向一片内存时，引用计数-1,                          减 为0时释放内存

week_ptr

            弱指针 ->辅助shared_ptr解决循环引用的问题

            weak_ptr是为了配合shared_ptr而引入的一种智能指针，因为它不具有普通指针的行为，没有重载operator*和->,它的最大               作用在于协助shared_ptr工作，像旁观者那样观测资源的使用情况。weak_ptr可以从一个shared_ptr或者另一个weak_ptr对            象构造，获得资源的观测权。但weak_ptr没有共享资源，它的构造不会引起指针引用计数的增加。使用weak_ptr的成员函             数use_count()可以观测资源的引用计数，另一个成员函数expired()的功能等价于use_count()==0,但更快，表示被观测的资源           (也就是shared_ptr的管理的资源)已经不复存在。weak_ptr可以使用一个非常重要的成员函数lock()从被观测的shared_ptr 获           得一个可用的shared_ptr对象， 从而操作资源。但当expired()==true的时候，lock()函数将返回一个存储空指针的shared_ptr

unique_ptr

           “唯一”拥有其所指对象，同一时刻只能有一个unique_ptr指向给定对象（禁止拷贝、赋值），可以释放所有权，转移所有权

5.智能指针的实现

/*************************************************************************
	> Motto : Be better!
	> Author: ShadowsGtt 
	> Mail  : [email protected]
	> Time  : 2018年07月24日 星期二 16时32分26秒
 ************************************************************************/

#include
#include
using namespace std;

/*  实现一个线程安全的智能指针 */


/* 引用计数基类 */
class Sp_counter
{
    private :
        size_t *_count;
        std::mutex mt;
    public :
        Sp_counter()
        {
            cout<<"父类构造,分配counter内存"<_count = spc._count;
        return *this;
    }
    Sp_counter &GetCounter()
    {
        return *this;
    }
    size_t Get_Reference()
    {
        return *_count;
    }
    virtual void Increase()
    {
        mt.lock();
        (*_count)++;
        //cout<<"_count++:"<<*_count<
class smart_pointer : public Sp_counter
{
    private :
        T *_ptr;
    public :
        smart_pointer(T *ptr = NULL);               
        ~smart_pointer();                               
        smart_pointer(smart_pointer &);
        smart_pointer &operator=(smart_pointer &);
        T &operator*();
        T *operator->(void);
        size_t use_count();
        
};


/* 子类参构造函数&带参数构造函数 */
template
inline smart_pointer::smart_pointer(T *ptr)
{
    if(ptr){
        cout<<"子类默认构造"<Increase();
    }
}   


/* 子类析构函数 */
template
smart_pointer::~smart_pointer()
{
    /* 指针非空才析构 */
    if(this->_ptr){
        cout<<"子类析构,计数减1"<Get_Reference())
            this->Decrease();
        if(!(this->Get_Reference()) ){
            cout<<"(((子类析构,主内存被释放)))"<
inline size_t smart_pointer::use_count()
{
    return this->Get_Reference();
}

/* 拷贝构造 */
template
inline smart_pointer::smart_pointer(smart_pointer &sp)
{
    cout<<"子类拷贝构造"<_ptr = sp._ptr;
        this->GetCounter() = sp.GetCounter();
        this->Increase();
    }
    
}
/* 赋值构造 */
template
inline smart_pointer &smart_pointer::operator=(smart_pointer &sp)
{

    /* 防止自己对自己的赋值以及指向相同内存单元的赋值 */
    if(this != &sp){

        cout<<"赋值构造"<_ptr && this->_ptr != sp._ptr){
            this->Decrease();

            /* 引用计数为0时 */
            if(!this->Get_Reference()){
                cout<<"引用计数为0,主动调用析构"<~smart_pointer();
                //this->~Sp_counter();
                cout<<"调用完毕"<_ptr = sp._ptr;
        this->GetCounter() = sp.GetCounter();
        this->Increase();
    }
    return *this;
}

/* 重载解引用*运算符 */
template
inline T &smart_pointer::operator*()
{
    return *(this->_ptr);
}
template
inline T *smart_pointer::operator->(void)
{
    return this->_ptr;
}

int main()
{
    int *a = new int(10);
    int *b = new int(20);
    cout<<"-------------默认构造测试----------------->"< sp(a);
    cout<<"sp.use_count:"<"<"< sp1(sp);
        cout<<"构造sp2  :sp2(sp)"< sp2(sp1);
        cout<<"sp1和sp2引用计数为3才是正确的"<"<"<"<"< sp3(b);
    cout<<"sp3.use_count:"<"<"<"<