前言

本篇文章將會主要講解建構式的初始化串列,static成員,以及內部類,目的是對前幾章講解類時候的一個深入和總結.

再談建構式

我們上一節講解建構式時候,了解了建構式的定義和使用,明白編譯器會通過呼叫建構式給類成員一個初始值,但是注意了~~,這個程序卻并不是初始化,而是只能叫做賦初值,因為初始化只能一次,比如下面的一段代碼:

class A {
public:
    A(int c = 10) {
        cout << "A(int c)" << endl;
        _c = c;
    }
private:
    int _c;
};

class B {
public:
    B(int a,int b,A& ca) {
        _a = a;
        _b = b;
        _ca = ca;
    }
private:
    int _a;
    int _b;
    A _ca;
};

int main() {
    A a(20);
    B b(1,2,a);
    return 0;
}

大家覺得上面的結果會是什么?沒錯,會列印兩句A(int c),但是博主在這里有個小小問題,就這兩句分別在哪一行代碼后列印的呢?

答案:

• 第一次定義A物件后,會呼叫一次建構式,也就列印了第一句A(int c).
• 第二次列印確是在程式B(int a,int b,A& ca)之后,程式_a = a之前,也就是在這兩句之間,不信嗎?我們下圖為例:

當程式執行到_a = a以后,已經列印出了A(int c),那么這是為什么呢? 請看下一小節的初始化串列.

初始化串列

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

什么意思呢?如下:

class Date {
public:
    Date(int year, int month, int day) 
        :_year(year),_month(month),_day(day)
    {
    }
    void Print(){
        cout<<"year是"<<_year<<endl;
        cout<<"month是"<<_month<<endl;
        cout<<"day是"<<_day<<endl;
    }
private:
    int _year;
    int _month;
    int _day;
};

int main(){
    Date date(2021,10,23);
    date.Print();
	return 0;
}

我們可以清晰地看到,通過建構式的初始化串列,就已經成功初始化了類資料成員.所以現在大家應該已經明白了,為什么說初始化串列才是真正的初始化資料成員,而通過建構式的函式體賦值形式叫做初次賦值.因為在函式體內部的賦值性質是可以修改初始化串列的結果,比如把建構式改成下面這樣:

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

那么剛才的結果將會是這樣:

初始化串列注意點

①每個資料成員只能在初始化串列中出現一次(因為只能初始化一次),還是按照上面的Date類為例,若這樣寫就錯誤了:

Date(int year, int month, int day) 
    :_year(year),_month(month),_day(day),_year(2000),_month(10),_day(20)
{
}

②資料初始化順序只和資料宣告順序有關,與初始化串列無關:

class A
{
public:
	A(int a)
		:_a1(a)
		,_a2(_a1)
		{}
	void Print() {
		cout<<_a1<<" "<<_a2<<endl;
	}
private:
	int _a2;
	int _a1;
};

該類的結果為:

我們能夠發現,_a2的值并不是100,因為最開始初始化的資料就是_a2,但是給_a2的值缺是還沒有初始化的_a1

③當類中含有以下三種資料成員時候,對他們初始化必須使用初始化串列,分別是:

• 參考成員變數
• 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
};

explicit關鍵字

他的作用說簡單點就是不允許定義物件時候使用=形式初始化,比如:

class Date {
public:
    explicit Date(int n) 
    {
        _n = n;
    }
private:
    int _n;
};

int main()
{
    Date date1(100);  
    Date date2 = 100; //正常情況下,這樣也是可以初始化的,但是加了explict就不可以.
    return 0;
}

static成員

概念:主要有兩種,一種是修飾資料成員,稱為靜態成員變數.一種是修飾成員函式,稱為靜態成員函式.其中靜態成員變數必須在類外進行初始化,并且靜態成員大小不計算在類內.

其特性為:

靜態成員為所有類物件所共享，不屬于某個具體的實體

class Date {
 	public:
    Date(int b  = 10)
    {
        _a++;
        _b = b;
    }
    static void cntans()
    {
        cout<<_a<<endl;
    }
    private:
	static int _a;    
    int _b;
};

int Date::_a = 10;   //靜態成員必須在外面初始化.

int main()
{
    Date d1;
    Date d2;
    Date d3;
    d1.cntans();
    d2.cntans();
    d3.cntans();
    return 0;
}

大家猜猜會列印什么呢?答案如下:

可以清晰的看到,三次列印都是13,原因就是因為靜態成員由所有類物件共享,并不是屬于某個具體物件

類靜態成員即可用類名::靜態成員或者物件.靜態成員來訪問

在上面我們已經使用過了物件.靜態成員訪問格式,現在就介紹一下類名::靜態成員.

仍然以上面為例:

int main(){
	Date d1;
    Date::cntans();    //類名::靜態成員格式
    return 0;
}

靜態成員函式沒有隱藏的this指標，不能訪問任何非靜態成員

我們仍然以上面Date類為例,比如下面的修改cntans函式的錯誤形式:

    static void cntans()
    {
        cout<<_a<<endl;  //_a是靜態成員,類內訪問沒問題.
        cout<<_b<<endl; //但是_b是非靜態成員,由于沒有this指標,所以訪問_b非法.
    }

靜態成員和靜態函式也有public、protected、private3種訪問級別，也可以具有回傳值

這個博主就不再贅述,大家自行檢查.

友元

友元和靜態很相似,具有兩種.修飾函式的叫做友元函式,修飾類的叫做友元類.在我們介紹這個之前,先做一個小測驗吧,我們利用之前學過的多載運算子,對<<或者>>進行多載,實作的類仍然是我們上面的日期類

友元函式

class Date
{
public:
    Date(int year, int month, int day)
    : _year(year)
    , _month(month)
    , _day(day)
    {}
    
    ostream& operator<<(ostream& out)
    {
    	out<<_year<<"-"<<_month<<"-"<<_day;
    	return cout;
    }
private:
    int _year;
    int _month;
    int _day;
};

大家覺得我們這樣進行多載,會不會有什么問題呢?我們先呼叫一下試試吧.

Date date(2021,10,10);
cout << date;

我們進行編譯,運行然后就能發現結果報錯:

為什么呢?我們之前在講運算子多載時候強調過,我們在寫引數串列時,需要按照運算子的運算元格式進行多載.但是這里呢>我們按照了嗎,并沒有,因為這里有隱藏的this指標,也就是說運算元弄反位置了.那怎么進行修改呢?目前我們的辦法只有一個,那就是放到全域:

ostream& operator<<(ostream& out,Date& date)
{
    out << _year << "-" << _month << "-" << _day;
    return cout;
}

但是像這樣又會遇到一個問題,那就是_year等成員是私有的,在外部無法訪問.那又怎樣進行解決呢?現在就是我們的老大哥—friend友元駕臨.

這種情況我們只需要在類Date中的任何位置放一份多載函式宣告,并在前面加上friend.

class Date
{
    
    friend ostream& operator<<(ostream& out,Date& date);  //一般習慣性的是加在這里
    
public:
    Date(int year, int month, int day)
    : _year(year)
    , _month(month)
    , _day(day)
    {}    
private:
    int _year;
    int _month;
    int _day;
};

注意:友元函式,只需要在函式的宣告前加上friend就行,并且友元不屬于任何類,只是為了突破類的作用域限制,以達到訪問類的私有或保護成員.

并且友元函式不可以用const進行修飾,不受任何的類作用域符限制,而同一個友元函式還可以是多個類的友元.

友元類

友元類和友元函式相似,當一個類A是類B的友元類后,類A便可以訪問B的任何成員和函式.使用方法和友元函式一模一樣,不再介紹.

內部類

概念：如果一個類定義在另一個類的內部，這個內部類就叫做內部類，注意此時這個內部類是一個獨立的類，它不屬于外部類，更不能通過外部類的物件去呼叫內部類，外部類對內部類沒有任何優越的訪問權限，
注意：內部類就是外部類的友元類，注意友元類的定義，內部類可以通過外部類的物件引數來訪問外部類中的所有成員，但是外部類不是內部類的友元.

特性：

1. 內部類可以定義在外部類的public、protected、private都是可以的，
2. 注意內部類可以直接訪問外部類中的static、列舉成員，不需要外部類的物件/類名，
3. sizeof(外部類)=外部類，和內部類沒有任何關系

class A
{
private:
    static int k;
    int h;
public:
    class B
    {
    public:
        void foo(const A& a)
        {
            cout << k << endl;//
            cout << a.h << endl;//   //想要訪問外部類的其他成員,必須通過外部類的物件引數.
        }
    };
};
int A::k = 1;

int main()
{
    A::B b;        //定義內部類,只能通過作用域限制符.
    b.foo(A());
    return 0;
}