学习函数的重载与覆盖

虚函数：

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

非虚函数：

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

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

代码：

 1 #include <stdlib.h>
 2 
 3 /***
 4 * @author:zanzan101
 5 */
 6 
 7 class A
 8 {
 9 public:
10     // 虚函数
11     virtual void foo1()    {printf("A:foo1\n");}
12     virtual void foo2()    {printf("A:foo2\n");}
13     virtual void foo3()    {printf("A:foo3\n");}
14     virtual void foo4()    {printf("A:foo4\n");}
15 
16     // 非虚函数
17     void fun1(){printf("A:fun1\n");}
18     void fun2(){printf("A:fun2\n");}
19     void fun3(){printf("A:fun3\n");}
20     void fun4(){printf("A:fun4\n");}
21     void fun5(){printf("A:fun5\n");}
22 };
23 class B : public A
24 {
25 public:
26     // 虚函数
27     void foo1(){printf("B:foo1\n");}
28     void foo2(int){printf("B:foo2\n");}
29     // int foo3(){printf("B:foo3\n"); return 0;} 非法！error C2555: “B::foo3”: 重写虚函数返回类型有差异，且不是来自“A::foo3”的协变
30     void foo4() const {printf("B:foo4\n");}
31 
32     // 非虚函数
33     void fun1(){printf("B:fun1\n");}
34     void fun2(int){printf("B:fun2\n");}
35     int fun3(){printf("B:fun3\n");return 0;}
36     void fun4() const {printf("B:fun4\n");}
37 
38     void func(){printf("B:func()\n");}
39 //    void func(){}    // 不能覆盖，非法重定义！
40     void func(int){printf("B:func(int)\n");}
41     void func(double){printf("B:func(double)\n");}
42     void func() const{printf("B:func() const\n");}
43 };
44 
45 
46 int _tmain(int argc, _TCHAR* argv[])
47 {
48     A* p = new B();
49     
50     printf(">> 同名同参同返回值：\n");
51     p->foo1();
52     
53     printf(">> 同名不同参同返回值：\n");
54     p->foo2();
55     // p->foo2(1); 非法！
56 
57     // printf(">> 同名同参不同返回值：\n");
58     // p->foo3(); 非法！
59     
60     printf(">> 同名同参同返回值，加const：\n");
61     p->foo4();
62 
63     B* q = new B();
64     printf(">> 同名同参同返回值：\n");
65     q->fun1();
66 
67     printf(">> 同名不同参同返回值：\n");
68     // q->fun2(); 非法！
69     q->fun2(1);
70 
71     printf(">> 同名同参不同返回值：\n");
72     q->fun3();
73 
74     printf(">> 同名同参同返回值，加const：\n");
75     q->fun4();
76 
77     printf(">> 不同名：\n");
78     q->fun5();
79 
80     printf(">> 同域的重载：\n");
81     q->func();                // 参数重载
82     q->func(1);                // 参数重载
83     q->func(1.0);            // 参数重载
84     ((const B*)q)->func();    // const重载
85 //    ((const B*)q)->func(1);    // 非法！
86 
87     system("pause");
88     return 0;
89 }

输出结果：

>> 同名同参同返回值：
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
请按任意键继续. . .

 

转载于:https://www.cnblogs.com/zanzan101/p/3405000.html