避免虚函数

Question

因此，假设我想创建一系列类，每个类都有一个具有相同功能的成员函数。 函数

void doYourJob();

让我们调用我想要最终将所有这些类放入同一个容器中的

，以便我可以循环遍历它们并让每个类执行“doYourJob()”显而易见的解决方案是使用该函数创建一个抽象类

 virtual void doYourJob();

，但我对此犹豫不决这样做。这是一个耗时的程序，而虚拟函数会大大削弱它的性能。此外，这个函数是类之间唯一的共同点，并且每个类的 doYourJob 的实现方式完全不同。

有没有办法避免使用带有虚函数的抽象类，或者我是否必须接受它？

Answer 1

虚拟功能的成本并不高。它们是间接调用，基本上就像函数指针一样。
性能成本是多少在 C++ 类中有一个虚拟方法？

如果您处于每次调用的每个周期都很重要的情况，那就是您在函数调用中做了很少的工作，并且从内部循环中调用它在性能关键型应用程序中，您可能需要完全不同的方法。

Answer 2

我担心循环中的一系列 dynamic_cast 检查会使性能比虚拟函数更差。如果您要将它们全部放入一个容器中，那么它们需要具有某种共同的类型，因此您不妨将其设为一个纯虚拟基类，并在其中包含该方法。

在该上下文中，虚拟函数分派并没有太多内容：vtable 查找、提供的 this 指针的调整以及间接调用。

如果性能如此关键，您也许可以为每个子类型使用单独的容器并独立处理每个容器。如果顺序很重要，你会做很多后空翻，虚拟调度可能会更快。

Answer 3

如果您要将所有这些对象存储在同一个容器中，那么您要么必须编写异构容器类型（缓慢且昂贵），要么必须存储 的容器void *s（恶心！），否则类必须通过继承相互关联。如果您选择使用前两个选项中的任何一个，则必须有一些逻辑来查看容器中的每个元素，找出它的类型，然后调用适当的 doYourJob() 实现，本质上归结为继承。

我强烈建议首先尝试使用继承这一简单、直接的方法。如果这足够快，那就太好了！你完成了。如果不是，请尝试使用其他方案。永远不要因为成本而回避有用的语言功能，除非你有一些有力的证据表明成本太大。

Answer 4

如果您需要速度，请考虑在对象中嵌入“类型（识别）编号”，并使用 switch 语句来选择特定于类型的代码。这可以完全避免函数调用开销——只需进行本地跳转。你不会比这更快。强制本地化（在交换机中）特定于类型的功能会产生成本（在可维护性、重新编译依赖性等方面）。

---

实现

#include <iostream>
#include <vector>

// virtual dispatch model...

struct Base
{
    virtual int f() const { return 1; }
};

struct Derived : Base
{
    virtual int f() const { return 2; }
};

// alternative: member variable encodes runtime type...

struct Type
{
    Type(int type) : type_(type) { }
    int type_;
};

struct A : Type
{
    A() : Type(1) { }
    int f() const { return 1; }
};

struct B : Type
{
    B() : Type(2) { }
    int f() const { return 2; }
};

struct Timer
{
    Timer() { clock_gettime(CLOCK_MONOTONIC, &from); }
    struct timespec from;
    double elapsed() const
    {
        struct timespec to;
        clock_gettime(CLOCK_MONOTONIC, &to);
        return to.tv_sec - from.tv_sec + 1E-9 * (to.tv_nsec - from.tv_nsec);
    }
};

int main(int argc)
{
  for (int j = 0; j < 3; ++j)
  {
    typedef std::vector<Base*> V;
    V v;

    for (int i = 0; i < 1000; ++i)
        v.push_back(i % 2 ? new Base : (Base*)new Derived);

    int total = 0;

    Timer tv;

    for (int i = 0; i < 100000; ++i)
        for (V::const_iterator i = v.begin(); i != v.end(); ++i)
            total += (*i)->f();

    double tve = tv.elapsed();

    std::cout << "virtual dispatch: " << total << ' ' << tve << '\n';

    // ----------------------------

    typedef std::vector<Type*> W;
    W w;

    for (int i = 0; i < 1000; ++i)
        w.push_back(i % 2 ? (Type*)new A : (Type*)new B);

    total = 0;

    Timer tw;

    for (int i = 0; i < 100000; ++i)
        for (W::const_iterator i = w.begin(); i != w.end(); ++i)
        {
            if ((*i)->type_ == 1)
                total += ((A*)(*i))->f();
            else
                total += ((B*)(*i))->f();
        }

    double twe = tw.elapsed();

    std::cout << "switched: " << total << ' ' << twe << '\n';

    // ----------------------------

    total = 0;

    Timer tw2;

    for (int i = 0; i < 100000; ++i)
        for (W::const_iterator i = w.begin(); i != w.end(); ++i)
            total += (*i)->type_;

    double tw2e = tw2.elapsed();

    std::cout << "overheads: " << total << ' ' << tw2e << '\n';
  }
}

---

性能结果

在我的 Linux 系统上：

~/dev  g++ -O2 -o vdt vdt.cc -lrt
~/dev  ./vdt                     
virtual dispatch: 150000000 1.28025
switched: 150000000 0.344314
overhead: 150000000 0.229018
virtual dispatch: 150000000 1.285
switched: 150000000 0.345367
overhead: 150000000 0.231051
virtual dispatch: 150000000 1.28969
switched: 150000000 0.345876
overhead: 150000000 0.230726

这表明内联类型数字切换方法约为 (1.28 - 0.23) / (0.344 - 0.23) = 9.2 倍快。当然，这特定于测试的确切系统/编译器标志和参数。版本等，但通常是指示性的。

---

关于虚拟调度的评论

必须指出的是，虚拟函数调用开销很少是重要的，并且仅对于经常调用的琐碎函数（如 getter 和 setter）而言。即使如此，您也可以提供一个函数来一次获取和设置很多东西，从而最大限度地降低成本。人们过于担心虚拟调度——因此在找到尴尬的替代方案之前一定要先进行分析。它们的主要问题是它们执行了外联函数调用，尽管它们也使执行的代码离域化，从而改变了缓存利用模式（变得更好或更糟）。