如何在CRTP类层级中静态断言派生类未实现指定方法

背景与场景 #

基于CRTP构建类层级时，外部库提供的基类接口不可修改，派生类通过「遮蔽」impl方法定制行为。现在需要引入一个继承自原基类的中间基类做接口适配：它实现部分impl方法，并提供新的适配方法，要求最终派生类必须使用新的适配方法，绝对不能实现中间类已经覆盖的impl方法（否则会跳过中间类的逻辑，导致功能异常）。

不可修改的外部基类接口 #

#include <iostream>
using namespace std;

template <class Derived>
struct Greeter {
    void greet() {
        cout << "Hello ";
        static_cast<Derived*>(this)->greetImpl();
        cout << "\n";
    }

    void greetImpl() {
        cout << "world";
    }
};

CRTP常规用法 #

派生类直接遮蔽基类的greetImpl实现定制逻辑：

struct MyGreeter: public Greeter<MyGreeter> {
    void greetImpl() {
        cout << "WORLD";
    }
};

引入中间基类ExcitedGreeter #

中间类继承自Greeter，重写greetImpl并调用派生类的新适配方法greetCamlyImpl，同时添加统一的额外逻辑（比如末尾加感叹号）：

template <class Derived>
struct ExcitedGreeter: public Greeter<Derived> {
    using Base = Greeter<Derived>;

    void greetImpl() {
        static_cast<Derived*>(this)->greetCamlyImpl();
        cout << "!!!";
    }

    void greetCamlyImpl() {
        Base::greetImpl();
    }
};

错误示例：派生类误实现greetImpl #

如果用户切换基类时忘记把greetImpl改成greetCamlyImpl，会直接跳过中间类的逻辑：

// 正确用法：实现适配方法greetCamlyImpl
struct MyWorkingGreeter: public ExcitedGreeter<MyWorkingGreeter> {
    void greetCamlyImpl() {
        cout << "beautiful world";
    }
};

// 错误用法：误实现greetImpl，导致中间类逻辑失效
struct MyBuggyGreeter: public ExcitedGreeter<MyBuggyGreeter> {
    void greetImpl() {
        cout << "buggy world";
    }
};

输出结果：

• MyWorkingGreeter::greet() 输出 Hello beautiful world!!!（符合预期）
• MyBuggyGreeter::greet() 输出 Hello buggy world（丢失了中间类添加的感叹号，不符合预期）

为什么直接比较函数指针/类型无效？ #

核心原因是C++的名称查找规则：在CRTP中间类的模板代码中，引用Derived::greetImpl时，编译器会优先在基类（包括中间基类）中查找名称，派生类的成员要到模板实例化阶段才会被考虑，但此时名称已经绑定到中间类的greetImpl方法了。所以无论派生类是否自己实现了greetImpl，&Derived::greetImpl都会被解析为中间类的版本，无法区分。

解决方案：用SFINAE检测派生类是否有独立的greetImpl #

通过重载决议和SFINAE（替换失败并非错误）机制，检测派生类是否拥有自己的greetImpl方法（而非继承自中间类的版本），然后通过静态断言阻止错误用法。

修改后的中间基类代码 #

#include <type_traits>

template <class Derived>
struct ExcitedGreeter: public Greeter<Derived> {
    using Base = Greeter<Derived>;

    void greetImpl() {
        static_cast<Derived*>(this)->greetCamlyImpl();
        cout << "!!!";
    }

    void greetCamlyImpl() {
        Base::greetImpl();
    }

private:
    // 辅助检测：如果Derived有自己的greetImpl，这个重载会优先匹配
    template <class T = Derived>
    static auto has_own_greetImpl(int) -> decltype(&T::greetImpl, std::true_type{});

    // 否则匹配这个重载
    static std::false_type has_own_greetImpl(...);

    // 静态断言：禁止派生类实现greetImpl
    static_assert(!decltype(has_own_greetImpl(0))::value, 
                  "Derived class must NOT implement greetImpl; use greetCamlyImpl instead!");
};

原理说明 #

• 当Derived自己实现了greetImpl时，第一个has_own_greetImpl重载会因为能获取到&T::greetImpl而生效，返回std::true_type；
• 如果Derived没有自己实现greetImpl，第一个重载会因为SFINAE规则被排除，匹配第二个重载，返回std::false_type；
• 静态断言检查结果，若为true（即派生类违规实现了greetImpl），则直接触发编译报错，提前阻止错误。

测试效果 #

• MyWorkingGreeter：编译通过，正常输出预期结果；
• MyBuggyGreeter：编译阶段触发静态断言，直接提示错误，避免运行时异常。

C++20+ 简化方案：用requires表达式 #

如果使用C++20及以上版本，可以用requires表达式更简洁地完成检测：

template <class Derived>
struct ExcitedGreeter: public Greeter<Derived> {
    // ... 其他代码不变 ...

private:
    static_assert(!requires(Derived d) { d.greetImpl(); } || 
                  !std::is_same_v<decltype(&Derived::greetImpl), decltype(&ExcitedGreeter::greetImpl)>,
                  "Derived class must NOT implement greetImpl; use greetCamlyImpl instead!");
};

逻辑：如果派生类有greetImpl，且该方法的地址不等于中间类的greetImpl地址，说明派生类自己实现了该方法，触发断言。

内容的提问来源于stack exchange，提问作者Nikolaus Demmel