对象特性：构造函数和析构函数

对象的初始化和清理是两个很重要的安全问题

构造函数：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用

语法：类名 () {}

注意事项：1. 构造函数，没有返回值也不写void

2. 函数名称与类名相同

3. 构造函数可以有参数，因此可以发生重载

4. 程序在调用对象时会自动调用构造，无须手动调用，而且只会调用一次

析构函数：主要作用在于对象销毁前系统自动调用，执行一些清理工作

语法：~类名 () {}

注意事项：1. 析构函数，没有返回值也不写void

2. 函数名称与类名相同，在名称前面加上~

3. 析构函数不可以有参数，因此不可以发生重载

4. 程序在销毁对象前会自动调用析构，无须手动调用，而且只会调用一次

#include<iostream>

using namespace std;

//对象的初始化和清理
//1. 构造函数进行初始化操作
//2. 析构函数进行清洗操作
class Person
{
public:
	//1.1. 构造函数，没有返回值也不写void
	//1.2. 函数名称与类名相同
	//1.3. 构造函数可以有参数，因此可以发生重载
	//1.4. 程序在调用对象时会自动调用构造，无须手动调用，而且只会调用一次
	Person()
	{
		cout << "Person构造函数的调用" << endl;
	}
	//2.1. 析构函数，没有返回值也不写void
	//2.2. 函数名称与类名相同，在名称前面加上~
	//2.3. 析构函数不可以有参数，因此不可以发生重载
	//2.4. 程序在销毁对象前会自动调用析构，无须手动调用，而且只会调用一次
	~Person()
	{
		cout << "Person析构函数的调用" << endl;
	}
};

//构造和析构都是必须有的实现，如果我们自己不提供，编译器会提供一个空实现的构造和析构
void test01()
{
	Person p; //栈区的数据，test01执行完毕后会释放这个对象
}

int main1()
{
	test01();

	//Person p;

	system("pause");
	return 0;
}

构造函数的分类及调用

两种分类方式：

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

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

三种调用方式：

括号法、显示法、隐式转换法

#include<iostream>

using namespace std;

//构造函数的分类及调用

//两种分类方式：
//按参数分为：有参构造和无参构造
//按类型分为：普通构造和拷贝构造

//三种调用方式：
//括号法、显示法、隐式转换法

class Person2
{
public:
	//构造函数
	//无参构造/默认构造
	Person2()
	{
		cout << "Person无参构造函数的调用" << endl;
	}

	//有参构造
	Person2(int a)
	{
		age = a;
		cout << "Person有参构造函数的调用" << endl;
	}

	//拷贝构造
	Person2(const Person2 &p)
	{
		//将传入的人身上的所有属性，拷贝到我身上
		age = p.age;
		cout << "Person拷贝构造函数的调用" << endl;
	}

	//析构函数
	~Person2()
	{
		cout << "Person析构函数的调用" << endl;
	}

	int age;
};

void test02()
{
	//1. 括号法
	//Person2 p1; //默认（无参）构造函数的调用
	//Person2 p2(10); //有参构造函数的调用
	//Person2 p3(p2); //拷贝构造函数的调用

	//注意事项1：调用默认构造函数时不要加小括号
	//因为下面这行代码，编译器会认为是一个函数的声明，不会认为在创建对象
	//Person2 p1();
	//void func();

	/*cout << "p2的年龄为：" << p2.age << endl;
	cout << "p3的年龄为：" << p3.age << endl;*/

	//2. 显示法
	Person2 p1; //默认（无参）构造函数的调用
	Person2 p2 = Person2(10); //有参构造函数的调用
	Person2 p3 = Person2(p2); //拷贝构造函数的调用

	//Person2(10); //匿名对象，特点：当前行执行结束后，系统会立即回收匿名对象

	//注意事项2：不要利用拷贝构造函数初始化匿名对象，编译器会认为Person2(p3) === Person2 p3;对象声明
	//Person2(p3); //重定义
	
	//3. 隐式转换法
	Person2 p4 = 10; //相当于写了Person p4 = Person(10); //有参构造函数的调用
	Person2 p5 = p4; //拷贝构造函数的调用
}

int main2()
{
	test02();

	system("pause");
	return 0;
}