CRTP。试图理解一个给定的例子

Question

当我试图理解 CRTP 时，我遇到了这个 example，它对我来说有点模糊。如果我做一些更简单的事情，我可以达到同样的结果：

#pragma once
#include <iostream>
template <typename T>
class Base
{
public:
    void method() {
        static_cast<T*>(this)->method();
    }
};

class Derived1 // : public Base<Derived1>   <-- commented inherintance
{
public:
    void method() {
        std::cout << "Derived1 method" << std::endl;
    }
};


class Derived2 // : public Base<Derived2>   <-- commmented inherintance
{
public:
    void method() {
        std::cout << "Derived2 method" << std::endl;
    }
};


#include "crtp.h"
int main()
{
    Derived1 d1;
    Derived2 d2;
    d1.method();
    d2.method();
    return 0;
}

我的问题是：CRTP 的目的是什么？经过一番思考，我猜这个用途是为了允许这样的事情：

template<typename T>
void call(Base<T>& x)
{
    x.method();
}

然后这样称呼它

int main()
{
    Derived1 d1;
    Derived2 d2;

   call(d1);
   call(d2)
}

我说的对吗？

Answer 1

经过一番思考，我猜这个用途是为了允许这样的事情：

template<typename T>
void call(Base<T>& x)
{
    x.method();
}

然后这样称呼它

int main()
{
    Derived1 d1;
    Derived2 d2;

    call(d1);
    call(d2);
}

你是对的，这是使用提供的 CRTP 示例的一种可能方式。

但是必须注意 - 正如您所知道的那样 - 示例的 main() 显示了一个糟糕的用例（直接调用派生方法），因为我们不需要 CRTP 或继承的方法来使示例工作.

---

关于这个：

vtables 真正提供的是使用基类（指针或引用）来调用派生方法。你应该在这里展示它是如何使用 CRTP 完成的。

为了理解这一点，首先要谨慎地解释为什么我们需要多态性。在必须理解的任何其他内容之前，CRTP 看起来只不过是一个巧妙的模板技巧。

您最初的猜测是正确的 - 当您想要访问派生类的行为/方法时，您会需要多态性，它会覆盖（或定义）我们需要通过基类获得的行为 .

像这样的普通继承：

struct A { void method() {} };
struct B : A { void method() {} };
int main () {
    B b;
    b.method();
    return 0;
}

发生的情况是B::method() 被解雇了，是的，但是如果我们省略了B::method()，那么它实际上会调用A::method()。在这个意义上B::method() 覆盖 A::method()。

如果我们想调用B::method()，但只有一个A对象，这是不够的：

int main () {
    B b;
    A *a = &b;
    a->method(); // calls A::method();
    return 0;
}

有两种方法可以实现（至少）：动态多态或静态多态。

动态多态

struct A1 {
    virtual ~A1(){}
    virtual void method() {}
};
struct B1 : A1 {
    virtual ~B1(){}
    virtual void method() override {}
};
int main () {
    B1 b;
    A1 *a = &b;
    a->method(); // calls B1::method() but this is not known until runtime.
    return 0;
}

详细地说，因为A1 有虚方法，所以这个类存在一个特殊的表（vtable），其中为每个虚方法存储了一个函数指针。这个函数指针可以被派生类覆盖（在某种意义上），这是B1 的每个实例所做的 - 将其设置为B1::method。

因为此信息存在于运行时，所以编译器只需查找 A1::method 的函数指针并调用它指向的任何内容，无论是 A1::method 还是 B1::method。相反，因为它是在运行时完成的，所以过程往往比事先知道类型要慢...

静态多态

以避免使用 vtable 的方式重做相同的示例：

template < class T > struct A2 {
    void method() {
        T *derived_this = static_cast<T*>(this);
        derived_this->method();
    }
};
struct B2 : A2 < B2 > {
    void method() {}
};
int main () {
    B2 b;
    A2<B2> *a = &b; // typically seen as a templated function argument
    a->method(); // calls B2::method() statically, known at compile-time
    return 0;
}

这次我们没有使用任何东西的动态查找，使用模板可以看到完全相同的行为，并且可以根据您的示例函数 template<class T> call(Base<T>*);

使用 模板参数类型推导

这两种方法的主要区别在于何时使用A*类型执行从A::method到B::method的解析。 CRTP 允许编译器知道这个派生方法，因为我们使用模板从基类型交换到派生类型 - 因此是 static 多态性。 vtable 与虚函数/方法一起使用，并通过存储指向正确类方法的函数指针间接“执行交换”（错误但有助于这样想）。

@Etherealone 向回答者提出的问题（真正的词？）是为了演示我刚刚在上面展示的内容 - 如何使用 CRTP 使用基类指针调用派生类方法，而不是依赖于vtable（一层间接实现相同，在调用代码中不知道派生类型本身）。

Answer 2

是的，模板函数“call”可以做同样的工作。但有时 CRTP 可能会更好。 用法举例：

     Base<Derived1> *d1 = new Derived1;
     d1->method();