C++中如何判断模板参数是否为特定类型（如string或整数）

现有代码存在的问题 #

• 类型萃取属性使用错误：std::is_integral<T>::dado是无效写法，std::is_integral用来判断类型是否为整数的静态常量是value，而非你的业务变量名dado。
• 普通运行时if分支会触发全分支编译检查：即便改对了value，编译阶段也会检查所有分支的语法合法性：当模板参数T为整数类型时，dado.length()调用不存在，直接编译报错；当T为std::string类型时，dado % aux的取模操作不合法，同样编译失败。
• 哈希计算逻辑存在缺陷：使用pow做幂运算会引入浮点数精度误差，且累加值很容易溢出int类型的取值范围，最终得到的索引完全不可靠。
• 变量冗余：aux和qtd_indice都存储了capacidade()的返回值，属于重复定义。

正确实现方案 #

要实现模板参数的类型分支判断，必须使用编译期分支逻辑，不同C++版本可以选择不同的实现方式：

方案1：C++17及以上版本，使用if constexpr #

if constexpr只会编译符合条件的分支，跳过不符合条件的分支的语法检查，完美适配该需求：

#include <type_traits>
#include <string>

// 假设T是当前函数的模板参数，dado是T类型的输入参数
size_t get_expected_index(const T& dado) {
    const size_t table_cap = capacidade();
    // 编译期判断是否为整数类型
    if constexpr (std::is_integral_v<T>) {
        return static_cast<size_t>(dado) % table_cap;
    } 
    // 编译期判断是否为std::string类型
    else if constexpr (std::is_same_v<T, std::string>) {
        size_t hash_sum = 0;
        // 替换pow实现，避免浮点误差和溢出问题
        for (char c : dado) {
            hash_sum = hash_sum * 31 + static_cast<unsigned char>(c);
        }
        return hash_sum % table_cap;
    }
    // 不支持的类型直接编译期报错提示
    static_assert(std::is_integral_v<T> || std::is_same_v<T, std::string>, "仅支持整数类型和std::string类型作为哈希键");
}

方案2：C++11/14版本，使用SFINAE重载实现 #

如果使用的是旧版本C++标准，可以通过函数重载+SFINAE的方式实现编译期类型匹配：

#include <type_traits>
#include <string>

// 整数类型的哈希计算重载
template<typename T>
typename std::enable_if<std::is_integral<T>::value, size_t>::type
calc_hash(const T& dado, size_t cap) {
    return static_cast<size_t>(dado) % cap;
}

// std::string类型的哈希计算重载
template<typename T>
typename std::enable_if<std::is_same<T, std::string>::value, size_t>::type
calc_hash(const T& dado, size_t cap) {
    size_t hash_sum = 0;
    for (char c : dado) {
        hash_sum = hash_sum * 31 + static_cast<unsigned char>(c);
    }
    return hash_sum % cap;
}

// 调用入口
size_t get_expected_index(const T& dado) {
    const size_t table_cap = capacidade();
    return calc_hash(dado, table_cap);
}

如果不需要自定义哈希逻辑，直接使用标准库封装好的std::hash即可，已经覆盖了所有基础类型和std::string的哈希计算，稳定性更高：

size_t expected_index = std::hash<T>{}(dado) % capacidade();

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