拷贝构造与赋值操作(string实例)【写的很棒！】

太过爱你忘了你带给我的痛 2021-12-12 02:15 183阅读 0赞

原文 出自 ：[http://blog.csdn.net/tujiaw/article/details/6103609][http_blog.csdn.net_tujiaw_article_details_6103609]

拷贝构造和赋值这两个操作总是被成对地声明并且兼容，为什么要自定义这两个操作呢？看下面的例子。

**\[c-sharp\]**  [view plain][] [copy][view plain]

1.  // MyString.cpp : 定义控制台应用程序的入口点。  
2.  //  
3.  \#include "stdafx.h"  
4.  \#include <stdio.h>  
5.  \#include <string.h>  
6.  **class** MyString  
7.  \{  
8.  **public**:  
9.      MyString(**const** **char** \*str = NULL);  
10.     MyString(**const** MyString &other);  
11.     ~MyString(**void**);  
12.     MyString & **operator** = (**const** MyString &other);  
13.     **int** OutputStr(**void**);  
14. **private**:  
15.     **char** \*m\_data;  
16. \};  
17. MyString::MyString(**const** **char** \*str)//普通的构造函数  
18. \{  
19.     **if** (str == NULL)  
20.     \{  
21.         m\_data = **new** **char**\[1\];  
22.         \*m\_data = '/0';  
23.     \}  
24.     **else**  
25.     \{  
26.         **int** length = strlen(str);  
27.         m\_data = **new** **char**\[length + 1\];  
28.         strcpy(m\_data, str);  
29.     \}  
30. \}  
31. MyString::MyString(**const** MyString &other)//拷贝构造函数  
32. \{  
33.     **int** length = strlen(other.m\_data);  
34.     m\_data = **new** **char**\[length + 1\];  
35.     strcpy(m\_data, other.m\_data);  
36. \}  
37. MyString::~MyString(**void**)  
38. \{  
39.     delete \[\] m\_data;  
40. \}  
41. MyString & MyString::**operator** = (**const** MyString &other)//赋值操作  
42. \{  
43.     **if** (**this** == &other)  
44.     \{  
45.         **return** \***this**;  
46.     \}  
47.     delete \[\] m\_data;  
48.     **int** length = strlen(other.m\_data);  
49.     m\_data = **new** **char**\[length + 1\];  
50.     strcpy(m\_data, other.m\_data);  
51.     **return** \***this**;  
52. \}  
53. **int** MyString::OutputStr(**void**)  
54. \{  
55.     **int** length = 0;  
56.     length = strlen(m\_data);  
57.     printf("the output string is : %s", m\_data);  
58.     **return** length;  
59. \}  
60. **int** \_tmain(**int** argc, \_TCHAR\* argv\[\])  
61. \{  
62.     MyString str("hello, world");//进入普通构造函数  
63.     MyString str2 = str;//初始化,进入拷贝构造函数  
64.     MyString str3(str);//初始化,进入拷贝构造函数  
65.     str2 = str;//赋值,进入赋值操作  
66.     str2.OutputStr();  
67.     //MyString \*str = new MyString("hello, world");//普通构造函数  
68.     //MyString \*str2 = new MyString(\*str);//拷贝构造函数  
69.     //\*str2 = \*str;//赋值操作  
70.     //str2->OutputStr();  
71.     getchar();  
72.     **return** 0;  
73. \}

假如：MyString类没有声明拷贝构造和赋值操作。  
MyString str1("hello");  
MyString str2("world");  
其结果就会如下所以：  
str1: m\_data ——>"hello/0"  
str2: m\_data ——>"world/0"  
对象str1的内部是一个指向包含字符串"hello"的内存的指针，  
对象str2的内部是一个指向包含字符串"world"的内存的指针。  
如果进行下面的赋值：  
str2 = str1;

因为没有自定义operator=可以调用，C++会生成并调用一个缺省的operator=操作符。这个缺省的赋值操作符

会执行从str1的成员到str2的成员的逐个成员的赋值操作，对指针(str1.m\_data和str2.m\_data）来说就是位

拷贝(位拷贝拷贝的是地址，而值拷贝则拷贝的是内容)。赋值后的结果如下所示：  
str1: m\_data ——>"hello/0"  
str2: m\_data ——>"hello/0"  
这种情况至少有两个问题。第一，str2曾指向的内存永远不会被删除，因而会永远丢失，造成内存泄漏；第二，  
现在str1和str2包含的指针指向同一个字符串，那么只要其中一个离开了它的生存空间，其析构函数就会删除掉  
另一个指针还指向的那块内存。

[http_blog.csdn.net_tujiaw_article_details_6103609]: http://blog.csdn.net/tujiaw/article/details/6103609
[view plain]: http://blog.csdn.net/tujiaw/article/details/6103609#