C++之虚函数

最新推荐文章于 2024-07-13 14:34:09 发布

FlyerGo

最新推荐文章于 2024-07-13 14:34:09 发布

阅读量3.1k

点赞数 3

分类专栏： C/C++ 文章标签： c++

本文链接：https://blog.csdn.net/u012944685/article/details/124503938

版权

C/C++ 专栏收录该内容

15 篇文章 2 订阅

订阅专栏

都说面向对象的三大特性是封装、继承、多态。C++作为一门面向对象编程语言，肯定也是具备了面向对象的三大特性，那么在C++中是如何实现多态的呢？

在C++中是通过虚函数动态绑定的方式实现多态的。

虚函数与纯虚函数

首先我们来回顾一下虚函数，在C++中是使用virtual关键字修饰的函数就是虚函数，下面是一个简单的虚函数例子:

class Base{
public:
    // 虚函数，必须实现，否则编译报错
    virtual void f1() const{
        std::cout << "我是Base的f1函数" << std::endl;
    }
};

class A:public Base{
    void f1() const override{
        std::cout << "我是A的f1函数" << std::endl;
    }
};

虚函数必须在基类中实现，如果不实现的话就会编译报错。

如果我们不想实现虚函数的话可以将其声明为纯虚函数，纯虚函数的声明方式如下：

virtual 返回值类型 函数名(函数参数) = 0；

声明了纯虚函数的类称为抽象类，继承抽象类的最终子类必须父类的纯虚函数，否则不能生产对应的类对象。以下是一个纯虚函数的例子:

class Base{
public:
    // 虚函数，必须实现，否则编译报错
    virtual void f1() const{
        std::cout << "我是Base的f1函数" << std::endl;
    }

    // 纯虚函数，不需要实现
    virtual void f2() const = 0;
};

class A:public Base{
public:
    void f1() const override{
        std::cout << "我是A的f1函数" << std::endl;
    }

    void f2() const override{
        std::cout << "我是A的纯虚函数f2" << std::endl;
    }
};

有了虚函数我们就能通过基类的的指针进行动态绑定，在运行时访问到子类的函数，但是动态绑定只能发生在指针或引用上。例如在以下的例子中，函数test3是不会访问到子类的函数的，
它访问的函数依然是基类的虚函数，也就是说它没有发生动态绑定，因为它既不是指针也不是引用。

class Base{
public:
    // 虚函数，必须实现，否则编译报错
    virtual void f1() const{
        std::cout << "我是Base的f1函数" << std::endl;
    }
};

class A:public Base{
public:
    void f1() const override{
        std::cout << "我是A的f1函数" << std::endl;
    }
};

// 引用传递参数
void test1(const Base &base){
    base.f1();
}

// 指针传递参数
void test2(Base *base){
    base->f1();
}

// 非引用、非指针传递参数
void test3(Base base){
    base.f1();
}

int main(int arg,char** argv) {
    Base *base =  new A();
    test1(*base);
    test2(base);
    test3(*base);
    return 0;
}

运行打印结果：

我是A的f1函数
我是A的f1函数
我是Base的f1函数

如果一个类可能会被继承，这个类的析构函数应该被声明为一个虚函数，否则会引发内存泄漏。例如以下例子:

class Base{
public:
    // 虚函数，必须实现，否则编译报错
    virtual void f1() const{
        std::cout << "我是Base的f1函数" << std::endl;
    }

    ~Base(){
        std::cout << "Base的析构函数" << std::endl;
    }
};

class A:public Base{
public:
    void f1() const override{
        std::cout << "我是A的f1函数" << std::endl;
    }

    ~A(){
        std::cout << "A的析构函数" << std::endl;
    }
};

int main(int arg,char** argv) {
    Base *base =  new A();
    delete base;
    return 0;
}

运行输出如下：

Base的析构函数

从运行结果可以看出A没有被正确析构，这是因为它的基类Base的析构函数没有被声明为虚函数的原因，此时只要我们把Base类的析构函数声明为虚函数即可修复这个内存泄漏的问题，也就是：

class Base{
public:
    // 虚函数，必须实现，否则编译报错
    virtual void f1() const{
        std::cout << "我是Base的f1函数" << std::endl;
    }

    // 可能被继承的类的析构函数应该是一个虚函数
   virtual ~Base(){
        std::cout << "Base的析构函数" << std::endl;
    }
};

虚函数总结：

1、当我们在派生类中覆盖了某个虚函数时，可以再一次使用virtual关键字指出该函数的性质。然而这么做并非必须，因为一旦某个函数被声明成虚函数，则在所有派生类中它都是虚函数。
2、虚函数只有在引用或者指针调用时才会发生动态绑定；
3、基类的析构函数需要声明为虚函数；
4、虚函数必须要在基类实现，不实现，编译会报错；
5、如果子类没有实现父类的纯虚函数，则该子类不能被构造成一个对象。

多态实现原理-虚函数表

通过上面的例子我们知道了在C++中通过引用或指针的形式进行虚函数的动态绑定而实现多态，那么动态绑定在C++中是如何实现呢？答案是虚函数表。

所谓的虚函数表就是：

当编译器在编译过程中遇到virtual关键字时，它不会对函数调用进行绑定，而是为包含虚函数的类建立一张虚函数表Vtable。在虚函数表中，编译器按照虚函数的声明顺序依次保存虚函数地址。同时，编译器会在类中添加一个隐藏的虚函数指针VPTR，指向虚函数表。在创建对象时，将虚函数指针VPTR放置在对象的起始位置，为其分配空间，并调用构造函数将其初始化为虚函数表地址。需要注意的是，虚函数表不占用对象空间。

虚函数表总结：
1、单继承下的虚函数表