当前位置：首页 > article >正文

C++虚函数（详解）

article 2024/10/31 16:39:52

一、什么是虚函数？

在基类中使用 virtual 关键字修饰的成员函数称为虚函数。

用法格式：

virtual 函数返回值类型 函数名 （参数表）{

    函数体；

}

虚函数是 C++ 中实现多态性的重要机制，它允许在派生类中重写基类中的函数。虚函数的核心特性在于，它使得通过基类指针或引用调用函数时，可以根据实际对象的类型选择相应的函数实现。

二、虚函数的作用

虚函数的作用，用专业术语来解释就是实现多态性（Polymorohism）,多态性是将接口与实现进行分离；用形象的语言来解释就是实现以共同的方法，但因个体差异，而采用不同的策略。

具体而言，就像买火车票这件事。同样是买火车票，不同的人去买有不同的结果，学生买火车票半价，而军人优先购票等。

下面来看这样一段代码：

#include<iostream>
using namespace std;
class A
{
    public:
        void print()
        {
            cout<<"This is A"<<endl;
        }
};
 
class B : public A
{
    public:
        void print()
        {
            cout<<"This is B"<<endl;
        }
};
 
class C : public A
{
    public:
        void print()
        {
            cout<<"This is C"<<endl;
        }
};

int main()
{
    //为了在以后便于区分，我这段main()代码叫做main1
    A a;
    B b;
    C c;
    a.print();
    b.print();
    c.print()
    return 0;
}

运行结果：

This is A
This is B
This is C

通过class A、class B和class C的print（）这个接口，可以看出这三个class因个体的差异而采用了不同的策略，但这并不是多态性行为。这里，a.print()、b.print() 和 c.print() 都是静态绑定，因此编译器直接根据对象的类型选择调用相应的 print() 方法，而不管是否存在派生类。

现在把main（）处的代码改一改。

#include<iostream>
using namespace std;
class A
{
public:
    void print()
    {
        cout<<"This is A"<<endl;
    }
};

class B : public A
{
public:
    void print()
    {
        cout<<"This is B"<<endl;
    }
};

class C : public A
{
public:
    void print()
    {
        cout<<"This is C"<<endl;
    }
};

int main()
{
    //为了在以后便于区分，我这段main()代码叫做main2
    A a;
    B b;
    C c;
    A *p1 = &a;
    A *p2 = &b;
    A *p3 = &c;

    p1->print();
    p2->print();
    p3->print();
    return 0;
}

运行结果：

This is A
This is A
This is A

问题来了，p2、p3明明指向的是class B、class C的对象但却是调用的class A的print（）函数，这不是我们所期望的结果，那么解决这个问题就需要用到虚函数。

#include<iostream>
using namespace std;
class A
{
public:
    virtual void print()
    {
        cout<<"This is A"<<endl;
    }
};

class B : public A
{
public:
    void print()
    {
        cout<<"This is B"<<endl;
    }
};

class C : public A
{
public:
    void print()
    {
        cout<<"This is C"<<endl;
    }
};

int main()
{
    //为了在以后便于区分，我这段main()代码叫做main2
    A a;
    B b;
    C c;
    A *p1 = &a;
    A *p2 = &b;
    A *p3 = &c;

    p1->print();
    p2->print();
    p3->print();
    return 0;
}

运行结果：

This is A
This is B
This is C

毫无疑问，class A的成员函数print（）已经成了虚函数，那么class B的print（）成了虚函数了吗？回答是Yes，我们只需在把基类的成员函数设为virtual，其派生类的相应的函数也会自动变为虚函数。所以，class B的print()也成了虚函数。那么对于在派生类的相应函数前是否需要用virtual关键字修饰，那就是你自己的问题了（语法上可加可不加，不加的话编译器会自动加上，但为了阅读方便和规范性，建议加上）。
现在重新运行main2的代码，这样输出的结果就是This is A、This is B和This is B了。
现在来消化一下，我作个简单的总结，指向基类的指针在操作它的多态类对象时，会根据不同的类对象，调用其相应的函数，这个函数就是虚函数。

C++中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数（动态绑定）。这种技术可以让父类的指针有“多种形态”，这是一种泛型技术。所谓泛型技术，说白了就是试图使用不变的代码来实现可变的算法。比如：模板技术，RTTI技术，虚函数技术，要么是试图做到在编译时决议，要么试图做到运行时决议。