6

考虑以下代码片段：

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中调用正确的override方法。std::vector

但是，我知道多态对象是什么类型，因为我在Manager::add<T>.

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

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

4

3 回答 3

8

但是，我知道多态对象是什么类型，因为我在Manager::add<T>.

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

如果您确实知道类型，那么您可以以非虚拟方式调用该函数：

i->T::func();

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

于 2013-10-21T15:27:09.190 回答
0

有时可以在这种情况下提供帮助的一个技巧是按类型对向量进行排序（您应该能够使用 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>();
}
于 2013-10-21T17:29:53.680 回答
0

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

您有点想在调用虚拟调用之前“解决”它。这在以下情况下可能很有趣：然后多次调用该函数，因为您没有每次都解决虚拟的开销。

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

于 2013-10-21T16:08:01.707 回答