目录
- 概述
- 构造函数的分类
- 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
