Fucking in c++第十三章筆記

 

1、組合就是由類成員（或稱成員類）組成新類

2、繼承實際上也是由基類做子成組成新類，但語法上有不同，體現了OOP的思想

基類在繼承類中默認是私有的，以Y:public X形式繼承則變為公有。

從繼承類的外部調用基類的任何成員都要加上基類名，如Y y; y.X::f( ); 而對于成員類則要加上對象名y.x.f( );

3   由于C++強制初始化，因此基類和成員類都必須在新類的構造函數初始化列表中初始化

初始化語法：對于基類，使用類名調用構造函數；對于成員類，使用對象名調用構造函數，如Y::Y(int i):X(i), x(i) {}

4    繼承類默認繼承了基類的成員函數，即，在不重定義的前提下,y.f( )和y.X::f( )調用的同一個函數

而組合類則必須通過成員類對象進行函數調用

繼承類和組合類的構/析造函數調用次序相反，前者從基類到子類

5   如果重定義了基類的函數，則基類的同名函數全部自動隱藏。

所謂“全部”是因為，可能在基類中有多個同名的重載函數，它們全部隱藏

所謂“隱藏”不是說不能調用，而是說，當調用y.f( )時調用的是Y中定義的新f( )，想調用基類的f則要顯式說明y.X::f( )

6   所有構造函數、析構函數、operator=都不能自動繼承

但編譯器會自動生成默認構造函數、拷貝構造函數、operator=，并正確地調用基類的相應函數，它們工作的很好

自動類型轉換函數會自動繼承

    如果想讓編譯器自動創建子類的默認構造函數，我們就不能為子類定義任何（包括拷貝）構造函數。這和普通類的規則是一樣的

但是如果不為子類定義任何構造函數，則只能使用自動生成的默認和拷貝構造函數

因此，如果想為子類定義帶參數的構造函數，則必須同時也定義子類的默認構造函數

如果自定義了拷貝構造函數，則也必須同時自定義默認構造函數

在子類的默認構造函數中，如果想調用基類的默認構造函數，無需顯式調用

在子類的拷貝構造函數中，如果想調用基類的拷貝構造函數，必須顯式在初始化列表調用，否則自動調用默認構造函數

在子類的operator=中，如果想調用基類的operator=，必須顯式在函數體中調用，否則編譯器什么也不做

8   靜態成員函數的繼承規則和非靜態成員函數一樣，只是static成員函數不能是virtual

9    所以最好的方案是：

如果不定義帶參數的構造函數，就什么都不要動，編譯器自動生成符合要求的默認/拷貝構造、析構、operator=

如果必須定義帶參構造函數，就要同時定義默認構造函數，但定義時無需顯式調用基類默認構造函數

沒事就不要自定義拷貝構造函數和operator=，如果一定要重定義，必須顯式調用基類的拷貝構造函數和operator=

10   可以看到，組合類和繼承類的編譯器實現是一樣的

到目前為止，兩者區別在于繼承類繼承了基類的函數接口，繼承是is-a關系，組合是has-a關系

C++默認是私有繼承，即此時并不能直接通過子類對象調用基類函數（即y.X::f()），而要在Y內用using X::f;

11   protected的意義是僅自己和子類可以訪問自己的成員，外部不可訪問

private-protected-public的關系很像linux中文件權限的owner-group-others的關系

也可以protected繼承，但通常沒有應用實例，它的存在只為語言的完備性 

12 除operator=之外的所有基類運算符都會自動繼承，但它們操作的都是子類中“基類的成員”

，即，如果X和Y都有int成員i，則Y y;++y;加的是X中的i，而不是y中的i；同理operator==的意義也不會檢測y中的i

13   C++支持多重繼承，但作者認為多重繼承總可以轉化為單重繼承，并且多重繼承很難掌握，因此不建議使用。

14   繼承和組合的優點之一是支持漸進式開發。程序員應當更多關心處理數據關系，而不是進行具體的位操作

15   子類可以自動向上類型轉換為基類，這對于類本身、類指針、類引用都有效

在編譯器自動生成的子類拷貝構造函數中，首先執行基類拷貝構造函數，之后按聲明順序執行成員類拷貝構造函數

多重繼承可以通過組合類的形式代替

指針和引用被自動向上類型轉換之后，子類的成員會不能訪問，這將通過下一章的virtual函數解決

////////////////////////////////////////

#include <iostream>
using namespace std;

class A {
    int i;
public:
    A( int I ) { i = I; 
    cout<<"a is fucking"<<endl;}
    ~A() {cout<<"a is not fucking"<<endl;}
    void f() const {}
};
class B {
    int i;
public:
    B( int I ) { i = I;cout<<"b is fucking"<<endl; }
    ~B() {cout<<"b is not fucking"<<endl;}
    void f() const {}
};
class C : public B {
    A a;
public:
    C( int I ) :  a( I ),B( I ) {cout<<"c is fucking"<<endl;}//調用了基類的構造函數和成員對象的構造函數
    ~C() {cout<<"c is not fucking"<<endl;}//調用~A與~B
    void f() const {//重定義了所繼承的B::f(),并且還調用基類的版本。（只能在繼承期間重定義函數）
        a.f();//通過成員對象，只能操作這個對象的公共接口，而不能重定義它
        B::f();//
    }
};


int main()
{
    C c(3);
    return 0;
}

結果：
b is fucking
a is fucking
c is fucking
c is not fucking
a is not fucking
b is not fucking
先初始化基類，隨后構造組合類，之后才是子類，析構順序正好相反，恰好回答了上次做錯的筆試題