1.拷贝构造函数与析构函数执行流程分析

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
#define _CRT_SECURE_NO_WARNINGS // strcpy运行会报错,支持

#include<iostream>
#include<string.h>
using namespace std;

class Student1
{
public:

int age;
char * name;

Student1() { cout << "空参数构造函数" << endl; }

Student1(char * name) :Student1(name, 99) { cout << "一个参数构造函数" << endl; }

Student1(char * name, int age) {
cout << "二个参数构造函数" << endl;

this->name = (char *) malloc(sizeof(char * ) * 10);
strcpy(this->name, name);

this->age = age;
}

~Student1() {
cout << "析构函数执行" << endl;

free(this->name);
this->name = NULL;
}

// 默认有一个拷贝构造函数 隐士的 我们看不见
// Student(const Student & stu) {
// stu 旧地址

// this 新地址

// s2 = 新地址
// }
};

void mainT1() {
// ① 情况分析 画图了
// Student s1;
// Student s2;
// cout << &s1 << endl;
// cout << &s2 << endl;
// 两个地址 完全不同
// 打印:
// 空参数构造函数
// 空参数构造函数
// 1000H
// 2000H


// ② 情况分析
Student1 s1;
Student1 s2 = s1;

// 两个地址 完全不同
// 打印:
// 空参数构造函数
// 1000H
// 2000H

cout << &s1 << endl;
cout << &s2 << endl;

getchar(); // 不要一闪而过,让程序停留
}

拷贝构造函数地址分析

2.拷贝构造函数与析构函数原理细节图研究

浅拷贝

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
#define _CRT_SECURE_NO_WARNINGS // strcpy运行会报错,支持

#include<iostream>
#include<string.h>
using namespace std;

class Student2
{
public:

int age;
char * name;

Student2() { cout << "空参数构造函数" << endl; }

Student2(char * name) :Student2(name, 99) {
cout << "一个参数构造函数 this:" << this << endl;
}

Student2(char * name, int age) {
cout << "二个参数构造函数 this:" << this << endl;

this->name = (char *)malloc(sizeof(char *)* 10);
strcpy(this->name, name);

this->age = age;
}

~Student2() {
cout << "析构函数执行 &this->name:" << &this->name << endl;

free(this->name);
this->name = NULL;
}

// 默认有一个拷贝构造函数 隐士的 我们看不见
// 一旦复写了拷贝构造函数,默认的还在吗? Java的构造函数一个思路
Student2(const Student2 & stu) {
// stu 旧地址

// this 新地址

// s2 = 新地址

cout << "拷贝构造函数 &stu:" << &stu << " this:" << this << endl;


// 新地址name = 旧地址 (浅拷贝)
this->name = stu.name;


// 深拷贝 后面见 原理全部打通的时候讲
} // 此拷贝构造函数执行完 旧会出现一个 this==新地址 给 main函数的 stu
};

Student2 getStudent(char * name) {
Student2 stu(name); // 旧地址

cout << "getStudent函数:" << &stu << endl; // 旧地址

return stu; // stu 旧地址
} // 弹栈 释放 栈成员 stu

void mainT3() {
// getStudent返回旧地址
// = 会执行拷贝构造函数
// stu 新地址
Student2 stu = getStudent("截拳道");

cout << "main函数:" << &stu << endl;

// 打印:
// 两个参数构造函数
// 一个参数构造函数
// getStudent函数: 1000H地址
// 拷贝构造函数 构建新地址 把新地址 给 main函数的 stu == 新地址
// getStudent函数,析构函数
// main函数: 新地址。
// VS中是新地址,CLion是旧地址????????

// getchar(); // 不要一闪而过,让程序停留 需要在拷贝构造函数中使用深拷贝,然后在析构函数中释放this的内存
} // main函数弹栈 stu 新地址 析构函数执行

3.拷贝构造函数配合析构函数制作奔溃

拷贝构造函数中this的新地址,和旧地址都是指向堆区的同一个地址,所以多次调用会出现崩溃

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
#include<iostream>
#include<string.h>
using namespace std;

class Student2
{
public:

int age;
char * name;

Student2() { cout << "空参数构造函数" << endl; }

Student2(char * name) :Student2(name, 99) {
cout << "一个参数构造函数 this:" << this << endl;
}

Student2(char * name, int age) {
cout << "二个参数构造函数 this:" << this << endl;

this->name = (char *)malloc(sizeof(char *)* 10);
strcpy(this->name, name);

this->age = age;
}

~Student2() {
cout << "析构函数执行 &this->name:" << &this->name << endl;

free(this->name);
this->name = NULL;
}

// 默认有一个拷贝构造函数 隐士的 我们看不见
// 一旦复写了拷贝构造函数,默认的还在吗? Java的构造函数一个思路
Student2(const Student2 & stu) {
// stu 旧地址

// this 新地址

// s2 = 新地址

cout << "拷贝构造函数 &stu:" << &stu << " this:" << this << endl;


// 新地址name = 旧地址 (浅拷贝)
this->name = stu.name;


// 深拷贝 后面见 原理全部打通的时候讲
} // 此拷贝构造函数执行完 旧会出现一个 this==新地址 给 main函数的 stu
};

void show(Student2 student2) {
cout << &student2 << endl; // 新地址
}

int main() {
Student2 student2; // 1.调用空参构造函数,旧地址
show(student2); // 2.调用show会执行拷贝构造函数
// 3.弹show栈释放this->name

// 执行两次会导致重复释放问题
show(student2); // 再次调用拷贝构造函数
// 弹show栈,this->name已经被释放了,导致崩溃。
return 0;
}
1
2
3
4
5
6
空参数构造函数
拷贝构造函数 &stu:0x62fd10 this:0x62fd20
0x62fd20
析构函数执行 &this->name:0x62fd28

Process finished with exit code -1073740940 (0xC0000374)

4.深拷贝解决奔溃,并分析原理

深拷贝:

如果类成员变量中有堆成员,就需要重写拷贝构造函数,实现深拷贝。默认的拷贝构造函数是浅拷贝

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
#define _CRT_SECURE_NO_WARNINGS // strcpy运行会报错,支持

#include<iostream>
#include<string.h>
using namespace std;

class Student
{
public:

int age;
char * name;

Student() { cout << "空参数构造函数" << endl; }

Student(char * name) :Student(name, 99) {
cout << "一个参数构造函数 this:" << (int)this << endl;
}

Student(char * name, int age) {
cout << "二个参数构造函数 this:" << (int)this << endl;

this->name = (char *)malloc(sizeof(char *)* 10);
strcpy(this->name, name);

this->age = age;
}

~Student() {
cout << "析构函数执行 &this->name:" << (int)this->name << endl;

free(this->name);
this->name = NULL;
}

// 默认有一个拷贝构造函数 隐士的 我们看不见
// 一旦复写了拷贝构造函数,默认的还在吗? Java的构造函数一个思路
// 自定义拷贝构造函数 如果有堆成员,必须采用深拷贝
Student(const Student & stu) {
// stu 旧地址

// this 新地址

// s2 = 新地址

cout << "拷贝构造函数 &stu:" << (int)&stu << " this:" << (int)this << endl;

// 【浅拷贝】:新地址name 旧地址name 指向同一个空间,会造成,重复free的问题,引发奔溃
// 新地址name = 旧地址 (浅拷贝)
// this->name = stu.name;

// 【深拷贝】
this->name = (char *)malloc(sizeof(char *)* 10);
strcpy(this->name, name);

this->age = stu.age;

cout << "拷贝构造函数2 this->name:" << ((int) this->name) << " stu.name:" << (int)stu.name << endl;

// 深拷贝 后面见 原理全部打通的时候讲
} // 此拷贝构造函数执行完 旧会出现一个 this==新地址 给 main函数的 stu


// 默认的拷贝构造函数 是浅拷贝
};


//stu是新地址,拷贝构造函数构建新地址
void showStudent(Student stu) {
cout << "showStudent函数:" << (int)&stu << " " << stu.name << "," << stu.age<< endl;
}

void main() {
Student stu("刘奋", 31);

showStudent(stu); // 弹栈后 新地址name释放一遍
// showStudent(stu); // 弹栈后 新地址name释放一遍
// 两次释放新地址name 会奔溃

// 释放一次新地址name 再释放一次旧name也报错

showStudent(stu);

getchar();
} // main函数弹栈 stu 旧地址