?

目錄

1、再談構(gòu)造函數(shù)

1.1 構(gòu)造函數(shù)體賦值

1.2 初始化列表

1.2.1 初始化列表的意義

1.3 explicit關(guān)鍵字

2、static成員

2.1 問題引入

2.2 特性

3、友元

3.1 友元函數(shù)

3.2 友元類

4、內(nèi)部類

1、再談構(gòu)造函數(shù)

1.1 構(gòu)造函數(shù)體賦值

在創(chuàng)建對象時(shí)，編譯器通過調(diào)用構(gòu)造函數(shù)，給對象中各個(gè)成員變量一個(gè)合適的初始值。

class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}

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

我們構(gòu)造函數(shù)盡量給全缺省，這樣就算想要實(shí)例化一個(gè)無參的對象這一個(gè)函數(shù)就兼顧了。

雖然上述構(gòu)造函數(shù)調(diào)用之后，對象中已經(jīng)有了一個(gè)初始值，但是不能將其稱為對對象中成員變量的初始化，構(gòu)造函數(shù)體中的語句只能將其稱為賦初值，而不能稱作初始化。因?yàn)?strong>初始化只能初始化一次，而構(gòu)造函數(shù)體內(nèi)可以多次賦值。

1.2 初始化列表

初始化列表：以一個(gè)冒號開始，接著是一個(gè)以逗號分隔的數(shù)據(jù)成員列表，每個(gè)"成員變量"后面跟一個(gè)放在括號中的初始值或表達(dá)式。

我們繼續(xù)以Date類來展開看：

class Date
{
public:

	// 初始化列表
	Date(int year, int month, int day)
		: _year(year)
		, _month(month)
		, _day(day)
	{}

private:
	// 成員變量聲明
	int _year;
	int _month;
	int _day;
};

上面的代碼就是初始化列表的實(shí)現(xiàn)。

1.2.1 初始化列表的意義

初始化列表是對象的成員變量定義的地方。

有些變量只能在定義的地方初始化：

a. const修飾的變量； b. 引用變量； c. 自定義類型（沒有默認(rèn)構(gòu)造函數(shù)）。

class A
{
public:
	A(int a)
		:_a(a)
	{}

private:
	int _a;
};
class Date
{
public:
	// 初始化列表
	Date(int year, int month, int day, int& i)
		: _year(year)
		, _month(month)
		, _day(day)
		, _x(1)
		, _refi(i)
		, _a(1)
	{}

private:
	// 成員變量的聲明
	int _year;
	int _month;
	int _day;

	// 定義時(shí)必須初始化
	const int _x;
	int& _refi;
	A _a;
};

成員變量給缺省值就是給初始化列表的；初始化列表如果沒有顯示定義內(nèi)置類型編譯器會(huì)給默認(rèn)定義并給隨機(jī)值；給缺省并初始化給值使用初始化給的值。

對于定義時(shí)必須初始化的成員變量我們看看放在函數(shù)體里賦初值的情況：

這里就會(huì)出錯(cuò)，因此初始化列表對于這樣的情況是很適用的。

注意：

1. 每個(gè)成員變量在初始化列表中只能出現(xiàn)一次(初始化只能初始化一次)
2. 類中包含以下成員，必須放在初始化列表位置進(jìn)行初始化：
a. 引用成員變量
b. const成員變量
c. 自定義類型成員(且該類沒有默認(rèn)構(gòu)造函數(shù)時(shí))
3. 盡量使用初始化列表初始化，因?yàn)椴还苣闶欠袷褂贸跏蓟斜?，對于自定義類型成員變量，一定會(huì)先使用初始化列表初始化。
4. 成員變量在類中聲明次序就是其在初始化列表中的初始化順序，與其在初始化列表中的先后次序無關(guān)

初始化后在構(gòu)造函數(shù)體里面還可以再給賦值。

1.3 explicit關(guān)鍵字

構(gòu)造函數(shù)不僅可以構(gòu)造與初始化對象，對于單個(gè)參數(shù)或者除第一個(gè)參數(shù)無默認(rèn)值其余均有默認(rèn)值的構(gòu)造函數(shù)，還具有類型轉(zhuǎn)換的作用。

class Date
{
public:
	Date(int year)
		: _year(year)
	{}

private:
	int _year;
};
int main()
{
	Date d1(2023);

	// 隱式類型轉(zhuǎn)換
	Date d2 = 2023;// 2023調(diào)用構(gòu)造函數(shù)生成臨時(shí)對象，再用臨時(shí)對象去拷貝構(gòu)造d2	

	return 0;
}

2023是int類型，但是將它賦值給Date類型的d2沒有報(bào)錯(cuò)，這就是因?yàn)?023發(fā)生了隱式類型轉(zhuǎn)換。如果我們不想讓發(fā)生隱士類型轉(zhuǎn)換，給構(gòu)造函數(shù)前加一個(gè)explicit修飾。

用explicit修飾構(gòu)造函數(shù)，將會(huì)禁止構(gòu)造函數(shù)的隱式轉(zhuǎn)換。

引申：

在C++11中，允許多參數(shù)的隱式類型轉(zhuǎn)換。

class Date
{
public:
	Date(int year, int month, int day)
		: _year(year)
		, _month(month)
		, _day(day)
	{}

private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	// 隱式類型轉(zhuǎn)換
	Date d = { 2023, 8, 7 };// 多參數(shù)隱式類型轉(zhuǎn)換要用{}將多個(gè)參數(shù)括起來	
	const Date& d1 = { 2023, 1, 1 };// 轉(zhuǎn)換時(shí)生成的臨時(shí)變量具有常性，因此需要const修飾
    
	return 0;
}

多參數(shù)隱式類型轉(zhuǎn)換要用 {} 將多個(gè)參數(shù)括起來。

2、static成員

2.1 問題引入

我們來統(tǒng)計(jì)一下A類創(chuàng)建了多少個(gè)，正在使用的多少個(gè)？

// 創(chuàng)建了多少個(gè)對象
int n = 0;
// 正在使用的有多少個(gè)對象
int m = 0;
class A
{
public:
	A() 
	{ 
		++n;
		++m;
	}
	A(const A & t) 
	{
		++n;
		++m;
	}
	~A() 
	{
		--m;
	}
};
A func(A aa)
{
	return aa;
}
int main()
{
	A a1;
	A a2;
	cout << n << " " << m << endl;

	A();// 匿名對象，在本行創(chuàng)建并在本行銷毀
	cout << n << " " << m << endl;

	func(a1);
	cout << n << " " << m << endl;

	return 0;
}

運(yùn)行結(jié)果：

我們能看到全局變量是可以實(shí)現(xiàn)的，但是全局變量是不安全的（全局變量在全局都可以進(jìn)行修改），并且是不利于封裝的，因此我們不用這樣的方法。

我們改一下方法來實(shí)現(xiàn)：

我們將計(jì)數(shù)器放在類里面，定義為私有的，但只是這樣還是不滿足，我們每創(chuàng)建一個(gè)對象就會(huì)有一個(gè)n與m，我們的目的是對象公用，因此我們使用static修飾，這樣就解決了這兩個(gè)問題。

class A
{
public:
	A() 
	{ 
		++n;
		++m;
	}
	A(const A & t) 
	{
		++n;
		++m;
	}
	~A() 
	{
		--m;
	}

//private:
	// 創(chuàng)建了多少個(gè)對象
	static int n;
	// 正在使用的有多少個(gè)對象
	static int m;
};
int A::n = 0;
int A::m = 0;

A func(A aa)
{
	return aa;
}
int main()
{
	cout << "sizeof(A):" << sizeof(A) << endl;

	A a1;
	A a2;
	cout << A::n << " " << A::m << endl;

	A();// 匿名對象，在本行創(chuàng)建并在本行銷毀
	cout << a1.n << " " << a2.m << endl;

	func(a1);
	cout << a1.n << " " << a2.m << endl;

	return 0;
}

這里static修飾之后n與m是靜態(tài)成員變量就不是某一個(gè)對象的了，而是所有對象的，因此不是存在于對象中，而是存在于靜態(tài)區(qū)的（sizeof算出來為1，是一個(gè)空類）。

其次，類里只是成員變量的聲明，靜態(tài)成員變量必須在類外定義，定義時(shí)就不需要再加static。
如果靜態(tài)成員我們定義成私有的，需要提供Get接口來訪問n，m

class A
{
public:
	A() 
	{ 
		++n;
		++m;
	}
	A(const A & t) 
	{
		++n;
		++m;
	}
	~A() 
	{
		--m;
	}

	int GetN()
	{
		return n;
	}
	int GetM()
	{
		return m;
	}

private:
	// 創(chuàng)建了多少個(gè)對象
	static int n;
	// 正在使用的有多少個(gè)對象
	static int m;
};
int A::n = 0;
int A::m = 0;

A func(A aa)
{
	return aa;
}
int main()
{
	A a1;
	A a2;
	cout << a1.GetN() << " " << a1.GetM() << endl;

	A();// 匿名對象，在本行創(chuàng)建并在本行銷毀
	cout << a1.GetN() << " " << a1.GetM() << endl;

	func(a1);
	cout << a1.GetN() << " " << a1.GetM() << endl;


	return 0;
}

假如我們只創(chuàng)建了兩個(gè)匿名對象，想要看n、m，沒有對象是調(diào)用不了的，要是創(chuàng)建一個(gè)對象去調(diào)用，這就影響了n、m，因此我們將函數(shù)也改為靜態(tài)的，這時(shí)只需要加上類域就可以訪問了。

class A
{
public:
	A() 
	{ 
		++n;
		++m;
	}
	A(const A & t) 
	{
		++n;
		++m;
	}
	~A() 
	{
		--m;
	}

	// 靜態(tài)成員函數(shù)的特點(diǎn)：沒有this指針
	static int GetN()
	{
		return n;
	}
	static int GetM()
	{
		return m;
	}

private:
	// 靜態(tài)成員變量屬于所有A對象，屬于整個(gè)類
	// 創(chuàng)建了多少個(gè)對象
	static int n;
	// 正在使用的有多少個(gè)對象
	static int m;
};
int A::n = 0;
int A::m = 0;

A func(A aa)
{
	return aa;
}
int main()
{
	A a1;
	A a2;
	cout << A::GetN() << " " << A::GetM() << endl;

	A();// 匿名對象，在本行創(chuàng)建并在本行銷毀
	cout << A::GetN() << " " << A::GetM() << endl;

	func(a1);
	cout << A::GetN() << " " << A::GetM() << endl;

	return 0;
}

注意：靜態(tài)成員函數(shù)里不能訪問非靜態(tài)成員函數(shù)，因?yàn)闆]有this指針。一般static修飾的成員變量于static修飾的成員函數(shù)是配套使用的。

2.2 特性

1. 靜態(tài)成員為所有類對象所共享，不屬于某個(gè)具體的對象，存放在靜態(tài)區(qū)
2. 靜態(tài)成員變量必須在類外定義，定義時(shí)不添加static關(guān)鍵字，類中只是聲明
3. 類靜態(tài)成員即可用 類名::靜態(tài)成員 或者 對象.靜態(tài)成員 來訪問
4. 靜態(tài)成員函數(shù)沒有隱藏的this指針，不能訪問任何非靜態(tài)成員
5. 靜態(tài)成員也是類的成員，受public、protected、private 訪問限定符的限制

3、友元

友元分為友元函數(shù)與友元類。

友元提供了一種突破封裝的方式，有時(shí)提供了便利。但是友元破壞了封裝，所以友元不宜多用。

3.1 友元函數(shù)

問題：上一篇中我們實(shí)現(xiàn)了Date類的所有需要重載的運(yùn)算符，如果我們需要使用cout來打印自定義類型對象，我們需要對流插入符號進(jìn)行重載。

打印的格式為cout << " " << endl;

那么重載流插入符號就不可以在類里面，在類里第一個(gè)參數(shù)是隱含的this指針，會(huì)與cout搶第一個(gè)參數(shù)位置，因此我們只能定義在類外面。
放在外面我們就無法訪問類成員變量了，這里就該我們的友元上場了。

友元函數(shù)可以直接訪問類的私有成員，它是定義在類外部的普通函數(shù)，不屬于任何類，但需要在類的內(nèi)部聲明，聲明時(shí)需要加friend關(guān)鍵字。

class Date
{
	// 友元
	friend ostream& operator<<(ostream& out, const Date& d);
	friend istream& operator>>(istream& in, Date& d);

public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}

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

ostream& operator<<(ostream& out, const Date& d)
{
	out << d._year << " " << d._month << " " << d._day;
	return out;
}
istream& operator>>(istream& in, Date& d)
{
	in >> d._year >> d._month >> d._day;
	return in;
}

int main()
{
	Date d1;
	cin >> d1;
	cout << d1;
}

運(yùn)行結(jié)果：

說明：

友元函數(shù)可訪問類的私有和保護(hù)成員，但不是類的成員函數(shù)
友元函數(shù)不能用const修飾（友元函數(shù)沒有this指針）
友元函數(shù)可以在類定義的任何地方聲明，不受類訪問限定符限制
一個(gè)函數(shù)可以是多個(gè)類的友元函數(shù)
友元函數(shù)的調(diào)用與普通函數(shù)的調(diào)用原理相同

3.2 友元類

友元類的所有成員函數(shù)都可以是另一個(gè)類的友元函數(shù)，都可以訪問另一個(gè)類中的非公有成員。

class Time
{
	friend class Date; // 聲明日期類為時(shí)間類的友元類，則在日期類中就直接訪問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;
};

class Date
{
	// 友元
	friend ostream& operator<<(ostream& out, const Date& d);
	friend istream& operator>>(istream& in, Date& d);

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)
    {
    // 直接訪問時(shí)間類私有的成員變量
    _t._hour = hour;
    _t._minute = minute;
    _t._second = second;
    }

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

};
ostream& operator<<(ostream& out, const Date& d)
{
	out << d._year << " " << d._month << " " << d._day;
	return out;
}
istream& operator>>(istream& in, Date& d)
{
	in >> d._year >> d._month >> d._day;
	return in;
}

1、友元關(guān)系是單向的，不具有交換性。
比如上述Time類和Date類，在Time類中聲明Date類為其友元類，那么可以在Date類中直接訪問Time類的私有成員變量，但想在Time類中訪問Date類中私有的成員變量則不行。
2、友元關(guān)系不能傳遞
如果C是B的友元， B是A的友元，則不能說明C時(shí)A的友元。

4、內(nèi)部類

概念：如果一個(gè)類定義在另一個(gè)類的內(nèi)部，這個(gè)內(nèi)部類就叫做內(nèi)部類。就是在一個(gè)類里面再定義一個(gè)類，內(nèi)部類是一個(gè)獨(dú)立的類，它不屬于外部類，更不能通過外部類的對象去訪問內(nèi)部類的成員。外部類對內(nèi)部類沒有任何優(yōu)越的訪問權(quán)限。

class A
{
public:
	class B
	{

	private:
		int _b;
	};
	int _a;
};
int main()
{
	cout << sizeof(A) << endl;
}

這里打印出來是4，因此我們可以知道，sizeof(外部類) = 外部類的大小，雖然里面嵌套了內(nèi)部類，但內(nèi)部類是不算在外部類大小里面的。

其次，內(nèi)部類默認(rèn)是外部類的友元類。

class A
{
public:
	class B
	{
	public:
		void func()
		{
			A a;
			a._a = 1;
			cout << a._a << endl;
		}

	private:
		int _b;
	};

private:
	int _a;
};
int main()
{
	A::B b;
	b.func();

	return 0;
}

我們在B類中定義了一個(gè)函數(shù)，函數(shù)里面訪問A類的成員變量_a，并且給其賦值了，來看是否可以正常運(yùn)行。

我們這里可以看到，在B類中可以訪問到A類的成員變量，并且為其賦值了。這就可以看出來B類是A類的友元。

但是，A類不是B類的友元，友元是單向的。

特性：

1. 內(nèi)部類可以定義在外部類的public、protected、private都是可以的。
2. 注意內(nèi)部類可以直接訪問外部類中的static成員，不需要外部類的對象/類名。
3. sizeof(外部類)=外部類，和內(nèi)部類沒有任何關(guān)系。文章來源地址http://www.zghlxwxcb.cn/news/detail-650898.html

到了這里，關(guān)于[C++]類與對象（下） -- 初始化列表 -- static成員 -- 友元 -- 內(nèi)部類，一篇帶你深度了解。的文章就介紹完了。如果您還想了解更多內(nèi)容，請?jiān)谟疑辖撬阉鱐OY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！