（转载）【C++拾遗】 C++函数重载、重写、重定义的区别

函数重载（overload）
函数重载是指在一个类中声明多个名称相同但参数列表不同的函数，这些的参数可能个数或顺序，类型不同，但是不能靠返回类型来判断。特征是：
（1）相同的范围（在同一个作用域中）；
（2）函数名字相同；
（3）参数不同；
（4）virtual 关键字可有可无（注：函数重载与有无virtual修饰无关）；
（5）返回值可以不同；

函数重写（也称为覆盖 override）
函数重写是指子类重新定义基类的虚函数。特征是：
（1）不在同一个作用域（分别位于派生类与基类）；
（2）函数名字相同；
（3）参数相同；
（4）基类函数必须有 virtual 关键字，不能有 static 。
（5）返回值相同，否则报错；
（6）重写函数的访问修饰符可以不同；

重定义（也称隐藏）
（1）不在同一个作用域（分别位于派生类与基类） ；
（2）函数名字相同；
（3）返回值可以不同；
（4）参数不同。此时，不论有无 virtual 关键字，基类的函数将被隐藏（注意别与重载以及覆盖混淆）；
（5）参数相同，但是基类函数没有 virtual关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）；

例子

[cpp] view plain copy
 print?
  1. #include <iostream>  
  2. using namespace std;  
  3.   
  4. class Base  
  5. {  
  6. public:  
  7.     // =========================================================================  
  8.     //  子类和父类返回值参数相同，函数名相同，有/无virtual关键字  
  9.     // =========================================================================  
  10.       
  11.     //  若无virtual关键字，则在子类中声明与父类同名的方法，从而覆盖了父类的方法（函数重定义）  
  12.     void a()   
  13.     {  
  14.         cout << "Base::a()" << endl;  
  15.     };  
  16.   
  17.     // 若有virtual关键字，即为虚函数。由对象的类型决定调用哪个函数（多态，函数重写override）。  
  18.     virtual void b()  
  19.     {  
  20.         cout << "Base::b()" << endl;  
  21.     }  
  22.   
  23.     // =========================================================================  
  24.     //  子类和父类返回值参数不同，函数名相同，有/无virtual关键字   
  25.     // =========================================================================  
  26.   
  27.     // 若无virtual关键字，父类的同名成员被隐藏。  
  28.     void d(int x)  
  29.     {  
  30.         cout << "Base::d() x = " << x << endl;  
  31.     }  
  32.   
  33.     // 若有virtual关键字，父类的同名成员同样被隐藏。  
  34.     virtual void e(int x)  
  35.     {  
  36.         cout << "Base::e() x = " << x << endl;  
  37.     }  
  38.   
  39.     // =========================================================================  
  40.     //  子类和父类返回值参数相同，函数名相同，函数返回值不同，有/无virtual关键字  
  41.     // =========================================================================  
  42.   
  43.     // 若无virtual关键字（函数重写，这种情况不属于“函数重载”范畴）  
  44.     void f()  
  45.     {  
  46.         cout << "void Base::f()" << endl;  
  47.     }  
  48.   
  49.     // 若有virtual关键字 (报错）  
  50.     virtual void g()  
  51.     {  
  52.         cout << "virtual void Base::g()" << endl;  
  53.     }  
  54. };  
  55.   
  56. class Derived : public Base  
  57. {  
  58. public:  
  59.     // =========================================================================  
  60.     //  子类和父类返回值参数相同，函数名相同，有/无virtual关键字  
  61.     // =========================================================================  
  62.   
  63.     //  覆盖了父类同名方法（函数重写）  
  64.     void a()   
  65.     {  
  66.         cout << "Derived::a()" << endl;  
  67.     }  
  68.   
  69.     // 多态  
  70.     virtual void b()  
  71.     {  
  72.         cout << "Derived::b()" << endl;  
  73.     }  
  74.   
  75.     // =========================================================================  
  76.     //  子类和父类返回值参数不同，函数名相同，有/无virtual关键字   
  77.     // （注：函数重载与virtual关键字有无没有关系）  
  78.     // =========================================================================  
  79.   
  80.     // 父类同名成员被隐藏  
  81.     void d(int x, int y)  
  82.     {  
  83.         cout << "Derived::d() x = " << x << " y = " << y<< endl;  
  84.     }  
  85.   
  86.     // 父类同名成员被隐藏  
  87.     virtual void e(int x, int y)  
  88.     {  
  89.         cout << "Derived::e() x = " << x << " y = " << y << endl;  
  90.     }  
  91.   
  92.     // =========================================================================  
  93.     //  子类和父类返回值参数相同，函数名相同，函数返回值不同，有/无virtual关键字  
  94.     // =========================================================================  
  95.   
  96.     // 返回值与基类不同  
  97.     int f()  
  98.     {  
  99.         cout << "int Derived::f()" << endl;  
  100.         return 1;  
  101.     }  
  102.   
  103.     //// 错误  
  104.     //virtual int g()  
  105.     //{  
  106.     //  cout << "virtual int Base::g()" << endl;  
  107.     //  return 1;  
  108.     //}  
  109. };  
  110.   
  111. int main()  
  112. {  
  113.     // 用作参数  
  114.     int xx = 100;  
  115.   
  116.     cout << "子类和父类返回值参数相同，函数名相同，无virtual关键字" << endl;  
  117.     Derived d;  
  118.     d.a();        
  119.     d.Base::a();    // 显示调用基类方法  
  120.     cout << "子类和父类返回值参数相同，函数名相同，有virtual关键字" << endl;  
  121.     Base* b = new Derived;  
  122.     b->b();  
  123.     cout << "子类和父类返回值参数不同，函数名相同，无virtual关键字" << endl;  
  124.     d.d(xx, xx);  
  125.     // d.d(xx); // 报错  
  126.     d.Base::d(xx); // 显示调用  
  127.     cout << "子类和父类返回值参数不同，函数名相同，有virtual关键字" << endl;  
  128.     d.e(xx, xx);  
  129.     //d.e(xx); // 报错  
  130.     d.Base::e(xx);  
  131.     cout << "子类和父类返回值参数相同，函数名相同，函数返回值不同, 无virtual关键字" << endl;  
  132.     d.f();  
  133.     d.Base::f();  
  134. }  

输出：

原文地址：http://blog.csdn.net/xiejingfa/article/details/48496593

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/wodehao0808/p/8252010.html