c++ - 类型删除的 std::function 与虚函数调用的开销

Question

假设我有一个模板类，它包装了它的模板参数以提供一些额外的功能，比如将对象的状态保存到磁盘的能力:

template<typename T>
class Persistent {
    std::unique_ptr<T> wrapped_obj;
public:
    Persistent(std::unique_ptr<T> obj_to_wrap);
    void take_snapshot(int version);
    void save(int to_version);
    void load(int to_version);
}

我想要另一个类，我们称之为 PersistentManager，存储这些模板化的 Persistent 对象的列表，并在不知道它们的模板参数的情况下调用它们的成员方法。我可以看到有两种方法可以做到这一点:使用 std::function 从每个方法中删除模板类型，或者使用抽象基类和虚函数调用。
使用 std::function，每个 Persistent 对象都能够返回绑定(bind)到其成员的 std::functions 包:

struct PersistentAPI {
    std::function<void(int)> take_snapshot;
    std::function<void(int)> save;
    std::function<void(int)> load;
}

template<typename T>
PersistentAPI Persistent<T>::make_api() {
    using namespace std::placeholders;
    return {std::bind(&Persistent<T>::take_snapshot, this, _1),
            std::bind(&Persistent<T>::save, this, _1),
            std::bind(&Persistent<T>::load, this, _1)}
}

然后 PersistentManager 可以存储 PersistentAPI 的列表s，并有这样的方法:

void PersistentManager::save_all(int version) {
    for(PersistentAPI& bundle : persistents) {
        bundle.save(version);
    }
}

使用继承，我将创建一个没有模板参数的抽象类，它将 Persistent 的每个方法都定义为虚拟的，并使 Persistent 继承自它。然后 PersistentManager 可以存储指向这个基类的指针，并通过虚函数调用来调用 Persistent 方法:

class AbstractPersistent {
public:
    virtual void take_snapshot(int version) = 0;
    virtual void save(int to_version) = 0;
    virtual void load(int to_version) = 0;
}
template<typename T>
class Persistent : public AbstractPersistent {
...
}

void PersistentManager::save_all(int version) {
    for(AbstractPersistent* obj : persistents) {
        obj->save(version);
    }
}

这两种方法都为 PersistentManager 的函数调用增加了一些开销:它们不需要将函数调用直接分派(dispatch)到 Persistent 实例，而是需要通过中间层，要么是 std::function 对象，要么是 AbstractPersistent 中的虚函数表。
我的问题是，哪种方法增加的开销更少？由于这些都是标准库中相当不透明的部分，因此我不太清楚 std::function 调用与通过基类指针进行的虚函数调用相比有多“昂贵”。
(我在这个网站上发现了一些其他关于 std::function 开销的问题，但它们都缺乏一个具体的替代方案来比较。)

Answer 1

我有点犹豫要不要回答这个问题，因为它很容易归结为意见。我一直在使用std::function在一个项目中，所以我不妨分享我的两分钱(你可以决定如何处理输入)。
首先，我想重复一下评论中已经说过的话。如果你真的想看到性能，你必须做一些基准测试。只有在进行基准测试后，您才能得出结论。
幸运的是，您可以使用 quick-bench用于快速基准测试(!)。我用你的两个版本提供了基准，添加了一个为每次调用增加的状态，以及一个变量的 getter:

// Type erasure:
struct PersistentAPI {
    std::function<void(int)> take_snapshot;
    std::function<void(int)> save;
    std::function<void(int)> load;
    std::function<int()> get;
};

// Virtual base class
class AbstractPersistent {
public:
    virtual void take_snapshot(int version) = 0;
    virtual void save(int to_version) = 0;
    virtual void load(int to_version) = 0;
    virtual int get() = 0;
};

每个函数只是在相应的类中增加一个整数，并返回 get() (希望编译器不会删除所有不必要的代码)。
结果有利于虚函数，对于 Clang 和 GCC，我们有大约 1.7 的速度差异(https://quick-bench.com/q/wUbPp8OdtzLZv8H1VylyuDnd2pU，您可以更改编译器并重新检查)。
现在开始分析:为什么抽象类看起来更快？好吧，std::function 有更多的间接方式。 ，但之前的包装中还有另一个间接，当我们调用 std::bind 时(!)。听 Scott Meyers 的话，lambda 比 std::bind 更受欢迎，不仅因为它们易于人们使用的语法(std::placeholders 并不漂亮)，而且它们的编译器语法! lambda 调用更容易内联。
内联对性能非常重要。如果可以通过在我们调用的地方添加代码来避免显式调用，我们可以节省一些周期!
更改 std::bind到 lambdas 并再次执行，我们在 std::function 和继承(对于 Clang 和 GCC)之间具有非常相似的性能:https://quick-bench.com/q/HypCbzz5UMo1aHtRpRbrc9B8v44 .
那么，它们为什么相似呢？对于 Clang 和 GCC，std::function在内部使用继承。在这里实现的类型删除只是隐藏了多态性。
(请注意，这个基准测试可能会产生误导，因为对这两种情况的调用可能是完全内联的，因此根本不使用间接。测试用例可能必须更加棘手才能欺骗编译器。)
所以假设你有 Clang 和 GCC 作为编译器，你应该使用哪种方法？
PersistentAPI 更灵活，因为实际上 take_snapshot , save和 load基本上是函数指针，不需要分配给单个类!和

struct PersistentAPI {
    std::function<void(int)> take_snapshot;
    std::function<void(int)> save;
    std::function<void(int)> load;
};

，作为开发人员完全有理由相信 PersistentAPI是指派发到多个对象，而不仅仅是一个*单个*。 take_snapshot例如可以调度到一个自由函数，而 save和 load到两个不同的类(class)。这是你想要的灵 active 吗？那么这就是你应该使用的。一般来说，我会使用 std::function通过 API 让用户注册回调到任何选择的可调用对象。
如果您想使用类型删除，但由于某种原因想要隐藏继承，您可以构建自己的版本。 std::function接受所有具有 operator() 的类型，我们可以构建一个接受所有具有接口(interface)“take_snapshot，save and load”的类。练习一下就好了!

// probably there is a better name for this class
class PersistentTypeErased {
public:
    template<typename T>
    PersistentTypeErased(T t) : t_(std::make_unique<Model<T>>(t)) {}

    void take_snapshot(int version) { t_->take_snapshot(version); }
    void save(int to_version) { t_->save(to_version); }
    void load(int to_version) { t_->load(to_version); }
private:
    struct Concept
    {
        virtual void take_snapshot(int version) = 0;
        virtual void save(int to_version) = 0;
        virtual void load(int to_version) = 0;
    };
    template<typename T>
    struct Model : Concept
    {
        Model(T t) : t_(t) {}
        void take_snapshot(int version) { t_.take_snapshot(version); }
        void save(int to_version) { t_.save(to_version); }
        void load(int to_version) { t_.load(to_version); }
        T t_;
    };
    std::unique_ptr<Concept> t_;
};

该技术类似于 std::function ，现在您可能还可以看到类型删除如何在后台使用多态性。你可以看看它是如何使用的here .