C++中的虚函数重载_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

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