C++ 重载，重定义（覆盖），重写名字隐藏

首先先给出定义吧

重载：同一个类中，函数名相同但是参数不同，不管是否有virtual关键字。

重定义：不同类中（特指基类和子类）函数名相同。但是参数列表和返回值不一定相同。

重写（覆盖）：基类函数有virtual关键字，且函数名、参数列表、返回值都相同。属于重定义一种。

名字隐藏：如果对基类的某一成员函数的版本在子类中重定义，那么基类中该函数的版本将被隐藏。

看个小程序。

点击(此处)折叠或打开

1. #include <iostream>
   
2. #include <string>
   
3. using namespace std;
   
4. 
   
5. class Base {
   
6. public:
   
7.     virtual void mf1()    
   
8.     {
   
9.         cout << "Base::virtual void mf1()" << endl;
   
10.     }
    
11.     virtual void mf1(int)        //重载mf1() virtual函数
    
12.     {
    
13.         cout << "Base::virtual void mf1(int)" << endl;
    
14.     }
    
15.     int f() const
    
16.     {
    
17.         cout << "Base::f()\n";
    
18.         return 1;
    
19.     }
    
20.     int f(string) const        //重载f()函数
    
21.     {
    
22.         cout << "Base::f(string)" << endl;
    
23.         return 1;
    
24.     }
    
25. };
    
26. 
    
27. class Derived : public Base {
    
28. public:
    
29.     using Base::f;        //使用using关键字让f()函数可见
    
30.     virtual void mf1()    // 重写基类虚函数
    
31.     {
    
32.         cout << "Derived::virtual void mf1()" << endl;
    
33.     }
    
34.     int f(int)    //重定义f()函数, 可以改变其参数列表
    
35.     {
    
36.         cout << "Derived::f(int) const\n";
    
37.     }
    
38. };
    
39. 
    
40. 
    
41. class Derived2 : public Base {
    
42. public:
    
43.     void f()    //重定义f()函数, 可以改变其返回值
    
44.     {
    
45.         cout << "Derived2::f() const\n";
    
46.     }
    
47. };
    
48. 
    
49. int main()
    
50. {
    
51.     Derived d;
    
52.     Derived2 d2;
    
53.     int x = 10;
    
54.     string str = "hello";
    
55.     
    
56.     
    
57.     d.mf1();        ///调用派生类中的函数
    
58. //!    d.mf1(x);        ///派生类重写了基类中的mf1虚函数，则基类中其他版本的函数都被隐藏了
    
59.     d.f(x);            ///调用派生类中的函数
    
60.     d.f();
    
61.     
    
62.     d2.f();
    
63. //!    d2.f(str);        ///派生类重定义基类中的f函数，则基类中其他版本的函数都被隐藏了
    
64. }