1

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

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 对象将能够返回绑定到其成员的 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 可以存储PersistentAPIs 的列表，并且有这样的方法：

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 的函数调用增加了一些开销：它们不需要将函数调用直接分派到 Persistent 实例，而是需要通过中间层，要么是 std::function 对象，要么是 AbstractPersistent 中的虚函数表。

我的问题是，哪种方法增加的开销更少？由于这些都是标准库中相当不透明的部分，因此我不太了解 std::function 调用与通过基类指针进行的虚函数调用相比有多“昂贵”。

（我在这个网站上发现了一些其他关于 std::function 开销的问题，但它们都缺乏一个具体的替代方案来比较。）

4

1 回答 1

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/wUbPp8OdtzLZv8H1VyyuDnd2pU，您可以更改编译器并重新检查）。

现在开始分析：为什么抽象类看起来更快？好吧，有更多的间接，但在我们调用(!)std::function时，之前的包装中还有另一个间接。std::bind听 Scott Meyers 的话，lambda 比 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不同的类。这是你想要的灵活性吗？那么这就是你应该使用的。一般来说，我会std::function通过 API 让用户注册一个回调到任何可调用的选项。

如果您想使用类型擦除，但由于某种原因想要隐藏继承，您可以构建自己的版本。std::function接受所有类型operator()，我们可以构建一个接受所有具有接口“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现在您可能还可以看到类型擦除如何在幕后使用多态性。你可以在这里看到它是如何使用的。

于 2020-06-29T10:58:32.873 回答