C++学习第十四天-类和对象(part 2)-对象的初始化和清理

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

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

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

语法：类名 () {}

注意事项：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;
}

拷贝构造函数调用时机

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

2. 值传递的方式给函数参数传值

3. 以值方式返回局部对象

#include<iostream>

using namespace std;

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

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

	//拷贝构造
	Person3(const Person3& p)
	{
		m_Age = p.m_Age;
		cout << "Person拷贝构造函数的调用" << endl;
	}

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

	int m_Age;
};

//拷贝构造函数调用时机

//1. 使用一个已经创建完毕的对象来初始化一个新对象
void test03()
{
	Person3 p1(20);
	Person3 p2(p1);

	cout << "p2的年龄为：" << p2.m_Age << endl;
}

//2. 值传递的方式给函数参数传值
void doWork(Person3 p)
{

}

void test04()
{
	Person3 p;
	doWork(p);
}

//3. 以值方式返回局部对象
Person3 doWork2()
{
	Person3 p1;
	return p1;
}

void test05()
{
	Person3 p = doWork2();
}

int main3()
{
	//test03();
	//test04();
	test05();

	system("pause");
	return 0;
}

构造函数调用规则

默认情况下，C++编译器至少给一个类添加3个函数

1. 默认构造函数（无参，函数体为空）

2. 默认析构函数（无参，函数体为空）

3. 默认拷贝构造函数，对属性进行值拷贝

构造函数调用规则如下：

如果用户定义有参构造函数，C++不再提供默认无参构造，但是会提供默认拷贝构造

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

#include<iostream>

using namespace std;

//构造函数调用规则

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

//构造函数调用规则如下：
//如果用户定义有参构造函数，C++不再提供默认无参构造，但是会提供默认拷贝构造
//如果用户定义拷贝构造函数，C++不再提供其他构造函数

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

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

	Person4(const Person4& p)
	{
		cout << "Person拷贝构造函数的调用" << endl;
		m_Age = p.m_Age;
	}

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

	int m_Age;
};

void test06()
{
	Person4 p;
	p.m_Age = 18;

	Person4 p2(p);

	cout << "p2的年龄为：" << p2.m_Age << endl;
}

void test07()
{
	Person4 p(28);
	Person4 p2(p);
	cout << "p2的年龄为：" << p2.m_Age << endl;
}

int main4()
{
	//test06();
	test07();

	system("pause");
	return 0;
}

深拷贝与浅拷贝

浅拷贝：简单的赋值拷贝操作

深拷贝：在堆区重新申请空间，进行拷贝操作

#include<iostream>

using namespace std;

//深拷贝与浅拷贝

//浅拷贝：简单的赋值拷贝操作

//深拷贝：在堆区重新申请空间，进行拷贝操作
class Person5
{
public:
	Person5()
	{
		cout << "Person默认构造函数的调用" << endl;
	}

	Person5(int age, int height)
	{
		cout << "Person有参构造函数的调用" << endl;
		m_Height = new int(height);
		m_Age = age;
	}

	//自己实现拷贝构造函数 解决浅拷贝带来的问题
	Person5(const Person5& p)
	{
		cout << "Person拷贝构造函数的调用" << endl;
		m_Age = p.m_Age;
		//m_Height = p.m_Height; //编译器默认实现
		//深拷贝操作
		m_Height = new int(*p.m_Height);
	}

	~Person5()
	{
		//析构代码，将堆区开辟的数据做释放操作
		//浅拷贝带来的问题就是堆区的内存重复释放
		if (m_Height != NULL)
		{
			delete m_Height;
			m_Height = NULL;
		}
		cout << "Person析构函数的调用" << endl;
	}

	int m_Age; //年龄
	int* m_Height; //身高
};

void test08()
{
	Person5 p1(18, 160);
	cout << "p1的年龄为：" << p1.m_Age << endl;
	cout << "p1的身高为：" << *p1.m_Height << endl;

	Person5 p2(p1);
	cout << "p2的年龄为：" << p2.m_Age << endl;
	cout << "p2的身高为：" << *p2.m_Height << endl;

}

int main5()
{
	test08();

	system("pause");
	return 0;
}