开发笔记:36，经典问题解析三

1 #include<iostream>
2 #include<string>
3
4 using namespace std;
5
6 //编译器会默认提供重载赋值操作符------仅仅完成浅拷贝
7
8 class Test
9 {
10 int* m_pointer; //指针成员
11 public:
12 Test()
13 {
14 m_pointer = NULL;
15 }
16 Test(int i)
17 {
18 m_pointer = new int(i); //指向堆空间的4个字节
19 }
20
21 void print()
22 {
23 cout <<"m_pointer=" < endl;
24 }
25
26 ~Test()
27 {
28 delete m_pointer;
29 }
30 };
31
32 int main()
33 {
34 Test t1=1; //t1对象的内部的成员指针指向堆空间的一片内存，内存里面的值设置为1
35 Test t2; //t2对象指针指向空
36
37 t2 = t1; //t1对象赋值t2 产生内存错误
38 //t1 t2指向相同堆空间,main()结束之前摧毁t1 t2两个对象，释放调用两次析构函数delete m_pointer;--------不合法的内存操作
39
40
41
42 t1.print();
43 t2.print();
44
45 return 0;
46 }

1 #include
2 #include<string>
3
4 using namespace std;
5
6 //什么时候进行深拷贝----要实现深拷贝就要重载赋值操作符
7
8 //类里有成员m_pointer指针指代了外部资源，浅拷贝不够用这时候需要自定义深拷贝和重载赋值操作符，有必要的时候自定义拷贝构造函数
9
10 class Test
11 {
12 int* m_pointer; //指针成员
13
14 public:
15 Test()
16 {
17 m_pointer = NULL;
18 }
19 Test(int i)
20 {
21 m_pointer = new int(i); //指向堆空间的4个字节
22 }
23
24
25
26 //自定义深拷贝构造函数
27 Test(const Test& obj)
28 {
29 m_pointer = new int(*obj.m_pointer); //1，堆空间申请一片内存，大小由参数对象决定，内存代表int类型的值，
30 //2，取出参数对象obj的m_pointer指针所指向的堆空间的整型值，赋值到新申请的空间内
31 }
32
33
34
35 //重载赋值操作符 注意4点： 1，返回值类型一定是引用Test&为了连续赋值 2，参数是const引用类型
36 // 3，赋值操作符不是自赋值a=a，要避免赋值，通过This判断，this指向当前对象的地址和参数地址不同才进行赋值操作（深拷贝）
37 // 4，返回当前对象地址*this
38
39 Test& operator=(const Test& obj)
40 {
41 //进行赋值操作
42 if (this != &obj)
43 {
44 delete m_pointer; //深拷贝之前将当前的指针删除
45 m_pointer = new int(*obj.m_pointer);
46 }
47
48 return *this;
49 }
50
51 void print()
52 {
53 cout <<"m_pointer=" < endl;
54 }
55
56 ~Test()
57 {
58 delete m_pointer;
59 }
60 };
61
62 int main()
63 {
64 Test t1=1; //t1对象的内部的成员指针指向堆空间的一片内存，内存里面的值设置为1
65 Test t2; //t2对象指针指向空
66
67 t2 = t1; //利用赋值操作符重载函数
68
69 // t1对象的m_pointer指针和t2对象的m_pointer指针所指向的堆空间不一样
70
71 t2 = t2; //没意义，只是支持 所以要避免自赋值 if (this != &obj)
72
73 t1.print();
74 t2.print();
75
76 return 0;
77 }

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 };
23
24 #endif
25 #endif

1 #include "IntArray.h"
2
3 IntArray::IntArray(int len)
4 {
5 m_length = len;
6 }
7
8 bool IntArray::construct()
9 {
10 bool ret = true;
11
12 m_pointer = new int[m_length];
13
14 if( m_pointer )
15 {
16 for(int i=0; i)
17 {
18 m_pointer[i] = 0;
19 }
20 }
21 else
22 {
23 ret = false;
24 }
25
26 return ret;
27 }
28
29 IntArray* IntArray::NewInstance(int length)
30 {
31 IntArray* ret = new IntArray(length);
32
33 if( !(ret && ret->construct()) )
34 {
35 delete ret;
36 ret = 0;
37 }
38
39 return ret;
40 }
41
42 int IntArray::length()
43 {
44 return m_length;
45 }
46
47 bool IntArray::get(int index, int& value)
48 {
49 bool ret = (0 <= index) && (index < length());
50
51 if( ret )
52 {
53 value = m_pointer[index];
54 }
55
56 return ret;
57 }
58
59 bool IntArray::set(int index, int value)
60 {
61 bool ret = (0 <= index) && (index < length());
62
63 if( ret )
64 {
65 m_pointer[index] = value;
66 }
67
68 return ret;
69 }
70
71 int& IntArray::operator [] (int index)
72 {
73 return m_pointer[index];
74 }
75
76 IntArray& IntArray::operator = (const IntArray& obj)
77 {
78 if( this != &obj ) //拷贝开始
79 {
80 int* pointer = new int[obj.m_length]; //申请堆空间内存，大小由参数对象决定
81
82 if( pointer ) //申请成功
83 {
84 for(int i=0; i) //复制，遍历参数对象所指的堆空间
85 {
86 pointer[i] = obj.m_pointer[i]; //参数对象所指堆空间的内容元素，全部复制到pointer所指的堆空间----以上都是浅拷贝
87 }
88 //下面是深拷贝
89 m_length = obj.m_length; //第一步：更新长度
90 delete[] m_pointer;　　　　//第二步：释放原有的空间
91 m_pointer = pointer;　　　 //第三步：深拷贝的关键-----将当前操作的pointer指针所指向的空间，赋值给m_pointer成员
92 }
93 }
94
95 return *this;
96 }
97
98 IntArray& IntArray::self()
99 {
100 return *this;
101 }
102
103 IntArray::~IntArray()
104 {
105 delete[]m_pointer;
106 }

#include
#include "IntArray.h"
using namespace std；
int main()
{
IntArray* a = IntArray::NewInstance(5);//数组对象
IntArray* b = IntArray::NewInstance(10); //数组对象
if(a && b)//二阶构造都成功，赋值操作
{
IntArray& array = a->self();
IntArray& brray = b->self();
cout <<"array.length() = " < cout <<"brray.length() = " < array = brray; //赋值
cout <<"array.length() = " < cout <<"brray.length() = " < }
delete a;
delete b;
return 0;
}

#include
#include<string>
//不能混合使用c语言和c++
using namespace std;
int main()
{
string s = "12345";
//程序试图在C的方式访问字符串（不建议这样用！）
const char* p = s.c_str(); //指针指向------c_str表示C方式的字符串内存空间

cout <

//12345 p成为了野指针
//cout <//12345

s.append("abcde"); //字符串插入函数
//p成为野指针，因为追加字符串，可能
//导致堆内存的重新分配，从而m_cstr
//指的堆内存地址改变了，但p并不知道！

cout <

// 12345--仍然指向旧的地址（野指针）
// cout <//12345abcde
return 0;
}

1 #include
2 #include<string>
3
4 //不能混合使用c语言和c++
5 using namespace std;
6
7 int main()
8 {
9 const string p = "12345";
10
11 string s = "";
12
13 s = p; //使用字符串对象------抛弃c语言编程，采用面对对象思想
14
15 cout < endl; //12345

16 return 0;
17 }