建议将虚函数和运行时多态性作为先决条件。下面是一个演示运行时多态性的示例程序。

filter_none

编辑

play_arrow

brightness_4

// A simple C++ program to demonstrate run-time  

// polymorphism 

#include <iostream> 

#include <chrono> 

using namespace std; 

typedef std::chrono::high_resolution_clock Clock; 

// To store dimensions of an image 

class Dimension 

{ 

public: 

    Dimension(int _X, int _Y) {mX = _X;  mY = _Y; } 

private: 

    int mX, mY; 

}; 

// Base class for all image types 

class Image 

{ 

public: 

    virtual void Draw() = 0; 

    virtual Dimension GetDimensionInPixels() = 0; 

protected: 

    int dimensionX; 

    int dimensionY; 

}; 

// For Tiff Images 

class TiffImage : public Image 

{ 

public: 

    void Draw() { } 

    Dimension GetDimensionInPixels() { 

        return Dimension(dimensionX, dimensionY); 

    } 

}; 

// There can be more derived classes like PngImage,  

// BitmapImage, etc 

// Driver code that calls virtual function 

int main() 

{ 

    // An image type   

    Image* pImage = new TiffImage; 

    // Store time before virtual function calls 

    auto then = Clock::now(); 

    // Call Draw 1000 times to make sure performance 

    // is visible 

    for (int i = 0; i < 1000; ++i) 

        pImage->Draw(); 

    // Store time after virtual function calls 

    auto now = Clock::now(); 

    cout << "Time taken: "

         << std::chrono::duration_cast 

           <std::chrono::nanoseconds>(now - then).count() 

         << " nanoseconds" << endl; 

    return 0; 

} 

输出：

所用时间：2613纳秒

见这对上述结果。

当一个方法被声明为虚拟时，编译器会秘密为我们做两件事：

在类对象的前4个字节中定义VPtr

在构造函数中插入代码以初始化VPtr以指向VTable

什么是VTable和VPtr？

当一个方法在类中声明为virtual时，编译器会创建一个虚拟表（也称为VTable）并在该表中存储虚方法的地址。然后创建虚拟指针（也称为VPtr）并初始化以指向该VTable。VTable在类的所有实例之间共享，即编译器仅创建一个VTable实例，以便在类的所有对象之间共享。该类的每个实例都有自己的VPtr版本。如果我们打印包含至少一个虚方法的类对象的大小，则输出将是sizeof（类数据）+ sizeof（VPtr）。

由于虚拟方法的地址存储在VTable中，因此可以操纵VPtr以调用那些虚拟方法，从而违反封装原则。见下面的例子：

filter_none

编辑

play_arrow

brightness_4

// A C++ program to demonstrate that we can directly 

// manipulate VPtr. Note that this program is based  

// on the assumption that compiler store vPtr in a  

// specific way to achieve run-time polymorphism. 

#include <iostream> 

using namespace std; 

#pragma pack(1) 

// A base class with virtual function foo() 

class CBase 

{ 

public: 

    virtual void foo() noexcept { 

        cout << "CBase::Foo() called" << endl; 

    } 

protected: 

    int mData; 

}; 

// A derived class with its own implementation 

// of foo()  

class CDerived : public CBase 

{ 

public: 

    void foo() noexcept  { 

        cout << "CDerived::Foo() called" << endl; 

    } 

private: 

    char cChar; 

}; 

// Driver code 

int main() 

{ 

    // A base type pointer pointing to derived 

    CBase *pBase = new CDerived; 

    // Accessing vPtr 

    int* pVPtr = *(int**)pBase; 

    // Calling virtual method 

    ((void(*)())pVPtr[0])(); 

    // Changing vPtr 

    delete pBase; 

    pBase = new CBase; 

    pVPtr = *(int**)pBase; 

    // Calls method for new base object 

    ((void(*)())pVPtr[0])(); 

    return 0; 

} 

输出：

CDerived :: Foo（）调用

调用CBase :: Foo（） 

我们能够访问vPtr并能够通过它调用虚拟方法。这里解释了对象的内存表示。

使用虚方法是明智的吗？

可以看出，通过基类指针，正在调度派生类方法。一切似乎都很好。那有什么问题呢？

如果多次调用虚拟例程（数十万的顺序），则会降低系统性能，原因是每次调用例程时，需要通过使用VPtr查看VTable来解析其地址。对虚拟方法的每次调用的额外间接（指针取消引用）使得访问VTable成为一项代价高昂的操作，最好尽可能地避免它。