1.再談建構式

1.1 建構式賦值

我們在之前建構式中談到建構式初始化，是直接給物件中各成員變數一個值，如下圖所示：

雖然上述建構式呼叫之后，物件中已經有了一個初始值，但是不能將其稱作為類物件成員的初始化，建構式體中的陳述句只能將其稱作為賦初值，而不能稱作初始化，因為初始化只能初始化一次，而建構式體內可以多次賦值

1.2 初始化串列

初始化串列：以一個冒號開始，接著是一個以逗號分隔的資料成員串列，每個“成員變數”后面跟一個放在括號中的初始值或運算式

如下圖所示：

• (1) 每個成員變數在初始化串列中只能出現一次(初始化只能初始化一次)
  
• (2) 類中包含以下成員，必須放在初始化串列位置進行初始化：
  
  參考成員變數
  
  const成員變數
  
  自定義型別成員變數(該類沒有默認建構式)

• (3) 盡量使用初始化串列初始化，因為不管你是否使用初始化串列，對于自定義型別成員變數，一定會先使用初始化串列初始化
• (4) 成員變數在類中宣告次序就是其在初始化串列中初始化的順序，與其在初始化串列中的先后順序無關

驗證一：

此代碼先宣告了_a1所以會先初始化_a1，再用_a1初始化_a2


驗證二：
此代碼先宣告了_a2，所以會先初始化_a2,但此時_a1還未初始化，所以編譯器會用隨機值初始化_a2，再用a初始化_a1，所以此程式的運行結果_a1=1，_a2為隨機值

2. explicit關鍵字

在認識explicit關鍵詞之前，我們先來了解一下隱式轉換和顯示轉換

2.1 隱式轉換

隱式轉換是系統根據程式的需要而自動轉換

2.2 顯示轉換

顯示轉化也叫強制轉換，是自己主動讓這個型別轉換成別的型別

2.3 explicit關鍵字

explicit關鍵字修飾建構式，禁止單參建構式的隱式轉換；在內置型別轉換為自定義型別進行賦值時，當沒有明確指出物件時，會隱式產生臨時物件，這個就是編譯器推演產生的那么就存在不可控因素，假如我們不想他轉換，但時它還是轉換了，那么就有安全隱患的存在

如下圖所示代碼就存在隱式轉換：

當我們在建構式前加上關鍵字explicit，就可以禁止單參建構式進行隱式轉換，如下圖所示：

3. static成員

3.1 static的基本概念

宣告為static的類成員稱之為類的靜態成員，用static修飾的成員變數，稱之為靜態成員變數；用static修飾的成員函式，稱之為靜態成員函式，靜態成員變數一定要在類外進行初始化

3.2 static成員的特性

• (1)靜態成員供類的所有物件共享，不屬于任何一個物件

代碼驗證如下：

#include<iostream>
using namespace std;

class Date
{
public:
	Date(int date) :_date(date)
	{}
public:
	static int m_date;
private:
	int _date;
};

int Date::m_date = 0;
void main()
{
	Date d1(1);
	Date d2(2);
	Date d3(3);
	printf("d1.m_date=%p\n", &(d1.m_date));
	printf("d2.m_date=%p\n", &(d2.m_date));
	printf("d3.m_date=%p\n", &(d3.m_date));
}

我們通過除錯查看物件d1,d2,d3的地址，再和列印出來的d1,d2,d3中m_date的地址，可以看出，三個物件在不同的空間中，而三個物件中m_date的地址是相同的，所以可以證明----->靜態成員供類的所有物件共享，不屬于任何一個物件

• (2)靜態成員變數必須在類外定義，定義時不添加static關鍵字
• (3)類靜態成員即可用（類名::靜態成員或者物件.靜態成員）來訪問

• (4)靜態成員函式沒有隱藏的this指標，不能訪問任何非靜態成員
• (5)靜態成員和類的普通成員一樣，也有public,protected,private3種訪問級別，也可以具有回傳值

3.3 面試題：實作一個類，計算程式中創建了多少個類物件

思路：給一個靜態變數初始化為0，任何讓這個靜態變數在建構式中++，因為每創建一個物件就要呼叫一次函式，即每創建一個物件建構式中的靜態變數就會+1

#include<iostream>
using namespace std;

class Date
{
public:
	Date(int date) :_date(date)
	{
		m_date++;
	}
public:
	static int GetCount()
	{
		return m_date;
	}

private:
	int _date;
	static int m_date;
};

int Date::m_date = 0;
void main()
{
	Date d1(1);
	Date d2(2);
	Date d3(3);
	cout << Date::GetCount() << endl;
}

3.4 [問題]

(1) 靜態成員函式可以呼叫非靜態成員函式嗎？

答：不可以，因為靜態成員函式沒有this指標

(2) 非靜態成員函式可以呼叫靜態成員函式嗎？

答：可以

4. 友元

4.1 前言

當我們想列印私有成員時，我們可以寫一個函式，如何讓這個函式回傳這個私有物件，呼叫這個函式列印，代碼如下

#include<iostream>
using namespace std;
class Test
{
public:
	Test(int data = 0) :m_data(data)
	{}
	Test(const Test& t)
	{
		m_data = t.m_data;
	}
	Test& operator=(const Test& t)
	{
		if (this != &t)
		{
			m_data = t.m_data;
		}
		return *this;
	}
	~Test()
	{}
public:
	int GetData()const
	{
		return m_data;
	}
private:
	int m_data;
};
int main()
{
	Test t(10);
	cout << "t=" << t.GetData() << endl;
	return 0;
}

可當我們想直接列印私有成員的資料怎么辦呢？

當我們使用友元函式就可以解決這個問題

4.2 友元的分類

友元分為：友元函式和友元類

友元提供了一種突破封裝的方式，又是提供了便利，但友元會增加耦合度，破壞了封裝，所以友元不宜多用

4.3 友元函式

友元函式可以直接訪問類的私有成員，它是定義在類外部的普通函式，不屬于任何類，但需要在類的內部宣告，宣告時需要加friend關鍵字

• 友元函式可以訪問類的私有和保護成員，但不是類的成員函式
• 友元函式不能用const修飾
• 友元函式可以在類定義的任何地方宣告，不受類訪問限定符約束(可在public/private/protected)
• 一個函式可以是多個類的友元函式
• 友元函式的呼叫與普通函式的呼叫原理相同

如下代碼所示：

一個函式可以是多個類的友元函式代碼驗證：

#include<iostream>
using namespace std;

//前向宣告
class Test;
class A
{
	friend int GetData(Test &d, A &a, int flag);
private:
	int m_adata = 120;
};


class Test
{
	friend ostream& operator<<(ostream& out, const Test&d);
	friend int GetData(Test &d, A &a, int flag);
public:
	Test(int data = 0) :m_data(data)
	{}
	Test(const Test& t)
	{
		m_data = t.m_data;
	}
	~Test()
	{}
private:
	int m_data;
};


int GetData(Test &d,A &a,int flag)
{
	if (flag == 0)
	{
		return d.m_data;
	}
	else
	{
		return a.m_adata;
	}
}


ostream& operator<<(ostream& out, const Test&d)
{
	out << "t=" <<d.m_data;
	return out;
}


int main()
{
	Test d(10);
	A a;
	cout << GetData(d, a, 1) << endl;
	return 0;
}

4.4 友元類

友元類的所有成員函式都可以是另一個類的友元函式，都可以訪問另一個類中的非公有成員

• 友元關系的單向的，不具有交換性
  
  比如A類和Test類，在A類中宣告Test類為其友元類，那么可以在Test類中直接訪問A類的私有成員變數，但想在A類中訪問Test類中的私有成員變數則不行
  
• 友元關系不能傳遞
  
  如果B是A的友元類，C是B的友元類，但不能說明C是A的友元

友元類代碼舉例如下：

#include<iostream>
using namespace std;

//前置宣告
class Time;
class Date
{
    //宣告時間類為日期類的友元類，則可在時間類中直接訪問日期類的私有成員
	friend class Time;
public:
	Date(int year = 0, int month = 0, int day = 0) :_year(year), _month(month), _day(day)
	{}
private:
	int _year;
	int _month;
	int _day;
};


class Time
{
	friend ostream& operator<<(ostream& out, const Time&d);
public:
	Time(int hour = 0, int minute = 0, int second = 0):_hour(hour), _minute(minute), _second(second)
	{}
	void SetDateTime(int year,int month,int day)
	{
	    //直接訪問日期類的私有成員
		_d._year = year;
		_d._month = month;
		_d._day = day;
		cout << _d._year <<"-"<< _d._month <<"-"<< _d._day<<" ";
	}
	~Time()
	{}
private:
	int _hour;
	int _minute;
	int _second;
	Date _d;
};
ostream& operator<<(ostream& out, const Time&d)
{
	out <<d._hour<<":"<<d._minute<<":"<<d._second;
	return out;
}


int main()
{
	Time b(22,18,5);
	b.SetDateTime(2021,4,15);
	cout << b << endl;
	return 0;
}

5. 內部類

如果一個類定義在另一個類的內部，這個內部的類就叫內部類；內部類是一個獨立的類，它不屬于外部類，更不能通過外部類的物件去呼叫內部類，內部類就是外部類的友元類

如下代碼中B就是一個內部類：

#include<iostream>
using namespace std;

class A
{
public:
	class B
	{
	public:
		void show()
		{
			cout << "This is B::show()" << endl;
		}
	private:
		int b_date;
	};
private:
	int a_date;
};

void main()
{
	A::B b;
	b.show();
}

注意：

• 內部類可以定義在外部類的public,protected,private都是可以的
• 內部類可以直接訪問外部類的static，列舉成員，不需要外部類的物件/類名
• sizeof(外部類)=外部類，和內部類沒關系