C++ 构造函数和析构函数 详解

目录

概述构造函数的分类1. 无参(默认)构造函数2. 有参构造函数3. 委托构造函数4. 复制(拷贝)构造函数5. 移动构造函数 构造函数调用规则析构函数

概述

C++中用构造函数和析构函数来初始化和清理对象，这两个函数将会被编译器自动调用。对象的初始化和清理是非常重要的，如果我们不提供构造函数与析构函数，编译器会自动提供两个函数的空实现。

构造函数：主要作用于创建函数时对对象成员的属性赋值。
析构函数：主要作用于在对象销毁前，执行一些清理工作（如释放new开辟在堆区的空间）。

主要特点：
构造函数语法：类名(){}
1.构造函数，没有返回值也不写void
2.函数名称与类名相同
3.构造函数可以有参数，因此可以发生重载
4.程序在调用对象时候会自动调用构造，无须手动调用，而且只会调用一次

析构函数语法： ~类名(){}
1.析构函数，没有返回值也不写void
2.函数名称与类名相同,在名称前加上符号 ~
3.析构函数不可以有参数，因此不可以发生重载
4.程序在对象销毁前会自动调用析构，无须手动调用，而且只会调用一次

其余特点：

构造函数和析构函数是一种特殊的公有成员函数，每一个类都有一个默认的构造函数和析构函数；构造函数在类定义时由系统自动调用，析构函数在类被销毁时由系统自动调用；构造函数的名称和类名相同，一个类可以有多个构造函数，只能有一个析构函数。不同的构造函数之间通过参数个数和参数类型来区分；我们可以在构造函数中给类分配资源，在类的析构函数中释放对应的资源。如果程序员没有提供构造和析构，系统会默认提供，空实现构造函数 和 析构函数，必须定义在public里面，才可以调用

简单示例：

#include<iostream>using namespace std;class Person{public:Person(){cout << "调用构造函数" << endl;}~Person()//对象销毁前，自动调用{cout << "析构函数的调用" << endl;}};void test(){//创建对象Person  p;//这是一个局部变量，test执行完毕后会释放该对象 进而调用析构函数}int main(){Person  p1;//如果在main函数创建对象，析构函数会在按任意键后再调用test();system("pause");return 0;}

运行结果：

可以看到该程序先调用对象p1的构造函数，再调用对象p的构造函数和析构函数，而p1的析构函数要在按任意键后再显示，因为p1是main函数的局部变量，将在退出main函数时释放，释放时就会调用p1的析构函数。

构造函数的分类

两种分类方式：

按参数分为： 有参构造和无参构造

按类型分为： 普通构造和拷贝构造

三种调用方式：

括号法（最为常用）

显式法

隐式转换法

对于有参，无参，拷贝三种构造函数对应三种调用方式示例(无参只有一种调用写法)：

#include<iostream>using namespace std;class Person{public:Person(){cout << "调用无参（默认）构造函数" << endl;}Person(int a){age = a;cout << "调用有参构造函数" << endl;}//拷贝构造函数用于拷贝传入的类到自身类上 //除了拷贝构造函数外都是普通构造函数Person(const Person &p)//传入的类不希望被改变所以加const 传入引用用p指向该类{age = p.age;cout << "调用拷贝构造函数" << endl;}~Person(){cout << "析构函数的调用" << endl;}int age;};void test(){    //调用    //1.括号法//注意：调用无参构造时不要输入()//Person p();会被编译器认为是函数的声明Person p;//调用无参构造函数Person p1(10);//调用有参函数构造Person p2(p1);//调用拷贝构造函数cout <<"p1的年龄"<< p1.age << endl;cout <<"p2的年龄"<< p2.age << endl;//2.显式法Person p3;//调用无参构造函数Person p4=Person (10);//调用有参函数构造Person p5=Person (p1);//调用拷贝构造函数//Person(10)为匿名对象 等号左侧就是它的名 //特点：当前行结束时，系统会立即回收掉匿名对象 即它的析构函数会在该行结束后就调用而不是test函数结束//3.隐式转换法Person p6 = 10; //调用有参函数构造 相当于Person p6=Person(10);  假如有两个参数就是 Person p6 = (10,9);Person p7 = p1;//调用拷贝构造函数 相当于Person p7=Person(p1);}int main(){test();system("pause");return 0;}

1. 无参(默认)构造函数

不含参数的构造函数，举个例子，创建一个Person类，包括年龄和身高两个属性，年龄(整形)，身高(整形指针)，默认构造初始化年龄是0，身高0。如果用户不实现，系统会默认空实现。

#include<iostream>using namespace std;class Person{public://默认构造函数Person();int m_Age;int* m_Height;};//初始化年龄和身高Person::Person() {cout << "默认构造函数的调用！" << endl;this->m_Age = 0;this->m_Height = new int(0);}int main(){Person p;cout << "此人的年龄是： " << p.m_Age << endl;cout << "此人的身高是： " << *(p.m_Height) << endl;return 0;}

注意创建对象时是Person p; 如果我们这样写Person p(); 编译器会认为是创建了一个函数p， 返回值类型Person，形参为空， {}空实现， 这个一定注意。

结果：

2. 有参构造函数

下面介绍一下有参构造，还是接着用上面的例子进行添加，继续，如果我们想创建一个指定年龄和身高的对象，这时候就要用到有参构造了，例子：

#include<iostream>using namespace std;class Person{public://默认构造函数Person();//有参构造Person(int age, int height);int m_Age;int* m_Height;};//默认构造Person::Person() {cout << "默认构造函数的调用！" << endl;this->m_Age = 0;this->m_Height = new int(0);}//有参构造，把age赋值给m_Age,身高用m_Height指向Person::Person(int age,int height){cout << "有参构造函数的调用！" << endl;this->m_Age = age;this->m_Height = new int(height);}int main(){Person p(18,175);cout << "此人的年龄是： " << p.m_Age << endl;cout << "此人的身高是： " << *(p.m_Height) << endl;return 0;}

3. 委托构造函数

顾名思义，委托构造函数就是把自己构造的事情，交给其他的构造函数顺带完成，例如我把默认构造函数修改一下，

#include<iostream>using namespace std;class Person{public://默认构造函数Person();//有参构造Person(int age, int height);//拷贝构造Person(const Person& p);int m_Age;int* m_Height;};//默认构造Person::Person() :Person(0, 0){cout << "委托构造函数的调用！" << endl;}//有参构造，把age赋值给m_Age,身高用m_Height指向Person::Person(int age, int height){cout << "有参构造函数的调用！" << endl;this->m_Age = age;this->m_Height = new int(height);}//拷贝构造函数调用Person::Person(const Person& p){cout << "拷贝构造函数的调用！" << endl;this->m_Age = p.m_Age;this->m_Height = new int(*p.m_Height);}int main(){Person p;cout << "p的年龄是： " << p.m_Age << endl;cout << "p的身高是： " << *(p.m_Height) << endl;return 0;}

4. 复制(拷贝)构造函数

上面都是开始是给出属性的值进行初始化，而拷贝构造函数在开始是传递一个对象，把对象的个属性拷贝到此对象中，进行对象的初始化(可以把传去的参数，看成一只羊，拷贝构造后克隆了一只新的羊，两只羊的属性一样)根据这样可以实现对象的创建。

#include<iostream>using namespace std;class Person{public://默认构造函数Person();//有参构造Person(int age, int height);//拷贝构造Person(const Person& p);int m_Age;int* m_Height;};//默认构造Person::Person(){cout << "默认构造函数的调用！" << endl;this->m_Age = 0;this->m_Height = new int(0);}//有参构造，把age赋值给m_Age,身高用m_Height指向Person::Person(int age, int height){cout << "有参构造函数的调用！" << endl;this->m_Age = age;this->m_Height = new int(height);}//拷贝构造函数调用Person::Person(const Person& p){cout << "拷贝构造函数的调用！" << endl;this->m_Age = p.m_Age;this->m_Height = new int(*p.m_Height);}int main(){Person p1(18, 175);cout << "p1的年龄是： " << p1.m_Age << endl;cout << "p1的身高是： " << *(p1.m_Height) << endl;Person p2(p1);//将对象p1复制给p2。注意复制和赋值的概念不同 cout << "p2的年龄是： " << p2.m_Age << endl;cout << "p2的身高是： " << *(p2.m_Height) << endl;return 0;}

复制构造函数默认实现的是值拷贝（浅拷贝）。这里我用了深拷贝构造，这样可以防止堆区的内存重复被析构函数释放，保证代码的安全。深浅拷贝以后有时间我再整理一下，拷贝前面加入const限定可以防止修改成员属性保证完全一致。这个用了左值引用，进行一个赋值，上面为左值参数的引用拷贝。

【思考】
复制(拷贝)构造函数的参数不用const行不行？const起了什么作用
最好是加const，常量左值引用可以接受左值、右值、常量左值、常量右值，而左值引用只能接受左值。
需要拷贝临时对象的时候，比如Integer a(Integer(100)); 没有const的拷贝构造函数将报错。

可参考 https://blog.csdn.net/jiaojinlin/article/details/124744513

5. 移动构造函数

该部分介绍篇幅不小，请移步另一篇文章有详细介绍：C++ 移动构造函数详解

构造函数调用规则

默认情况下，C++编译器至少给一个类添加3个函数

1．默认构造函数(无参，函数体为空)

2．默认析构函数(无参，函数体为空)

3．默认拷贝构造函数，对属性进行值拷贝

构造函数调用规则如下：

如果用户定义有参构造函数，c++不再提供默认无参构造，但是会提供默认拷贝构造

如果用户定义拷贝构造函数，c++不会再提供其他构造函数

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

析构函数

析构函数是用于在对象被删除之前的清理工作，在对象生命周期即将结束时被自动调用。(析构函数可以清理对象并且释放内存)
析构函数 ~加上类名() 进行操作，目的时清空数据，释放内存。
下面举一个示例：创建一个默认构造函数p，进行默认构造，然后调用展示信息函数输出信息，最后析构函数，释放内容，防止内存泄漏！

#include<iostream>using namespace std;class Person{public://默认构造函数Person();//有参构造Person(int age, int height);//拷贝构造Person(const Person& p);//移动构造函数Person(Person&& p);//析构函数~Person();//展示信息void ShowPerson();int m_Age;int* m_Height;};//默认构造Person::Person(){cout << "默认构造函数的调用！" << endl;this->m_Age = 0;this->m_Height = new int(0);}//有参构造，把age赋值给m_Age,身高用m_Height指向Person::Person(int age, int height){cout << "有参构造函数的调用！" << endl;this->m_Age = age;this->m_Height = new int(height);}//拷贝构造函数调用Person::Person(const Person& p):m_Age(p.m_Age),m_Height(new int (*p.m_Height)){cout << "拷贝构造函数的调用！" << endl;/*this->m_Age = p.m_Age;this->m_Height = new int(*p.m_Height);*/}//移动构造函数Person::Person(Person&& p){cout << "移动构造函数的调用！" << endl;this->m_Age = p.m_Age;this->m_Height = p.m_Height;p.m_Height = NULL;}//展示信息void Person::ShowPerson(){cout << "年龄是： " << this->m_Age << endl;    cout << "身高是： " << *(this->m_Height) << endl;}Person::~Person(){cout << "析构函数的调用！" << endl;if (this->m_Height != NULL){delete this->m_Height;}}//返回一个右值的对象Person GetPerson(){Person p;return p;}int main(){Person p;p.ShowPerson();return 0;}

【参考鸣谢】
https://blog.csdn.net/qq_44768163/article/details/114661958
https://blog.csdn.net/hbbfvv1h/article/details/115371496
https://blog.csdn.net/m0_61973596/article/details/123458069 【优质】
https://blog.csdn.net/qqyuanhao163/article/details/101396233
https://blog.csdn.net/weixin_39270987/article/details/116306065

https://blog.csdn.net/zyq11223/article/details/48766515#
https://blog.csdn.net/u014201706/article/details/103032246
https://blog.csdn.net/qq_34170700/article/details/107214554
https://blog.csdn.net/yi_chengyu/article/details/120775215