首页 > > 程序设计 > C/C++ >

C++中的赋值操作符重载和拷贝构造函数

2019-05-23 09:54:26来源：博客园阅读 ()

1，关于赋值的疑问：

1，什么时候需要重载赋值操作符？

2，编译器是否提供默认的赋值操作符？

2，关于赋值的疑问：

1，编译器为每个类默认重载了赋值操作符；

1，意味着同类型的类对象可以相互赋值；

2，默认的赋值操作符仅完成浅拷贝；

3，当需要进行深拷贝时必须重载赋值操作符；

1，和拷贝构造函数相同；

4，赋值操作符与拷贝构造函数有相同的存在意义；

3，默认赋值操作符重载编程实验：

1，main.cpp 文件：

 1 #include <iostream>
 2 #include <string>
 3 
 4 using namespace std;
 5 
 6 class Test
 7 {
 8     int* m_pointer;
 9 public:
10     Test()
11     {
12         m_pointer = NULL;
13     }
14     Test(int i)
15     {
16         m_pointer = new int(i);
17     }
18     Test(const Test& obj)
19     {
20         m_pointer = new int(*obj.m_pointer);
21     }
22     Test& operator = (const Test& obj)  
23     {
24         if( this != &obj )  // 避免自赋值；
25         {
26             delete m_pointer;
27             m_pointer = new int(*obj.m_pointer);
28         }
29         
30         return *this;
31     }
32     void print()
33     {
34         cout << "m_pointer = " << hex << m_pointer << endl;
35     }
36     ~Test()
37     {
38         delete m_pointer;
39     }
40 };
41 
42 int main()
43 {
44     Test t1 = 1;
45     Test t2;
46     
47     t2 = t1;  // 默认赋值操作符的浅拷贝使得两个对象内部指针指向同一片空间；
48 
49     int i = 0;  // C 语言中允许这样，所以 C++ 中也必须允许；
50     i = i;
51 
52     t2 = t2;  // C++  中也要允许自赋值，但是没有意义；
53     
54     t1.print();
55     t2.print();
56     
57     return 0;
58 }

　2，输出结果：

　　m_pointer = 0x9387008

　　m_pointer = 0x9387018

　3，赋值操作符重载注意事项：

　　1，赋值操作符返回值一定是引用，为了连续赋值；

　　2，参数类型一定是 const Type&；

3，不能自赋值；

4，返回当前对象；

4，关于赋值的疑问：

1，如果要进行深拷贝，拷贝构造函数和赋值操作符的实现都要自定义；

5，一般性原则：

1，重载赋值操作符，必然要实现深拷贝；

1，实现深拷贝和自定义赋值操作符及拷贝构造函数是充要条件；

6，数组类的优化编程实验：

1，IntArray.h 文件：

 1 #ifndef _INTARRAY_H_
 2 #define _INTARRAY_H_
 3 
 4 class IntArray
 5 {
 6 private:
 7     int m_length;
 8     int* m_pointer;
 9     
10     IntArray(int len);
11     IntArray(const IntArray& obj);
12     bool construct();
13 public:
14     static IntArray* NewInstance(int length); 
15     int length();
16     bool get(int index, int& value);
17     bool set(int index ,int value);
18     int& operator [] (int index);
19     IntArray& operator = (const IntArray& obj);
20     IntArray& self();
21     ~IntArray();
22 };

2，首先写出赋值操作符注意事项模板：

1 IntArray& IntArray::operator = (cosnt IntArray& obj)
2 {
3      if( this != &obj )
4      {
5          
6      }
7 
8      return *this;
9 }

3，函数实现：

 1 IntArray& IntArray::operator = (const IntArray& obj)
 2 {
 3     if( this != &obj )
 4     {
 5         int* pointer = new int[obj.m_length];
 6         
 7         if( pointer )
 8         {
 9         /* 复制参数对象中的元素 */
10             for(int i=0; i<obj.m_length; i++)
11             {
12                 pointer[i] = obj.m_pointer[i];
13             }
14             
15         /* 深拷贝 */
16             m_length = obj.m_length;
17             delete[] m_pointer;
18             m_pointer = pointer;
19         }
20     }
21     
22     return *this;
23 }

　4，main.cpp 文件：

 1 #include <iostream>
 2 #include <string>
 3 #include "IntArray.h"
 4 
 5 using namespace std;
 6 
 7 int main()
 8 {
 9     IntArray* a = IntArray::NewInstance(5);   
10     IntArray* b = IntArray::NewInstance(10);
11     
12     if( a && b )
13     {
14         IntArray& array = a->self();
15         IntArray& brray = b->self();
16         
17         cout << "array.length() = " << array.length() << endl;
18         cout << "brray.length() = " << brray.length() << endl;
19     
20         array = brray;
21         
22         cout << "array.length() = " << array.length() << endl;
23         cout << "brray.length() = " << brray.length() << endl;
24     }
25     
26     delete a;
27     delete b;
28     
29     return 0;
30 }

　5，输出结果：

1 array.length() = 5

2 brray.length() = 10

3 array.length() = 10

4 brray.length() = 10

6，使用二阶构造后，拷贝构造函数是私有的，拷贝构造函数就没有作用了，不允许拷贝构造，但是应该重载赋值操作符重载；

7，编译器默认提供函数：

1，虽然类中什么都没写，但是编译器会放四个函数实现进去；

8，下面的代码输出什么？为什么？

1，代码示例：

1 string s = "12345";
2 const char* p = s.c_str();  // 返回字符指针，代表 C 语言中的字符串；
3 
4 cout << p << endl;
5 
6 s.append("abced");
7 
8 cout << p << endl;

9，字符串问题 1 编程实验：

1，main.cpp 文件：

 1 #include <iostream>
 2 #include <string>
 3 
 4 using namespace std;
 5 
 6 int main()
 7 {
 8     string s = "12345";
 9     const char* p = s.c_str();  // 只有这一行用了 C 方式；
10         
11     cout << p << endl;     
12         
13     s.append("abced");  // p 成为了野指针
14         
15     cout << p << endl;     
16 
17     return 0;
18 }

　2，这段代码混合了 C 和 C++ 的方式，出了意想不到的错误；

10，关于 string 的疑问 1：

1，string 对象内部维护了一个指向数据的 char* 指针，这个指针可能在程序运行的过程中发生改变，我们尽量不要操作这个指针；

2，执行 s.append() 函数后，char* 指针指向了新的堆空间 0xFF445566，而将旧的堆空间 0xFF112233 释放，此时 p 指针成了野指针；

3，学习 C++，并且用的是标准库中的内容，所以现在采用的编程思想就应该是 C++ 编程思想，不要混合使用 C 和 C++ 思想；

11，下面的程序输出什么？为什么？

1，代码示例：

 1 const char* p = "12345";  // p 可以用字符串对象代替；
 2 string s = "";  // 混合了，该注意了；
 3         
 4 s.reserve(10);
 5     
 6 // 不要使用 C 语言中的方式操作 C++ 中的字符串
 7 for(int i=0; i<5; i++)
 8 {
 9        s[i] = p[i];
10 }
11 
12 if( !s.empty() )
13 {
14     cout << s << endl;
15 }

2，没有输出；

12，字符串问题 2 编程实验：

1，main.cpp 文件：

 1 #include <iostream>
 2 #include <string>
 3 
 4 using namespace std;
 5 
 6 int main()
 7 {
 8     const char* p = "12345";
 9     string s = "";
10         
11     s.reserve(10);
12     
13     // 不要使用 C 语言中的方式操作 C++ 中的字符串
14     for(int i=0; i<5; i++)
15     {
16         s[i] = p[i];
17     }
18 
19             if( !s.empty() )  // 打印不出；
20         {
21           cout << s << endl;
22         }
23 
24     cout << s << endl;  // 打印不出；
25 
26     for(int i=0; i<5; i++)  // 可以打印；
27     {
28         cout << s[i] << endl;
29     }
30     
31     return 0;
32 }

　2，更改程序为：

 1 #include <iostream>
 2 #include <string>
 3 
 4 using namespace std;
 5 
 6 int main()
 7 {
 8     const string p = "12345";
 9     string s = "";
10 
11     s = p;
12 
13     cout << s << endl;
14     
15     return 0;
16 }