含有指针成员的类的拷贝

本文转自：http://zhedahht.blog.163.com/blog/static/25411174200722710364233/

题目：下面是一个数组类的声明与实现。请分析这个类有什么问题，并针对存在的问题提出几种解决方案。

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 == ©)
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;

结论：在包含有指针成员的类中，应该实现拷贝构造函数和重载赋值运算符（=）函数，以实现深度拷贝，以免调用系统生成的默认的拷贝构造函数和赋值=运算符函数（这两个函数会进行浅拷贝）。

对于重载赋值元算符函数 operator=函数来说要注意四点，上一篇讨论String的时候就已经详细讨论过，这里再次总结如下：

1、应该返回类型的引用，以便连续赋值。

2、参数应该为常应用，避免拷贝，并且因为不会改变参数的值，顾采用常引用。

3、在程序起始时应该判断this与参数的地址是否相同，如果是自己拷贝自己，则直接返回（比如参数为parameter，则要判断if(this == ¶meter) return;）。

4、因为是实现深度拷贝，所以如果指针成员不为空，即已经指向了数据。那么要先释放指针成员指向的空间，避免内存泄露，然后再重新分配空间，并将保存在参数中的数据拷贝到重新分配的空间中。