C++基類、派生類、虛函數的幾個知識點

1.盡管派生類中含有基類繼承來的成員，但派生類初始化這部分變量需要調用基類的構造函數。

class A
{
private:
    int x;
    virtual void f(){cout<<"A f"<<endl;}
public:
    A(/* args */){x=1;cout<<"A構造"<<endl;}
    ~A(){}
    friend void p(const A& a){cout<<a.x;}
};
class B:A{
    public:
    void f() override {cout<<"B f"<<endl;}
    operator A()const {}
};
int main()
{
    B x;
    system("pause");
    return 0;
}

 2.如果基類定義了一個靜態成員，則整個繼承體系中只存在該成員的唯一定義。並且不論基類派生出多少派生類，該靜態成員只存在唯一實例。

並且屬性也一致。基類中某靜態成員是public，派生類中也是public。如果基類中是private，那么派生類也無法調用該靜態成員。

/* 基類的靜態成員 */

#include<iostream>

using namespace std;

class base
{
public:
    static int num;

    base()
    {
        num+=1;
    }

    ~base()
    {
        num-=1;
    }
};

// 基類定義的靜態成員,被所有派生類共享 
// 起到計數器的作用，自身還有所有派生類對象的個數
// 遵循私有 公有 保護的繼承機制 訪問不同
// 可以通過父類  子類對象訪問 還可以通過父類  子類類名訪問
int base::num = 0;// 類的靜態成員

class basenew : public base
{
    
};

class basenewx : public basenew
{
    
};


void main()
{
    basenew *p = new basenew[100];

    base *p1 = new base[40]

    basenewx *p2 = new basenewx[50];
    
    cout << p->num << endl;// 190
    cout << p1->num << endl;// 190
    cout << p2->num << endl;// 190


    cin.get();
}

3.如果不想讓某個類被繼承，在類名后加final關鍵字。

 

final除了可以修飾類外，還可以修飾成員函數。還可以指明某個基類的虛函數不能被其派生類版本覆蓋，如下：

首先要明確覆蓋（override）與重載（overload）的定義，區別出什么是覆蓋和重載：

覆蓋就是派生類中虛成員函數覆蓋基類中同名且參數相同的成員函數。

class A
{
public:
    A(/* args */){}
    virtual void f()final {}
    virtual ~A(){}
};
class B:public A{
    public:
    void f(int x){}//重載（overload）
    void f(){}  //覆蓋（override，非法，因為A中的f聲明了final）
};

 

 4.派生類對象是基類對象，派生類中包含有基類的成員。基類對象不是派生類對象，它不能包含派生類型的成員。

派生類可以向基類轉化（僅限指針和引用），基類不能向派生類轉化（畢竟派生類有多余的數據，基類沒法自己生成）

如果用派生類對象為一個基類對象初始化或者賦值，只有其中的基類部分會被拷貝/移動/賦值，它的派生類部分會被忽略。

class A
{
private:
    int x;
public:
    A(/* args */){x=1;cout<<"A構造"<<endl;}
    virtual ~A(){}
};
class B:public A{
    
};
int main()
{
    A x;
    B y;
    A* p=&y;//正確，將基類指針指向派生類變量，派生類指針隱式轉換為基類指針。
    B* q=&x;//錯誤
    system("pause");
    return 0;
}

5.動態綁定（即dynamic bninding）只有當我們通過指針或者引用調用虛函數時才會發生。

由於繼承導致對象的指針和引用具有兩種不同的類型：靜態類型和動態類型。
靜態類型：指針或者是引用聲明時的類型。
動態類型：由實際指向的類型確定。

其中靜態類型編譯時就已經確定，動態類型只有到運行的時候才能知道。所以如果用普通類類型調用虛函數，編譯時就會把要調用的虛函數版本確定下來。

class A
{
public:
    A(/* args */){}
    virtual void f(){cout<<"基類的f"<<endl;}
    virtual ~A(){}
};
class B:public A{
    public:
    void f(){cout<<"派生類的f"<<endl;}
};
void F(A& p){
    p.f();
}
int main()
{
    A x;
    B y;
    F(x);
    F(y);
    system("pause");
    return 0;
}

可以看到同一個函數F，因為調用不同類型實參，最終在內部調用了不同版本的f函數，這就是動態綁定。

 

 

如果F的形參改成普通類型，那么兩次都會調用基類的f函數，其中F(y)會把y隱式類型轉換為一個A類型的臨時變量傳給形參。

 

 

6.如果一個派生類虛函數需要調用其基類版本，但沒有使用“基類::”修飾，則運行時該調用會被解析為對其自身的調用，這將導致無限遞歸。

7.派生類中的虛函數可以在形參后加override，顯式告知編譯器該虛函數覆蓋了其基類版本。