#include<iostream>
using namespace std;
class Array
{
public:
Array(){length = 0; num = NULL;};
Array(int * A, int n);
Array(Array & a);
Array & operator= (const Array & a);
void setnum(int value, int index);
int * getaddress();
void display();
int getlength(){return length;}
private:
int length;
int * num;
};
Array::Array(Array & a)
{
//复制一个数组
if(a.num != NULL)
{
cout<<"a.num ="<<a.num<<endl;
length = a.length;
num = new int[length];
for(int i=0; i<length; i++)
num[i] = a.num[i];
}
else
{
length = 0;
num = 0;
}
}
//重载赋值操作符
Array & Array::operator= (const Array & a)
{
if( this != &a )
{
delete[] num;
if(a.num != NULL)
{
length = a.length;
num = new int[length];
for(int i=0; i<length; i++)
num[i] = a.num[i];
}
else
{
length = 0;
num = 0;
}
}
return *this;
}
Array::Array(int *A, int n)
{
//复制数组的前n 项
num = new int[n];
length = n;
for(int i=0; i<n; i++)
num[i] = A[i];
}
void Array::setnum(int value, int index)
{
if(index < length)
num[index] = value;
else
cout<<"index out of range!"<<endl;
}
void Array::display()
{
for(int i=0; i<length; i++)
cout<<num[i]<<" ";
cout<<endl;
}
int * Array::getaddress()
{
return num;
}
int main()
{
int A[5] = {10,2,33,4,5};
Array arr1(A, 5);
arr1.display();
Array arr2(arr1);
arr2.display();
cout <<"--------------------"<<endl;
arr2.setnum(8,2);
arr1.display();
arr2.display();
cout <<"--------------------"<<endl;
cout<<arr1.getaddress()<<" "<<arr2.getaddress()<<endl;
arr1 = arr2;
arr1.display();
arr2.display();
arr2.setnum(9,3);
arr1.display();
arr2.display();
cout<<arr1.getaddress()<<" "<<arr2.getaddress()<<endl;
return 0;
}
10 2 33 4 5
a.num =0x5564b6672e70
10 2 33 4 5
--------------------
10 2 33 4 5
10 2 8 4 5
--------------------
0x5564b6672e70 0x5564b66732a0
10 2 8 4 5
10 2 8 4 5
10 2 8 4 5
10 2 8 9 5
0x5564b6672e70 0x5564b66732a0
在这个例子中，我们以类成员函数的形式重载了赋值操作符，因为前面已经介绍过该程序了，下面就直接来看主函数。
主函数中，前半部分和之前介绍拷贝构造函数时是相同的，这个我们也忽略过去。直接从arr1 = arr2;语句开始看起。这个语句就会调用类中的操作符重载函数，我们可以将这一语句理解为：
arr1.operator=(arr2);
该语句会执行赋值操作符重载函数中的函数体。在该函数体中，我们为 arr1 重新开辟了一个内存空间，因此就可以规避 arr1 和 arr2 中的 num 指向同一块存储区域的风险。如此一来，使用系统默认提供的赋值操作符所带来的风险就可以避免了。在这之后的语句中，我们还修改了 arr2 中的数据，并没有影响到 arr1，可见确实将风险给化解了。
当然，如果类中并没有包含需要动态分配内存的指针成员变量时，我们使用系统提供的默认拷贝构造函数和赋值操作符也就可以了，无需再多此一举地重新定义和重载一遍
