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

====================================================||

欢迎讨论技术的可以相互加微信：windgs (请备注csdn+xx职业)

====================================================||

一、重定义-父子类

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

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

(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)

   {

         cout << "父类 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;
    }

    virtual void VirFn(int n)

   {

         cout << "父类 VirFn" << endl;

   }
};

//子类
class CDeriver : public CBase
{
public:
    void Fn(int a1){
        cout << "子类 Fn" << endl;//参数个数不同
    }

    void 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;
    }

    virtual void VirFn(int n)

   {

         cout << "父类 VirFn" << endl;

   }
};

//子类
class CDeriver : public CBase
{
public:
    void Fn(int a1){
        cout << "子类 Fn" << endl;//参数个数不同
    }

    void VirFn(){
        cout << "子类 VirFn" << endl;//返回值相同、参数列表不同
    }
};

//主函数
int main()
{
    CDeriver cd;
    cd.VirFn(5); //报错函数不接受 1 个参数

    cd.VirFn(); //输出子类的方法
    system("pause");
    return 0;
}

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

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

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

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

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