C++中的虚函数重载

在一次修改代码过程中踩的坑,下来研究了一下,发现C++中虚函数重载后会产生很多有意思的情况,在这里总结了一下。

C++中有重载(overload)和重写(override)以及重定义这几个概念,1 overload:指的是相同作用域中的两个函数的函数名相同,但参数列表的个数、顺序、类型不同。而override指的是子类中重新定义的父类的虚函数。
2 override:overload要求两个函数的参数列表必须不同,但是不要求这两个函数必须是虚函数。而override要求必须是虚函数且父类的虚函数必须有virtual关键字,函数的参数列表和返回值也必须相同。子类中override的虚函数的访问修饰符可以不同。
3 重定义也是描述分别位于父类与子类中的同名函数的,但返回值可以不同。如果参数列表不同,这时子类中重定义的函数不论是否有virtual关键字,都会隐藏父类的同名函数。
如果参数列表相同,但父类中的同名函数没有virtual关键字修饰,此时父类中的函数仍然被隐藏。

虚函数的典型用法是:

#include <iostream>
using namespace std; 

class Base{
public:
    virtual void f();

};

void Base::f(){
    cout << "Base::f()" << endl;
}

class Derived:public Base{
public:
    virtual void f();
};

void Derived::f(){
    cout << "Derived::f()" << endl;
}

int main() {
    Base *p1 = new Base;
    Base *p2 = new Derived;
    p1->f();
    p2->f();
    
    delete p1;
    delete p2;

    return 0;
}

程序的输出是:

Base::f()
Derived::f()

那么如果虚函数之间又发生了overload,会出现什么情况?
我们先看最简单的情况:

#include <iostream>
using namespace std; 

class Base{
public:
    virtual void f(int);
};

void Base::f(int a){
    cout << "Base::f(int) " << a << endl;
}

class Derived:public Base{
public:
    virtual void f();
};

void Derived::f(){
    cout << "Derived::f()" << endl;
}

int main() {
    Base *p1 = new Base;
    p1->f(1);
    
    Base *p2 = new Derived;
    p2->f();
    
    delete p1;
    delete p2;
    
    return 0;
}

编译上面的代码,会发生如下错误:

test.cpp: In function ‘int main()’:
test.cpp:28:11: error: no matching function for call to ‘Base::f()’
     p2->f();
           ^
test.cpp:10:6: note: candidate: virtual void Base::f(int)
 void Base::f(int a){
      ^
test.cpp:10:6: note:   candidate expects 1 argument, 0 provided

这就是因为父类中虚函数的参数列表已经发生变化,这时不论子类中重定义的函数不论是否有virtual关键字,都会隐藏父类的同名函数。这时子类中只是重定义了一个自己的函数virtual void f(),而并没有override父类中对应的虚函数。
p2是一个指向Base类型的指针,根据虚函数的特性,对p2→f();的处理取决于是否override了父类的虚函数,如果没有,仍然会调用调用父类中被override的虚函数,但是现在父类中的函数已经成为了virtual void f(int),因此在执行p2→f()时会由于缺少输入参数而出现上述错误。
为了证明上述论断,可以在执行p2→f()时传入参数来判断:

#include <iostream>
using namespace std; 

class Base{
public:
    virtual void f(int);
};

void Base::f(int a){
    cout << "Base::f(int) " << a << endl;
}

class Derived:public Base{
public:
    virtual void f();
};

void Derived::f(){
    cout << "Derived::f()" << endl;
}

int main() {
    Base *p1 = new Base;
    p1->f(1);
    
    Base *p2 = new Derived;
    p2->f(2);
    
    delete p1;
    delete p2;
    
    return 0;
}

这时可以通过编译,执行结果为

Base::f(int) 1
Base::f(int) 2

可以看到,子类自己定义的virtual void f()其实是父类的virtual void f(int)的一个重定义的函数,这时尽管p2实际指向了一个Derived对象,但由于没有override父类对应的虚函数,在执行 p2→f(2)时将执行父类的virtual void f(int)。
也可以这样修改:

#include <iostream>
using namespace std; 

class Base{
public:
    virtual void f(int);
    virtual void f();
};

void Base::f(int a){
    cout << "Base::f(int) " << a << endl;
}

void Base::f(){
    cout << "Base::f() " << endl;
}

class Derived:public Base{
public:
    virtual void f();
};

void Derived::f(){
    cout << "Derived::f()" << endl;
}

int main() {
    Base *p1 = new Base;
    p1->f(1);
    
    Base *p2 = new Derived;
    p2->f();
    
    delete p1;
    delete p2;
    
    return 0;
}

因为父类中定义了可被子类override的函数,所以这时执行p2→f()又会重新执行子类的virtual void f():

Base::f(int) 1
Derived::f()

我们甚至还可以这样验证:

#include <iostream>
using namespace std; 

class Base {
public:
    virtual void f(int);
    virtual void f();
};

void Base::f(int a) {
    cout << "Base::f(int) " << a << endl;
}

void Base::f() {
    cout << "Base::f() " << endl;
}

class Derived:public Base {
public:
    virtual void f(float);
};

void Derived::f(float a) {
    cout << "Derived::f(float)" << showpoint << a << endl;
}


int main() {
    Base *p1 = new Base;
    p1->f(1);
    
    Base *p2 = new Derived;
    p2->f(**2.0**);
    
    delete p1;
    delete p2;
    
    return 0;
}

这时输出仍然为

Base::f(int) 1
Base::f(int) 2

这说明如果通过指向父类的指针,调用虚函数时,如果子类重定义了该虚函数(参数列表发生变化),则实际调用的仍是父类中的虚函数。
上面都是通过指向父类的指针来调用虚函数的,那么如果通过指向子类的指针调用虚函数会发生什么:

#include <iostream>
using namespace std; 

class Base {
public:
    virtual void f(int);
    virtual void f();

};

void Base::f(int a) {
    cout << "Base::f(int) " << a << endl;
}

void Base::f() {
    cout << "Base::f() " << endl;
}

class Derived:public Base {
public:
    virtual void f(float);
};

void Derived::f(float a) {
    cout << "Derived::f(float)" << showpoint << a << endl;
}

int main() {
    Base *p1 = new Base;
    p1->f(1);
    
    Derived *p2 = new Derived;
    p2->f(2.0);
    p2->f(3);
    
    delete p1;
    delete p2;
    
    return 0;
}

这时输出就变为了:

Base::f(int) 1
Derived::f(float)2.00000
Derived::f(float)3.00000

这说明,如果通过指向子类的指针调用虚函数,并且子类重定义了父类的虚函数,这时实际调用的就将是子类中的虚函数。


  • 24
    点赞
  • 39
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值