C++ virtual

引言

virtual关键字主要用以下用法:虚函数,虚析构函数,纯虚函数,多态,虚基类;

1. virtual常见用法

1.1 虚函数

当在基类中声明一个成员函数为virtual时，该函数就成为虚函数。这意味着如果派生类中有一个同名、同参数列表的函数，那么这个函数将被视为是对基类虚函数的重写。当通过基类的指针或引用调用这个函数时，C++运行时系统会查找并调用实际对象类型中相应的函数。

#include <iostream>
 
class Animal {
public:
    virtual void speak() {
        std::cout << "Some generic sound." << std::endl;
    }
    virtual ~Animal() {} // 虚析构函数
};
 
class Dog : public Animal {
public:
    void speak() override {
        std::cout << "Woof!" << std::endl;
    }
};
 
class Cat : public Animal {
public:
    void speak() override {
        std::cout << "Meow!" << std::endl;
    }
};
 
int main() {
    Animal* animal1 = new Dog();
    Animal* animal2 = new Cat();
    
    animal1->speak(); // 输出: Woof!
    animal2->speak(); // 输出: Meow!
    
    delete animal1;
    delete animal2;
    
    return 0;
}

1.2 动态绑定

动态绑定是指在运行时根据对象的实际类型决定调用哪个方法。实现动态绑定的关键是虚函数。通过在基类中声明虚函数，派生类可以重写这些函数;

#include <iostream>

class Base {
public:
    virtual void show() { // 虚函数
        std::cout << "Base class show." << std::endl;
    }
};

class Derived : public Base {
public:
    void show() override { // 重写
        std::cout << "Derived class show." << std::endl;
    }
};

void display(Base* b) {
    b->show(); // 动态绑定
}

int main() {
    Base b;
    Derived d;

    display(&b); // 调用 Base::show()
    display(&d); // 调用 Derived::show()

    return 0;
}

1.3 多态

多态是指同一操作在不同对象上可以表现出不同的行为。在C++中，主要通过虚函数实现多态。多态可以分为编译时多态和运行时多态,本文所说的多态为运行时多态; 

编译时多态（静态多态）：通过函数重载和运算符重载实现。

运行时多态（动态多态）：通过虚函数实现，允许在运行时根据对象的实际类型选择合适的方法。

#include <iostream>
 
class Base {
public:
    virtual void print() {
        std::cout << "Base::print()" << std::endl;
    }
    virtual ~Base() {}
};
 
class Derived : public Base {
public:
    void print() override {
        std::cout << "Derived::print()" << std::endl;
    }
};
 
int main() {
    // 所谓的基类指针指向子类对象
    Base* basePtr = new Derived();
    basePtr->print();  // 这里将调用 Derived::print()，而不是 Base::print()
    delete basePtr;
    return 0;
}

1.4 纯虚函数

通过将虚函数的实现留空（只声明不定义），可以创建纯虚函数，这样的函数看起来像这样：virtual void func() = 0;。包含纯虚函数的类被称为抽象类，不能实例化，但可以作为其他类的基类;

#include <iostream>
 
class AbstractClass {
public:
    virtual void doSomething() = 0; // 纯虚函数
    virtual ~AbstractClass() {}
};
 
class Implementation : public AbstractClass {
public:
    void doSomething() override {
        std::cout << "Implementation of doSomething." << std::endl;
    }
};
 
int main() {
    AbstractClass* abs = new Implementation();
    abs->doSomething(); // 调用Implementation的doSomething
    
    delete abs;
    
    return 0;
}

1.5 虚析构函数

确保正确的析构顺序,使得子类对象资源得到正确的清理;

Base类拥有一个虚析构函数，这意味着当basePtr指向一个Derived类型的对象并被删除时，会先调用Derived的析构函数，再调用Base的析构函数，从而确保资源得到正确的清理;

#include <iostream>
 
class Base {
public:
    virtual ~Base() {
        std::cout << "Base destructor called." << std::endl;
    }
};
 
class Derived : public Base {
public:
    ~Derived() {
        std::cout << "Derived destructor called." << std::endl;
    }
};
 
int main() {
    Base* basePtr = new Derived();
    delete basePtr; // 如果没有虚析构函数，这里只会调用Base的析构函数
    
    return 0;
}

1.6 虚基类

虚基类（Virtual Base Class）是C++中用于解决多重继承中“菱形继承”问题的一种机制。当一个类从多个基类继承，而这些基类又共享一个更基础的基类时，如果没有使用虚基类，那么在派生类中会存在基础基类的多个实例，这会导致成员变量的二义性和资源浪费。

虚基类确保即使在多重继承的路径中，共享的基础基类也只被继承一次，从而保证了成员变量的唯一性。

#include <iostream>
 
class A {
public:
    A() {
        std::cout << "A constructor called.\n";
    }
};
 
class B : public virtual A {
public:
    B() {
        std::cout << "B constructor called.\n";
    }
};
 
class C : public virtual A {
public:
    C() {
        std::cout << "C constructor called.\n";
    }
};
 
class D : public B, public C {
public:
    D() {
        std::cout << "D constructor called.\n";
    }
};
 
int main() {
    D d;
    return 0;
}

2. Reference

C++ virtual关键字介绍