CRTP与“派生的”函数中的函数的直接实现对比

Question

我正在尝试更好地了解 CRTP。到目前为止，我的理解是它允许人们编写如下所示的函数。

template <class T>
void foo(Base<T> x ) { x.do_stuff() }

现在，根据传递给函数 foo() 的实际编译时派生对象 x，它将执行不同的操作。

但是，我可以从 Base 派生类 Derived ，并使用非虚拟但重写的 屏蔽/遮蔽其 do_stuff()派生::do_stuff。因此，什么时候使用 CRTP 才是正确的，而是最简单的非平凡示例，它显示了 CRTP 相对于阴影/掩蔽的优势。

Answer 1

CRTP 的要点是能够在没有虚拟性的情况下获取派生对象的类型。如果您这样做

struct B { void foo() const; }
struct D : B { void foo() const; }

void bar(const B& x) { x.foo(); }

，那么当您传递 D 对象时，bar 会调用 B::foo 而不是 D::foo ，因为 foo 不是虚函数。如果您希望调用 D::foo，那么您需要虚拟函数或 CRTP。

使用最简单的 CRTP：

template <typename>
struct B { void foo() const; }

struct D : B<D> { void foo() const; }

template <typename T>
void bar(const B<T>& x)
{
    static_cast<const T&>(x).foo();
}

当您将 D 对象传递给 bar 时，它会调用 D::foo()。

另一种 CRTP 技巧会强制 D 提供 foo 的实现，

template <typename T>
struct B
{
    void foo() const { static_cast<const T*>(this)->foo_impl(); }
    // default implementation if needed
    // void foo_impl() const { ... }
};

struct D : B<D> { void foo_impl() const { ... } };

template <typename T>
void bar(const B<T>& x) { x.foo(); }

但您仍然需要 B 的模板参数（以便foo 正确调度），因此是模板 bar 函数。

另外，如果你不使用 CRTP，你最好有一个虚拟析构函数，这可能会为完全内联的轻量级类增加不必要的开销。使用 CRTP，您只需编写一个受保护的析构函数（C++0x 中的私有析构函数 + friend T）。