重寫父類函數時的特殊狀況

1.靜態父類方法

       在C++中沒法重寫靜態方法。其實子類和父類存在同名的靜態方法，它們是兩個獨立的方法。靜態方法是屬於類的，調用是經過類名而不是對象，雖然也能夠經過對象調用靜態方法，也就至關與class::function，可是C++在調用靜態方法時，不關心對象實際是什麼，只是關心編譯時的類型。以下的結果：

       

/************************************************
*
*author:周翔
*e-mail:604487178@qq.com
*blog:http://blog.csdn.net/zhx6044
*
*
*************************************************/

#ifndef SUPER_HPP
#define SUPER_HPP

#include <iostream>
/**
 * @brief The Super class 超類  父類
 */
class Super
{
public:
    Super() {}
    virtual ~Super() {}
    virtual void fun(const std::string &arg = "Super") const {
        std::cout << arg << '\n';
    }

    static void staticFun() {
        std::cout << "Super Static Function!\n";
    }
};

#endif // SUPER_HPP
/************************************************
*
*author:周翔
*e-mail:604487178@qq.com
*blog:http://blog.csdn.net/zhx6044
*
*
*************************************************/

#ifndef SUB_HPP
#define SUB_HPP
#include "super.hpp"

/**
 * @brief The Sub class 子類
 */
class Sub : public Super
{
public:
    Sub():Super() {}
    virtual void fun(const std::string &arg = "Sub") const{
        std::cout << arg << '\n';
    }

    static void staticFun() {
        std::cout << "Sub Static Function!\n";
    }
};

#endif // SUB_HPP
#include "sub.hpp"


int main()
{
    Super::staticFun();
    Sub::staticFun();
    Sub su;
    Super &s = su;
    s.staticFun();
    return 0;
}

因此子類不要重寫靜態方法，那是新的方法，還有就是靜態方法調用經過類名。

2.父類方法被重載

    當指定名稱以及一組參數重寫某個方法時，編譯器會隱式的隱藏父類中的同名方法的全部其餘實例。它的意思是，你居然重寫了其中的一個，那麼重載的你也應該所有重寫，由於是相同的方法名，功能其實也應該是相同的，只是參數不同樣而已，你居然改變一個方法，那說明功能所有要改變。

   

/************************************************
*
*author:周翔
*e-mail:604487178@qq.com
*blog:http://blog.csdn.net/zhx6044
*
*
*************************************************/

#ifndef SUPER_HPP
#define SUPER_HPP

#include <iostream>
/**
 * @brief The Super class 超類  父類
 */
class Super
{
public:
    Super() {}
    virtual ~Super() {}
    virtual void fun(const std::string &arg = "Super") const {
        std::cout << arg << '\n';
    }

    static void staticFun() {
        std::cout << "Super Static Function!\n";
    }
    //下面爲兩個重載的函數
    virtual void overload() const {
        std::cout << "Super overload()\n";
    }

    virtual void overload(int t) const {
        std::cout << "Super overload(int) and arg is " << t << '\n';
    }
};

#endif // SUPER_HPP

/************************************************
*
*author:周翔
*e-mail:604487178@qq.com
*blog:http://blog.csdn.net/zhx6044
*
*
*************************************************/

#ifndef SUB_HPP
#define SUB_HPP
#include "super.hpp"

/**
 * @brief The Sub class 子類
 */
class Sub : public Super
{
public:
    Sub():Super() {}
    virtual void fun(const std::string &arg = "Sub") const{
        std::cout << arg << '\n';
    }

    static void staticFun() {
        std::cout << "Sub Static Function!\n";
    }
    //Sub重寫了其中的一個
    virtual void overload() const {
        std::cout << "Sub overload()\n";
    }
};

#endif // SUB_HPP

#include "sub.hpp"


int main()
{
    Sub su;
    su.overload(8);
    return 0;
}

一個Sub的對象調用了形參爲int的函數，編譯時報no matching method of 'overload(int)'的錯誤，說明，在子類中的父類重載方法已經被隱式的隱藏了。

可是你實在須要這些問題，而你又不須要重寫，可使用using語句，添加一句using Super::overload，標明我接受父類全部的重載函數。

3.重寫private和protected父類方法

   訪問限定符只是限定訪問和重寫沒有關係。其實這種重寫private和protected方法是一種設計模式，被稱爲模板。在作android開發中，Activity類有protected void onCreate方法須要重寫，就是在一個類繼承體系中，這幾個操做是固定有的，在沒有子類實現的行爲是不同的。再舉個例子，在Qt中一個QWidget的子類能夠須要處理一些事件，可是每一個子類對響應事件多是不一樣的。

4.父類方法具備默認參數值

   在C++中解析默認參數值是根據描述對象的表達式類型綁定默認參數，而不是根據實際的對象類型綁定參數。這點和上述提到的第一點很像。

  

#include "sub.hpp"


int main()
{
    Sub su;
    Super &s = su;
    s.fun();
    return 0;
}

5.子類函數具備不一樣的訪問級別

訪問基本的改變無非兩種，要不增強，要不放鬆。能夠有以下形式，下降訪問級別可讓子類爲訪問級別高的提供一個public修飾的包裹函數，還有就是直接在子類中重寫方法和修改訪問限定符。提升訪問級別，只能在子類中修改訪問限定符，但是有時也不能作到徹底的提升。

/************************************************
*
*author:周翔
*e-mail:604487178@qq.com
*blog:http://blog.csdn.net/zhx6044
*
*
*************************************************/

#ifndef SUPER_HPP
#define SUPER_HPP

#include <iostream>
/**
 * @brief The Super class 超類  父類
 */
class Super
{
public:
    Super() {}
    virtual ~Super() {}
    //public 訪問級別的函數
    virtual void fun() const {
        std::cout << "public" << '\n';
    }

    static void staticFun() {
        std::cout << "Super Static Function!\n";
    }
    //下面爲兩個重載的函數
    virtual void overload() const {
        std::cout << "Super overload()\n";
    }

    virtual void overload(int t) const {
        std::cout << "Super overload(int) and arg is " << t << '\n';
    }

    virtual void overload(double t) const {
        std::cout << "Super overload(double) and arg is " << t << '\n';
    }

};

#endif // SUPER_HPP


/************************************************
*
*author:周翔
*e-mail:604487178@qq.com
*blog:http://blog.csdn.net/zhx6044
*
*
*************************************************/

#ifndef SUB_HPP
#define SUB_HPP
#include "super.hpp"

/**
 * @brief The Sub class 子類
 */
class Sub : public Super
{
public:
    Sub():Super() {}


    static void staticFun() {
        std::cout << "Sub Static Function!\n";
    }
    //Sub重寫了其中的一個
    virtual void overload() const {
        std::cout << "Sub overload()\n";
    }
    using Super::overload;
protected:
private:
    //private
    virtual void fun() const{
        std::cout << "private" << '\n';
    }
};

#endif // SUB_HPP

#include "sub.hpp"


int main()
{
    Sub su;
 //   su.fun();
    Super &s = su;
    s.fun();
    return 0;
}