使用CRTP确定性生成代码：模板选择性生成函数代码段的疑问

嘿，很高兴看到你在深挖CRTP和模板编程的技巧——这玩意儿确实能把运行时开销压到最低，你的思路完全对，那些运行时if确实没必要，咱们可以用编译期分支或者模板特化来让编译器直接生成对应类的专属代码，根本不用在运行时做判断。下面给你几种实用的方案：

如果你的项目已经用上C++17或更高版本，constexpr if是最直接的解决方案。它的条件是编译期常量，编译器会为每个Derived实例化时只保留符合条件的分支，完全消除运行时判断的开销。

假设你原来的代码是这样的（带冗余if）：

#include <type_traits>
#include <iostream>

template<typename Derived>
struct CRTPBase {
    void process() {
        // 运行时判断，没必要
        if (std::is_same_v<Derived, ClassA>) {
            std::cout << "Processing ClassA\n";
        } else if (std::is_same_v<Derived, ClassB>) {
            std::cout << "Processing ClassB\n";
        }
    }
};

struct ClassA : CRTPBase<ClassA> {};
struct ClassB : CRTPBase<ClassB> {};

改成constexpr if后：

#include <type_traits>
#include <iostream>

template<typename Derived>
struct CRTPBase {
    void process() {
        // 编译期分支，没用的代码会被直接删掉
        if constexpr (std::is_same_v<Derived, ClassA>) {
            std::cout << "Processing ClassA\n";
        } else if constexpr (std::is_same_v<Derived, ClassB>) {
            std::cout << "Processing ClassB\n";
        } else {
            // 可选：静态断言，防止未处理的派生类
            static_assert(!std::is_same_v<Derived, Derived>, "Unsupported Derived type");
        }
    }
};

struct ClassA : CRTPBase<ClassA> {};
struct ClassB : CRTPBase<ClassB> {};

如果需要兼容更早的C++标准，模板特化是个可靠的选择。把不同派生类的逻辑拆到特化的辅助模板里，CRTP基类只负责调用对应的实现。

首先定义通用的实现模板和特化版本：

#include <iostream>

// 通用实现（默认）
template<typename Derived>
struct ProcessImpl {
    static void run() {
        std::cout << "Default processing\n";
    }
};

// 为ClassA特化
template<>
struct ProcessImpl<ClassA> {
    static void run() {
        std::cout << "Processing ClassA\n";
    }
};

// 为ClassB特化
template<>
struct ProcessImpl<ClassB> {
    static void run() {
        std::cout << "Processing ClassB\n";
    }
};

然后在CRTP基类里调用：

template<typename Derived>
struct CRTPBase {
    void process() {
        ProcessImpl<Derived>::run();
    }
};

struct ClassA : CRTPBase<ClassA> {};
struct ClassB : CRTPBase<ClassB> {};

这种方式逻辑清晰，每个派生类的实现完全独立，维护起来很方便。

如果你的判断条件比较复杂（比如不是简单的类型匹配，而是检查类是否有某个成员函数），标签分发（Tag Dispatch）会更灵活。它利用函数重载解析来选择对应的实现。

首先定义标签类型和标签提供者：

#include <iostream>
#include <type_traits>

// 定义标签
struct ClassATag {};
struct ClassBTag {};
struct DefaultTag {};
struct SpecialTag {};

// 标签提供者：为每个派生类分配对应的标签
template<typename Derived>
struct TagProvider {
    using type = DefaultTag;
};

template<>
struct TagProvider<ClassA> {
    using type = ClassATag;
};

template<>
struct TagProvider<ClassB> {
    using type = ClassBTag;
};

// 扩展：用SFINAE判断类是否有special_method，分配对应标签
template<typename T>
struct HasSpecialMethod {
    template<typename U>
    static auto test(int) -> decltype(std::declval<U>().special_method(), std::true_type{});
    template<typename U>
    static std::false_type test(...);
    static constexpr bool value = decltype(test<T>(0))::value;
};

template<typename Derived>
struct TagProvider<Derived, std::enable_if_t<HasSpecialMethod<Derived>::value>> {
    using type = SpecialTag;
};

然后写重载的辅助函数：

namespace detail {
    void process_impl(ClassATag) {
        std::cout << "Processing ClassA\n";
    }

    void process_impl(ClassBTag) {
        std::cout << "Processing ClassB\n";
    }

    void process_impl(DefaultTag) {
        std::cout << "Default processing\n";
    }

    void process_impl(SpecialTag) {
        std::cout << "Processing class with special method\n";
    }
}

最后在CRTP基类里调用：

template<typename Derived>
struct CRTPBase {
    void process() {
        detail::process_impl(typename TagProvider<Derived>::type{});
    }
};

struct ClassA : CRTPBase<ClassA> {};
struct ClassB : CRTPBase<ClassB> {};
struct SpecialClass : CRTPBase<SpecialClass> {
    void special_method() {}
};

这种方式可以处理非常复杂的编译期条件，扩展性很强。

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