学习函数的重载与覆盖

虚函数：

• 覆盖的条件：同名 && 同参 && 同返回值 && 同const类型
• 重载的条件：同名 && （不同参 || 不同const类型）
• 非法的条件：同名 && 同参 && 不同返回值类型

非虚函数：

• 覆盖的条件：同名
• 重载的条件：不能重载基类的函数，一旦同名，就会覆盖基类的函数，但是可以平级重载

注意：覆盖只能发生在继承过程中，不是继承不能覆盖，出现非法重定义的错误。

代码：

#include <stdlib.h>

/***
* @author:zanzan101
*/

class A
{
public:
    // 虚函数
    virtual void foo1()    {printf("A:foo1
");}
    virtual void foo2()    {printf("A:foo2
");}
    virtual void foo3()    {printf("A:foo3
");}
    virtual void foo4()    {printf("A:foo4
");}

    // 非虚函数
    void fun1(){printf("A:fun1
");}
    void fun2(){printf("A:fun2
");}
    void fun3(){printf("A:fun3
");}
    void fun4(){printf("A:fun4
");}
    void fun5(){printf("A:fun5
");}
};
class B : public A
{
public:
    // 虚函数
    void foo1(){printf("B:foo1
");}
    void foo2(int){printf("B:foo2
");}
    // int foo3(){printf("B:foo3
"); return 0;} 非法！error C2555: “B::foo3”: 重写虚函数返回类型有差异，且不是来自“A::foo3”的协变
    void foo4() const {printf("B:foo4
");}

    // 非虚函数
    void fun1(){printf("B:fun1
");}
    void fun2(int){printf("B:fun2
");}
    int fun3(){printf("B:fun3
");return 0;}
    void fun4() const {printf("B:fun4
");}

    void func(){printf("B:func()
");}
//    void func(){}    // 不能覆盖，非法重定义！
    void func(int){printf("B:func(int)
");}
    void func(double){printf("B:func(double)
");}
    void func() const{printf("B:func() const
");}
};


int _tmain(int argc, _TCHAR* argv[])
{
    A* p = new B();
    
    printf(">> 同名同参同返回值：
");
    p->foo1();
    
    printf(">> 同名不同参同返回值：
");
    p->foo2();
    // p->foo2(1); 非法！

    // printf(">> 同名同参不同返回值：
");
    // p->foo3(); 非法！
    
    printf(">> 同名同参同返回值，加const：
");
    p->foo4();

    B* q = new B();
    printf(">> 同名同参同返回值：
");
    q->fun1();

    printf(">> 同名不同参同返回值：
");
    // q->fun2(); 非法！
    q->fun2(1);

    printf(">> 同名同参不同返回值：
");
    q->fun3();

    printf(">> 同名同参同返回值，加const：
");
    q->fun4();

    printf(">> 不同名：
");
    q->fun5();

    printf(">> 同域的重载：
");
    q->func();                // 参数重载
    q->func(1);                // 参数重载
    q->func(1.0);            // 参数重载
    ((const B*)q)->func();    // const重载
//    ((const B*)q)->func(1);    // 非法！

    system("pause");
    return 0;
}

输出结果：

>> 同名同参同返回值：
B:foo1
>> 同名不同参同返回值：
A:foo2
>> 同名同参同返回值，加const：
A:foo4
>> 同名同参同返回值：
B:fun1
>> 同名不同参同返回值：
B:fun2
>> 同名同参不同返回值：
B:fun3
>> 同名同参同返回值，加const：
B:fun4
>> 不同名：
A:fun5
>> 同域的重载：
B:func()
B:func(int)
B:func(double)
B:func() const
请按任意键继续. . .