C++类中的三大函数(构造，析构，拷贝)

下面一段话与大家共勉&＃xff1a;

每个人的一生都会遇到很多边界&＃xff0c;有些边界可以突破&＃xff0c;有些则不能。那些无法突破的边界就是你的极限&＃xff0c;而划分边界的标准就是“阈值”。每次突破阈值之后&＃xff0c;人生轨迹就会发生剧烈变化&＃xff0c;其间需要你做出很多思考和判断&＃xff0c;直到最后找到自己的极限。

时间过的很快&＃xff0c;转眼间&＃xff0c;已经半个多月没更新了&＃xff0c;这段时间很忙&＃xff0c;事情非常多&＃xff0c;最近沉迷于高数&＃xff0c;下个决定&＃xff0c;大二参加数竞&＃xff0c;所以以后可能不会那么频繁的更新&＃xff0c;可能会把更多时间放在数学上面。今天和大家分享一下C&＃43;&＃43;中在创建类的时候编译器会提供给一个类至少三个函数&＃xff0c;分别是默认构造函数&＃xff0c;析构函数&＃xff0c;拷贝构造函数。

目录&＃xff1a;

一.构造函数

1.构造函数的作用

2.构造函数的语法 类名(){}

一.构造函数

1.构造函数的作用

我们在创建好类的对象之后&＃xff0c;首先对它的每一个成员属性赋值之后再对它们进行输出操作&＃xff0c;如果不赋值就输出&＃xff0c;这些值就会是垃圾值。而为了代码的简介&＃xff0c;一次性为所有成员属性初始化&＃xff0c;C&＃43;&＃43;的类提供了这样的一个函数—构造函数。

2.构造函数的语法 类名(){}

1&＃xff09;构造函数&＃xff0c;没有返回值也不写void

2&＃xff09; 函数名称与类名相同

3&＃xff09;构造函数可以有参数&＃xff0c;因此可以发生重载

4&＃xff09;程序在调用对象时候会自动调用构造&＃xff0c;无须手动调用,而且只会调用一次

二.析构函数

1.析构函数的作用

析构函数的作用与构造函数相反&＃xff0c;一般是执行对象的清理工作&＃xff0c;当对象的生命周期结束的时候&＃xff0c;会自动的调用。析构函数的作用并不是删除对象&＃xff0c;在对象撤销它所占用的内存之前&＃xff0c;做一些清理的工作。清理之后&＃xff0c;这部分内存就可以被系统回收再利用了。在设计这个类的时候&＃xff0c;系统也会默认的提供一个析构函数。在对象的生命周期结束的时候&＃xff0c;程序就会自动执行析构函数来完成这些工作。同构造函数&＃xff0c;用户自己定义&＃xff0c;系统自动调用。

2.析构函数的语法~类名(){}

1&＃xff09;析构函数&＃xff0c;没有返回值也不写void

2&＃xff09; 函数名称与类名相同,在名称前加上符号 ~

3&＃xff09;析构函数不可以有参数&＃xff0c;因此不可以发生重载

4&＃xff09; 程序在对象销毁前会自动调用析构&＃xff0c;无须手动调用,而且只会调用一次

代码演示&＃xff1a;

class Person
{public://构造函数Person(){cout <<"Person的构造函数调用" <//析构函数
~Person(){cout <<"Person的析构函数调用" <};
void test01()
{Person p;
}
int main(){test01();system("pause");return 0;}

三.构造函数的分类及调用

1.两种分类方式&＃xff1a;

按参数分为&＃xff1a; 有参构造和无参构造

按类型分为&＃xff1a; 普通构造和拷贝构造

2.三种调用方式&＃xff1a;

括号法

显示法

隐式转换法

//1、构造函数分类
// 按照参数分类分为 有参和无参构造 无参又称为默认构造函数
// 按照类型分类分为 普通构造和拷贝构造
class Person {
public://无参&＃xff08;默认&＃xff09;构造函数
Person() {
cout <<"无参构造函数!" <}//有参构造函数
Person(int a) {
age &＃61; a;
cout <<"有参构造函数!" <}//拷贝构造函数
Person(const Person& p) {
age &＃61; p.age;
cout <<"拷贝构造函数!" <}//析构函数
~Person() {
cout <<"析构函数!" <}public:
int age;
};//2、构造函数的调用
//调用无参构造函数
void test01() {
Person p; //调用无参构造函数
}//调用有参的构造函数
void test02() {
//2.1 括号法&＃xff0c;常用
Person p1(10);
//注意1&＃xff1a;调用无参构造函数不能加括号&＃xff0c;如果加了编译器认为这是一个函数声明
//Person p2();//2.2 显式法
Person p2 &＃61; Person(10);
Person p3 &＃61; Person(p2);
//Person(10)单独写就是匿名对象 当前行结束之后&＃xff0c;马上析构//2.3 隐式转换法
Person p4 &＃61; 10; // Person p4 &＃61; Person(10);
Person p5 &＃61; p4; // Person p5 &＃61; Person(p4);
//注意2&＃xff1a;不能利用 拷贝构造函数 初始化匿名对象 编译器认为是对象声明
//Person p5(p4);
}
int main() {
test01();
//test02();
system("pause");
return 0;
}

四.拷贝构造函数调用时机

C&＃43;&＃43;中拷贝构造函数调用时机通常有三种情况

1.使用一个已经创建完毕的对象来初始化一个新对象

2.值传递的方式给函数参数传值

3.以值方式返回局部对象

class Person {
public:
Person() {
cout <<"无参构造函数!" <mAge &＃61; 0;
}
Person(int age) {
cout <<"有参构造函数!" <mAge &＃61; age;
}
Person(const Person& p) {
cout <<"拷贝构造函数!" <mAge &＃61; p.mAge;
}
//析构函数在释放内存之前调用
~Person() {
cout <<"析构函数!" <}
public:
int mAge;
};
//1. 使用一个已经创建完毕的对象来初始化一个新对象
void test01() {
Person man(100); //p对象已经创建完毕
Person newman(man); //调用拷贝构造函数
Person newman2 &＃61; man; //拷贝构造
//Person newman3;
//newman3 &＃61; man; //不是调用拷贝构造函数&＃xff0c;赋值操作
}
//2. 值传递的方式给函数参数传值
//相当于Person p1 &＃61; p;
void doWork(Person p1) {}
void test02() {
Person p; //无参构造函数
doWork(p);
}
//3. 以值方式返回局部对象
Person doWork2()
{
Person p1;
cout <<(int *)&p1 <return p1;
}
void test03()
{
Person p &＃61; doWork2();
cout <<(int *)&p <}
int main() {
//test01();
//test02();
test03();
system("pause");
return 0;
}

五.构造函数调用规则

默认情况下&＃xff0c;c&＃43;&＃43;编译器至少给一个类添加3个函数

1&＃xff0e;默认构造函数(无参&＃xff0c;函数体为空)

2&＃xff0e;默认析构函数(无参&＃xff0c;函数体为空)

3&＃xff0e;默认拷贝构造函数&＃xff0c;对属性进行值拷贝

构造函数调用规则如下&＃xff1a;

如果用户定义有参构造函数&＃xff0c;c&＃43;&＃43;不在提供默认无参构造&＃xff0c;但是会提供默认拷贝构造

如果用户定义拷贝构造函数&＃xff0c;c&＃43;&＃43;不会再提供其他构造函数

class Person {
public:
//无参&＃xff08;默认&＃xff09;构造函数
Person() {
cout <<"无参构造函数!" <}
//有参构造函数
Person(int a) {
age &＃61; a;
cout <<"有参构造函数!" <}
//拷贝构造函数
Person(const Person& p) {
age &＃61; p.age;
cout <<"拷贝构造函数!" <}
//析构函数
~Person() {
cout <<"析构函数!" <}
public:
int age;
};
void test01()
{
Person p1(18);
//如果不写拷贝构造&＃xff0c;编译器会自动添加拷贝构造&＃xff0c;并且做浅拷贝操作
Person p2(p1);
cout <<"p2的年龄为&＃xff1a; " <}
void test02()
{
//如果用户提供有参构造&＃xff0c;编译器不会提供默认构造&＃xff0c;会提供拷贝构造
Person p1; //此时如果用户自己没有提供默认构造&＃xff0c;会出错
Person p2(10); //用户提供的有参
Person p3(p2); //此时如果用户没有提供拷贝构造&＃xff0c;编译器会提供
//如果用户提供拷贝构造&＃xff0c;编译器不会提供其他构造函数
Person p4; //此时如果用户自己没有提供默认构造&＃xff0c;会出错
Person p5(10); //此时如果用户自己没有提供有参&＃xff0c;会出错
Person p6(p5); //用户自己提供拷贝构造
}
int main() {
test01();
system("pause");
return 0;
}

六.深拷贝与浅拷贝

浅拷贝&＃xff1a;简单的赋值拷贝操作

深拷贝&＃xff1a;在堆区重新申请空间&＃xff0c;进行拷贝操作

示例&＃xff1a;

class Person {
public:
//无参&＃xff08;默认&＃xff09;构造函数
Person() {
cout <<"无参构造函数!" <}
//有参构造函数
Person(int age ,int height) {
cout <<"有参构造函数!" <m_age &＃61; age;
m_height &＃61; new int(height);
cout <<"拷贝构造函数!" <//如果不利用深拷贝在堆区创建新内存&＃xff0c;会导致浅拷贝带来的重复释放堆区问题
m_age &＃61; p.m_age;
m_height &＃61; new int(*p.m_height)
}
//拷贝构造函数
Person(const Person& p) {
;
}
//析构函数
~Person() {
cout <<"析构函数!" <if (m_height !&＃61; NULL)
{
delete m_height;
}
}
public:
int m_age;
int* m_height;
};
void test01()
{
Person p1(18, 180);
Person p2(p1);
cout <<"p1的年龄&＃xff1a; " <cout <<"p2的年龄&＃xff1a; " <}
int main() {
test01();
system("pause");
return 0;
}

总结&＃xff1a;如果属性有在堆区开辟的&＃xff0c;一定要自己提供拷贝构造函数&＃xff0c;防止浅拷贝带来的问题