c++ - CRTP 模式还在数据结构中存储非同质类型

Question

我有兴趣了解 CRTP。我想为引擎实现一个组件系统，我不想访问组件统一风格

GetComponent("withThisName");

而是在编译时(虚幻风格)

GetComponent<FromThisType>();

虽然实现 CRTP 相当容易，但我真的不知道如何在不再次引入动态调度的情况下管理数据结构中的 CRTP 派生类。

Wiki 描述了一个带有形状的例子:

// Base class has a pure virtual function for cloning
class Shape {
public:
    virtual ~Shape() {};
    virtual Shape *clone() const = 0;
};
// This CRTP class implements clone() for Derived
template <typename Derived>
class Shape_CRTP : public Shape {
public:
    virtual Shape *clone() const {
        return new Derived(static_cast<Derived const&>(*this));
    }
};

// Nice macro which ensures correct CRTP usage
#define Derive_Shape_CRTP(Type) class Type: public Shape_CRTP<Type>

// Every derived class inherits from Shape_CRTP instead of Shape
Derive_Shape_CRTP(Square) {};
Derive_Shape_CRTP(Circle) {};

在这个例子中，我仍然可以做类似的事情

std::vector<Shape*> shapes;

但是还有虚函数，而这正是我首先试图摆脱的。我的结论是，我可能仍然没有正确使用 CRTP，或者当它被使用时，另一方面我看到虚幻引擎正在使用它，以我想要的方式使用它。

Answer 1

CRTP 惯用语并不是要为非同类类提供通用接口(interface)。几乎都是关于静态多态性的，但是得到的类型却完全不同。
考虑一下:

template<typename T>
struct CRTP { /* ... */ };

struct A: CRTP<A> {};
struct B: CRTP<B> {};

A 和 B 没有任何共同点，它们是不同的类型，您不能将它们存储在容器中，除非您给它们一个公共(public)接口(interface)作为基类(即是你建议的，即使你不喜欢它)。
它们是同一类模板的两个特化这一事实并不能为您提供一种通过简单地忽略它们是不同类型这一事实来将它们存储在某个地方的方法。

CRTP 可能不是您要找的东西。相反，请考虑为您的目的使用类型删除。
作为一个最小的工作示例:

#include <type_traits>
#include <utility>
#include <memory>
#include <vector>

class Shape {
    template<typename Derived>
    static std::unique_ptr<Shape> clone_proto(void *ptr) {
        return std::unique_ptr<Shape>(new Derived{*static_cast<Derived *>(ptr)});
    }

public:
    template<typename T, typename... Args>
    static std::enable_if_t<std::is_base_of<Shape, T>::value, std::unique_ptr<Shape>>
    create(Args&&... args) {
        auto ptr = std::unique_ptr<Shape>(new T{std::forward<Args>(args)...});
        ptr->clone_fn = &Shape::clone_proto<T>;
        return ptr;
    }

    std::unique_ptr<Shape> clone() {
        return clone_fn(this);
    }

private:
    using clone_type = std::unique_ptr<Shape>(*)(void *);
    clone_type clone_fn;
};

struct Rectangle: Shape {};
struct Circle: Shape {};

int main() {
    std::vector<std::unique_ptr<Shape>> vec;
    vec.push_back(Shape::create<Rectangle>());
    vec.push_back(Shape::create<Circle>());
    auto other = vec.at(0)->clone();
}

如您所见，在这种情况下，派生类的类型实际上被删除，您从create 函数中得到的是一个Shape，仅此而已。 Circle 和 Rectangle 是 Shape，您可以轻松创建 Shape 的 vector 。
根本没有虚函数，但仍然向内部数据成员 clone_fn 进行双重调度，返回正确的类型并正确克隆对象。

多态性是该语言的一个(让我这么说)特性，它实际上允许用户删除 一堆类型并在运行时正确地分派(dispatch)任何函数调用。如果你想在编译时删除类型，你可以这样做，但这不是(也不能完全)免费的。此外，它没有什么神奇之处:如果你想删除一个类型，你需要一个中介，它知道这个类型是什么，并且能够让它恢复正常工作(虚拟方法或静态函数充当调度程序或其他任何东西，如果您想以某种方式使用该类型，则无法避免它们)。