智能指针与引用计数详解（一）

前言
在C++项目开发中，有时候会遇到悬垂指针的问题，其中提供的解决方案推荐使用智能指针。
在《C++Primer》书13.5章 提到了该技术的具体使用场景和实现。通过反复阅读和代码测试终于了解其中的思想，下面谈谈自己的理解，如果发现有什么问题，请大家批评指正。

什么是智能指针？
智能指针其实就是一个类，除了增加了一些功能外，其因为跟跟普通指针一样。通常情况，new一个对象会申请一块内存，复制或者赋值时，会导致多个指针指向同一个内存区域，如果对其中任意一个指针进行操作，比如修改指针指向的值，那么其它指针也指向的值都会改变，如果删除了其中一个指针所指向的对象，那么其它指针所指向的对象也都不存在了，这些指针也就变成悬垂指针了。另外如果new出的对象还没有到delete方法执行那么就好造成内存泄漏。智能指针主要目的就是管理这块内存，避免内存泄漏和悬垂指针。

为什么要使用智能指针？
上述说得对象复制或者赋值的时候会导致多个指针指向同一个内存区域，那么只要我们重写这个两个方法，采用深复制那么就不会出现该问题了吧。答案确实是可以的，但是这样如果被复制的对象较大并且使用很频繁，同时只是获取对象值的情况，这样做无疑增加了内存开销也影响性能。所以这时候可以考虑智能指针实现。

普通指针的问题
一个带有简单指针的类：
图示：

代码测试：
hasPtr.h

#ifndef _HasPtr_H
#define _HasPtr_H

class HasPtr {

    public:
        HasPtr(int *p = 0, int i = 0);
        ~HasPtr();
        int *get_ptr() const;
        void set_ptr(int *p);

        int get_int() const;
        void set_int(int i);

        int get_ptr_val() const;
        void set_ptr_val(int val);

    private:
        int *ptr;
        int val;

};
#endif

hasPtr.cpp

#include "hasPtr.h"
#include 
using namespace std;

HasPtr::HasPtr(int *p, int i)
    :ptr(p)
    ,val(i)
{

}

int *HasPtr::get_ptr() const {
    return ptr;
}

void HasPtr::set_ptr(int *p) {
    ptr = p;
}

int HasPtr::get_int() const {
    return val;
}

void HasPtr::set_int(int i) {
    val = i;
}

int HasPtr::get_ptr_val() const {
    return *ptr;
}

void HasPtr::set_ptr_val(int val) {
    *ptr = val;
}

HasPtr::~HasPtr() {
    cout<<"HasPtr destruct"<

指针共享同一个对象：

    int obj = 10;
    HasPtr ptr1(&obj, 42);
    HasPtr ptr2(ptr1);
    ptr2.set_ptr_val(20);
    int ptr_val2 = ptr2.get_ptr_val();
    cout<<"ptr_val2 = "<
 
  
引用计数类：
 uPtr.h
 
  
#ifndef _UPtr_H
#define _UPtr_H

class HasPtr;
class U_Ptr {
    private:
    friend class HasPtr;

    U_Ptr(int *p);
    ~U_Ptr();
    
    int *m_ip;
    int m_useCount;
};
#endif
 
  
uPtr.cpp
 
  
#include "uPtr.h"
#include 
using namespace std;

U_Ptr::U_Ptr(int *p)
    :m_ip(p)
    ,m_useCount(1)
{

}

U_Ptr::~U_Ptr()
{
    cout<<"U_Ptr destruct"<
 
  
智能指针类实现：
 hasPtr.h
 
  
#ifndef _HasPtr_H
#define _HasPtr_H

#include "uPtr.h"

class HasPtr {

    public:
        HasPtr(int *p = 0, int i = 0);
        HasPtr(const HasPtr &ptr);
        HasPtr& operator=(const HasPtr &rhs);
        ~HasPtr();

        int *get_ptr() const;
        void set_ptr(int *p);

        int get_int() const;
        void set_int(int i);

        int get_ptr_val() const;
        void set_ptr_val(int val);

    private:
        int m_val;
        U_Ptr *m_uptr;

};
#endif
 
  
hasPtr.cpp
 
  
#include "hasPtr.h"
#include 
using namespace std;

HasPtr::HasPtr(int *p, int i)
    :m_uptr(new U_Ptr(p))
    ,m_val(i)
{
    cout<<"HasPtr  constructor"<m_useCount = "<m_useCount<m_useCount;
}

HasPtr& HasPtr::operator=(const HasPtr &rhs)
{
    cout<<"HasPtr assignment rhs.m_uptr->m_useCount = "<m_useCount<m_useCount = "<m_useCount<m_useCount;
    if (--m_uptr->m_useCount == 0) {
        delete m_uptr;
        m_uptr = NULL;
    }
    m_uptr = rhs.m_uptr;
    m_val = rhs.m_val;
    return *this;
}

int *HasPtr::get_ptr() const {
    return m_uptr->m_ip;
}

void HasPtr::set_ptr(int *p) {
    m_uptr->m_ip = p;
}

int HasPtr::get_int() const {
    return m_val;
}

void HasPtr::set_int(int i) {
    m_val = i;
}

int HasPtr::get_ptr_val() const {
    return *m_uptr->m_ip;
}

void HasPtr::set_ptr_val(int val) {
    *m_uptr->m_ip = val;
}

HasPtr::~HasPtr() {
    cout<<"HasPtr destruct m_uptr->m_useCount = "<m_useCount<m_useCount == 0) {
        delete m_uptr;
        m_uptr = NULL;
    }
}
 
  
这里赋值函数比较复杂，左操作数减一是因为指向新对象，那么之前指向的对象应该被回收，右操作数加一是因为该操作数已经指向了这个对象，现在即将又有一个新指针（左操作数）指向该对象。
 
  
main()
 
  
    int *ip = new int(12);
    HasPtr ptr(ip, 20);            //执行构造函数
    HasPtr ptr1(ptr);              //执行复制构造函数
    HasPtr ptr2(ptr);             //执行复制构造函数
    // 下面使用花括号是为了控制HasPtr对象生命周期
    {
        HasPtr ptr3 = NULL;      //执行复制构造函数
        ptr3 = ptr;              //执行赋值函数
        // HasPtr ptr3 = ptr；    //注意，这里调用的是复制构造函数，因为有新对象创建
    }
 
  
输出结果：
 U_Ptr constructor
 HasPtr constructor
 HasPtr copy constructor m_uptr->m_useCount = 1
 HasPtr copy constructor m_uptr->m_useCount = 2
 U_Ptr constructor
 HasPtr constructor
 HasPtr assignment rhs.m_uptr->m_useCount = 3
 HasPtr assignment m_uptr->m_useCount = 1
 U_Ptr destruct //左操作数指向的对象被回收
 HasPtr destruct m_uptr->m_useCount = 4
 HasPtr destruct m_uptr->m_useCount = 3
 HasPtr destruct m_uptr->m_useCount = 2
 HasPtr destruct m_uptr->m_useCount = 1
 U_Ptr destruct //删除指针
 
  
从结果来看，当程序执行完毕时对象会被全部回收掉，这里直到最后才真正删除指针。
 
  
demo展示：
 https://download.csdn.net/download/yj_android_develop/10841655
 
  
扩展：
 测试过程中发现智能指针的赋值方法其实还可以改进，另外智能指针也不应该仅限于一个具体指针（C++模板）。
 具体请见 智能指针与引用计数详解（二）