知道类型后如何避免虚拟通话？

Question

考虑以下代码sn-p：

struct Base { virtual void func() { } };
struct Derived1 : Base { void func() override { print("1"); } };
struct Derived2 : Base { void func() override { print("2"); } };

class Manager {
    std::vector<std::unique_ptr<Base>> items;

    public:
        template<class T> void add() { items.emplace_back(new T); }
        void funcAll() { for(auto& i : items) i->func(); }
};

int main() {
    Manager m;
    m.add<Derived1>();
    m.add<Derived2>();
    m.funcAll(); // prints "1" and "2"
};

我正在使用virtual 调度，以便从多态对象的std::vector 调用正确的override 方法。

但是，我知道多态对象是什么类型，因为我在 Manager::add<T> 中指定了它。

我的想法是通过获取成员函数T::func() 的地址并将其直接存储在某处来避免virtual 调用。但是这是不可能的，因为我需要将其存储为 void* 并将其转换回 Manager::funcAll()，但我当时没有类型信息。

我的问题是：在这种情况下，对于多态性，我似乎拥有比平常更多的信息（用户在 Manager::add<T> 中指定派生类型 T） - 有什么方法可以使用此类型信息来防止看似不需要的virtual 电话？ （不过，用户应该能够创建自己的类，这些类派生自其代码中的Base。）

Answer 1

在这种情况下有时可以提供帮助的一个技巧是按类型对向量进行排序（您应该能够使用 add() 函数中可用的类型知识来强制执行此操作）如果元素的顺序不否则没关系。如果您主要是为了调用虚函数而迭代向量，这将有助于 CPU 的分支预测器预测调用的目标。或者，您可以在管理器中为每种类型维护单独的向量并依次迭代它们，这具有类似的效果。

您的编译器的优化器也可以帮助您处理此类代码，尤其是在它支持 Profile Guided Optimization (POGO) 的情况下。编译器可以在某些情况下对调用进行去虚拟化，或者使用 POGO 可以在生成的程序集中做一些事情来帮助 CPU 的分支预测器，比如测试最常见的类型，并对那些回退到间接调用的直接调用不太常见的类型。

这是一个测试程序的结果，它说明了按类型排序的性能优势，Manager 是您的版本，Manager2 维护一个按 typeid 索引的向量哈希表：

Derived1::count = 50043000, Derived2::count = 49957000
class Manager::funcAll took 714ms
Derived1::count = 50043000, Derived2::count = 49957000
class Manager2::funcAll took 274ms
Derived1::count = 50043000, Derived2::count = 49957000
class Manager2::funcAll took 273ms
Derived1::count = 50043000, Derived2::count = 49957000
class Manager::funcAll took 714ms

测试代码：

#include <iostream>
#include <vector>
#include <memory>
#include <random>
#include <unordered_map>
#include <typeindex>
#include <chrono>

using namespace std;
using namespace std::chrono;

static const int instanceCount = 100000;
static const int funcAllIterations = 1000;
static const int numTypes = 2;

struct Base { virtual void func() = 0; };
struct Derived1 : Base { static int count; void func() override { ++count; } };
int Derived1::count = 0;
struct Derived2 : Base { static int count; void func() override { ++count; } };
int Derived2::count = 0;

class Manager {
    vector<unique_ptr<Base>> items;

public:
    template<class T> void add() { items.emplace_back(new T); }
    void funcAll() { for (auto& i : items) i->func(); }
};

class Manager2 {
    unordered_map<type_index, vector<unique_ptr<Base>>> items;

public:
    template<class T> void add() { items[type_index(typeid(T))].push_back(make_unique<T>()); }
    void funcAll() { 
        for (const auto& type : items) {
            for (auto& i : type.second) {
                i->func();
            }
        }
    }
};

template<typename Man>
void Test() {
    mt19937 engine;
    uniform_int_distribution<int> d(0, numTypes - 1);

    Derived1::count = 0;
    Derived2::count = 0;

    Man man;
    for (auto i = 0; i < instanceCount; ++i) {
        switch (d(engine)) {
        case 0: man.add<Derived1>(); break;
        case 1: man.add<Derived2>(); break;
        }
    }

    auto startTime = high_resolution_clock::now();
    for (auto i = 0; i < funcAllIterations; ++i) {
        man.funcAll();
    }
    auto endTime = high_resolution_clock::now();

    cout << "Derived1::count = " << Derived1::count << ", Derived2::count = " << Derived2::count << "\n"
         << typeid(Man).name() << "::funcAll took " << duration_cast<milliseconds>(endTime - startTime).count() << "ms" << endl;
}

int main() {
    Test<Manager>();
    Test<Manager2>();

    Test<Manager2>();
    Test<Manager>();
}

Answer 2

如果我理解得很好，您希望获取对象类的 add 方法根据该对象类将正确的函数存储在您的向量中。 你的向量只包含函数，没有关于对象的更多信息。

您有点想在调用虚拟调用之前“解决”它。 这在以下情况下可能很有趣：该函数随后被多次调用，因为您不必每次都解决虚拟问题。

因此，您可能希望使用与“虚拟”类似的过程，即使用“虚拟表”。 virtual 的实现是在底层完成的，与你想出的任何东西相比都非常快，所以同样，在它变得有趣之前，函数应该被调用很多次。

Answer 3

但是，我知道多态对象是什么类型，因为我在 Manager::add<T> 中指定了它。

不，你没有。在add 中，您知道要添加的对象的类型；但是您可以添加不同类型的对象，就像您在示例中所做的那样。 funcAll 无法静态确定元素的类型，除非您将 Manager 参数化为仅处理一种类型。

如果你确实知道类型，那么你可以非虚拟地调用函数：

i->T::func();

但是，重申一下，您不能在这里静态确定类型。