C++之管理指针成员

#ifndef PLAIN-PTR_H_INCLUDED
#define PLAIN-PTR_H_INCLUDED
//浅复制
class AHasPtr
{
public:
    AHasPtr(int *p,int i):ptr(p),val(i){}
    //get方法
    int *get_ptr() const {return ptr;}
    int get_int() const {return val;}
    //set方法
    void set_ptr(int *p){ptr=p;}
    void set_int(int i){val=i;}
    //值
    int get_ptr_val()const {return *ptr;}
    void set_ptr_val(int val){*ptr=val;}
private:
    int val;
    int *ptr;
};

#endif // PLAIN-PTR_H_INCLUDED

#ifndef VALUE-PTR_H_INCLUDED
#define VALUE-PTR_H_INCLUDED

//深复制
class CHasPtr
{
public:
    //构造函数
    CHasPtr(const int &p,int i):ptr(new int(p)),val(i){}
    //复制构造函数 CHasPtr p1(p2);
    CHasPtr(const CHasPtr &orig):
        ptr(new int(*orig.ptr)),
        val(orig.val){}
    //赋值构造函数 p1=p2
    CHasPtr &operator=(const CHasPtr &rhs)
    {
        //赋值操作符是把指针指向的对象赋值过来
        //.的优先级高于*
        *ptr=*rhs.ptr;
        val=rhs.val;
        return *this;
    }
    //析构函数
    ~CHasPtr()
    {
        delete ptr;
    }
    //get方法
    int *get_ptr() const {return ptr;}
    int get_int() const {return val;}
    //set方法
    void set_ptr(int *p){ptr=p;}
    void set_int(int i){val=i;}
    //值
    int get_ptr_val()const {return *ptr;}
    void set_ptr_val(int val){*ptr=val;}
private:
    int val;
    int *ptr;
};

#endif // VALUE-PTR_H_INCLUDED

#ifndef SMART-PTR_H_INCLUDED
#define SMART-PTR_H_INCLUDED
//智能指针

class U_Ptr
{
    friend class BHasPtr;
private:
    int *ip;
    //计数 计算有多少个对象使用智能指针
    //当计数为0时删除
    size_t use;
    //当有指针传递进来时就将计数值设为1
    U_Ptr(int *p):ip(p),use(1){}
    ~U_Ptr()
    {
        delete ip;
    }
};

class BHasPtr
{
public:
    //new U_Ptr(p)将p传递给U_Ptr并赋给ip
    BHasPtr(int *p,int i):ptr(new U_Ptr(p)),val(i){}

    BHasPtr(const BHasPtr &orig):
        ptr(orig.ptr),
        val(orig.val)
        {
            //复制的时候计数加加，因为有多个使用
            ++ptr->use;
        }

    BHasPtr &operator=(const BHasPtr &rhs)
    {
        //??????为什么右边的++左边的--
        ++rhs.ptr->use;
        if(--ptr->use==0)
        {
            delete ptr;
        }
        ptr=rhs.ptr;
        val=rhs.val;
        return *this;
    }

    ~BHasPtr()
    {
        //如果减到0就删除指针
        if(--ptr->use==0)
        {
            delete ptr;
        }
    }
    //get方法
    int *get_ptr() const {return ptr->ip;}
    int get_int() const {return val;}
    //set方法
    void set_ptr(int *p){ptr->ip=p;}
    void set_int(int i){val=i;}
    //值
    //->优先级高于*
    int get_ptr_val()const {return *ptr->ip;}
    void set_ptr_val(int val){*ptr->ip=val;}
private:
    int val;
    //智能指针
    U_Ptr *ptr;
//    int *ptr;
};


#endif // SMART-PTR_H_INCLUDED

#include <iostream>
#include "plain-ptr.h"
#include "value-ptr.h"
#include "smart-ptr.h"

using namespace std;

void test_AHasPtr()
{
    int i=42;
    AHasPtr p1(&i,42);
    //浅复制
    AHasPtr p2=p1;
    cout<<p2.get_ptr_val()<<endl;
    p1.set_ptr_val(0);
    cout<<p2.get_ptr_val()<<endl;
    //申请一抄个整型变量空间，赋初值为42，
    //并定义一个整型指针a指向该地百址空间
    int *ip=new int(42);
    AHasPtr ptr(ip,10);
    cout<<ptr.get_ptr_val()<<endl;
    delete ip;
    cout<<ptr.get_ptr_val()<<endl;

}

void test_BHasPtr()
{
    int obj=0;
    BHasPtr ptr3(&obj,42);
    BHasPtr ptr4(ptr3);
    cout<<ptr3.get_ptr_val()<<','<<ptr3.get_int()<<endl;
    cout<<ptr4.get_ptr_val()<<','<<ptr4.get_int()<<endl;
    ptr4.set_ptr_val(2);
    ptr4.set_int(22);
    cout<<ptr3.get_ptr_val()<<','<<ptr3.get_int()<<endl;
    cout<<ptr4.get_ptr_val()<<','<<ptr4.get_int()<<endl;
}

void test_CHasPtr()
{
    int obj=0;
    CHasPtr ptr1(obj,42);
    CHasPtr ptr2(ptr1);
    cout<<ptr1.get_ptr_val()<<','<<ptr1.get_int()<<endl;
    cout<<ptr2.get_ptr_val()<<','<<ptr2.get_int()<<endl;
    ptr2.set_ptr_val(32);
    ptr2.set_int(43);
    cout<<ptr1.get_ptr_val()<<','<<ptr1.get_int()<<endl;
    cout<<ptr2.get_ptr_val()<<','<<ptr1.get_int()<<endl;
}

int main()
{
    cout<<"=========常规指针 浅复制==========="<<endl;
    test_AHasPtr();
    cout<<"==========深复制=========="<<endl;
    test_CHasPtr();
    cout<<"==========智能指针=========="<<endl;
    test_BHasPtr();
    return 0;
}

 示意图：