C++ 重定义（父子类），（virtual虚）函数重写（覆盖）（父子类）、重载（同一类）

一、重定义-父子类

重定义是指子类中重新定义了父类中的同名函数。（函数三要素：返回类型，函数名，参数）：

如果返回类型和参数不相同，能隐藏父类的同名函数吗？

(1)、返回类型，函数名，参数全部相同

#include <iostream>
 using namespace std;//父类
 class CBase
 {
 public:
     void Fn(int n1){
         cout << "父类 Fn函数" << endl;
     }
 };//子类
 class CDeriver : public CBase
 {
 public:
     void Fn(int n1){
         cout << "子类 Fn" << endl;   //函数名，返回类型，参数完全都相同
     }
 };//主函数
 int main()
 {
     CDeriver cd;
     cd.Fn(5);
     system("pause");
     return 0;
 }

调用子类成员函数输出：子类 Fn

（2）、函数名，返回类型相同，参数不同

#include <iostream>
 using namespace std;//基类
 class CBase
 {
 public:
     void  Fn(int n1,int n2){
         cout << "父类 Fn" << endl;
     }
 };//子类
 class CDeriver : public CBase
 {
 public:
     void Fn(int a1){
         cout << "子类 Fn" << endl;//参数个数不同
     }
 };//主函数
 int main()
 {
     CDeriver cd;
     cd.Fn(5);//一个参数
     cd.Fn(5,5);//两个参数，此时会报错，函数不接受两个参数。说明这个时候，子类覆盖了基类的同名函数，变成了1个参数的函数。一个参数的时候，调用子类的成员函数，输出为：子类。两个参数的时候报错，说明基类方法已经被隐藏了（重新定义继承函数，原来的函数被隐藏）
     system("pause");
     return 0;
 }

（3）重定义继承方法，应确保与原来的原型完全一致

#include <iostream>
 using namespace std;//基类
 class CBase
 {
 public:
     void  Fn(int n1,int n2){
         cout << "父类 Fn" << endl;
     }    virtual void VirFn(int n)
   {
父类 VirFn" << endl;
   }
 };//子类
 class CDeriver : public CBase
 {
 public:
     void Fn(int a1){
         cout << "子类 Fn" << endl;//参数个数不同
     }    int VirFn(int n){
         cout << "子类 VirFn" << endl;//返回类型不同，编辑器会理解为子类想重写基类的虚函数方法，实现多太
     }
 };//主函数
 int main()
 {
     CDeriver cd;
     cd.VirFn(5);//输出结果报错：重写虚函数返回类型有差异，test.cpp:20:9: error: conflicting return type specified for ‘virtual int CDerivedA::Walk()’
     system("pause");
     return 0;
 }

第二：虚函数重写（覆盖）（返回值类型必须相同） 

1、返回值、参数列表相同

#include <iostream>
 using namespace std;//基类
 class CBase
 {
 public:
     void  Fn(int n1,int n2){
         cout << "父类 Fn" << endl;
     }VirFn(int n)
   {
父类 VirFn" << endl;
   }
 };//子类
 class CDeriver : public CBase
 {
 public:
     void Fn(int a1){
         cout << "子类 Fn" << endl;//参数个数不同
     }VirFn(int n){
         cout << "子类 VirFn" << endl;//重写了基类的方法
     }
 };//主函数
 int main()
 {
     CDeriver cd;
     cd.VirFn(5); //输出子类的方法
     system("pause");
     return 0;
 }

最常见的对父类虚函数重写

 

2、返回值相同、参数列表不同

#include <iostream>
 using namespace std;//基类
 class CBase
 {
 public:
     void  Fn(int n1,int n2){
         cout << "父类 Fn" << endl;
     }VirFn(int n)
   {
父类 VirFn" << endl;
   }
 };//子类
 class CDeriver : public CBase
 {
 public:
     void Fn(int a1){
         cout << "子类 Fn" << endl;//参数个数不同
     }VirFn(){
         cout << "子类 VirFn" << endl;//返回值相同、参数列表不同
     }
 };//主函数
 int main()
 {
     CDeriver cd;
     cd.VirFn(5); //报错函数不接受 1 个参数VirFn(); //输出子类的方法
     system("pause");
     return 0;
 }

对虚函数重新定义，这里是重定义，父类中同名函数被隐藏

结论： 
在类继承中，重定义，重载。

重定义：函数名相同，返回类型必须相同，参数列表可以相同，可以不同；非虚函数时(隐藏: 只要子类出现与父类同名的函数，子类就不会继承父类同名函数)

重载：函数名相同，返回类型和参数列表至少一个不同。 

重写（覆盖）：父类声明为虚函数时（virtual），子类重新定义了同名函数