新秀系列C/C++经典问题(六)

类包含一个指向成员复制

称号：下面是类和执行的阵列的声明。题。并针对存在的问题提出几种解决方式。

template<typename T> class Array
{
public:
    Array(unsigned arraySize) :data(0), size(arraySize)
    {
        if (size > 0)
            data = new T[size];
    }

    ~Array()
    {
        if (data) delete[] data;
    }

    void setValue(unsigned index, const T& value)
    {
        if (index < size)
            data[index] = value;
    }

    T getValue(unsigned index) const
    {
        if (index < size)
            return data[index];
        else
            return T();
    }

private:
    T* data;
    unsigned size;
};

分析：我们注意在类的内部封装了用来存储数组数据的指针。软件存在的大部分问题通常都能够归结指针的不对处理。

这个类仅仅提供了一个构造函数。而未定义构造拷贝函数和重载拷贝运算符函数。当这个类的用户依照以下的方式声明并实例化该类的一个实例：

Array A(10);
Array B(A);

或者依照以下的方式把该类的一个实例赋值给另外一个实例

Array A(10);
Array B(10);
B=A;

编译器将调用其自己主动生成的构造拷贝函数或者拷贝运算符的重载函数。在编译器生成的缺省的构造拷贝函数和拷贝运算符的重载函数，对指针实行的是按位拷贝，只不过拷贝指针的地址，而不会拷贝指针的内容。因此在运行完前面的代码之后。A.data和B.data指向的同一地址。当A或者B中随意一个结束其生命周期调用析构函数时，会删除data。因为他们的data指向的是同一个地方。两个实例的data都被删除了。

但另外一个实例并不知道它的data已经被删除了，当企图再次用它的data的时候，程序就会不可避免地崩溃。

因为问题出现的根源是调用了编译器生成的缺省构造拷贝函数和拷贝运算符的重载函数。一个最简单的办法就是禁止使用这两个函数。于是我们能够把这两个函数声明为私有函数，假设类的用户企图调用这两个函数，将不能通过编译。实现的代码例如以下：

private:
    Array(const Array& copy);
    const Array& operator = (const Array& copy);

最初的代码存在问题是由于不同实例的data指向的同一地址，删除一个实例的data会把另外一个实例的data也同一时候删除。因此我们还能够让构造拷贝函数或者拷贝运算符的重载函数拷贝的不仅仅是地址，而是数据。由于我们又一次存储了一份数据，这样一个实例删除的时候，对另外一个实例没有影响。这样的思路我们称之为深度拷贝。实现的代码例如以下：

public:
    Array(const Array& copy) :data(0), size(copy.size)
    {
        if (size > 0) // 这里没有自拷贝检查， 请读者思考该怎么解决
        {
            data = new T[size];
            for (int i = 0; i < size; ++i)
                setValue(i, copy.getValue(i));
        }
    }

    const Array& operator = (const Array& copy)
    {
        if (this == &copy) // 自赋值检查
            return *this;

        if (data != NULL)
        {
            delete[]data;
            data = NULL;
        }

        size = copy.size;
        if (size > 0)
        {
            data = new T[size];
            for (int i = 0; i < size; ++i)
                setValue(i, copy.getValue(i));
        }
    }

为了防止有多个指针指向的数据被多次删除，我们还能够保存到底有多少个指针指向该数据。仅仅有当没有不论什么指针指向该数据的时候才干够被删除。这样的思路通常被称之为引用计数技术。在构造函数中，引用计数初始化为1；每当把这个实例赋值给其它实例或者以參数传给其它实例的构造拷贝函数的时候。引用计数加1，由于这意味着又多了一个实例指向它的data；每次须要调用析构函数或者须要把data赋值为其它数据的时候，引用计数要减1，由于这意味着指向它的data的指针少了一个。

当引用计数降低到0的时候，data已经没有不论什么实例指向它了，这个时候就能够安全地删除。

实现的代码例如以下：

public:
    Array(unsigned arraySize)
        :data(0), size(arraySize), count(new unsigned int)
    {
        *count = 1;
        if (size > 0)
            data = new T[size];
    }

    Array(const Array& copy)
        : size(copy.size), data(copy.data), count(copy.count)
    {
        ++(*count);
    }

    ~Array()
    {
        Release();
    }

    const Array& operator = (const Array& copy)
    {
        if (data == copy.data)
            return *this;

        Release();

        data = copy.data;
        size = copy.size;
        count = copy.count;
        ++(*count);
    }

 private:
     void Release()
     {
         --(*count);
         if (*count == 0)
         {
             if (data)
             {
                 delete[]data;
                 data = NULL;
             }

             delete count;
             count = 0;
         }
     }

     unsigned int *count;

请指出错误，转载请注明出处，谢谢！