C++如何通过模板特化继承让char/short等整型复用int模板实例减少膨胀

你不需要修改原有的if constexpr分支逻辑，仅新增一层类型映射转发即可实现需求：

#include <type_traits>

// 自定义类型映射规则：所有宽度不超过int的整型统一映射为int，其他类型保持不变
template<class T>
struct normalize_type {
    using type = std::conditional_t<
        std::is_integral_v<T> && sizeof(T) <= sizeof(int),
        int,
        T
    >;
};
template<class T>
using normalize_type_t = typename normalize_type<T>::type;

// 内部实际实现函数，仅会为映射后的类型生成实例
template<class T>
void foo_impl() {
    if constexpr (std::is_same_v<T, int>) {
        // 原整型分支的逻辑代码
    } else if constexpr (std::is_floating_point_v<T>) {
        // 其他原分支逻辑保持不变
    }
    // 其余分支按需扩展
}

// 对外暴露的调用接口，自动做类型转换转发
template<class T>
void foo() {
    foo_impl<normalize_type_t<T>>();
}

该方案的优势：

• 无侵入性，原有逻辑不需要做任何调整
• 所有char、short等符合转换规则的类型，都会调用同一个foo_impl<int>实例，不会生成冗余代码
• 外层转发函数会被编译器完全内联，无运行时开销

如果希望把逻辑拆分到不同特化中，完全抛弃if constexpr分支，你的思路是完全可行的，实现如下：

#include <type_traits>

// 基础模板声明
template<class T>
struct FooImpl;

// int类型特化，存放实际的整型分支逻辑
template<>
struct FooImpl<int> {
    static void run() {
        // 原整型分支的逻辑代码
    }
};

// C++20约束写法：所有符合规则的小整型特化直接继承int的实现
template<class T>
requires std::is_integral_v<T> && sizeof(T) <= sizeof(int) && !std::is_same_v<T, int>
struct FooImpl<T> : FooImpl<int> {};

// 其他类型特化示例：浮点型
template<>
struct FooImpl<double> {
    static void run() {
        // 浮点分支逻辑
    }
};

// 对外接口
template<class T>
void foo() {
    FooImpl<T>::run();
}

如果需要兼容C++17，可将约束替换为enable_if实现：

template<class T, typename = void>
struct FooImpl;

template<>
struct FooImpl<int> {
    static void run() { /* 整型逻辑 */ }
};

template<class T>
struct FooImpl<T, std::enable_if_t<
    std::is_integral_v<T> && sizeof(T) <= sizeof(int) && !std::is_same_v<T, int>
>> : FooImpl<int> {};

两种写法都不会为小整型生成额外的函数实例，所有小整型的调用都会直接复用FooImpl<int>::run()的实现。

你给出的调用示例完全符合预期：

int main() {
    foo<short>(); // 调用int版本实现
    foo<char>(); // 调用int版本实现
    foo<int>(); // 调用int版本实现
    foo<double>(); // 调用double版本实现
    return 0;
}

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