构造函数和析构函数 c++-----类和对象

---

一、构造函数和析构函数

构造函数：主要作用创建对象时为对象的成员属性赋值，构造函数编译器会自动调用，不用手动进行调用。
析构函数：对象销毁前系统自动调用，进行清理工作。不写编译器会自动写一个，但只会空实现，不会有什么表示。

二、使用步骤

1.语法

构造函数 类名（） {}

注意：
1.没有返回值，也不写void；
2.函数名称和类名相同；
3.构造函数可以有参数，可以发生重载；
4.对象调用对象时自动调用构造，但只会调用一次 ；

析构函数 ~类名 （）{}

1.没有返回值，也不写void；
2.函数名称和类名相同，最前面要写上~
3.析构函数没有参数，无法重载
4.程序在销毁对象前会自动调用，但只会调用一次 ；

代码如下（示例）：

#include<bits/stdc++.h>
using namespace std;
//构造函数  进行初始化
class student
{
	public:
	student()
	{
		cout<<"调用构造函数无参"<<endl; 
	 }
	 ~student()
	 {
	 	cout<<"调用析构函数"<<endl;//fun执行完后，进行释放对象操作
	 }
 };
 void fun(){
 	student p;
 } 
int main(){
	fun(); 
	return 0;
} 

2.分类方法

按参数分类： 有参构造和无参构造
按类型分类： 普通构造和拷贝构造
代码如下（示例）：

class student
{
	public:
	int age;
	string name;
	student()
	{
		cout<<"调用构造函数无参"<<endl; //无参构造又叫默认构造 
	 }
	 student(int a)                      //有参构造 
	 {
	 	cout<<"调用构造函数有参"<<endl; 
	 }

	                                    //拷贝函数
	    student(const student &p)
		{
			age= p.age;
			name=p.name;
			cout<<"拷贝函数调用"<<endl; 
		}              

3.调用方法

括号法：
显示法：
隐式转换法：
注意：默认参数构造不加（），student p（）会被当作一个函数的声明
代码如下（示例）：

#include<bits/stdc++.h>
using namespace std;
//构造函数  进行初始化
class student
{
	public:
	int age;
	string name;
	student()
	{
		cout<<"调用构造函数无参"<<endl; //无参构造又叫默认构造 
	 }
	 student(int a)                      //有参构造 
	 {
	 	cout<<"调用构造函数有参"<<endl;
		 cout<<"p2年龄"<<a<<endl; 
	 }

	                                    //拷贝函数
	    student(const student &p)
		{
			age= p.age;
			name=p.name;
			cout<<"拷贝函数调用"<<endl; 
		}                                
										 
	 ~student()
	 {
	 	cout<<"调用析构函数"<<endl;
	 }
 };
 void fun(){
 	student p;
 } 
int main()
{
						//调用
	//1.括号法
//	student p1;      //调用无参构造
//	student p2(10); //调用有参构造
//	student p3(p2); //拷贝构造 
//	cout<<"p2年龄"<<p2.age<<endl;
//	cout<<"p3年龄"<<p3.age<<endl;
	//2.显示法
//student p1;
//student p2=student(10);//有参构造    student（10）匿名对象，当前执行结束后会被立即回收 
//student p3=student(p2);//拷贝构造 		不要利用拷贝函数初始化匿名对象，编译器会认为student（p3）==student p3，是一个对象声明，造成重定义 
	 //3.隐式转换法 
	 student p4=10; //有参构造   student p2=student(10)
	 student p5=p4; //拷贝构造 
	return 0;
} 

3.拷贝函数调用时机

1.使用一个已经创建完毕的对象来初始化一个对象
2.值传递方式给函数参数传值
3.以值方式返回对象

#include<bits/stdc++.h>
using namespace std;
//构造函数  进行初始化
class student
{
	public:

	student()
	{
		cout<<"默认构造函数调用"<<endl; //无参构造又叫默认构造 
	 }
	 
	 student(int a)                      //有参构造 
	 {
	 	age=a; 
	 	cout<<"调用有参构造函数"<<endl;
		 cout<<"p2年龄"<<age<<endl; 
	 }
	 student(const student & p)
	 {
	 	age=p.age;
	 	cout<<"调用拷贝构造函数"<<endl;
	 }
	 int age;
	string name;
	                                    //拷贝函数
		 ~student()
	 {
	 	cout<<"析构函数调用"<<endl;
	 }	 								 
	
 };
                    //使用一个已经创建完毕的对象初始化一个新对象 
 void fun1(){
 	student p1(20);
 	student p2(p1);
 } 
 int main()
{
	fun1();
	return 0;
} 

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

#include<bits/stdc++.h>
using namespace std;
//构造函数  进行初始化
class student
{
	public:

	student()
	{
		cout<<"默认构造函数调用"<<endl; //无参构造又叫默认构造 
	 }
	 
	 student(int a)                      //有参构造 
	 {
	 	age=a; 
	 	cout<<"调用有参构造函数"<<endl;
		 cout<<"p2年龄"<<age<<endl; 
	 }
	 student(const student & p)
	 {
	 	age=p.age;
	 	cout<<"调用拷贝构造函数"<<endl;
	 }
	 int age;
	string name;
	                                    //拷贝函数
		 ~student()
	 {
	 	cout<<"析构函数调用"<<endl;
	 }	 								 
	
 };

                   //用值传递的方法给函数参数传值 
 void dowork(student p){
 	
 }
 void fun2()
 {
 	student p; 
 	dowork(p); //编译器会根据fun2里声明的p，用拷贝函数进行拷贝，传入dowork函数 
 } 
int main()
{
	fun2();
	return 0;
} 

用值传递的方法给函数参数传值
编译器会根据fun2里声明的p，用拷贝函数进行拷贝，传入dowork函数

#include<bits/stdc++.h>
using namespace std;
//构造函数  进行初始化
class student
{
	public:

	student()
	{
		cout<<"默认构造函数调用"<<endl; //无参构造又叫默认构造 
	 }
	 
	 student(int a)                      //有参构造 
	 {
	 	age=a; 
	 	cout<<"调用有参构造函数"<<endl;
		 cout<<"p2年龄"<<age<<endl; 
	 }
	 student(const student & p)
	 {
	 	age=p.age;
	 	cout<<"调用拷贝构造函数"<<endl;
	 }
	 int age;
	                                    //拷贝函数
		 ~student()
	 {
	 	cout<<"析构函数调用"<<endl;
	 }	 								 
	
 };
  student dowork2()
 {
 	student p1;
 	return p1;
 }
 void fun3()
 {
 	student p2=dowork2();
  } 
int main()
{
	fun3();
	return 0;
} 

由于编译器的优化，拷贝函数被调用但不显示

4.构造函数的调用规则

1在默认情况下，编译器至少给一个类添加三个函数

1.默认构造函数（无参，函数体为空）
2.默认析构函数（无参，函数体为空 ）
3.默认拷贝函数，堆属性进行拷贝

2.用户有自定义有参构造函数，c++不在提供默认构造函数，但会提供默认拷贝函数
3.如果用户定义拷贝构造函数，c++不会再提供其他构造函数

#include<bits/stdc++.h>
using namespace std;
//构造函数  进行初始化
class student
{
	public:

	student()
	{
		cout<<"默认构造函数调用"<<endl; //无参构造又叫默认构造 
	 }
	 
	 student(int a)                      //有参构造 
	 {
	 	age=a; 
	 	cout<<"调用有参构造函数"<<endl;
		 cout<<"p2年龄"<<age<<endl; 
	 }
	 student(const student & p)
	 {
	 	age=p.age;
	 	cout<<"调用拷贝构造函数"<<endl;
	 }
	 int age;
	                                    //拷贝函数
		 ~student()
	 {
	 	cout<<"析构函数调用"<<endl;
	 }	 								 
	
 };

 void fun()
 {
 	student p1;
 	 p1.age=18;
	student p2(p1);
	cout<<"p2  "<<p2.age<<endl;
	
  } 
int main()
{
	fun();
	return 0;
} 

当你自己自定义了拷贝函数运行后会显示，如果不自定义，c++帮你定义，但不会给你显示出来

拷贝函数被注释后的运行截图

2.用户有自定义有参构造函数，c++不在提供默认构造函数，但会提供默认拷贝函数

#include<bits/stdc++.h>
using namespace std;
//构造函数  进行初始化
class student
{
	public:
//
//	student()
//	{
//		cout<<"默认构造函数调用"<<endl; //无参构造又叫默认构造 
//	 }
	 
	 student(int a)                      //有参构造 
	 {
	 	age=a; 
	 	cout<<"调用有参构造函数"<<endl;
		 cout<<"p2年龄"<<age<<endl; 
	 }
//	 student(const student & p)
//	 {
//	 	age=p.age;
//	 	cout<<"调用拷贝构造函数"<<endl;
//	 }
	 int age;
	                                    //拷贝函数
		 ~student()
	 {
	 	cout<<"析构函数调用"<<endl;
	 }	 								 
	
 };

 void fun()
 {
 	student p1;
 	 p1.age=18;
	student p2(p1);
	cout<<"p2  "<<p2.age<<endl;
	
  } 
int main()
{
	fun();
	return 0;
} 

当我们写了有参构造函数，注释掉默认构造函数，系统不自动给我们分配默认构造函数，就会报错。

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

直接运行会报错，系统没有分配默认构造函数和有参构造函数

---