c++ - 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

After thought a bit I guess this use is to allow something like this:

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

and call it like this

int main()
{
    Derived1 d1;
    Derived2 d2;

    call(d1);
    call(d2);
}

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

但是，必须注意 - 就像您一样 - 该示例的 main()给出了一个糟糕的用例(直接调用派生方法)，因为我们不需要 CRTP 或继承的方法来使示例工作。

---

关于这个:

What vtables truly provide is using the base class (pointer or reference) to call derived methods. You should show how it is done with CRTP here.

为了理解这一点，明智的做法是首先解释为什么我们需要多态性。在必须理解任何其他内容之前，否则 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::method至 B::method使用 A*类型被执行。 CRTP 允许编译器了解此派生方法，因为我们使用模板从基类型交换到派生类型 - 因此 static 多态性。 vtable与虚函数/方法一起使用，并通过存储指向正确类方法的函数指针间接地“执行交换”(错误但有助于这样想)。

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