第四课 类和对象-对象的初始化和清理

4.2对象的初始化和清理
4.2.1构造函数和析构函数
C++通过构造函数和析构函数对对象进行初始化及使用完后的及时清理
如果不提供构造和析构函数，编译器会提供，但编译器提供的函数是空实现的

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

构造函数语法：类名(){}
1.构造函数没有返回值也不写void
2.函数名与类名相同
3.构造函数可以有参数，因此可以发成重载
4.程序在调用对象时候会自动调用构造，无需手动调用，而且只调用一次

析构函数语法：~类名(){}
1.析构函数没有返回值也不写void
2.函数名与类名相同，在类名前加~
3.析构函数不可以有参数，因此不能发生重载
4.程序在对象销毁前会自动调用析构，无需手动调用，而且只会调用一次

class Person
{
public:

	Person()
	{
		cout << "Person 构造函数调用" << endl;
	}

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

void test()
{
	Person p;  //栈区数据，test()执行完后，释放该对象
}

int main()
{
	//test();
	Person p1;

	system("pause");
	return 0;
}

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

//1.构造函数的分类及调用
//分类
//    按参数分类    无参构造和有参构造
class Person
{
public:
	//构造函数
	Person()
	{
		cout << "Person 无参（默认）构造函数调用" << endl;
	}
	Person(int a)
	{
		m_Age = a;
		cout << "Person 有参构造函数调用" << endl;
	}
	Person(const Person &p)
	{
		m_Age = p.m_Age;
		cout << "Person 拷贝构造函数调用" << endl;
	}

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

	int m_Age;
};

void test01()
{
	// 1.括号法
	//Person p1;
	//Person p2(10);
	//Person p3(p2);

	// 注意：调用默认构造函数时，不要加(),否则编译器会认为是一个函数的声明，不会在认为创建对象
	
	// 2.显示法
	//Person p1;
	//Person p2 = Person(10);
	//Person p3 = Person(p2);

	//Person(10)  // 匿名对象  特点：当前执行结束后，系统会立刻收回匿名对象
	//注意：不要利用拷贝构造函数 初始化匿名对象 编译器会认为 Person(p3) === Person p3

	// 3.隐式转换法
	Person p2 = 10;  // 相当于Person p2 = Person(10);
	Person p3 = p2;


}

int main()
{
	test01();

	system("pause");
	return 0;
}

4.2.3拷贝构造函数调用时机
1.使用一个已经创建完毕的对象来初始化一个新对象
2.值传递的方式给函数参数传值
3.值方式返回局部对象

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

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

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

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

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

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

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

}

void test02()
{
	Person p;
	dowork01(p);
}

// 3.值方式返回局部对象
Person dowork02()
{
	Person p1;
	cout << (int)&p1 << endl;
	return p1;
}

void test03()
{
	Person p = dowork02();
	cout << (int)&p << endl;

}

int main()
{
	//test01();
	//test02();
	test03();

	system("pause");
	return 0;
}

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

构造函数调用规则如下：

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

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

class Person
{
public:
	// 有参构造函数
	Person(int age, int height)
	{
		m_Age = age;
		m_Height = new int(height);
		cout << "Person 有参构造函数" << endl;
	}

	Person(const Person &p)
	{
		m_Age = p.m_Age;
		// m_Height = *p.m_Height; // 编译器默认实现这段代码
		m_Height = new int(*p.m_Height);
		cout << "Person 拷贝构造函数" << endl;
	}

	~Person()
	{
		// 析构代码，将堆区开辟数据做释放操作
		if (m_Height != NULL)
		{
			delete m_Height;
			m_Height = NULL;
		}
		cout << "Person 析构函数" << endl;
	}

	int m_Age;
	int * m_Height;
};

void test()
{
	Person p1(10,160);

	cout << "p1的age：" << p1.m_Age << " heignt：" << *p1.m_Height << endl;

	Person p2(p1);

	cout << "p2的age：" << p2.m_Age << " heignt：" << *p2.m_Height << endl;
}

int main()
{
	test();
	system("pause");
	return 0;
}

4.2.6 初始化列表
作用：C++提供了初始化列表语法，用来初始化属性
语法：构造函数():属性1(值1),属性2(值2),...

Person():m_A(10),m_B(25)
{}

Person(int a,int b):m_A(a),m_B(b)
{}

4.2.7 类对象作为类成员
C++类中的成员可以是另一个类的成员，我们称该成员为对象成员

class Phone
{
public:
	Phone(string phone_name):m_PhoneName(phone_name)
	{
		cout << "Phone 有参构造函数" << endl;
	}
	~Phone()
	{
		cout << "Phone 析构函数" << endl;
	}
	string m_PhoneName;
};

class Person
{
public:
	// m_PhoneName = phone_name 隐式转换法
	Person(string name,string phone_name):m_Name(name),m_PhoneName(phone_name)
	{
		cout << "Person 有参构造函数" << endl;
	}
	~Person()
	{
		cout << "Person 析构函数" << endl;
	}
	string m_Name;
	Phone m_PhoneName;
	// 构造调用顺序 先调用对象成员的构造，再调用本类构造；析构调用顺序相反
};

void test()
{
	Person p("张三", "iphoneX");
	cout << p.m_Name << "拿着" << p.m_PhoneName.m_PhoneName << "手机" << endl;
}

4.2.8 静态成员
静态成员就是在成员变量和成员函数前加上关键字static，称谓静态成员
静态成员分为：

• 静态成员变量：所有对象共享同一份数据；在编译阶段分配内存；类内声明，类外初始化；

class Person
{
public:
	// 类内声明
	static string m_Name;
};
// 类外初始化
string Person::m_Name = "张三";

int main()
{
	Person p1;

	cout << p1.m_Name << endl;  // 张三

	Person p2;
	p2.m_Name = "新之助";
	cout << p2.m_Name << endl;  // 新之助

	system("pause");
	return 0;
}

• 静态成员函数：所有对象共享同一个函数；静态成员函数只能访问静态成员变量；

class Person
{
public:
	static void func()
	{
		//m_Name = "张三";  // 报错，因为m_Name 不是静态成员变量
		m_Number = 250;
		cout << "static void func 调用" << endl;
	}

	int m_Name;
	static int m_Number;
};
int Person::m_Number = 100;

// 两种访问方式
void test01()
{
	Person p1;
	// 1.通过对象
	p1.func();
	// 2.通过类名
	Person::func();

}

int main()
{
	test01();
	system("pause");
	return 0;
}