拷贝构造函数（三）——重载赋值运算符

拷贝构造函数（一）——哲学三连：http://www.cnblogs.com/tenjl-exv/p/8017814.html

拷贝构造函数（二）——深拷贝与浅拷贝：http://www.cnblogs.com/tenjl-exv/p/8017909.html

拷贝构造函数（三）——重载赋值运算符：http://www.cnblogs.com/tenjl-exv/p/8017983.html

关于拷贝函数中的赋值操作符重载

以下讨论中将用到的例子:

 1 class CExample 
 2 { 
 3     public: 
 4         CExample()
 5         {
 6             pBuffer=NULL; 
 7             nSize=0;
 8         } 
 9         ~CExample()
10         {    
11             delete pBuffer;
12         } 
13 
14         void Init(int n)
15         {
16              pBuffer=new char[n]; 
17             nSize=n;
18         } 
19     private: 
20         char *pBuffer; //类的对象中包含指针,指向动态分配的内存资源 
21         int nSize; 
22 };

这个类的主要特点是包含指向其他资源的指针。

pBuffer指向堆中分配的一段内存空间。

一、拷贝构造函数

1 int main(int argc, char* argv[]) 
2 { 
3     CExample theObjone; 
4     theObjone.Init(40); 
5 
6     //现在需要另一个对象,需要将他初始化称对象一的状态 
7     CExample theObjtwo = theObjone; 
8     ... 
9 }

语句"CExample theObjtwo=theObjone;"

用theObjone初始化theObjtwo。

其完成方式是内存拷贝，复制所有成员的值。

完成后，theObjtwo.pBuffer==theObjone.pBuffer。

即它们将指向同样的地方，指针虽然复制了，但所指向的空间并没有复制，而是由两个对象共用了。

这样不符合要求，对象之间不独立了，并为空间的删除带来隐患。

所以需要采用必要的手段来避免此类情况。

回顾一下此语句的具体过程：首先建立对象theObjtwo，并调用其构造函数，然后成员被拷贝。

可以在构造函数中添加操作来解决指针成员的问题。

所以C++语法中除了提供缺省形式的构造函数外，

还规范了另一种特殊的构造函数：拷贝构造函数。

上面的语句中，如果类中定义了拷贝构造函数，这对象建立时，调用的将是拷贝构造函数，

在拷贝构造函数中，可以根据传入的变量，复制指针所指向的资源。

提供了拷贝构造函数后的CExample类定义为:

 1 class CExample 
 2 { 
 3     public: 
 4         CExample()
 5         {
 6             pBuffer=NULL; nSize=0;
 7         } 
 8         ~CExample()   
 9         {
10             delete pBuffer;
11         } 
12         CExample(const CExample&); //拷贝构造函数 
13 
14         void Init(int n)
15         { 
16             pBuffer=new char[n]; 
17             nSize=n;
18         } 
19     private: 
20         char *pBuffer; //类的对象中包含指针,指向动态分配的内存资源 
21         int nSize; 
22         }; 
23 
24 CExample::CExample(const CExample& RightSides) //拷贝构造函数的定义 
25 { 
26     nSize=RightSides.nSize; //复制常规成员 
27     pBuffer=new char[nSize]; //复制指针指向的内容 
28     memcpy(pBuffer,RightSides.pBuffer,nSize*sizeof(char)); 
29 }

这样，定义新对象，并用已有对象初始化新对象时，

CExample(const CExample& RightSides)将被调用，

而已有对象用别名RightSides传给构造函数，以用来作复制。

原则上，应该为所有包含动态分配成员的类都提供拷贝构造函数。

拷贝构造函数的另一种调用。

二、赋值操作符的重载

下面的代码与上例相似

 1 int main(int argc, char* argv[]) 
 2 { 
 3     CExample theObjone; 
 4     theObjone.Init(40); 
 5 
 6     CExample theObjthree; 
 7     theObjthree.Init(60); 
 8 
 9     //现在需要一个对象赋值操作,被赋值对象的原内容被清除，并用右边对象的内容填充。 
10     theObjthree = theObjone; //对一个已存在的对象赋值 
11     return 0; 
12 }

也用到了"="号，但与"一、"中的例子不同，

"一、"的例子中，"="在对象声明语句中，表示初始化，更多时候,这种初始化也可用括号表示。

例如 CExample theObjone(theObjtwo);

而在本例中，"="表示赋值操作。

将对象theObjone的内容复制到对象theObjthree，

这其中涉及到对象theObjthree原有内容的丢弃，新内容的复制。

但"="的缺省操作只是将成员变量的值相应复制。旧的值被自然丢弃。

由于对象内包含指针，将造成不良后果：指针的值被丢弃了，但指针指向的内容并未释放（delete）。

指针的值被复制了，但指针所指内容并未复制。

因此，包含动态分配成员的类除提供拷贝构造函数外，还应该考虑重载"="赋值操作符号。

类定义变为:

 1 class CExample 
 2 { 
 3     ... 
 4     CExample(const CExample&);                  //拷贝构造函数 
 5     CExample& operator = (const CExample&);     //赋值符重载 
 6     ... 
 7 }; 
 8 
 9 //赋值操作符重载 
10 CExample & CExample::operator = (const CExample& RightSides) 
11 { 
12     nSize=RightSides.nSize;         //复制常规成员 
13     char *temp=new char[nSize];     //复制指针指向的内容 
14     memcpy(temp,RightSides.pBuffer,nSize*sizeof(char)); 
15 
16     delete []pBuffer; 
17     //删除原指针指向内容  (将删除操作放在后面，避免X=X特殊情况下，内容的丢失) 
18     pBuffer=temp;   //建立新指向 
19     return *this 
20 }

拷贝构造函数使用赋值运算符重载后的代码

1 CExample::CExample(const CExample& RightSides) 
2 { 
3     pBuffer=NULL; 
4     *this=RightSides  //调用重载后的"=" 
5 }

如果不主动编写拷贝构造函数和赋值函数，编译器将以“位拷贝”的方式自动生成缺省的函数。

倘若类中含有指针变量，那么这两个缺省的函数就隐含了错误。

以类String 的两个对象a,b 为例，

假设a.m_data 的内容为 “hello”，b.m_data 的内容为 “world”。

现将a 赋给b，缺省赋值函数的“位拷贝”意味着执行 b.m_data = a.m_data。

这将造成三个错误：

1） b.m_data 原有的内存没被释放，造成内存泄露；

2） b.m_data 和 a.m_data 指向同一块内存，a 或b 任何一方变动都会影响另一方；

3）在对象被析构时，m_data 被释放了两次。

类String 的拷贝构造函数与赋值函数

 1 // 拷贝构造函数 
 2 String::String(const String &other) 
 3 { 
 4     // 允许操作other 的私有成员m_data 
 5     int length = strlen(other.m_data); 
 6     m_data = new char[length+1]; 
 7     strcpy(m_data, other.m_data); 
 8 } 
 9 
10 // 赋值函数 
11 String & String::operate =(const String &other) 
12 { 
13     // (1) 检查自赋值 
14     if(this == &other) 
15     return *this;
16  
17     // (2) 释放原有的内存资源 
18     delete [] m_data; 
19 
20     // （3）分配新的内存资源，并复制内容 
21     int length = strlen(other.m_data); 
22     m_data = new char[length+1]; 
23     strcpy(m_data, other.m_data); 
24 
25     // （4）返回本对象的引用 
26 
27     return *this; 
28 }

类String 拷贝构造函数与普通构造函数的区别是：

在函数入口处无需与NULL 进行比较，这是因为“引用”不可能是NULL，而“指针”可以为NULL。

类String 的赋值函数比构造函数复杂得多，分四步实现：

（1）第一步，检查自赋值。

你可能会认为多此一举，难道有人会愚蠢到写出 a = a 这样的自赋值语句！

的确不会。

但是间接的自赋值仍有可能出现，例如

 1 // 内容自赋值 
 2 b = a; 
 3 … 
 4 c = b; 
 5 … 
 6 a = c; 
 7 
 8 // 地址自赋值 
 9 b = &a; 
10 … 
11 a = *b;

也许有人会说：“即使出现自赋值，我也可以不理睬，大不了花点时间让对象复制自己而已，反正不会出错！”
那就大错特错了。

看看第二步的delete，自杀后还能复制自己吗？

所以，如果发现自赋值，应该马上终止函数。

注意不要将检查自赋值的if 语句

if(this == &other)

错写成为

if( *this == other)

（2）第二步，用delete 释放原有的内存资源。

如果现在不释放，以后就没机会了，将造成内存泄露。

（3）第三步，分配新的内存资源，并复制字符串。

注意函数strlen 返回的是有效字符串长度，不包含结束符‘/0’。

函数strcpy 则连‘/0’一起复制。

（4）第四步，返回本对象的引用。

目的是为了实现象 a = b = c 这样的链式表达。

注意不要将 return *this 错写成 return this 。

那么能否写成return other 呢？效果不是一样吗？

不可以！因为我们不知道参数other 的生命期。

有可能other 是个临时对象，在赋值结束后它马上消失，那么return other 返回的将是垃圾。

偷懒的办法处理拷贝构造函数与赋值函数

如果我们实在不想编写拷贝构造函数和赋值函数，

又不允许别人使用编译器生成的缺省函数，怎么办？

偷懒的办法是：只需将拷贝构造函数和赋值函数声明为私有函数，不用编写代码。

例如：

1 class A 
2 { … 
3     private: 
4     A(const A &a); // 私有的拷贝构造函数 
5     A & operate =(const A &a); // 私有的赋值函数 
6 };

如果有人试图编写如下程序：

A b(a);   // 调用了私有的拷贝构造函数 
b = a;    // 调用了私有的赋值函数

编译器将指出错误，因为外界不可以操作A的私有函数。