复制控制(管理指针成员)

智能指针

1. 目的：解决多个对象‘共享内存’问题。

   带有动态分配内存的对象，在用析构函数释放内存的时候，可能出现多次释放的问题：内存泄漏/double free

2. 方法：跟踪对象：即用一个计数器，记录拷贝的对象个数，通过不断减少计数器里的值达到只释放一次内存的目的

#include <iostream>
#include <cstring>

using namespace std;

class Banji
{
    public:
        Banji():num(10),money(12.2),name(NULL){}

        Banji(char *s, int n, double f)
        {
            name = new char[20];
            strcpy(name, s);

            num = n;
            money = f;
        }

        Banji(const Banji &b)
        {
            cout << "copy constructor..." << endl;
    //      name = new char[20];
            use++;  //计数器跟踪拷贝出来的对象个数
            strcpy(name, b.name);

            num = b.num;
            money = b.money;
        }

        ~Banji()
        {
            cout << "~Banji()...." << endl;
            if(--use==0)
            {
                if(name!=NULL)
                {
                    delete[] name;
                    name = NULL;
                }
            }
        }

        void disp();

        Banji &operator=(const Banji &b);

    private:
        int num;
        char *name;
        static int use;
        double money;
};

int Banji::use = 1;

void Banji::disp()
{
    cout << name << " ";
    cout << num << " ";
    cout << money << endl;
}

Banji &Banji::operator=(const Banji &b)
{
//这是想让this->name 和 b.name指到一块去(即同一内存)
#if 0
    if(this->name!=NULL)
    {
        cout << "this.name !=NULL.." << endl;
        delete[] this->name;
        this->name=NULL;
    }

    cout << "operator=..." << endl;

    this->name = b.name;
#endif
//这是不改变this->name的值，而改变this->name所指内存的数据，达到完完全全的赋值

    strcpy(name, b.name);
    this->num = b.num;
    this->money = b.money;

    return *this;
}

int main()
{
    char *name = {"xinghuang"};
    char *name1 = {"huaxia"};
    char *name2 = {"zhonghua"};

    Banji b1(name, 10, 12.2);
    b1.disp();

    Banji b2 = b1, b3 = b2;
    b2.disp();
    b3.disp();

    b3 = b1;
}

值型指针

作用解决类中指针的 ‘动态内存’ 问题。

实现方法：在上面的拷贝构造函数中将

name = new char[20]

放开。这是通过拷贝时直接创建我独立的内存达到 拷贝对象 与 源对象 互不干扰的目的，当然这也就没有上面的共享内存的事儿了。