重载 覆盖 隐藏

【1】重载

（1）重载是指在同一个类内被声明的几个具有不同参数列的同名函数。

函数名必须相同，不考虑函数的返回值类型。

（2）示例代码如下：

#include <iostream>
using  namespace std;

class Sample
{
public:
    void  Func(int a, char ch)       // 原函数
    {
        cout << "a " << a << "  " << "ch " << ch << endl;
    }
    void  Func(char ch, int a)   // 重载1：参数顺序不同
    {
        cout << "ch " << ch << " " << "a " << a << endl;
    }
    void  Func(int a)           // 重载2：参数个数不同
    {
        cout << "a  " << a << endl;    
    }
    void  Func(int a, double db) // 重载3：参数类型不同
    {
        cout << "a " << a << " " << "db " << db << endl;
    }
    void  Func(int a, char ch) const      // 重载4：常函数(被const修饰的函数)
    {
        cout << "a " << a << "  " << "ch " << ch << endl;
    }
    /*
    int Func(int a, char ch)      // error! 非重载，编译无法通过。因为编译器认为是重定义。
    {
        cout << "a" << a << "  " << "ch" << endl;
        return a;
    }
    */
};

void main()
{
    Sample ss;
    ss.Func(10, 'a');
    ss.Func('a', 20);
    ss.Func(30);
    ss.Func(40, 12.34);
    system("pause");
}

// 运行结果：
/*
a 10  ch a
ch a a 20
a  30
a 40 db 12.34
请按任意键继续. . .
*/

分析总结：

<1> 在同一个类中（同一作用域中）。

<2> 方法名相同。

<3> 参数个数、参数类型或者参数顺序不同。

<4> 与函数的返回值类型无关。

如果仅仅返回值类型不同，那么对编译器来说会在调用时产生二义性。

所以，抛开返回值类型再分析即相当于重定义，重定义是被禁止的（一个函数只允许有一份函数体）。

<5> const修饰。类中成员函数，const 用在函数后一般修饰的是this指针。所以，也算重载的范畴。

【2】覆盖

（1）覆盖也叫重写，是指在派生类中重写基类某虚函数的实现体的一种形式。

函数名、参数列表、返回值类型都必须同基类被重写的虚函数的严格一致。

仅仅只是函数实现体不同。即达到严格的覆盖目的。

（2）示例代码如下：

#include <iostream>
using  namespace std;

class Sample
{
public:
    virtual void Func()
    {
        cout << "Sample::Func" << endl;
    }
};

class  Test : public Sample
{
public:
    void Func()
    {
        cout << "Test::Func" << endl;
    }
};

void  main()
{
     Sample* pa = new Test();
     pa->Func();
     delete pa;
     pa = NULL;
     system("pause");
}
/* run out:
Test::Func
请按任意键继续. . .
*/

分析总结：

<1> 不同的范围（分别位于基类和派生类，不同作用域中）。

<2> 方法名相同。

<3> 参数严格一致。

<4> 返回类型相同。

<5> 基类函数前必须要加关键字virtual，即必须是虚函数。

【3】隐藏

（1）隐藏是指在派生类中隐藏基类的同名函数。

与重载范围不同，隐藏函数和被隐藏函数不在同一个类中。

与覆盖条件不同，隐藏函数和被隐藏函数的参数可以相同，也可以不同，但是函数名必须要相同。

重要备注：

<1> 当参数相同时，如果基类中的函数被virtual修饰，基类的函数就是所谓被覆盖。

<2> 当参数相同时，如果基类中的函数没有被virtual修饰，基类的函数就是所谓被隐藏。

<3> 当参数不相同时，无论基类中的函数是否被virtua修饰，基类的函数都是所谓的被隐藏。

（2）示例代码如下：

#include <iostream>
using namespace std;

class Sample
{
public:
    virtual void Func0()
    {
        cout << "Sample::Func0" << endl;
    }

    virtual void Func1()
    {
        cout << "Sample::Func1" << endl;
    }

    void Func2(int a)
    {
        cout << "Sample::Func2" << endl;
    }

    void Func3(const char *db)
    {
        cout << "Sample::Func3" << endl;
    }

    void Func4(int n, int m)
    {
        cout << "Sample::Func4" << endl;
    }
};

class Test : public Sample
{
public:
    // 覆盖
    void Func0()  // 带virtual关键字，参数相同
    {
        cout << "Test::Func0" << endl;
    }
    // 隐藏1
    void Func1(int a)   // 带virtual关键字,参数不同
    {
        cout << "Test::Func1" << endl;
    }

#if 0
    int Func1()   // 带virtual关键字,参数相同,但返回值不同
    {
        cout << "Test::Func1_R" << endl;
        return 0;
    }
    // -- E0317    返回类型与重写虚拟函数 "Sample::Func1" 的返回类型 "void" 既不相同，也不协变
#endif

    // 隐藏2
    void Func2(int a)   // 不带virtual，参数相同，返回值相同
    {
        cout << "Test::Func2" << endl;
    }

#if 0
    int Func2(int a)   // 不带virtual，参数相同，但返回值不同
    {
        cout << "Test::Func2_R" << endl;
        return 0;
    }
    // -- E0311    无法重载仅按返回类型区分的函数
#endif

    // 隐藏3
    void Func3(int a)   // 不带virtual，参数不同，返回值相同
    {
        cout << "Test::Func3" << endl;
    }
    // 隐藏4
    int Func4(double dn, double dm) // 不带virtual，参数不同, 返回值不同
    {
        cout << "Test::Func4" << endl;
        return 0;
    }
};

int main()
{
    Test t1;
    t1.Func0();  // Test::Func0 
//  t1.Func1();  // error! 被隐藏，无法调用
    t1.Func1(10); // Test::Func1
    t1.Func2(20); // Test::Func2

    const char *str = "kaizen";
//  t1.Func3(str);  // error! 被隐藏，无法调用
    t1.Func3(30);   // Test::Func3
    t1.Func4(10, 20); // Test::Func4
    cout << endl;

    Sample* pSamp = new Test();
    pSamp->Func0(); // Test::Func0
    pSamp->Func1(); // Sample::Func1
    pSamp->Func2(200); // Sample::Func2
    pSamp->Func3(str); // Sample::Func3
    pSamp->Func4(100, 200); // Sample::Func4
    delete pSamp;
    pSamp = NULL;
    cout << endl;

    Test* pTest = new Test();
    pTest->Func0(); // Test::Func0
//  pTest->Func1();  // error! 参数不匹配
    pTest->Func2(200); // Test::Func2
//  pTest->Func3(str);  // error! 参数不匹配
    pTest->Func4(100, 200); // Test::Func4
    delete pTest;
    pTest = NULL;

    system("pause");

    return 0;
}
// run out:
/*
Test::Func0
Test::Func1
Test::Func2
Test::Func3
Test::Func4

Test::Func0
Sample::Func1
Sample::Func2
Sample::Func3
Sample::Func4

Test::Func0
Test::Func2
Test::Func4
请按任意键继续. . .
*/

分析总结：

<1> 不同的范围（分别位于基类和派生类，不同作用域）。

<2> 方法名相同。

<3> 有关键字virtual，必须要参数不同。

<4> 无关键字virtual，参数任意。

<5> 图解

【4】总结

三者的关系，总结为一张图：

Good Good Study, Day Day Up.

顺序 选择 循环 总结