再談建構式

1、建構式賦值問題

前面我們談到，建構式賦值，都是通過有參函式來賦值的，雖然我們通過呼叫建構式使物件已經有了一個初始值，但不能將其稱為類物件成員的初始化，

class A
{
public:
	A(){}
	A(int a)
	{
		_a = a;
	}
private:
	int _a;
};
class Date
{
public:
	Date(int a, int b)
	{
		//函式體內初始化
		_aa = A(a);
		_b = b;
	}
private:
	A _aa;//自定義型別
	int _b;//內置型別
};

重點

建構式體中的陳述句只能將其稱作為賦初值，而不能稱作初始化，因為初始化只能初始化一次，而建構式體內可以多次賦值

2、初始化串列

• 那怎么去初始化？
  這里我們就要用到初始化串列

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

舉例：Date(int a, int b):_aa(a),_b(b)

class A
{
public:
	A(){}
	A(int a)
	{
		_a = a;
	}
private:
	int _a;
};
class Date
{
public:
	Date(int a, int b):_aa(a),_b(b)
	{
		//函式體內初始化 
//=》對于自定義型別成員來說，改用初始化串列初始化可以提高效率
		/*_aa = A(a);
		_b = b;*/
	}
private:
	A _aa;//自定義型別
	int _b;//內置型別
};

但是我們在初始化串列的時候，需要注意初始化的順序，如果順序相反，會導致出現隨機值的問題，

class A
{
public:
	A(int a) //_a1和_a2的初始化順序相反
		:_a2(a)
		,_a1(_a2)		 
	{}
	void Print() {
		cout << _a1 << " " << _a2 << endl;
	}
private:
	int _a1;
	int _a2;
};
int main()
{
	A person(10);
	person.Print();
	return 0;
}

初始化順序必須與在類中宣告的順序一樣，否則會出現隨機值

還有一點就是以下成員必須使用初始化串列進行初始化：

• 參考成員變數
• const成員變數
• 自定義型別成員(該類沒有默認建構式)

class A
{
public:
	A(int a):_a(a)
	{}
private:
	int _a;
};
class B
{
public:
	B(int a, int ref):_aobj(a),_ref(ref),_n(10)
	{}
private:
	A _aobj; // 沒有默認建構式
	int& _ref; // 參考
	const int _n; // const
};

還有一點就是，無法用初始化串列初始化的成員變數，我們可以函式內部初始化，串列初始化和函式內部初始化搭配著用，靈活運用

總結：

1. 每個成員變數在初始化串列中只能出現一次(初始化只能初始化一次)
2. 類中包含以下成員，必須放在初始化串列位置進行初始化：

• 參考成員變數
• const成員變數
• 自定義型別成員(該類沒有默認建構式

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

explicit關鍵字

建構式不僅可以構造與初始化物件，對于單個引數的建構式，還具有型別轉換的作用

建構式對于單個引數的隱式轉換可能會帶來我們不想要的，所以我們這里可以加explicit關鍵字去避免隱式轉換，

用explicit修飾建構式，將會禁止單參建構式的隱式轉換

static成員

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

• 靜態成員變數位于資料段（記憶體分布下一節再講，這里先說明一下）

static的作用

c語言

1. 修飾全域變數和全域函式，改變鏈接屬性，只在當前檔案可見
2. 修飾區域變數，改變宣告周期

上面的特性在C++中依舊有用，C++兼容c的這些特性

cpp

1. 修飾成員變數和成員函式，成員變數屬于整個類，所有相對像共享，成員函式沒有this指標

我們先來看一道面試題：實作一個類，計算中程式中創建出了多少個類物件

int countC = 0;
int countCC = 0;
class A
{
public:
	A()
	{
		++countC;
	}

	A(const A& a)
	{
		++countCC;
	}
};
A f(A a)
{
	A ret(a);//拷貝構造
	return ret;
}
int main()
{
	A a1 = f(A());//匿名物件傳參時，不會呼叫拷貝建構式
	A a2;
	A a3;
	a3 = f(a2);
	cout << countC << endl;
	cout << countCC << endl;
	return 0;
}

我們這里輕松就能想到用全域變數來計數，但我們使用static具有封裝性，使用更安全，

class A
{
public:
	A()
	{
		++countC;
	}

	A(const A& a)
	{
		++countCC;
	}
	//靜態成員函式沒有this指標
	static int GetACountC() { return countC; }
	static int GetACountCC() { return countCC; }
private:
	static int countC;
	// 存在靜態區，屬于整個類，也屬于每個定義出來的物件共享
	// 跟全域變數比較，他受類域和訪問限定符限制，更好體現封裝，別人不能輕易修改他
	static int countCC;
};
//靜態成員變數不能在建構式初始化，在全域位置定義初始化
int A::countC = 0;
int A::countCC = 0;
A f(A a)
{
	A ret(a);//拷貝構造
	return ret;
}
int main()
{
	A a1 = f(A());//匿名物件傳參時，不會呼叫拷貝建構式
	A a2;
	A a3;
	a3 = f(a2);
	//屬于整個類，也屬于每個定義出來的物件共享
	//我們可以使用類::靜態成員或者物件.靜態成員來訪問
	cout << A::GetACountC() << endl;
	cout << A::GetACountCC() << endl;
	return 0;
}

• 我們在來看看靜態成員為什么無法呼叫非靜態成員？

由于static成員沒有this指標，而物件的實體化之后，都是有隱藏的this指標去呼叫函式或者成員變數，所以這里報錯（需要注意）

給你們留兩個問題

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

不能，因為靜態成員沒有隱藏的this指標（this指標忘記的自己看看前幾節博客）

2. 非靜態成員函式可以呼叫類的靜態成員函式嗎？

可以，因為非靜態成員有this指標

總結

1. 靜態成員為所有類物件所共享，不屬于某個具體的實體
2. 靜態成員變數必須在類外定義，定義時不添加static關鍵字
3. 類靜態成員即可用類名::靜態成員或者物件.靜態成員來訪問
4. 靜態成員函式沒有隱藏的this指標，不能訪問任何非靜態成員
5. 靜態成員和類的普通成員一樣，也有public、protected、private3種訪問級別，也可以具有回傳值

友元

友元是什么？

• 朋友？

差不多是這個意思，也就是一個類可以去訪問例外一個類里面的成員，不過指的是單方面去訪問，

友元函式

我們先來看一個問題，現在我們嘗試去多載operator<<，然后發現我們沒辦法將operator<<多載成成員函式，

因為cout的輸出流物件和隱含的this指標在搶占第一個引數的位置，this指標默認是第一個引數也就是左運算元了，但是實際使用中cout需要是第一個形參物件，才能正常使用，所以我們要將operator<<多載成全域函式，但是這樣的話，又會導致類外沒辦法訪問成員，那么這里就需要友元來解決，operator>>同理

class Date
{
public:
	//必須弄為友元，類外才能訪問成員
	friend ostream& operator<<(ostream& _cout, const Date& d);//加const，輸出運算子多載，不需要改變
	friend istream& operator>>(istream& _cin, Date& d);//輸入運算子多載，需要改變
	Date(int year, int month, int day)
		: _year(year)
		, _month(month)
		, _day(day)
	{}
private:
	int _year;
	int _month;
	int _day;
};
//輸出流
ostream& operator<<(ostream& _cout, const Date& d)
{
	_cout << d._year << "-" << d._month << "-" << d._day;
	return _cout;
}
//輸入流
istream& operator>>(istream& _cin, Date& d)
{
	_cin >> d._year >> d._month >> d._day;
	return _cin;
}
int main()
{
	Date d(2017, 12, 24);
	cout << d;
	cin >> d;
	return 0;
}

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

class Date
{
	friend void Print(const Date& d);
private:
	int _year = 2021;//宣告，這里是預設值，不是初始化的值，更不是定義
	int _month = 10;
	int _day = 27;
};
void Print(const Date& d)
{
	cout << d._year << " " << d._month << " " << d._day << endl;
}
int main()
{
	Date d;
	Print(d);//友元函式呼叫
	return 0;
}

友元函式跟普通函式呼叫方法一樣，

還有一點性質，一個函式可以是多個類的友元函式

友元函式總結

1. 友元函式可訪問類的私有和保護成員，但不是類的成員函式
2. 友元函式不能用const修飾
3. 友元函式可以在類定義的任何地方宣告，不受類訪問限定符限制
4. 一個函式可以是多個類的友元函式
5. 友元函式的呼叫與普通函式的呼叫和原理相同

友元類

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

• 友元關系是單向的，不具有交換性，

比如上述Time類和Date類，在Time類中宣告Date類為其友元類，那么可以在Date類中直接訪問Time類的私有成員變數，但想在Time類中訪問Date類中私有的成員變數則不行，

• 友元關系不能傳遞

如果B是A的友元，C是B的友元，則不能說明C是A的友元，

class Time
{
	friend class Date;   // 宣告日期類為時間類的友元類，則在日期類中就直接訪問Time類中的私有成員變數
public:
	Time(int hour = 0, int minute = 0, int second = 0)
		: _hour(hour)
		, _minute(minute)
		, _second(second)
	{}
private:
	int _hour;
	int _minute;
	int _second;
};

// 友元關系是單向的，Date是Time的友元，在Date類中可以使用物件訪問Time的私有保護成員
// 但是Time不是Date的友元，在Time類中不可以使用物件訪問Date的私有保護成員
class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
		: _year(year)
		, _month(month)
		, _day(day)
	{}

	void SetTimeOfDate(int hour, int minute, int second)
	{
		// 直接訪問時間類私有的成員變數
		_t._hour = hour;
		_t._minute = minute;
		_t._second = second;
		cout << _t._hour << " " << _t._minute << " " << _t._second << endl;
	}

private:
	int _year;
	int _month;
	int _day;
	Time _t;
};

int main()
{
	Date d;
	d.SetTimeOfDate(16, 50, 30);
	return 0;
}

最后分享一張圖片，對于類和物件的理解，

沒說的：內部類，再次理解封裝，這些自己下去看看就好，要理解，不要去死記硬背類與物件，

點贊富三代