C++深入探究重載重寫覆蓋的區(qū)別

更新時間：2022年08月08日 15:33:13 作者：戀戀風辰

C++ 允許多個函數(shù)擁有相同的名字，只要它們的參數(shù)列表不同就可以，這就是函數(shù)的重載（Function Overloading），借助重載，一個函數(shù)名可以有多種用途

基類實現(xiàn)

我們先實現(xiàn)一個基類

class BaseTest
{
private:
    virtual void display() { cout << "Base display" << endl; }
    void say() { cout << "Base say()" << endl; }
public:
    virtual void func() { cout << "Base func()" << endl; }
    void exec()
    {
        display();
        say();
    }
    void f1(string a) { cout << "Base f1(string)" << endl; }
    void f1(int a) { cout << "Base f1(int)" << endl; }
    void exec2()
    {
        display();
        say();
    }
};

BaseTest類中我們實現(xiàn)了一個虛函數(shù)display和 func。

BaseTest類內部重載了f1函數(shù)，實現(xiàn)了兩個版本，一個參數(shù)為string一個參數(shù)為int。

同一個類中的多個同名函數(shù)叫做重載。

實現(xiàn)了普通函數(shù)say，exec以及exec2函數(shù)。exec和exec2函數(shù)內部調用了display和say函數(shù)。

子類實現(xiàn)

子類DeriveA繼承了基類

class DeriveA : public BaseTest
{
public:
    void display() { cout << "DeriveA display()" << endl; }
    void f1(int a, int b) { cout << "DeriveA f1(int,int)" << endl; }
    void say() { cout << "DeriveA say()" << endl; }
    virtual void func() { cout << "DeriveA func()" << endl; }
    void use_base_f1(int a, int b)
    {
        BaseTest::f1(2);
        BaseTest::f1("test");
        cout << "DeriveA f1(int, int)" << endl;
    }
    void exec2()
    {
        display();
        say();
    }
};

子類DeriveA 子類重新實現(xiàn)了display和func函數(shù)，子類重新實現(xiàn)父類的虛函數(shù)，叫做重寫。

同樣子類重新實現(xiàn)了f1和say函數(shù)，由于父類有f1和say，所以子類重新實現(xiàn)覆蓋了父類的函數(shù)，

這種普通函數(shù)被子類重寫導致父類的函數(shù)被隱藏了，叫做覆蓋。

函數(shù)調用

接下來我們通過函數(shù)調用，看一下覆蓋，重載和重寫的區(qū)別

void derive_base_test1()
{
    DeriveA a;
    BaseTest *b = &a;
    shared_ptr<BaseTest> c = make_shared<BaseTest>();
    //輸出DeriveA func()
    b->func();
    //輸出DeriveA func()
    a.func();
    //輸出Base f1(string)
    b->f1("abc");
    //輸出Base f1(int)
    b->f1(3);
    //輸出DeriveA f1(int,int)
    a.f1(3, 5);
    a.use_base_f1(2, 4);
    cout << "========================" << endl;
    //輸出DeriveA display()
    //輸出Base say()
    b->exec();
    //輸出DeriveA display()
    //輸出Base say()
    a.exec();
    //輸出Base display
    //輸出Base say()
    c->exec();
    cout << "======================== \n"
         << endl;
    //輸出 DeriveA display()
    //輸出 Base say()
    b->exec2();
    //輸出 DeriveA display()
    //輸出 DeriveA say()
    a.exec2();
    //輸出 Base display
    //輸出 Base say()
    c->exec2();
}

代碼里我們生成了一個DeriveA的實例a, 并將該實例返回給基類BaseTest的指針b，所以：

1 b->func();會根據(jù)多態(tài)的效果調用子類DeriveA的func函數(shù)

2 a.func() 因為a是一個對象，所以調用子類DeriveA的func函數(shù)

3 b->f1(“abc”) 調用基類BaseTest的f1，因為f1是一個普通函數(shù)

4 a.f1(3, 5) 調用DeriveA的f1，因為a是一個普通對象。

5 當我們想在子類里調用基類的f1函數(shù)，可以通過基類作用域加函數(shù)名的方式，比如例子中的

a.use_base_f1就在函數(shù)內部通過BaseTest::f1調用了基類函數(shù)f1

6 b->exec，首先b是一個指針且exec為普通函數(shù)只在基類實現(xiàn)了，所以調用基類的exec，

但是exec內部調用了虛函數(shù)display，此時觸發(fā)多態(tài)機制調用DeriveA的display函數(shù)，因為b是一個指向子類DeriveA對象的基類BaseTest指針，exec內部調用了普通函數(shù)display，因為display不是虛函數(shù)，所以調用BaseTest的display函數(shù)

7 a.exec(); a是一個DeriveA對象，DeriveA自己沒有實現(xiàn)exec函數(shù)，所以調用基類BaseTest的exec函數(shù)，exec內部調用display虛函數(shù)時由于DeriveA重寫了display函數(shù)，所以調用DeriveA的display函數(shù)，exec內部調用say函數(shù)時由于say是普通函數(shù)，所以此時調用的是BaseTest的say函數(shù)。

8 c->exec(); 因為c為BaseTest類型，所以調用的就是BaseTest的exec，內部執(zhí)行的也是BaseTest的display和say。

9 b->exec2(); 因為b是一個子類BaseTest的指針，所以調用BaseTest的exec2函數(shù)，exec2內部調用display時觸發(fā)多態(tài)機制調用DeriveA的display，調用say時因為say是普通函數(shù)，所以調用BaseTest的say函數(shù)。

10 a.exec2(); 因為a是DeriveA類對象，且DeriveA實現(xiàn)了exec2，所以a調用DeriveA的exec2，這樣exec2內部調用的都是DeriveA的say和display

11 c->exec2(); c為BaseTest類對象，所以調用BaseTest類的exec2以及display和say函數(shù)。