C++ CRTP 中基类接口获取子类定义的类型？

其实是之前在学院群里的一个问题，当时并没有真正解决，只是通过暴力解决了。一个是对CRTP的理解不够深入，另一个是对于C++的模板元编程的使用不够熟练。希望记录一下。

问题#

下面代码是很常见的CRTP，我们的目的是在Base类中获取Derived类中定义的RawT类型。但是却报错了no typename RawT in Derived<byteVector>，因为Base类并不知道Derived类的定义，所以无法获取RawT类型。可是CRTP却让Base类能够使用到Derived类的成员函数？

1
#include <print>
2
#include <vector>
3

4
using byteVector = std::vector< std::byte >;
5

6
template < typename DerivedT >
7
class Base {
8
  public:
9
    using RawT = typename DerivedT::RawT;
10

11
    void foo() {
12
        std::println("{}", typeid(RawT).name());
13
        static_cast< DerivedT* >(this)->impl();
14
    }
15
};
16

17
template < typename T >
18
class Derived;
19

20
template <>
21
class Derived< byteVector > : public Base< Derived< byteVector > > {
22
    template < typename U >
23
    friend class Base; // make all Base's member functions visible to Derived
24

25
    using RawT = byteVector;
26

27
    void impl() { std::println("Derived<int>::impl()"); }
28
};
29

30
int main() {
31
    Derived< byteVector > d;
32
    d.foo();
33
    return 0;
34
}

为什么`CRTP`能够让`Base`类使用到`Derived`类的成员函数？#

以下来自Claude 3.5 Sonnet，感觉解释的很好，我就直接翻译过来了。

这是一个很好的问题，涉及到 CRTP（Curiously Recurring Template Pattern，奇异递归模板模式）的核心机制。让我们深入探讨一下：

CRTP 的基本结构

在 CRTP 中，基类模板接受派生类作为模板参数：

1
template <typename DerivedT>
2
class Base {
3
    // ...
4
};
5

6
class Derived : public Base<Derived> {
7
    // ...
8
};

编译器的两阶段名称查找

CRTP 能够工作的关键在于 C++ 编译器的两阶段名称查找（two-phase name lookup）机制：

a. 第一阶段：在模板定义时，编译器会检查语法和非依赖名称。 b. 第二阶段：在模板实例化时，编译器会检查依赖名称。

延迟绑定

当基类模板中使用 Derived 类的成员时，这些名称被视为依赖名称。编译器会延迟这些名称的解析，直到模板实例化时。

示例解析

考虑以下代码：

1
template <typename DerivedT>
2
class Base {
3
public:
4
    void interface() {
5
        static_cast<DerivedT*>(this)->implementation();
6
    }
7
};
8

9
class Derived : public Base<Derived> {
10
public:
11
    void implementation() {
12
        std::cout << "Derived implementation" << std::endl;
13
    }
14
};

在这个例子中：

当编译器首次遇到 Base 类模板时，它不会报错说找不到 implementation()。
编译器知道 Derived 是一个模板参数，因此假设 implementation() 将在 Derived 中定义。
当 Derived 类实例化 Base<Derived> 时，编译器检查 Derived 是否真的有 implementation() 方法。

为什么不报错

编译器不会立即报错，因为：

在模板定义时，编译器不知道 Derived 的具体内容，所以它假设 Derived 会提供所需的方法。
只有在实际实例化模板时，如果缺少所需的方法，编译器才会报错。

注意事项

如果 Derived 类没有定义所需的方法，错误只会在使用 Derived 类时出现，而不是在定义 Base 模板时。
这种延迟检查可能导致错误消息出现在意想不到的地方，有时会使调试变得复杂。

总结：CRTP 利用了 C++ 模板的延迟实例化和两阶段名称查找机制，允许基类模板使用尚未定义的派生类成员，而不会在模板定义时报错。这种机制提供了强大的静态多态性，但也需要开发者确保正确实现所有必要的方法。

为什么`Base`类无法获取`Derived`类中定义的`RawT`类型？#

严格编译期确定#

这与CRTP是有不同的，在继承时发生了模板实例化public Base<Derived<byteVector>>, 此时实例化的Base类中 using RawT = typename Der::RawT;会去查找Derived<byteVector>类中的RawT类型，但是请注意，此时的 Derived<byteVector>类还没有定义RawT类型(因为我们从继承的时候就开始了Base的实例化，而此时甚至还没有进入到Derived的定义) 所以会报错。也就是说，Derived<byteVector>的完整类型出现在Base之后。

编译期间Derived<byteVector>在类型不完整的时候就被依赖了。

`CRTP`的延迟绑定#

CRTP中，基类通常不会直接使用派生类的成员，而是使用其成员函数。方法的调用完全可以延迟到实例化完成后，而类型的获取则必须在编译时确定。

解决方案#

获取一个模板类的第一个参数#

其实通过分析我们不难发现，我们不能在实例化的时候用Base的模板参数来获取RawT，因为这样的话派生类必然还没有完整定义。所以我们可以通过套一层模板来直接获取一个模板类的参数，简单来说就是有一个模板能获取模板类的模板参数。这样说比较绕，我们直接看代码。

1
get_raw_t< Derived< byteVector > > -> byteVector
2
get_raw_t< std::vector< int > > -> int

所以目标是构造一个get_raw_t模板，能够获取Derived类的RawT类型。

1
template < typename >
2
struct get_raw;
3

4
/*
5
 * @brief: get_raw< std::vector< std::byte > > -> std::byte
6
 */
7
template < template < typename... > class TemplateClass, typename InnerType >
8
struct get_raw< TemplateClass< InnerType > > {
9
    using type = InnerType;
10
};
11

12
template < typename T >
13
using get_raw_t = typename get_raw< T >::type;

我们知道，类似于std::vector< std::byte >这样的模板类，其实是一个被实例化的模板类。如果使用get_raw< std::vector< std::byte > >，那么就会匹配到特化的get_raw，从而获取到std::byte类型。也即是get_raw< TemplateClass< InnerType > >对应get_raw< std::vector< std::byte > >。所以 < TemplateClass, InnerType > 匹配到< std::vector, std::byte >。

改进我们的代码#

只需要在Base类中使用get_raw_t就可以了。

1
template < typename DerivedT >
2
class Base {
3
  public:
4
    // bypass using RawT = typename Der::RawT;
5
    using RawT = get_raw_t< DerivedT >;
6

7
    void foo() {
8
        std::println("{}", typeid(RawT).name());
9
        static_cast< DerivedT* >(this)->impl();
10
    }
11
};

本质上还是绕过DerivedT这个不完整类型。通过实例化的get_raw_t来获取RawT类型。当然，必须保证Derived类中的 RawT就是被CRTP的Derived类的模板参数。

关于`C++ 23`之后`CRTP`的一些改善#

C++ 23引入了显示this。大大增强了CRTP的能力，可以直接在Base类中获取Derived类的类型。

1
template < typename Der >
2
class Base {
3
  public:
4
    using RawT = get_raw_t< Der >;
5

6
    void foo(this auto&& self) {
7
        std::println("{}", typeid(RawT).name());
8
        self.impl();
9
    }
10
};

通过将this作为参数传递给foo函数，我们实例化的Derived就可以被直接传入作为第一个参数，从而直接调用Derived的成员函数。不过此时应该将Base设置为友元类，以便Base类能够访问Derived类的私有成员。

1
template < typename T >
2
class Derived;
3

4
template <>
5
class Derived< byteVector > : public Base< Derived< byteVector > > {
6
    template < typename U >
7
    friend class Base; // make all Base's member functions visible to Derived
8

9
    void impl() { std::println("Derived<int>::impl()"); }
10
};
11

12
int main() {
13
    Derived< byteVector > d;
14
    d.foo();
15
    return 0;
16
}

问题#

为什么CRTP能够让Base类使用到Derived类的成员函数？#

为什么Base类无法获取Derived类中定义的RawT类型？#