2021-04-10

构造函数和析构函数

构造函数：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用。
析构函数：主要作用在于对象销毁前系统自动调用，执行一些清理工作。

1.1构造函数语法:类名(){}

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

1.2析构函数语法:~类名(){}

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

#include<iostream>
using namespace std;
//对象的初始化和清理
class Person
{
	public:
	Person()  //1.构造函数进行初始化操作
	{
		cout<<"Person构造函数的调用"<<endl;
	}
	~Person()  //2.析构函数 
	{
		cout<<"Person析构函数的调用"<<endl;
	}
}; 
void test1()
{
	Person p;
}
int main()
{
	test1();
}

1.3构造函数的分类及调用

两种分类方式：
按参数分为：有参构造和无参构造
按类型分为：普通构造和拷贝构造
三种调用方式：
括号法 ， 显示法 ， 隐式转换法

#include<iostream>
using namespace std;
//构造函数的分类及调用
//按照参数分类   无参构造(默认构造)和有参构造 
//按照类型分类   普通构造   拷贝构造 
class Person
{
	public:
	Person() //构造函数 
	{
		cout<<"Person的无参构造函数的调用"<<endl;
	}
	Person(int a) 
	{
		age=a;
		cout<<"Person的有参构造函数的调用"<<endl;
	}
	//拷贝构造函数
	Person(const Person &p)
    {
    	cout<<"Person的拷贝构造函数调用"<<endl; //将传入的人身上所有属性拷贝到我身上
    	age=p.age;  
	    
	}
	~Person() 
	{
		cout<<"Person的析构函数调用"<<endl;
	}
	int age;
	
}; 
//调用 
void test1()
{
	//1.括号法 
	//Person p1; //默认构造函数调用 
	//Person p2(10); //有参构造函数调用
	//Person p3(p2); //拷贝构造函数调用 
	//调用默认构造函数时，不要加()，因为编译器会认为时一个函数声明，不会认为在创建对象 
	//cout<<"p2的年龄:"<<p2.age<<endl;
	//cout<<"p3的年龄:"<<p3.age<<endl;
    //2.显示法
	Person p1; 
	Person p2=Person(10);//有参构造  
	//Person(10)是匿名对象，特点：当前执行结束后，系统会立即回收掉匿名对象
	Person p3=Person(p2);// 拷贝构造 
	//不要利用拷贝构造函数初始化匿名对象，编译器会认为Person(p3)==Person p3；对象声明(重定义) 
	//3.隐式转换法
	Person p4=10; //相当于写了Person p4=Person(10); 有参构造
	Person p5=p4; //拷贝构造 
}
int main()
{
	test1();
	return 0;
}

1.4拷贝构造函数的调用时机

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

#include<iostream>
using namespace std;
class Person
{
	public:
		Person()
		{
			cout<<"Person默认构造函数的调用"<<endl;
		}
		Person(int age)
		{
			cout<<"Person有参构造函数的调用"<<endl;
			m_age=age;
		}
		Person(const Person &p)
		{
			cout<<"Person拷贝构造函数的调用"<<endl;
			m_age=p.m_age;
		}
		~Person()
		{
			cout<<"Person析构函数的调用"<<endl;
		}
		int m_age;
};
//1.使用一个已经创建完毕的对象来初始化一个新对象
void test1()
{
	Person p1(20);
	Person p2(p1);
	cout<<"p2的年龄:"<<p2.m_age<<endl;
} 
//2.值传递的方式给函数参数传值
void work(Person p)
{
	
}
void test2()
{
	Person p;
	work(p);
} 
//3.值方式返回局部对象 
Person work2()
{
	Person p1;
	return p1;
} 
void test3()
{
	Person p=work2(); 
}
int main()
{
	//test1();
	//test2();
	test3();
	return 0;
}

1.5构造函数调用的规则

默认情况下，c++编译器至少给一个类添加3个函数
1.默认构造函数(无参，函数体为空)
2.默认析构函数(无参，函数体为空)
3.默认拷贝构造函数，对属性进行值拷贝

调用规则：

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

#include<iostream>
using namespace std;
class Person
{
	public:
		Person()
		{
			cout<<"Person默认构造函数的调用"<<endl;
		}
		Person(int age)
		{
			cout<<"Person 的有参构造函数调用"<<endl;
			m_age=age;
		}
		Person(const Person &p)
		{
			cout<<"Person的拷贝构造函数调用"<<endl;
			m_age=p.m_age;
		}
		~Person()
		{
			cout<<"Person析构函数的调用"<<endl;
		}
		int m_age;
};
void test1()
{
	Person p;
	p.m_age=18;
	Person p2(p);
	cout<<"p2的年龄:"<<p2.m_age<<endl;
} 
void test2()
{
	Person p(28);
	Person p2(p);
	cout<<"p2的年龄:"<<p2.m_age<<endl;
} 
int main()
{
	//test1();
	test2();
	return 0;
}

1.6深拷贝与浅拷贝

浅拷贝：简单的赋值操作
深拷贝：在堆区重新申请空间，进行拷贝操作

#include<iostream>
using namespace std;
class Person
{
	public:
		Person()
		{
			cout<<"Person默认构造函数的调用"<<endl;
		}
		Person(int age,int height)
		{
			m_age=age;
			m_Height=new int(height);
			cout<<"Person的有参构造函数调用"<<endl;
		}
		//自己实现拷贝构造函数，解决浅拷贝带来的问题
		Person(const Person &p)
		{
			cout<<"Person拷贝构造函数调用"<<endl;
			m_age=p.m_age;
			//m_Height=p.m_Height; 编译器默认实现就是这行代码
			//深拷贝操作
			m_Height=new int(*p.m_Height); 
	    }
		~Person()
		{
			//析构代码，将堆区开辟数据做释放操作
			if(m_Height!=NULL)
			{
				delete m_Height;
				m_Height=NULL;
			} 
			cout<<"Person析构函数的调用"<<endl;
		}
		int m_age;
		int *m_Height;
};
void test1()
{
	Person p1(18,160);
	cout<<"p1的年龄:"<<p1.m_age<<"身高为:"<<*p1.m_Height<<endl;
	Person p2(p1);
	cout<<"p2的年龄:"<<p2.m_age<<"身高为:"<<*p2.m_Height<<endl;
} 
int main()
{
	test1();
	return 0;
}