CRTP避免动态多态

Question

如何在 C++ 中使用 CRTP 以避免虚拟成员函数的开销？

Answer 1

有两种方法。

第一个是为类型结构静态指定接口：

template <class Derived>
struct base {
  void foo() {
    static_cast<Derived *>(this)->foo();
  };
};

struct my_type : base<my_type> {
  void foo(); // required to compile.
};

struct your_type : base<your_type> {
  void foo(); // required to compile.
};

第二个是避免使用基址引用或基址指针习惯用法并在编译时进行连接。 使用上面的定义，您可以拥有如下所示的模板函数：

template <class T> // T is deduced at compile-time
void bar(base<T> & obj) {
  obj.foo(); // will do static dispatch
}

struct not_derived_from_base { }; // notice, not derived from base

// ...
my_type my_instance;
your_type your_instance;
not_derived_from_base invalid_instance;
bar(my_instance); // will call my_instance.foo()
bar(your_instance); // will call your_instance.foo()
bar(invalid_instance); // compile error, cannot deduce correct overload

因此，将结构/接口定义和函数中的编译时类型推导结合起来，您可以进行静态分派而不是动态分派。 这就是静态多态性的本质。

Answer 2

我自己一直在寻找有关 CRTP 的不错的讨论。 Todd Veldhuizen 的科学 C++ 技术是一本很棒的书此资源 (1.3) 以及许多其他高级技术（例如表达式模板）。

另外，我发现您可以在 Google 图书上阅读 Coplien 的大部分原始 C++ Gems 文章。 也许情况仍然如此。

Answer 3

我必须查找 CRTP。 然而，完成此操作后，我发现了一些关于静态多态性的内容。 我怀疑这就是你问题的答案。

事实证明，ATL 相当广泛地使用了这种模式。

Answer 4

采用严格签名检查的 CRTP/SFINAE 静态调度

这种静态调度解决方案使用了 CRTP 和 SFINAE，这并不新鲜。
该解决方案的独特之处在于它还强制执行严格的签名
检查，这允许我们在同一个静态中调度重载方法
动态调度适用于虚拟功能的方式。

首先，让我们首先看看使用传统解决方案的局限性
SFINAE。 以下内容摘自 Ben Deane 的 CppCon 2016 Lightning Talk
“虚拟函数的静态替代方案，使用表达式 SFINAE。”

#define SFINAE_DETECT(name, expr)                                       \
  template <typename T>                                                 \
  using name##_t = decltype(expr);                                      \
  template <typename T, typename = void>                                \
  struct has_##name : public std::false_type {};                        \
  template <typename T>                                                 \
  struct has_##name<T, void_t<name##_t<T>>> : public std::true_type {};

// detect CommonPrefix(string)
SFINAE_DETECT(common_prefix,
              declval<T>().CommonPrefix(std::string()))

使用上述代码，模板实例化 has_complete
一般来说，会做你所期望的事情。 如果 DerivedClass 有一个名为
Complete 接受 std::string，结果类型将是
std::true_type。

当你想重载一个函数时会发生什么？

template <class Derived>
struct Base {
    std::string foo(bool);
    std::string foo(int);
    ...
};

struct Derived : public Base<Derived>
{
    std::string foo(int);
};

在本例中，Derived 实际上有一个名为 foo 的方法，该方法接受
bool 因为 bool 可以隐式转换为 int。 所以，
即使我们只为接受 bool 的签名设置调度，has_foo 也会解析为 std::true_type，并且调用将是
分派到 Derived::foo(int)。 这是我们想要的吗？ 可能不会，因为
这不是虚拟函数的工作方式。 一个函数只能覆盖一个
如果两个签名完全匹配，则为虚函数。 我建议我们做一个
静态调度机制的行为方式相同。

template <template <class...> class Op, class... Types>
struct dispatcher;

template <template <class...> class Op, class T>
struct dispatcher<Op, T> : std::experimental::detected_t<Op, T> {};

template <template <class...> class Op, class T, class... Types>
struct dispatcher<Op, T, Types...>
  : std::experimental::detected_or_t<
    typename dispatcher<Op, Types...>::type, Op, T> {};

template <template <class...> class Op, class... Types>
using dispatcher_t = typename dispatcher<Op, Types...>::type;

这很好，但仅此并不能强制执行签名检查。 严格执行
签名检查，我们必须正确定义模板模板参数
操作。 为此，我们将使用成员的 std::integral_constant
函数指针。 看起来是这样的：

template <class T>
using foo_op_b = std::integral_constant<std::string(T::*)(bool), &T::foo>;

template <class T>
using foo_op_i = std::integral_constant<std::string(T::*)(int), &T::foo>

以这种方式定义我们的 Op 允许我们只分派到带有
签名完全匹配。

// Resolves to std::integral_constant<std::string(T::*)(bool), &Derived::foo>
using foo_bool_ic = dispatcher_t<foo_op_b, Derived, Defaults>;

// Resolves to std::integral_constant<std::string(T::*)(int), &Defaults::foo>
using foo_int_ic = dispatcher_t<foo_op_i, Derived, Defaults>;

现在让我们把它们放在一起。

#include <iostream>
#include <experimental/type_traits>
#include <string>

template <template <class...> class Op, class... Types>
struct dispatcher;

template <template <class...> class Op, class T>
struct dispatcher<Op, T> : std::experimental::detected_t<Op, T> {};

template <template <class...> class Op, class T, class... Types>
struct dispatcher<Op, T, Types...>
  : std::experimental::detected_or_t<
    typename dispatcher<Op, Types...>::type, Op, T> {};

template <template <class...> class Op, class... Types>
using dispatcher_t = typename dispatcher<Op, Types...>::type;


// Used to deduce class type from a member function pointer
template <class R, class T, class... Args>
auto method_cls(R(T::*)(Args...)) -> T;


struct Defaults {
    std::string foo(bool value) { return value ? "true" : "false"; }
    std::string foo(int  value) { return value ? "true" : "false"; }

    // Ensure that the class is polymorphic so we can use dynamic_cast
    virtual ~Defaults() {};
};

template <class Derived>
struct Base : Defaults {
    template <class T>
    using foo_op_b = std::integral_constant<std::string(T::*)(bool), &T::foo>;

    template <class T>
    using foo_op_i = std::integral_constant<std::string(T::*)(int), &T::foo>;

    std::string foo(bool value) {
        auto method = dispatcher_t<foo_op_b, Derived, Defaults>::value;
        auto *target = dynamic_cast<decltype(method_cls(method)) *>(this);
        return (target->*method)(value);
    }

    std::string foo(int value) {
        auto method = dispatcher_t<foo_op_i, Derived, Defaults>::value;
        auto *target = dynamic_cast<decltype(method_cls(method)) *>(this);
        return (target->*method)(value);
    }
};

struct Derived : Base<Derived> {
    std::string foo(bool value) { return value ? "TRUE" : "FALSE"; }
};

int main() {
    Derived d;
    std::cout << dynamic_cast<Base<Derived> *>(&d)->foo(true) << std::endl; // TRUE
    std::cout << dynamic_cast<Base<Derived> *>(&d)->foo(1) << std::endl;    // true
}

编写一个为非重载成员函数创建调度程序的宏
会很简单，但是制作一个支持重载函数的会
更具挑战性一点。 如果有人愿意贡献这一点，我欢迎
添加。

Answer 5

这个维基百科答案拥有您所需的一切。 即：

template <class Derived> struct Base
{
    void interface()
    {
        // ...
        static_cast<Derived*>(this)->implementation();
        // ...
    }

    static void static_func()
    {
        // ...
        Derived::static_sub_func();
        // ...
    }
};

struct Derived : Base<Derived>
{
    void implementation();
    static void static_sub_func();
};

虽然我不知道这实际上能给你带来多少钱。 虚拟函数调用的开销为（当然取决于编译器）：

• 内存：每个虚拟函数一个函数指针
• 运行时：一次函数指针调用

而 CRTP 静态多态性的开销为：

• 内存：每个模板实例化的基数复制
• 运行时：1函数指针调用 + 无论 static_cast 正在做什么