C++ 构造函数和析构函数详解-Toy模板网

这篇具有很好参考价值的文章主要介绍了C++ 构造函数和析构函数详解。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

概述

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;
}

运行结果：
c构造函数和析构函数,C++,c++,算法,开发语言
可以看到该程序先调用对象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，形参为空， {}空实现，这个一定注意。

结果：
c构造函数和析构函数,C++,c++,算法,开发语言

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;
}

c构造函数和析构函数,C++,c++,算法,开发语言

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;
}

c构造函数和析构函数,C++,c++,算法,开发语言

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;
}

c构造函数和析构函数,C++,c++,算法,开发语言

复制构造函数默认实现的是值拷贝（浅拷贝）。这里我用了深拷贝构造，这样可以防止堆区的内存重复被析构函数释放，保证代码的安全。深浅拷贝以后有时间我再整理一下，拷贝前面加入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;
}

c构造函数和析构函数,C++,c++,算法,开发语言
【参考鸣谢】
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文章来源地址https://www.toymoban.com/news/detail-788345.html

到了这里，关于C++ 构造函数和析构函数详解的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！