C++核心編程_04類和對象

4 類和對象

C++面向對象的三大特性爲：封裝、繼承、多態

C++認爲萬事萬物都皆爲對象，對象上有其屬性和行爲

例如：

人可以作爲對象，屬性有姓名、年齡、身高、體重…，行爲有走、跑、跳、吃飯、唱歌…

車也可以作爲對象，屬性有輪胎、方向盤、車燈…,行爲有載人、放音樂、放空調…

具有相同性質的對象，我們可以抽象稱爲類，人屬於人類，車屬於車類

4.1 封裝

4.1.1 封裝的意義

封裝是C++面向對象三大特性之一

封裝的意義：

將屬性和行爲作爲一個整體，表現生活中的事物
將屬性和行爲加以權限控制

封裝意義一：

在設計類的時候，屬性和行爲寫在一起，表現事物

語法： class 類名{ 訪問權限：屬性 / 行爲 };

示例1：設計一個圓類，求圓的周長

示例代碼：

//圓周率
const double PI = 3.14;

//1、封裝的意義
//將屬性和行爲作爲一個整體，用來表現生活中的事物

//封裝一個圓類，求圓的周長
//class代表設計一個類，後面跟着的是類名
class Circle
{
public:  //訪問權限  公共的權限（public讓參數在類內類外都可以訪問）

	//屬性
	int m_r;//半徑

	//行爲
	//獲取到圓的周長
	double calculateZC()
	{
		//2 * pi  * r
		//獲取圓的周長
		return  2 * PI * m_r;
	}
};

int main() {

	//通過圓類，創建圓的對象
	// c1就是一個具體的圓
	Circle c1;
	c1.m_r = 10; //給圓對象的半徑 進行賦值操作

	//2 * pi * 10 = = 62.8
	cout << "圓的周長爲： " << c1.calculateZC() << endl;

	system("pause");

	return 0;
}

示例2：設計一個學生類，屬性有姓名和學號，可以給姓名和學號賦值，可以顯示學生的姓名和學號

示例2代碼：

//學生類
class Student {
public:
	void setName(string name) {    //給姓名賦值
		m_name = name;
	}
	void setID(int id) {
		m_id = id;
	}

	void showStudent() {   //顯示姓名和學號
		cout << "name:" << m_name << " ID:" << m_id << endl;
	}
public:  //屬性
	string m_name;
	int m_id;
};

int main() {

	Student stu;
	stu.setName("德瑪西亞");
	stu.setID(250);
	stu.showStudent();

	system("pause");

	return 0;
}

封裝意義二：

類在設計時，可以把屬性和行爲放在不同的權限下，加以控制

訪問權限有三種：

public 公共權限
protected 保護權限
private 私有權限

示例：

//三種權限
//公共權限  public     類內可以訪問  類外可以訪問
//保護權限  protected  類內可以訪問  類外不可以訪問（兒子可以訪問父親中的保護內容）
//私有權限  private    類內可以訪問  類外不可以訪問(兒子不可以訪問父親的私有內容)

class Person
{
	//姓名  公共權限
public:
	string m_Name;

	//汽車  保護權限
protected:
	string m_Car;

	//銀行卡密碼  私有權限
private:
	int m_Password;

public:
	void func()    //函數也有權限
	{
		m_Name = "張三"; 
		m_Car = "拖拉機";
		m_Password = 123456;
	}
};

int main() {

	Person p;
	p.m_Name = "李四";
	//p.m_Car = "奔馳";  //保護權限類外訪問不到
	//p.m_Password = 123; //私有權限類外訪問不到

	system("pause");

	return 0;
}

4.1.2 struct和class區別

在C++中 struct和class唯一的區別就在於 默認的訪問權限不同

區別：

struct （結構體）默認權限爲公共
class 默認權限爲私有

class C1
{
	int  m_A; //默認是私有權限
};

struct C2
{
	int m_A;  //默認是公共權限
};

int main() {

	C1 c1;
	c1.m_A = 10; //錯誤，訪問權限是私有

	C2 c2;
	c2.m_A = 10; //正確，訪問權限是公共

	system("pause");

	return 0;
}

4.1.3 成員屬性設置爲私有

優點1：將所有成員屬性設置爲私有，可以自己控制讀寫權限

優點2：對於寫權限，我們可以檢測數據的有效性

示例：

#include <string>

class Person {
public:

	//姓名設置可讀可寫
	void setName(string name) {
		m_Name = name;
	}
    //獲取姓名
	string getName()
	{
		return m_Name;
	}

	//獲取年齡 
	int getAge() {
		return m_Age;
	}
	//設置年齡
	void setAge(int age) {
		if (age < 0 || age > 150) {
			cout << "你個老妖精!" << endl;
			return;
		}
		m_Age = age;
	}

	//情人設置爲只寫
	void setLover(string lover) {
		m_Lover = lover;
	}

private:
	string m_Name; //可讀可寫  姓名
	
	int m_Age; //只讀  年齡

	string m_Lover; //只寫  情人
};


int main() {

	Person p;
	//姓名設置
	p.setName("張三");
	cout << "姓名： " << p.getName() << endl;

	//年齡設置
	p.setAge(50);
	cout << "年齡： " << p.getAge() << endl;

	//情人設置
	p.setLover("蒼井");
	//cout << "情人： " << p.m_Lover << endl;  //只寫屬性，不可以讀取

	system("pause");

	return 0;
}

練習案例1：設計立方體類

設計立方體類(Cube)

求出立方體的面積和體積

分別用全局函數和成員函數判斷兩個立方體是否相等。

練習案例2：點和圓的關係

設計一個圓形類（Circle），和一個點類（Point），計算點和圓的關係。

4.2 對象的初始化和清理

生活中我們買的電子產品都基本會有出廠設置，在某一天我們不用時候也會刪除一些自己信息數據保證安全
C++中的面向對象來源於生活，每個對象也都會有初始設置以及對象銷燬前的清理數據的設置。

4.2.1 構造函數和析構函數

對象的初始化和清理也是兩個非常重要的安全問題

一個對象或者變量沒有初始狀態，對其使用後果是未知

同樣的使用完一個對象或變量，沒有及時清理，也會造成一定的安全問題

c++利用了構造函數和析構函數解決上述問題，這兩個函數將會被編譯器自動調用，完成對象初始化和清理工作。

對象的初始化和清理工作是編譯器強制要我們做的事情，因此如果我們不提供構造和析構，編譯器會提供

編譯器提供的構造函數和析構函數是空實現。

構造函數：主要作用在於創建對象時爲對象的成員屬性賦值，構造函數由編譯器自動調用，無須手動調用。
析構函數：主要作用在於對象銷燬前系統自動調用，執行一些清理工作。

構造函數語法：類名(){}

構造函數，沒有返回值也不寫void
函數名稱與類名相同
構造函數可以有參數，因此可以發生重載
程序在調用對象時候會自動調用構造，無須手動調用,而且只會調用一次

析構函數語法： ~類名(){}

析構函數，沒有返回值也不寫void
函數名稱與類名相同,在名稱前加上符號 ~
析構函數不可以有參數，因此不可以發生重載
程序在對象銷燬前會自動調用析構，無須手動調用,而且只會調用一次

class Person
{
public:
	//構造函數
	Person()
	{
		cout << "Person的構造函數調用" << endl;
	}
	//析構函數
	~Person()
	{
		cout << "Person的析構函數調用" << endl;
	}

};

//構造和析構都是必須有的實現，如果我們自己不提供，編譯器會提供一個空實現的構造和析構
void test01()   //測試用例
{
	Person p; //局部變量，在棧上的數據，test01執行完畢後，釋放這個對象
}

int main() {
	
    //Person p; //main函數中的對象，等到代碼結束纔會釋放對象，自動調用析構函數
    
	test01();   //會自動調用構造函數，且只會調用一次，調用完對象就會被釋放，會調用析構代碼

	system("pause");

	return 0;
}

4.2.2 構造函數的分類及調用

兩種分類方式：

按參數分爲：有參構造和無參構造

按類型分爲：普通構造和拷貝構造

三種調用方式：

括號法

顯示法

隱式轉換法

示例：

//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() {
	Person p; //調用無參構造函數
}

//調用有參的構造函數
void test02() {

	//2.1  括號法，常用
	//Person p1;  //默認構造函數調用
    Person p2(10);  //有參構造函數
    Person p3(p2);  //拷貝構造函數
	//注意1：調用無參構造函數不能加括號，如果加了編譯器認爲這是一個函數聲明，不會認爲在創建對象
	//Person p2();

	//2.2 顯式法
    Person p1;
	Person p2 = Person(10);  //有參構造
	Person p3 = Person(p2);  //拷貝構造
	//Person(10)單獨寫就是匿名對象  特點：當前行結束之後，馬上析構

	//2.3 隱式轉換法
	Person p4 = 10; // Person p4 = Person(10); 
	Person p5 = p4; // Person p5 = Person(p4); 

	//注意2：不能利用 拷貝構造函數 初始化匿名對象 編譯器認爲是對象聲明
	//Person p5(p4);
}

int main() {

	test01();
	//test02();

	system("pause");

	return 0;
}

4.2.3 拷貝構造函數調用時機

C++中拷貝構造函數調用時機通常有三種情況

使用一個已經創建完畢的對象來初始化一個新對象
值傳遞的方式給函數參數傳值
以值方式返回局部對象

示例：

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);  //值傳遞，修改形參不會影響實參
}

//3. 以值方式返回局部對象
Person doWork2()
{
	Person p1; //局部對象，調用完就會被釋放
	cout << (int *)&p1 << endl;
	return p1;
}

void test03()
{
	Person p = doWork2();
	cout << (int *)&p << endl;
}


int main() {

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

	system("pause");

	return 0;
}

4.2.4 構造函數調用規則

默認情況下，c++編譯器至少給一個類添加3個函數

1．默認構造函數(無參，函數體爲空)

2．默認析構函數(無參，函數體爲空)

3．默認拷貝構造函數，對屬性進行值拷貝

構造函數調用規則如下：

如果用戶定義有參構造函數，c++不在提供默認無參構造，但是會提供默認拷貝構造
如果用戶定義拷貝構造函數，c++不會再提供其他構造函數

示例：

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

4.2.5 深拷貝與淺拷貝

深淺拷貝是面試經典問題，也是常見的一個坑

淺拷貝：簡單的賦值拷貝操作（比如編譯器寫的拷貝構造函數）

深拷貝：在堆區重新申請空間，進行拷貝操作

示例：

class Person {
public:
	//無參（默認）構造函數
	Person() {
		cout << "無參構造函數!" << endl;
	}
	//有參構造函數
	Person(int age ,int height) {
		
		cout << "有參構造函數!" << endl;

		m_age = age;
		m_height = new int(height);
		
	}
	//拷貝構造函數來解決淺拷貝帶來的問題  
	Person(const Person& p) {
		cout << "拷貝構造函數!" << endl;
		//如果不利用深拷貝在堆區創建新內存，會導致淺拷貝帶來的重複釋放堆區問題
		m_age = p.m_age;
        //m_height = p.m_height;  編譯器默認實現就是這個代碼
        //自己實現的深拷貝
		m_height = new int(*p.m_height);
		
	}

	//析構函數
	~Person() {
        //析構代碼，將堆區開闢數據做釋放操作
		cout << "析構函數!" << endl;
		if (m_height != NULL)
		{
			delete m_height;
		}
	}
public:
	int m_age;
	int* m_height;
};

void test01()
{
	Person p1(18, 180);

	Person p2(p1);

	cout << "p1的年齡： " << p1.m_age << " 身高： " << *p1.m_height << endl;

	cout << "p2的年齡： " << p2.m_age << " 身高： " << *p2.m_height << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

總結：如果屬性有在堆區開闢的，一定要自己提供拷貝構造函數，防止淺拷貝帶來的問題

4.2.6 初始化列表

作用：

C++提供了初始化列表語法，用來初始化屬性

語法：構造函數()：屬性1(值1),屬性2（值2）... {}

示例：

class Person {
public:

	////傳統方式初始化
	//Person(int a, int b, int c) {
	//	m_A = a;
	//	m_B = b;
	//	m_C = c;
	//}

	//初始化列表方式初始化
	Person(int a, int b, int c) :m_A(a), m_B(b), m_C(c) {}
	void PrintPerson() {
		cout << "mA:" << m_A << endl;
		cout << "mB:" << m_B << endl;
		cout << "mC:" << m_C << endl;
	}
private:
	int m_A;
	int m_B;
	int m_C;
};

int main() {

	Person p(1, 2, 3);
	p.PrintPerson();


	system("pause");

	return 0;
}

4.2.7 類對象作爲類成員

C++類中的成員可以是另一個類的對象，我們稱該成員爲對象成員

例如：

class A {}
class B
{
    A a；
}

B類中有對象A作爲成員，A爲對象成員

那麼當創建B對象時，A與B的構造和析構的順序是誰先誰後？

示例：

#include <string>

class Phone
{
public:
	Phone(string name)
	{
		m_PhoneName = name;
		cout << "Phone構造" << endl;
	}

	~Phone()
	{
		cout << "Phone析構" << endl;
	}

	string m_PhoneName;

};


class Person
{
public:

	//初始化列表可以告訴編譯器調用哪一個構造函數
    //Phone m_Phone =pName  隱式轉換法
	Person(string name, string pName) :m_Name(name), m_Phone(pName)//Phone m_Phone =pName
	{
		cout << "Person構造" << endl;
	}

	~Person()
	{
		cout << "Person析構" << endl;
	}

	void playGame()
	{
		cout << m_Name << " 使用" << m_Phone.m_PhoneName << " 牌手機! " << endl;
	}

	string m_Name;
	Phone m_Phone;

};
void test01()
{
	//當類中成員是其他類對象時，我們稱該成員爲 對象成員
	//構造的順序是 ：先調用對象成員的構造，再調用本類構造
	//析構順序與構造相反
	Person p("張三" , "蘋果X");
	p.playGame();

}


int main() {

	test01();

	system("pause");

	return 0;
}

4.2.8 靜態成員

靜態成員就是在成員變量和成員函數前加上關鍵字static，稱爲靜態成員

靜態成員分爲：

靜態成員變量
- 所有對象共享同一份數據
- 在編譯階段分配內存
- 類內聲明，類外初始化
靜態成員函數
- 所有對象共享同一個函數
- 靜態成員函數只能訪問靜態成員變量

示例1 ：靜態成員變量

class Person
{
	
public:

	static int m_A; //靜態成員變量

	//靜態成員變量特點：
	//1 在編譯階段分配內存
	//2 類內聲明，類外初始化
	//3 所有對象共享同一份數據

private:
	static int m_B; //靜態成員變量也是有訪問權限的
};
int Person::m_A = 10;
int Person::m_B = 10;

void test01()
{
	//靜態成員變量兩種訪問方式

	//1、通過對象
	Person p1;
	p1.m_A = 100;
	cout << "p1.m_A = " << p1.m_A << endl;

	Person p2;
	p2.m_A = 200;
	cout << "p1.m_A = " << p1.m_A << endl; //共享同一份數據
	cout << "p2.m_A = " << p2.m_A << endl;

	//2、通過類名
	cout << "m_A = " << Person::m_A << endl;


	//cout << "m_B = " << Person::m_B << endl; //私有權限訪問不到
}

int main() {

	test01();

	system("pause");

	return 0;
}

示例2：靜態成員函數

class Person
{

public:

	//靜態成員函數特點：
	//1 程序共享一個函數
	//2 靜態成員函數只能訪問靜態成員變量
	
	static void func()
	{
		cout << "func調用" << endl;
		m_A = 100;
		//m_B = 100; //錯誤，不可以訪問非靜態成員變量，無法區分是那個對象的m_b屬性
	}

	static int m_A; //靜態成員變量
	int m_B; // 
private:

	//靜態成員函數也是有訪問權限的
	static void func2()
	{
		cout << "func2調用" << endl;
	}
};
int Person::m_A = 10;


void test01()
{
	//靜態成員變量兩種訪問方式

	//1、通過對象
	Person p1;
	p1.func();

	//2、通過類名
	Person::func();


	//Person::func2(); //私有權限訪問不到
}

int main() {

	test01();

	system("pause");

	return 0;
}

4.3 C++對象模型和this指針

4.3.1 成員變量和成員函數分開存儲

在C++中，類內的成員變量和成員函數分開存儲

只有非靜態成員變量才屬於類的對象上

class Person {
public:
	Person() {
		mA = 0;
	}
	//非靜態成員變量佔對象空間,按照int分配內存
	int mA;
	//靜態成員變量不佔對象空間，不屬於類對象上
	static int mB; 
	//函數也不佔對象空間，所有函數共享一個函數實例
	void func() {
		cout << "mA:" << this->mA << endl;
	}
	//靜態成員函數也不佔對象空間
	static void sfunc() {
	}
};

void test01(){
    Person p;
    //空對象佔用內存空間：1
    //c++編譯器會給每個空對象分配一個字節空間，是爲了區分空對象佔用內存的位置
    //每個空對象也應該有一個獨一無二的內存地址；
    cout << "size of p" << sizeof(p) << endl;
}


int main() {

    //test01();
    
	cout << sizeof(Person) << endl;

	system("pause");

	return 0;
}

4.3.2 this指針概念

通過4.3.1我們知道在C++中成員變量和成員函數是分開存儲的

每一個非靜態成員函數只會誕生一份函數實例，也就是說多個同類型的對象會共用一塊代碼

那麼問題是：這一塊代碼是如何區分那個對象調用自己的呢？

c++通過提供特殊的對象指針，this指針，解決上述問題。this指針指向被調用的成員函數所屬的對象

this指針是隱含每一個非靜態成員函數內的一種指針

this指針不需要定義，直接使用即可

this指針的用途：

當形參和成員變量同名時，可用this指針來區分
在類的非靜態成員函數中返回對象本身，可使用return *this

class Person
{
public:

	Person(int age)
	{
		//1、當形參和成員變量同名時，可用this指針來區分,**this指針指向被調用的成員函數所屬的對象**
		this->age = age;
	}

	Person& PersonAddPerson(Person p)  //引用返回元對象，不用引用會返回新的對象
	{
		this->age += p.age;
		//this指向p2的指針，而*this指向的就是p2對象本身
		return *this;
	}

	int age;
};

void test01()
{
	Person p1(10);
	cout << "p1.age = " << p1.age << endl;

	Person p2(10);
    //鏈式編程思想
	p2.PersonAddPerson(p1).PersonAddPerson(p1).PersonAddPerson(p1);
	cout << "p2.age = " << p2.age << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

4.3.3 空指針訪問成員函數

C++中空指針也是可以調用成員函數的，但是也要注意有沒有用到this指針

如果用到this指針，需要加以判斷保證代碼的健壯性

示例：

//空指針訪問成員函數
class Person {
public:

	void ShowClassName() {
		cout << "我是Person類!" << endl;
	}

	void ShowPerson() {
		if (this == NULL) {
			return;
		}
        //報錯原因是因爲傳入的指針爲Null
		cout << mAge << endl;
	}

public:
	int mAge;
};

void test01()
{
	Person * p = NULL;
	p->ShowClassName(); //空指針，可以調用成員函數
	p->ShowPerson();  //但是如果成員函數中用到了this指針，就不可以了
}

int main() {

	test01();

	system("pause");

	return 0;
}

4.3.4 const修飾成員函數

常函數：

成員函數後加const後我們稱爲這個函數爲常函數
常函數內不可以修改成員屬性
成員屬性聲明時加關鍵字mutable後，在常函數中依然可以修改

常對象：

聲明對象前加const稱該對象爲常對象
常對象只能調用常函數

示例：

class Person {
public:
	Person() {
		m_A = 0;
		m_B = 0;
	}

	//this指針的本質是一個指針常量，指針的指向不可修改
	//如果想讓指針指向的值也不可以修改，需要聲明常函數
	void ShowPerson() const {
		//const Type* const pointer;
		//this = NULL; //不能修改指針的指向 Person* const this;
		//this->mA = 100; //但是this指針指向的對象的數據是可以修改的

		//const修飾成員函數，表示指針指向的內存空間的數據不能修改，除了mutable修飾的變量
		this->m_B = 100;
	}

	void MyFunc() const {
		//mA = 10000;
	}

public:
	int m_A;
	mutable int m_B; //可修改 可變的
};


//const修飾對象  常對象
void test01() {

	const Person person; //常量對象  
	cout << person.m_A << endl;
	//person.mA = 100; //常對象不能修改成員變量的值,但是可以訪問
	person.m_B = 100; //但是常對象可以修改mutable修飾成員變量

	//常對象訪問成員函數
	person.MyFunc(); //常對象不能調用const的函數

}

int main() {

	test01();

	system("pause");

	return 0;
}

4.4 友元

生活中你的家有客廳(Public)，有你的臥室(Private)

客廳所有來的客人都可以進去，但是你的臥室是私有的，也就是說只有你能進去

但是呢，你也可以允許你的好閨蜜好基友進去。

在程序裏，有些私有屬性也想讓類外特殊的一些函數或者類進行訪問，就需要用到友元的技術

友元的目的就是讓一個函數或者類訪問另一個類中私有成員

友元的關鍵字爲 friend

友元的三種實現

全局函數做友元
類做友元
成員函數做友元

4.4.1 全局函數做友元

#include <string>

class Building
{
	//告訴編譯器 goodGay全局函數 是 Building類的好朋友，可以訪問類中的私有內容
	friend void goodGay(Building * building);

public:

	Building()
	{
		this->m_SittingRoom = "客廳";
		this->m_BedRoom = "臥室";
	}


public:
	string m_SittingRoom; //客廳

private:
	string m_BedRoom; //臥室
};


void goodGay(Building * building)
{
	cout << "好基友正在訪問： " << building->m_SittingRoom << endl;
	cout << "好基友正在訪問： " << building->m_BedRoom << endl;
}


void test01()
{
	Building b;
	goodGay(&b);
}

int main(){

	test01();

	system("pause");
	return 0;
}

4.4.2 類做友元

class Building;
class goodGay
{
public:

	goodGay();
	void visit();  //參觀函數，訪問building中的屬性

private:
	Building *building;
};


class Building
{
	//告訴編譯器 goodGay類是Building類的好朋友，可以訪問到Building類中私有內容
	friend class goodGay;

public:
	Building();

public:
	string m_SittingRoom; //客廳
private:
	string m_BedRoom;//臥室
};

Building::Building()
{
	this->m_SittingRoom = "客廳";
	this->m_BedRoom = "臥室";
}

goodGay::goodGay()
{
	building = new Building;
}

void goodGay::visit()
{
	cout << "好基友正在訪問" << building->m_SittingRoom << endl;
	cout << "好基友正在訪問" << building->m_BedRoom << endl;
}

void test01()
{
	goodGay gg;
	gg.visit();

}

int main(){

	test01();

	system("pause");
	return 0;
}

4.4.3 成員函數做友元


class Building;
class goodGay
{
public:

	goodGay();
	void visit(); //只讓visit函數作爲Building的好朋友，可以發訪問Building中私有內容
	void visit2(); 

private:
	Building *building;
};


class Building
{
	//告訴編譯器  goodGay類中的visit成員函數 是Building好朋友，可以訪問私有內容
	friend void goodGay::visit();

public:
	Building();

public:
	string m_SittingRoom; //客廳
private:
	string m_BedRoom;//臥室
};

Building::Building()
{
	this->m_SittingRoom = "客廳";
	this->m_BedRoom = "臥室";
}

goodGay::goodGay()
{
	building = new Building;
}

void goodGay::visit()
{
	cout << "好基友正在訪問" << building->m_SittingRoom << endl;
	cout << "好基友正在訪問" << building->m_BedRoom << endl;
}

void goodGay::visit2()
{
	cout << "好基友正在訪問" << building->m_SittingRoom << endl;
	//cout << "好基友正在訪問" << building->m_BedRoom << endl;
}

void test01()
{
	goodGay  gg;
	gg.visit();

}

int main(){
    
	test01();

	system("pause");
	return 0;
}

4.5 運算符重載

運算符重載概念：對已有的運算符重新進行定義，賦予其另一種功能，以適應不同的數據類型

4.5.1 加號運算符重載

作用：實現兩個自定義數據類型相加的運算

class Person {
public:
	Person() {};
	Person(int a, int b)
	{
		this->m_A = a;
		this->m_B = b;
	}
	//成員函數實現 + 號運算符重載
	Person operator+(const Person& p) {
		Person temp;
		temp.m_A = this->m_A + p.m_A;
		temp.m_B = this->m_B + p.m_B;
		return temp;
	}


public:
	int m_A;
	int m_B;
};

//全局函數實現 + 號運算符重載
//Person operator+(const Person& p1, const Person& p2) {
//	Person temp(0, 0);
//	temp.m_A = p1.m_A + p2.m_A;
//	temp.m_B = p1.m_B + p2.m_B;
//	return temp;
//}

//運算符重載 可以發生函數重載 
Person operator+(const Person& p2, int val)  
{
	Person temp;
	temp.m_A = p2.m_A + val;
	temp.m_B = p2.m_B + val;
	return temp;
}

void test() {

	Person p1(10, 10);
	Person p2(20, 20);

	//成員函數方式
	Person p3 = p2 + p1;  //相當於 p2.operaor+(p1)
	cout << "mA:" << p3.m_A << " mB:" << p3.m_B << endl;


	Person p4 = p3 + 10; //相當於 operator+(p3,10)
	cout << "mA:" << p4.m_A << " mB:" << p4.m_B << endl;

}

int main() {

	test();

	system("pause");

	return 0;
}

總結1：對於內置的數據類型的表達式的的運算符是不可能改變的

總結2：不要濫用運算符重載

4.5.2 左移運算符重載

作用：可以輸出自定義數據類型

class Person {
	friend ostream& operator<<(ostream& out, Person& p);

public:

	Person(int a, int b)
	{
		this->m_A = a;
		this->m_B = b;
	}

	//成員函數 實現不了  p << cout 不是我們想要的效果
	//void operator<<(Person& p){
	//}

private:
	int m_A;
	int m_B;
};

//全局函數實現左移重載
//ostream對象只能有一個
ostream& operator<<(ostream& out, Person& p) {
	out << "a:" << p.m_A << " b:" << p.m_B;
	return out;
}

void test() {

	Person p1(10, 20);

	cout << p1 << "hello world" << endl; //鏈式編程
}

int main() {

	test();

	system("pause");

	return 0;
}

總結：重載左移運算符配合友元可以實現輸出自定義數據類型

4.5.3 遞增運算符重載

作用：通過重載遞增運算符，實現自己的整型數據


class MyInteger {

	friend ostream& operator<<(ostream& out, MyInteger myint);

public:
	MyInteger() {
		m_Num = 0;
	}
	//前置++
	MyInteger& operator++() {
		//先++
		m_Num++;
		//再返回
		return *this;
	}

	//後置++
	MyInteger operator++(int) {
		//先返回
		MyInteger temp = *this; //記錄當前本身的值，然後讓本身的值加1，但是返回的是以前的值，達到先返回後++；
		m_Num++;
		return temp;
	}

private:
	int m_Num;
};


ostream& operator<<(ostream& out, MyInteger myint) {
	out << myint.m_Num;
	return out;
}


//前置++ 先++ 再返回
void test01() {
	MyInteger myInt;
	cout << ++myInt << endl;
	cout << myInt << endl;
}

//後置++ 先返回 再++
void test02() {

	MyInteger myInt;
	cout << myInt++ << endl;
	cout << myInt << endl;
}

int main() {

	test01();
	//test02();

	system("pause");

	return 0;
}

總結：前置遞增返回引用，後置遞增返回值

4.5.4 賦值運算符重載

c++編譯器至少給一個類添加4個函數

默認構造函數(無參，函數體爲空)
默認析構函數(無參，函數體爲空)
默認拷貝構造函數，對屬性進行值拷貝
賦值運算符 operator=, 對屬性進行值拷貝

如果類中有屬性指向堆區，做賦值操作時也會出現深淺拷貝問題

示例：

class Person
{
public:

	Person(int age)
	{
		//將年齡數據開闢到堆區
		m_Age = new int(age);
	}

	//重載賦值運算符 
	Person& operator=(Person &p)
	{
		if (m_Age != NULL)
		{
			delete m_Age;
			m_Age = NULL;
		}
		//編譯器提供的代碼是淺拷貝
		//m_Age = p.m_Age;

		//提供深拷貝 解決淺拷貝的問題
		m_Age = new int(*p.m_Age);

		//返回自身
		return *this;
	}


	~Person()
	{
		if (m_Age != NULL)
		{
			delete m_Age;
			m_Age = NULL;
		}
	}

	//年齡的指針
	int *m_Age;

};


void test01()
{
	Person p1(18);

	Person p2(20);

	Person p3(30);

	p3 = p2 = p1; //賦值操作

	cout << "p1的年齡爲：" << *p1.m_Age << endl;

	cout << "p2的年齡爲：" << *p2.m_Age << endl;

	cout << "p3的年齡爲：" << *p3.m_Age << endl;
}

int main() {

	test01();

	//int a = 10;
	//int b = 20;
	//int c = 30;

	//c = b = a;
	//cout << "a = " << a << endl;
	//cout << "b = " << b << endl;
	//cout << "c = " << c << endl;

	system("pause");

	return 0;
}

4.5.5 關係運算符重載

作用：重載關係運算符，可以讓兩個自定義類型對象進行對比操作

示例：

class Person
{
public:
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	};

	bool operator==(Person & p)
	{
		if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
		{
			return true;
		}
		else
		{
			return false;
		}
	}

	bool operator!=(Person & p)
	{
		if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
		{
			return false;
		}
		else
		{
			return true;
		}
	}

	string m_Name;
	int m_Age;
};

void test01()
{
	//int a = 0;
	//int b = 0;

	Person a("孫悟空", 18);
	Person b("孫悟空", 18);

	if (a == b)
	{
		cout << "a和b相等" << endl;
	}
	else
	{
		cout << "a和b不相等" << endl;
	}

	if (a != b)
	{
		cout << "a和b不相等" << endl;
	}
	else
	{
		cout << "a和b相等" << endl;
	}
}


int main() {

	test01();

	system("pause");

	return 0;
}

4.5.6 函數調用運算符重載

函數調用運算符 () 也可以重載
由於重載後使用的方式非常像函數的調用，因此稱爲仿函數
仿函數沒有固定寫法，非常靈活

示例：

class MyPrint
{
public:
	void operator()(string text)
	{
		cout << text << endl;
	}

};
void test01()
{
	//重載的（）操作符 也稱爲仿函數
	MyPrint myFunc;
	myFunc("hello world");
}


class MyAdd
{
public:
	int operator()(int v1, int v2)
	{
		return v1 + v2;
	}
};

void test02()
{
	MyAdd add;
	int ret = add(10, 10);
	cout << "ret = " << ret << endl;

	//匿名對象調用  
	cout << "MyAdd()(100,100) = " << MyAdd()(100, 100) << endl;
}

int main() {

	test01();
	test02();

	system("pause");

	return 0;
}

4.6 繼承

繼承是面向對象三大特性之一

有些類與類之間存在特殊的關係，例如下圖中：

我們發現，定義這些類時，下級別的成員除了擁有上一級的共性，還有自己的特性。

這個時候我們就可以考慮利用繼承的技術，減少重複代碼

4.6.1 繼承的基本語法

例如我們看到很多網站中，都有公共的頭部，公共的底部，甚至公共的左側列表，只有中心內容不同

接下來我們分別利用普通寫法和繼承的寫法來實現網頁中的內容，看一下繼承存在的意義以及好處

普通實現：

//Java頁面
class Java 
{
public:
	void header()
	{
		cout << "首頁、公開課、登錄、註冊...（公共頭部）" << endl;
	}
	void footer()
	{
		cout << "幫助中心、交流合作、站內地圖...(公共底部)" << endl;
	}
	void left()
	{
		cout << "Java,Python,C++...(公共分類列表)" << endl;
	}
	void content()
	{
		cout << "JAVA學科視頻" << endl;
	}
};
//Python頁面
class Python
{
public:
	void header()
	{
		cout << "首頁、公開課、登錄、註冊...（公共頭部）" << endl;
	}
	void footer()
	{
		cout << "幫助中心、交流合作、站內地圖...(公共底部)" << endl;
	}
	void left()
	{
		cout << "Java,Python,C++...(公共分類列表)" << endl;
	}
	void content()
	{
		cout << "Python學科視頻" << endl;
	}
};
//C++頁面
class CPP 
{
public:
	void header()
	{
		cout << "首頁、公開課、登錄、註冊...（公共頭部）" << endl;
	}
	void footer()
	{
		cout << "幫助中心、交流合作、站內地圖...(公共底部)" << endl;
	}
	void left()
	{
		cout << "Java,Python,C++...(公共分類列表)" << endl;
	}
	void content()
	{
		cout << "C++學科視頻" << endl;
	}
};

void test01()
{
	//Java頁面
	cout << "Java下載視頻頁面如下： " << endl;
	Java ja;
	ja.header();
	ja.footer();
	ja.left();
	ja.content();
	cout << "--------------------" << endl;

	//Python頁面
	cout << "Python下載視頻頁面如下： " << endl;
	Python py;
	py.header();
	py.footer();
	py.left();
	py.content();
	cout << "--------------------" << endl;

	//C++頁面
	cout << "C++下載視頻頁面如下： " << endl;
	CPP cp;
	cp.header();
	cp.footer();
	cp.left();
	cp.content();

}

int main() {

	test01();

	system("pause");

	return 0;
}

繼承實現：

//公共頁面
class BasePage
{
public:
	void header()
	{
		cout << "首頁、公開課、登錄、註冊...（公共頭部）" << endl;
	}

	void footer()
	{
		cout << "幫助中心、交流合作、站內地圖...(公共底部)" << endl;
	}
	void left()
	{
		cout << "Java,Python,C++...(公共分類列表)" << endl;
	}

};

//Java頁面
class Java : public BasePage
{
public:
	void content()
	{
		cout << "JAVA學科視頻" << endl;
	}
};
//Python頁面
class Python : public BasePage
{
public:
	void content()
	{
		cout << "Python學科視頻" << endl;
	}
};
//C++頁面
class CPP : public BasePage
{
public:
	void content()
	{
		cout << "C++學科視頻" << endl;
	}
};

void test01()
{
	//Java頁面
	cout << "Java下載視頻頁面如下： " << endl;
	Java ja;
	ja.header();
	ja.footer();
	ja.left();
	ja.content();
	cout << "--------------------" << endl;

	//Python頁面
	cout << "Python下載視頻頁面如下： " << endl;
	Python py;
	py.header();
	py.footer();
	py.left();
	py.content();
	cout << "--------------------" << endl;

	//C++頁面
	cout << "C++下載視頻頁面如下： " << endl;
	CPP cp;
	cp.header();
	cp.footer();
	cp.left();
	cp.content();


}

int main() {

	test01();

	system("pause");

	return 0;
}

總結：

繼承的好處：可以減少重複的代碼

class A : public B;

A 類稱爲子類或派生類

B 類稱爲父類或基類

派生類中的成員，包含兩大部分：

一類是從基類繼承過來的，一類是自己增加的成員。

從基類繼承過過來的表現其共性，而新增的成員體現了其個性。

4.6.2 繼承方式

繼承的語法：class 子類 : 繼承方式父類

繼承方式一共有三種：

公共繼承
保護繼承
私有繼承

示例：

class Base1
{
public: 
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};

//公共繼承
class Son1 :public Base1
{
public:
	void func()
	{
		m_A; //可訪問 public權限
		m_B; //可訪問 protected權限
		//m_C; //不可訪問
	}
};

void myClass()
{
	Son1 s1;
	s1.m_A; //其他類只能訪問到公共權限
}

//保護繼承
class Base2
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};
class Son2:protected Base2
{
public:
	void func()
	{
		m_A; //可訪問 protected權限
		m_B; //可訪問 protected權限
		//m_C; //不可訪問
	}
};
void myClass2()
{
	Son2 s;
	//s.m_A; //不可訪問
}

//私有繼承
class Base3
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};
class Son3:private Base3
{
public:
	void func()
	{
		m_A; //可訪問 private權限
		m_B; //可訪問 private權限
		//m_C; //不可訪問
	}
};
class GrandSon3 :public Son3
{
public:
	void func()
	{
		//Son3是私有繼承，所以繼承Son3的屬性在GrandSon3中都無法訪問到
		//m_A;
		//m_B;
		//m_C;
	}
};

4.6.3 繼承中的對象模型

問題：從父類繼承過來的成員，哪些屬於子類對象中？

示例：

class Base
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C; //私有成員只是被隱藏了，但是還是會繼承下去
};

//公共繼承
class Son :public Base
{
public:
	int m_D;
};

void test01()
{
	cout << "sizeof Son = " << sizeof(Son) << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

利用工具查看：

打開工具窗口後，定位到當前CPP文件的盤符

然後輸入： cl /d1 reportSingleClassLayout查看的類名所屬文件名

效果如下圖：

結論：父類中私有成員也是被子類繼承下去了，只是由編譯器給隱藏後訪問不到

4.6.4 繼承中構造和析構順序

子類繼承父類後，當創建子類對象，也會調用父類的構造函數

問題：父類和子類的構造和析構順序是誰先誰後？

示例：

class Base 
{
public:
	Base()
	{
		cout << "Base構造函數!" << endl;
	}
	~Base()
	{
		cout << "Base析構函數!" << endl;
	}
};

class Son : public Base
{
public:
	Son()
	{
		cout << "Son構造函數!" << endl;
	}
	~Son()
	{
		cout << "Son析構函數!" << endl;
	}

};


void test01()
{
	//繼承中 先調用父類構造函數，再調用子類構造函數，析構順序與構造相反
	Son s;
}

int main() {

	test01();

	system("pause");

	return 0;
}

總結：繼承中先調用父類構造函數，再調用子類構造函數，析構順序與構造相反

4.6.5 繼承同名成員處理方式

問題：當子類與父類出現同名的成員，如何通過子類對象，訪問到子類或父類中同名的數據呢？

訪問子類同名成員直接訪問即可
訪問父類同名成員需要加作用域

示例：

class Base {
public:
	Base()
	{
		m_A = 100;
	}

	void func()
	{
		cout << "Base - func()調用" << endl;
	}

	void func(int a)
	{
		cout << "Base - func(int a)調用" << endl;
	}

public:
	int m_A;
};


class Son : public Base {
public:
	Son()
	{
		m_A = 200;
	}

	//當子類與父類擁有同名的成員函數，子類會隱藏父類中所有版本的同名成員函數
	//如果想訪問父類中被隱藏的同名成員函數，需要加父類的作用域
	void func()
	{
		cout << "Son - func()調用" << endl;
	}
public:
	int m_A;
};

void test01()
{
	Son s;

	cout << "Son下的m_A = " << s.m_A << endl;
	cout << "Base下的m_A = " << s.Base::m_A << endl;

	s.func();
	s.Base::func();
	s.Base::func(10);

}
int main() {

	test01();

	system("pause");
	return EXIT_SUCCESS;
}

總結：

子類對象可以直接訪問到子類中同名成員
子類對象加作用域可以訪問到父類同名成員
當子類與父類擁有同名的成員函數，子類會隱藏父類中同名成員函數，加作用域可以訪問到父類中同名函數

4.6.6 繼承同名靜態成員處理方式

問題：繼承中同名的靜態成員在子類對象上如何進行訪問？

靜態成員和非靜態成員出現同名，處理方式一致

訪問子類同名成員直接訪問即可
訪問父類同名成員需要加作用域

示例：

class Base {
public:
	static void func()
	{
		cout << "Base - static void func()" << endl;
	}
	static void func(int a)
	{
		cout << "Base - static void func(int a)" << endl;
	}

	static int m_A;
};

int Base::m_A = 100;

class Son : public Base {
public:
	static void func()
	{
		cout << "Son - static void func()" << endl;
	}
	static int m_A;
};

int Son::m_A = 200;

//同名成員屬性
void test01()
{
	//通過對象訪問
	cout << "通過對象訪問： " << endl;
	Son s;
	cout << "Son  下 m_A = " << s.m_A << endl;
	cout << "Base 下 m_A = " << s.Base::m_A << endl;

	//通過類名訪問
	cout << "通過類名訪問： " << endl;
	cout << "Son  下 m_A = " << Son::m_A << endl;
	cout << "Base 下 m_A = " << Son::Base::m_A << endl;
}

//同名成員函數
void test02()
{
	//通過對象訪問
	cout << "通過對象訪問： " << endl;
	Son s;
	s.func();
	s.Base::func();

	cout << "通過類名訪問： " << endl;
	Son::func();
	Son::Base::func();
	//出現同名，子類會隱藏掉父類中所有同名成員函數，需要加作作用域訪問
	Son::Base::func(100);
}
int main() {

	//test01();
	test02();

	system("pause");

	return 0;
}

總結：同名靜態成員處理方式和非靜態處理方式一樣，只不過有兩種訪問的方式（通過對象和通過類名）

4.6.7 多繼承語法

C++允許一個類繼承多個類

語法：class 子類：繼承方式父類1 ，繼承方式父類2...

多繼承可能會引發父類中有同名成員出現，需要加作用域區分

C++實際開發中不建議用多繼承

示例：

class Base1 {
public:
	Base1()
	{
		m_A = 100;
	}
public:
	int m_A;
};

class Base2 {
public:
	Base2()
	{
		m_A = 200;  //開始是m_B 不會出問題，但是改爲mA就會出現不明確
	}
public:
	int m_A;
};

//語法：class 子類：繼承方式 父類1 ，繼承方式 父類2 
class Son : public Base2, public Base1 
{
public:
	Son()
	{
		m_C = 300;
		m_D = 400;
	}
public:
	int m_C;
	int m_D;
};


//多繼承容易產生成員同名的情況
//通過使用類名作用域可以區分調用哪一個基類的成員
void test01()
{
	Son s;
	cout << "sizeof Son = " << sizeof(s) << endl;
	cout << s.Base1::m_A << endl;
	cout << s.Base2::m_A << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

總結：多繼承中如果父類中出現了同名情況，子類使用時候要加作用域

4.6.8 菱形繼承

菱形繼承概念：

兩個派生類繼承同一個基類

又有某個類同時繼承者兩個派生類

這種繼承被稱爲菱形繼承，或者鑽石繼承

典型的菱形繼承案例：

菱形繼承問題：

羊繼承了動物的數據，駝同樣繼承了動物的數據，當草泥馬使用數據時，就會產生二義性。

草泥馬繼承自動物的數據繼承了兩份，其實我們應該清楚，這份數據我們只需要一份就可以。

示例：

class Animal
{
public:
	int m_Age;
};

//繼承前加virtual關鍵字後，變爲虛繼承
//此時公共的父類Animal稱爲虛基類
class Sheep : virtual public Animal {};
class Tuo   : virtual public Animal {};
class SheepTuo : public Sheep, public Tuo {};

void test01()
{
	SheepTuo st;
	st.Sheep::m_Age = 100;
	st.Tuo::m_Age = 200;

	cout << "st.Sheep::m_Age = " << st.Sheep::m_Age << endl;
	cout << "st.Tuo::m_Age = " <<  st.Tuo::m_Age << endl;
	cout << "st.m_Age = " << st.m_Age << endl;
}


int main() {

	test01();

	system("pause");

	return 0;
}

總結：

菱形繼承帶來的主要問題是子類繼承兩份相同的數據，導致資源浪費以及毫無意義
利用虛繼承可以解決菱形繼承問題

4.7 多態

4.7.1 多態的基本概念

多態是C++面向對象三大特性之一

多態分爲兩類

靜態多態: 函數重載和運算符重載屬於靜態多態，複用函數名
動態多態: 派生類和虛函數實現運行時多態

靜態多態和動態多態區別：

靜態多態的函數地址早綁定 - 編譯階段確定函數地址
動態多態的函數地址晚綁定 - 運行階段確定函數地址

下面通過案例進行講解多態

class Animal
{
public:
	//Speak函數就是虛函數
	//函數前面加上virtual關鍵字，變成虛函數，那麼編譯器在編譯的時候就不能確定函數調用了。
	virtual void speak()
	{
		cout << "動物在說話" << endl;
	}
};

class Cat :public Animal
{
public:
	void speak()
	{
		cout << "小貓在說話" << endl;
	}
};

class Dog :public Animal
{
public:

	void speak()
	{
		cout << "小狗在說話" << endl;
	}

};
//我們希望傳入什麼對象，那麼就調用什麼對象的函數
//如果函數地址在編譯階段就能確定，那麼靜態聯編
//如果函數地址在運行階段才能確定，就是動態聯編

void DoSpeak(Animal & animal)
{
	animal.speak();
}
//
//多態滿足條件： 
//1、有繼承關係
//2、子類重寫父類中的虛函數
//多態使用：
//父類指針或引用指向子類對象

void test01()
{
	Cat cat;
	DoSpeak(cat);


	Dog dog;
	DoSpeak(dog);
}


int main() {

	test01();

	system("pause");

	return 0;
}

總結：

多態滿足條件

有繼承關係
子類重寫父類中的虛函數

多態使用條件

父類指針或引用指向子類對象

重寫：函數返回值類型函數名參數列表完全一致稱爲重寫

4.7.2 多態案例一-計算器類

案例描述：

分別利用普通寫法和多態技術，設計實現兩個操作數進行運算的計算器類

多態的優點：

代碼組織結構清晰
可讀性強
利於前期和後期的擴展以及維護

示例：

//普通實現
class Calculator {
public:
	int getResult(string oper)
	{
		if (oper == "+") {
			return m_Num1 + m_Num2;
		}
		else if (oper == "-") {
			return m_Num1 - m_Num2;
		}
		else if (oper == "*") {
			return m_Num1 * m_Num2;
		}
		//如果要提供新的運算，需要修改源碼
	}
public:
	int m_Num1;
	int m_Num2;
};

void test01()
{
	//普通實現測試
	Calculator c;
	c.m_Num1 = 10;
	c.m_Num2 = 10;
	cout << c.m_Num1 << " + " << c.m_Num2 << " = " << c.getResult("+") << endl;

	cout << c.m_Num1 << " - " << c.m_Num2 << " = " << c.getResult("-") << endl;

	cout << c.m_Num1 << " * " << c.m_Num2 << " = " << c.getResult("*") << endl;
}



//多態實現
//抽象計算器類
//多態優點：代碼組織結構清晰，可讀性強，利於前期和後期的擴展以及維護
class AbstractCalculator
{
public :

	virtual int getResult()
	{
		return 0;
	}

	int m_Num1;
	int m_Num2;
};

//加法計算器
class AddCalculator :public AbstractCalculator
{
public:
	int getResult()
	{
		return m_Num1 + m_Num2;
	}
};

//減法計算器
class SubCalculator :public AbstractCalculator
{
public:
	int getResult()
	{
		return m_Num1 - m_Num2;
	}
};

//乘法計算器
class MulCalculator :public AbstractCalculator
{
public:
	int getResult()
	{
		return m_Num1 * m_Num2;
	}
};


void test02()
{
	//創建加法計算器
	AbstractCalculator *abc = new AddCalculator;
	abc->m_Num1 = 10;
	abc->m_Num2 = 10;
	cout << abc->m_Num1 << " + " << abc->m_Num2 << " = " << abc->getResult() << endl;
	delete abc;  //用完了記得銷燬

	//創建減法計算器
	abc = new SubCalculator;
	abc->m_Num1 = 10;
	abc->m_Num2 = 10;
	cout << abc->m_Num1 << " - " << abc->m_Num2 << " = " << abc->getResult() << endl;
	delete abc;  

	//創建乘法計算器
	abc = new MulCalculator;
	abc->m_Num1 = 10;
	abc->m_Num2 = 10;
	cout << abc->m_Num1 << " * " << abc->m_Num2 << " = " << abc->getResult() << endl;
	delete abc;
}

int main() {

	//test01();

	test02();

	system("pause");

	return 0;
}

總結：C++開發提倡利用多態設計程序架構，因爲多態優點很多

4.7.3 純虛函數和抽象類

在多態中，通常父類中虛函數的實現是毫無意義的，主要都是調用子類重寫的內容

因此可以將虛函數改爲純虛函數

純虛函數語法：virtual 返回值類型函數名（參數列表）= 0 ;

當類中有了純虛函數，這個類也稱爲抽象類

抽象類特點：

無法實例化對象
子類必須重寫抽象類中的純虛函數，否則也屬於抽象類

示例：

class Base
{
public:
	//純虛函數
	//類中只要有一個純虛函數就稱爲抽象類
	//抽象類無法實例化對象
	//子類必須重寫父類中的純虛函數，否則也屬於抽象類
	virtual void func() = 0;
};

class Son :public Base
{
public:
	virtual void func() 
	{
		cout << "func調用" << endl;
	};
};

void test01()
{
	Base * base = NULL;
	//base = new Base; // 錯誤，抽象類無法實例化對象
	base = new Son;
	base->func();
	delete base;//記得銷燬
}

int main() {

	test01();

	system("pause");

	return 0;
}

4.7.4 多態案例二-製作飲品

案例描述：

製作飲品的大致流程爲：煮水 - 沖泡 - 倒入杯中 - 加入輔料

利用多態技術實現本案例，提供抽象製作飲品基類，提供子類製作咖啡和茶葉

示例：

//抽象製作飲品
class AbstractDrinking {
public:
	//燒水
	virtual void Boil() = 0;
	//沖泡
	virtual void Brew() = 0;
	//倒入杯中
	virtual void PourInCup() = 0;
	//加入輔料
	virtual void PutSomething() = 0;
	//規定流程
	void MakeDrink() {
		Boil();
		Brew();
		PourInCup();
		PutSomething();
	}
};

//製作咖啡
class Coffee : public AbstractDrinking {
public:
	//燒水
	virtual void Boil() {
		cout << "煮農夫山泉!" << endl;
	}
	//沖泡
	virtual void Brew() {
		cout << "沖泡咖啡!" << endl;
	}
	//倒入杯中
	virtual void PourInCup() {
		cout << "將咖啡倒入杯中!" << endl;
	}
	//加入輔料
	virtual void PutSomething() {
		cout << "加入牛奶!" << endl;
	}
};

//製作茶水
class Tea : public AbstractDrinking {
public:
	//燒水
	virtual void Boil() {
		cout << "煮自來水!" << endl;
	}
	//沖泡
	virtual void Brew() {
		cout << "沖泡茶葉!" << endl;
	}
	//倒入杯中
	virtual void PourInCup() {
		cout << "將茶水倒入杯中!" << endl;
	}
	//加入輔料
	virtual void PutSomething() {
		cout << "加入枸杞!" << endl;
	}
};

//業務函數
void DoWork(AbstractDrinking* drink) {
	drink->MakeDrink();
	delete drink;
}

void test01() {
	DoWork(new Coffee);
	cout << "--------------" << endl;
	DoWork(new Tea);
}


int main() {

	test01();

	system("pause");

	return 0;
}

4.7.5 虛析構和純虛析構

多態使用時，如果子類中有屬性開闢到堆區，那麼父類指針在釋放時無法調用到子類的析構代碼

解決方式：將父類中的析構函數改爲虛析構或者純虛析構

虛析構和純虛析構共性：

可以解決父類指針釋放子類對象
都需要有具體的函數實現

虛析構和純虛析構區別：

如果是純虛析構，該類屬於抽象類，無法實例化對象

虛析構語法：

virtual ~類名(){}

純虛析構語法：

virtual ~類名() = 0;

類名::~類名(){}

示例：

class Animal {
public:

	Animal()
	{
		cout << "Animal 構造函數調用！" << endl;
	}
	virtual void Speak() = 0;

	//析構函數加上virtual關鍵字，變成虛析構函數
	//virtual ~Animal()
	//{
	//	cout << "Animal虛析構函數調用！" << endl;
	//}


	virtual ~Animal() = 0;
};

Animal::~Animal()
{
	cout << "Animal 純虛析構函數調用！" << endl;
}

//和包含普通純虛函數的類一樣，包含了純虛析構函數的類也是一個抽象類。不能夠被實例化。

class Cat : public Animal {
public:
	Cat(string name)
	{
		cout << "Cat構造函數調用！" << endl;
		m_Name = new string(name);
	}
	virtual void Speak()
	{
		cout << *m_Name <<  "小貓在說話!" << endl;
	}
	~Cat()
	{
		cout << "Cat析構函數調用!" << endl;
		if (this->m_Name != NULL) {
			delete m_Name;
			m_Name = NULL;
		}
	}

public:
	string *m_Name;
};

void test01()
{
	Animal *animal = new Cat("Tom");
	animal->Speak();

	//通過父類指針去釋放，會導致子類對象可能清理不乾淨，造成內存泄漏
	//怎麼解決？給基類增加一個虛析構函數
	//虛析構函數就是用來解決通過父類指針釋放子類對象
	delete animal;
}

int main() {

	test01();

	system("pause");

	return 0;
}

總結：

1. 虛析構或純虛析構就是用來解決通過父類指針釋放子類對象

2. 如果子類中沒有堆區數據，可以不寫爲虛析構或純虛析構

3. 擁有純虛析構函數的類也屬於抽象類

4.7.6 多態案例三-電腦組裝

案例描述：

電腦主要組成部件爲 CPU（用於計算），顯卡（用於顯示），內存條（用於存儲）

將每個零件封裝出抽象基類，並且提供不同的廠商生產不同的零件，例如Intel廠商和Lenovo廠商

創建電腦類提供讓電腦工作的函數，並且調用每個零件工作的接口

測試時組裝三臺不同的電腦進行工作

示例：

#include<iostream>
using namespace std;

//抽象CPU類
class CPU
{
public:
	//抽象的計算函數
	virtual void calculate() = 0;
};

//抽象顯卡類
class VideoCard
{
public:
	//抽象的顯示函數
	virtual void display() = 0;
};

//抽象內存條類
class Memory
{
public:
	//抽象的存儲函數
	virtual void storage() = 0;
};

//電腦類
class Computer
{
public:
	Computer(CPU * cpu, VideoCard * vc, Memory * mem)
	{
		m_cpu = cpu;
		m_vc = vc;
		m_mem = mem;
	}

	//提供工作的函數
	void work()
	{
		//讓零件工作起來，調用接口
		m_cpu->calculate();

		m_vc->display();

		m_mem->storage();
	}

	//提供析構函數 釋放3個電腦零件
	~Computer()
	{

		//釋放CPU零件
		if (m_cpu != NULL)
		{
			delete m_cpu;
			m_cpu = NULL;
		}

		//釋放顯卡零件
		if (m_vc != NULL)
		{
			delete m_vc;
			m_vc = NULL;
		}

		//釋放內存條零件
		if (m_mem != NULL)
		{
			delete m_mem;
			m_mem = NULL;
		}
	}

private:

	CPU * m_cpu; //CPU的零件指針
	VideoCard * m_vc; //顯卡零件指針
	Memory * m_mem; //內存條零件指針
};

//具體廠商
//Intel廠商
class IntelCPU :public CPU
{
public:
	virtual void calculate()
	{
		cout << "Intel的CPU開始計算了！" << endl;
	}
};

class IntelVideoCard :public VideoCard
{
public:
	virtual void display()
	{
		cout << "Intel的顯卡開始顯示了！" << endl;
	}
};

class IntelMemory :public Memory
{
public:
	virtual void storage()
	{
		cout << "Intel的內存條開始存儲了！" << endl;
	}
};

//Lenovo廠商
class LenovoCPU :public CPU
{
public:
	virtual void calculate()
	{
		cout << "Lenovo的CPU開始計算了！" << endl;
	}
};

class LenovoVideoCard :public VideoCard
{
public:
	virtual void display()
	{
		cout << "Lenovo的顯卡開始顯示了！" << endl;
	}
};

class LenovoMemory :public Memory
{
public:
	virtual void storage()
	{
		cout << "Lenovo的內存條開始存儲了！" << endl;
	}
};


void test01()
{
	//第一臺電腦零件
	CPU * intelCpu = new IntelCPU;
	VideoCard * intelCard = new IntelVideoCard;
	Memory * intelMem = new IntelMemory;

	cout << "第一臺電腦開始工作：" << endl;
	//創建第一臺電腦
	Computer * computer1 = new Computer(intelCpu, intelCard, intelMem);
	computer1->work();
	delete computer1;

	cout << "-----------------------" << endl;
	cout << "第二臺電腦開始工作：" << endl;
	//第二臺電腦組裝
	Computer * computer2 = new Computer(new LenovoCPU, new LenovoVideoCard, new LenovoMemory);;
	computer2->work();
	delete computer2;

	cout << "-----------------------" << endl;
	cout << "第三臺電腦開始工作：" << endl;
	//第三臺電腦組裝
	Computer * computer3 = new Computer(new LenovoCPU, new IntelVideoCard, new LenovoMemory);;
	computer3->work();
	delete computer3;

}