C++17类外定义成员函数模板特化的编译错误排查与解决

问题背景 #

在类模板Test中声明两个带std::enable_if条件的static成员函数special，取消注释#define ISSUE后出现大量编译错误。需求是仅在类体内声明重载函数，实现代码放在类定义后的同一文件中，编译器仅支持C++17。

问题原因 #

类内的两个special函数模板，核心模板签名完全一致（都是template<typename U>），仅靠默认参数中的std::enable_if条件，C17编译器无法将它们视为不同的重载。因为C17及更早版本规定，函数模板的重载必须依赖模板参数数量/类型或函数参数列表的硬差异，默认模板参数不参与签名区分。哪怕两个enable_if的条件完全互斥，编译器仍会认为这是重复的模板声明，进而无法匹配类外的实现代码，导致编译错误。

修复方案 #

以下两种方案均适配C++17，可让编译器正确区分两个重载函数：

方案一：添加额外默认模板参数 #

给第二个special的模板参数列表增加一个额外的默认参数（如typename = void），通过模板参数数量差异区分签名：

#include <cstdint>
#include <iostream>
#include <type_traits>

#define ISSUE

template <typename T>
class Test
{
public:
    template<typename U = T,
        std::enable_if_t<
            std::is_same<T, bool>::value ||
            std::is_same<T, int8_t>::value ||
            std::is_same<T, uint8_t>::value ||
            (std::is_enum<T>::value && (sizeof(T) == 1U))
        ,int> = 0>
    static void special(T data);

#if defined(ISSUE)
    // 新增typename = void作为额外默认模板参数
    template<typename U = T,
        std::enable_if_t<
            std::is_same<T, int32_t>::value ||
            std::is_same<T, uint32_t>::value ||
            (std::is_enum<T>::value && (sizeof(T) == 4U))
        ,int> = 0,
        typename = void>
    static void special(T data);
#endif    
};

template <typename T>
template <typename U, 
        std::enable_if_t<
            std::is_same<T, bool>::value ||
            std::is_same<T, int8_t>::value ||
            std::is_same<T, uint8_t>::value ||
            (std::is_enum<T>::value && (sizeof(T) == 1U))
        ,int>>
void Test<T>::special(T data)
{
    std::cout << "print 8-bit\n";
}

#if defined(ISSUE)
// 实现时需匹配额外的typename模板参数
template <typename T>
template <typename U, 
        std::enable_if_t<
            std::is_same<T, int32_t>::value ||
            std::is_same<T, uint32_t>::value ||
            (std::is_enum<T>::value && (sizeof(T) == 4U))
        ,int>,
        typename>
void Test<T>::special(T data)
{
    std::cout << "print 32-bit\n";
}
#endif    

int main()
{
    Test<uint8_t>{}.special(5);
    Test<int8_t>{}.special(5);
    Test<bool>{}.special(true);
#if defined(ISSUE)
    Test<uint32_t>{}.special(5);
    Test<int32_t>{}.special(5);
#endif    
}

方案二：将enable_if移至函数参数列表 #

把std::enable_if作为函数的默认参数，通过函数参数列表的差异实现重载，可读性更强：

#include <cstdint>
#include <iostream>
#include <type_traits>

#define ISSUE

template <typename T>
class Test
{
public:
    // enable_if作为函数默认参数
    static void special(T data, 
        std::enable_if_t<
            std::is_same<T, bool>::value ||
            std::is_same<T, int8_t>::value ||
            std::is_same<T, uint8_t>::value ||
            (std::is_enum<T>::value && (sizeof(T) == 1U))
        , int> = 0);

#if defined(ISSUE)
    // 32-bit版本的enable_if条件互斥，作为函数默认参数
    static void special(T data, 
        std::enable_if_t<
            std::is_same<T, int32_t>::value ||
            std::is_same<T, uint32_t>::value ||
            (std::is_enum<T>::value && (sizeof(T) == 4U))
        , int> = 0);
#endif    
};

// 8-bit版本实现
template <typename T>
void Test<T>::special(T data, 
    std::enable_if_t<
        std::is_same<T, bool>::value ||
        std::is_same<T, int8_t>::value ||
        std::is_same<T, uint8_t>::value ||
        (std::is_enum<T>::value && (sizeof(T) == 1U))
    , int>)
{
    std::cout << "print 8-bit\n";
}

#if defined(ISSUE)
// 32-bit版本实现
template <typename T>
void Test<T>::special(T data, 
    std::enable_if_t<
        std::is_same<T, int32_t>::value ||
        std::is_same<T, uint32_t>::value ||
        (std::is_enum<T>::value && (sizeof(T) == 4U))
    , int>)
{
    std::cout << "print 32-bit\n";
}
#endif    

int main()
{
    Test<uint8_t>{}.special(5);
    Test<int8_t>{}.special(5);
    Test<bool>{}.special(true);
#if defined(ISSUE)
    Test<uint32_t>{}.special(5);
    Test<int32_t>{}.special(5);
#endif    
}

内容的提问来源于Stack Exchange，提问作者Simon