老套路，线上代码
#define _CRT_SECURE_NO_WARNINGS // windows 平台 vscode strcpy运行会报错，支持 mac 不会
#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 = 新地址
// }
};
int main() {
// ① 情况分析 画图了
// Student1 s1;
// Student1 s2;
// cout << &s1 << endl;
// cout << &s2 << endl;
// 两个地址 完全不同
// 打印：
// 空参数构造函数
// 空参数构造函数
// 1000H
// 2000H
// ② 情况分析
Student1 s1;
Student1 s2 = s1;
// 两个地址 完全不同
// 打印：
// 空参数构造函数
// 1000H
// 2000H
// cout << &s1 << endl;
// cout << &s2 << endl;
// getchar(); // 不要一闪而过，让程序停留VS Clion 不需要
return 0;
}
① 情况分析 画图了
Student1 s1;
Student1 s2;
cout << &s1 << endl;
cout << &s2 << endl;
①函数内存图.png
空参数构造函数
空参数构造函数
地址一
地址二
② 情况分析
Student1 s1;
Student1 s2 = s1;
②函数内存图.png
所以打印只有一个空参构造函数，通过拷贝构造函数，隐式创建的，进行赋值产生新的this指针 就是新的地址。
结果：
空参数构造函数
0x7ffee81b21d8
0x7ffee81b21c8
析构函数执行
自己覆写拷贝构造函数
#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
int main() {
// = 会执行拷贝构造函数
// stu 新地址
Student2 stu = getStudent("张起灵");
cout << "main函数:" << &stu << endl;
// 打印：
// 两个参数构造函数
// 一个参数构造函数
// getStudent函数: 1000H地址
// 拷贝构造函数 构建新地址 把新地址 给 main函数的 stu == 新地址
// 析构函数
// main函数:
return 0;
} // main函数弹栈 stu 新地址 析构函数执行
③ 情况分析，有拷贝构造函数
可能是这种打印，因为每次可能地址在变
二个参数构造函数 this:0x7ffee81a11d8
一个参数构造函数 this:0x7ffee81a11d8
getStudent函数:0x7ffee81a11d8
main函数:0x7ffee81a11d8
析构函数执行 &this->name:0x7ffee81a11e0
截屏2021-03-18 16.14.45.png
getStudent 就会生成新地址。
深拷贝和浅拷贝分析
#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:" << this << endl;
}
Student(char *name, int age) {
cout << "二个参数构造函数 this:" << this << endl;
this->name = (char *) malloc(sizeof(char *) * 10);
strcpy(this->name, name);
this->age = age;
}
~Student() {
cout << "析构函数执行 &this->name:" << this->name << endl;
free(this->name);
this->name = NULL;
}
// 默认有一个拷贝构造函数 隐士的 我们看不见
// 一旦复写了拷贝构造函数，默认的还在吗？ Java的构造函数一个思路
// 自定义拷贝构造函数 如果有堆成员，必须采用深拷贝
Student(const Student &stu) {
// stu 旧地址
// this 新地址
// s2 = 新地址
cout << "拷贝构造函数 &stu:" << &stu << " this:" << 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:" << (this->name) << " stu.name:" << stu.name << endl;
// 深拷贝 后面见 原理全部打通的时候讲
} // 此拷贝构造函数执行完 旧会出现一个 this==新地址 给 main函数的 stu
// 默认的拷贝构造函数 是浅拷贝
};
void showStudent(Student stu) {
cout << "showStudent函数：" << &stu << " " << stu.name << "," << stu.age << endl;
}
int main() {
Student stu("刘奋", 31);
printf("===============\n");
showStudent(stu); // 弹栈后 新地址name释放一遍
// showStudent(stu); // 弹栈后 新地址name释放一遍
// 两次释放新地址name 会奔溃
// 释放一次新地址name 再释放一次旧name也报错
// showStudent(stu);
//
//
// showStudent(stu);
//
//
// showStudent(stu);
// showStudent(stu);
return 0;
} // main函数弹栈 stu 旧地址
①【浅拷贝】：新地址name 旧地址name 指向同一个空间，会造成，重复free的问题，引发崩溃
// 新地址name = 旧地址 （浅拷贝）
this->name = stu.name;
我们来看下打印
二个参数构造函数 this:0x7ffeeee451d8
===============
拷贝构造函数 &stu:0x7ffeeee451d8 this:0x7ffeeee451b8
拷贝构造函数2 this->name:刘奋 stu.name:刘奋
showStudent函数：0x7ffeeee451b8 刘奋,31
析构函数执行 &this->name:刘奋
析构函数执行 &this->name:刘奋
xxxxx error 信息 。。。xxxx
执行了两次析构也就是释放了统一块内存两次
② 【深拷贝】来解决
this->name = (char *) malloc(sizeof(char *) * 10);
strcpy(this->name, name);
二个参数构造函数 this:0x7ffeebd3e1d8
===============
拷贝构造函数 &stu:0x7ffeebd3e1d8 this:0x7ffeebd3e1b8
拷贝构造函数2 this->name: stu.name:刘奋
showStudent函数：0x7ffeebd3e1b8 ,31
析构函数执行 &this->name:
析构函数执行 &this->name:刘奋
深拷贝，我们从新分配地址。两次释放不是同一个
截屏2021-03-18 16.50.36.png
浅拷贝带来的问题:
浅拷贝.jpg
深拷贝图:
深拷贝.jpg
