C++对象的初始化和清理之构造函数和析构函数分析与实例（一）

class Person
{
public:
	//构造函数
	Person()
	{
		cout << "Person的构造函数调用" << endl;
	}
	//析构函数
	~Person()
	{
		cout << "Person的析构函数调用" << endl;
	}

};

void test01()
{
	Person p;
}

int main() {
	
	test01();

	system("pause");

	return 0;
}

//1、构造函数分类
// 按照参数分类分为 有参和无参构造   无参又称为默认构造函数
// 按照类型分类分为 普通构造和拷贝构造

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

//2、构造函数的调用

void test01() {
    //2.1  括号法（常用）
	Person p1;//调用无参构造函数，默认构造函数的调用
    Person p2(10);//有参构造函数
    Person p3(p2);//拷贝构造函数
	//注意1：调用无参构造函数不能加括号，如果加了编译器认为这是一个函数声明
	//Person p2();

	//2.2 显式法
	Person p2 = Person(10); //相当于给匿名对象Person(10)起个名字叫p2
	Person p3 = Person(p2);
	//Person(10)单独写就是匿名对象（等同于int(10)存于栈上），特点：当前行结束之后，马上析构，即系统立即回收掉匿名对象。

	//2.3 隐式转换法（简化的显示法）
	Person p4 = 10; // Person p4 = Person(10); 
	Person p5 = p4; // Person p5 = Person(p4); 
    //注意2：不能利用 拷贝构造函数 初始化匿名对象 编译器认为是对象声明
	//Person (p5);等同于Person p5；

}

int main() {

	test01();

	system("pause");

	return 0;
}

class Person {
public:
	Person() {
		cout << "无参构造函数!" << endl;
		mAge = 0;
	}
	Person(int age) {
		cout << "有参构造函数!" << endl;
		mAge = age;
	}
	Person(const Person& p) {
		cout << "拷贝构造函数!" << endl;
		mAge = p.mAge;
	}
	//析构函数在释放内存之前调用
	~Person() {
		cout << "析构函数!" << endl;
	}
public:
	int mAge;
};

//1. 使用一个已经创建完毕的对象来初始化一个新对象
void test01() {

	Person man(100); //p对象已经创建完毕
	Person newman(man); //调用拷贝构造函数
	Person newman2 = man; //拷贝构造

	//Person newman3;
	//newman3 = man; //不是调用拷贝构造函数，赋值操作
}

//2. 值传递的方式给函数参数传值
//相当于Person p1 = p;
void doWork(Person p1) 
{}
void test02() {
	Person p; //无参构造函数
	doWork(p);//值传递拷贝新数据
}
//关键：值传递拷贝一份新的数据。先进后出：先是p的构造函数调用，再是p1的拷贝函数的调用，之后是p1的析构函数的调用，再是p的析构函数的调用。

//3. 以值方式返回局部对象
Person doWork2()
{
	Person p1;
	cout << (int *)&p1 << endl;//打印p1的地址
	return p1;//返回的p1是根据p1重新拷贝出来的一份新的数据。所以运行dowork2()后会先是调用构造再调用拷贝构造最后是析构和析构。用值的方式返回相当于拷贝构造。
}

void test03()
{
	Person p = doWork2();
	cout << (int *)&p << endl;//打印p的地址
}
//p1和p不是同一个地址验证了值返回的是一个新的对象。

int main() {

	//test01();
	//test02();
	test03();

	system("pause");

	return 0;
}

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