C++ 重寫虛函數的代碼使用注意點+全部知識點+全部例子實現

h--------------------------
    #ifndef VIRTUALFUNCTION_H
    #define VIRTUALFUNCTION_H
    /*
     * 派生類中覆蓋虛函數的使用知識點
     * 1、返回值必須相同。 一個特例，返回值為本類類型的引用或指針，且可轉為基類類型。
     *          參見：
     *                  virtual virtualFunction * own()
     *                  double defaultChange() override
     *                  float defaultChange() override
     *
     * 2、參數類型必須相同，參數個數必須相同，參數類型的順序必須相同。
     *          參見：
     *                  void param(double, float, int) override
     *                  void param(int, double, float) override
     *
     * 3、虛函數帶有默認實參。
     *      a)基類指針或引用指向派生類對象，調用含有默認參數的虛函數時，在編譯時靜態綁定基類默認的實參值，而不是派生類的實參值。
     *        此情況將與預期不符合，值得注意。
     *          參見：
     *               virtual void defaultParam(int a = 10)
     *               void defaultParam(int a = 20) override
     *               pvf->defaultParam()
     *      b)派生類指針或引用，調用含有默認參數的虛函數時，也是編譯時靜態綁定基類默認的實參值，但綁定的是派生類的實參值。
     *          參見：
     *               virtual void defaultParam(int a = 10)
     *               void defaultParam(int a = 20) override
     *               ppf->defaultParam()
     *
     * 4、回避虛函數，或者說，用指向派生類對象的基類指針或引用去調用基類版本的虛函數
     *             參見：
     *                  pvf->virtualFunction::own()
     *
     *            ，或者說，在派生類中調用基類版本的虛函數
     *             參見：
     *                  void parentFunction::dieCircle()
     *
     *            ，或者說，用派生類對象調用基類版本的虛函數
     *             參見：
     *                  ppf->virtualFunction::own()
     *
     * 5、C++11新增關鍵字override,在派生類中標識虛函數被覆蓋。
     *      a)override可加可不加，添加override編譯器可以幫我們檢查重寫的函數返回值和參數是否符合規則，不符合規則會報錯。
     *      b)若不加override，把返回值或參數類型和順序寫錯了，便不是覆蓋，而是函數重載
     *          參見：
     *              double defaultChange() override
     *
     * 6、C++11新增關鍵字final。final可修飾類和成員函數。
     *                       a)被final修飾的類不可以用於派生基類。
     *                       b)被final修飾的成員函數不可以在派生類中被覆蓋。
     *          參見：
     *                  void finalVirtualFunc() override
     *                  class parentClass: public finalClass
     */
    
    class virtualFunction
    {
    public:
        virtualFunction();
        virtual virtualFunction * own();
        virtual float defaultChange();
        virtual void param(int, double, float);
        virtual void defaultParam(int a = 10);
        virtual void dieCircle();
        virtual void finalVirtualFunc() final;
    };
    
    class parentFunction: public virtualFunction
    {
    public:
        parentFunction * own() override; //正確
    
        //double defaultChange() override; //報錯 conflicting return type
        float defaultChange() override; //正確
    
        //void param(double, float, int) override;  //報錯 maked override, but does not override
        void param(int, double, float) override; //正確
    
        void defaultParam(int a = 20) override;
        void dieCircle() override;
    
    //    void finalVirtualFunc() override; //錯誤 error overriding final function
    };
    
    class finalClass final
    {};
    
    //class parentClass: public finalClass //錯誤：cannot derive from 'final' base 'finalCalss' in derived type 'parentClass'
    //{};
    
    #endif // VIRTUALFUNCTION_H



main-----------------------
#include "virtualfunction.h"
#include "finalfix.h"


int main(void)
{
    virtualFunction *pvf;
    parentFunction *ppf;
    pvf = new parentFunction();
    ppf = new parentFunction();

    pvf->own();
    pvf->virtualFunction::own();
    ppf->virtualFunction::own();

    pvf->defaultChange();

    pvf->param(0,0,0);
    pvf->defaultParam();
    ppf->defaultParam();

    pvf->dieCircle();
    //    system("pause");
    return 0;
}



打印輸出---------------
i am parentFunction father...
i am virualFunction son...
i am virualFunction son...
i am father float...
i am father, my param order is int - double - float...
i am father, my default param value is  10 ...
i am father, my default param value is  20 ...
i am son circle...
i am father circle...


cpp-------------------
#include "virtualfunction.h"
#include <QDebug>
virtualFunction::virtualFunction()
{

}

virtualFunction *virtualFunction::own()
{
    qDebug()<<"i am virualFunction son...";
}

float virtualFunction::defaultChange()
{
    qDebug()<<"i am son float...";
}

void virtualFunction::param(int, double, float)
{
    qDebug()<<"i am son , my param order is int - double - float...";
}

void virtualFunction::defaultParam(int a)
{
    qDebug()<<"i am son, my default param value is "<<a<<"...";
}

void virtualFunction::dieCircle()
{
    qDebug()<<"i am son circle...";
}

void virtualFunction::finalVirtualFunc()
{
    qDebug()<<"i am son final function, i can't be override...";
}

parentFunction *parentFunction::own()
{
    qDebug()<<"i am parentFunction father...";
}

void parentFunction::param(int, double, float)
{
    qDebug()<<"i am father, my param order is int - double - float...";
}

void parentFunction::defaultParam(int a)
{
    qDebug()<<"i am father, my default param value is "<<a<<"...";
}

void parentFunction::dieCircle()
{
//    dieCircle();  //錯誤，自己調用自己是死循環
    virtualFunction::dieCircle();
    qDebug()<<"i am father circle...";
}

//void parentFunction::param(double, float, int)
//{
//    qDebug()<<"i am father, my param order is double - float - int...";
//}

float parentFunction::defaultChange()
{
    qDebug()<<"i am father float...";
}