如何实现C语言中父子类关系下虚函数重写、同一类函数重载的父子类重定义？
- 内容介绍
- 文章标签
- 相关推荐
本文共计1189个文字，预计阅读时间需要5分钟。
一、重定义 - 子类 + 重定义是指子类中重新定义了父类中的同名函数。
函数三要素：返回类型、函数名、参数。
1. 如果返回类型、参数不同，可以隐藏父类的同名函数。
2.（1）返回类型和参数相同，是否能隐藏父类的同名函数？
一、重定义-父子类
重定义是指子类中重新定义了父类中的同名函数。（函数三要素：返回类型，函数名，参数）：
如果返回类型和参数不相同，能隐藏父类的同名函数吗？
(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），子类重新定义了同名函数
本文共计1189个文字，预计阅读时间需要5分钟。
一、重定义 - 子类 + 重定义是指子类中重新定义了父类中的同名函数。
函数三要素：返回类型、函数名、参数。
1. 如果返回类型、参数不同，可以隐藏父类的同名函数。
2.（1）返回类型和参数相同，是否能隐藏父类的同名函数？
一、重定义-父子类
重定义是指子类中重新定义了父类中的同名函数。（函数三要素：返回类型，函数名，参数）：
如果返回类型和参数不相同，能隐藏父类的同名函数吗？
(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），子类重新定义了同名函数