如何使用 SFINAE 创建相同方法的 2 个不同实现

Question

我已阅读有关 SFINAE 的一些文章，但找不到适合我的情况的解决方案。这是我想做的：

#include <type_traits>

struct CByteArray {};
struct HLVariant {
    HLVariant() {}
    HLVariant(const HLVariant&) {}
    HLVariant(const CByteArray&) {}

    };

template <typename T>
struct Serializer
{
    static inline typename std::enable_if<std::is_pod<T>::value, CByteArray>::type serialize(const T& value)
    {
        static_assert(std::is_pod<T>::value, "Not a POD type");
        return CByteArray();
    }

    static inline typename std::enable_if<!std::is_pod<T>::value, CByteArray>::type serialize(const T& value)
    {
        return Serializer<HLVariant>::serialize(HLVariant(value));
    }
};

template <>
struct Serializer<HLVariant>
{
    static inline CByteArray serialize(const HLVariant& value)
    {
        return CByteArray();
    }
};

int main()
{
    int i = 0;
    Serializer<int>::serialize(i);
    Serializer<CByteArray>::serialize(CByteArray());
    Serializer<HLVariant>::serialize(HLVariant());

    return 0;
}

当然，我收到的是error C2039: 'type' : is not a member of 'std::enable_if<false,CByteArray>'

如何实现我想要的？

另外，是否有可能以某种方式重新组织Serializer，以便可以隐式推导出模板参数-Serializer::serialize(i); 而不是Serializer<int>::serialize(i);？

Answer 1

为了使用std::enable_if<condition>，您必须在模板中超过条件。一种选择是将您的函数声明为具有默认参数的模板

template <typename T>
struct Serializer
{
    template<bool pod = std::is_pod<T>::value>  // template over condition
    static typename std::enable_if<pod, CByteArray>::type
    serialize(const T& value)
    { return CByteArray(); }

    template<bool pod = std::is_pod<T>::value>
    static typename std::enable_if<!pod, CByteArray>::type 
    serialize(const T& value)
    { return Serializer<HLVariant>::serialize(HLVariant(value)); }
};

template<>
struct Serializer<HLVariant>
{
    static CByteArray serialize(const HLVariant&);
};

或者，您可以直接在类模板范围内应用 SFINAE：

template<typename T, typename = void> struct Serializer;

template<>
struct Serializer<HLVariant>
{
    static CByteArray serialize(const HLVariant&)
    { return CByteArray(); }
};

template<typename T>
struct Serializer<T,typename std::enable_if<is_pod<T>::type>
{
    static CByteArray serialize(const T&)
    { return CByteArray(); }
};

template<typename T>
struct Serializer<T,typename std::enable_if<!is_pod<T>::type>
{
    static CByteArray serialize(const T&value)
    { return Serializer<HLVariant>::serialize(HLVariant(value));
};

或者你可以去掉类 Serializer 并直接通过模板函数声明它：

inline CByteArray
serialize(const HLVariant&)
{ return CByteArray(); }

template<typename T>
inline typename enable_if<std::is_pod<T>::value, CByteArray>::type
serialize(const T&)
{ return CByteArray(); }

template<typename T>
inline typename enable_if<!std::is_pod<T>::value, CByteArray>::type
serialize(const T&value)
{ return serialize(HLVariant(value)); }

顺便说一句，C++14 定义了非常有用的别名

template<bool C, typename T>
using enable_if_t = typename enable_if<C,T>::type;

当然，您也可以这样做。这样就避免了繁琐的typename 和::type。

Answer 2

SFINAE 是“替代失败不是错误”的首字母缩写词。根据定义，这意味着它仅适用于在模板定义中用模板实参代替参数时。您的 serialize 函数是类模板的成员函数，它们本身不是函数模板。直接的答案是将函数转换为函数模板（Live code）：

template <typename> struct Serializer;

template <>
struct Serializer<HLVariant>
{
    static CByteArray serialize(const HLVariant& /* value */)
    {
        return CByteArray();
    }
};

template <typename T>
struct Serializer
{
    template <typename U = T>
    static typename std::enable_if<std::is_pod<U>::value, CByteArray>::type
    serialize(const U& /* value*/)
    {
        static_assert(std::is_pod<U>::value, "Not a POD type");
        return CByteArray();
    }

    template <typename U = T>
    static typename std::enable_if<!std::is_pod<U>::value, CByteArray>::type
    serialize(const U& value)
    {
        return Serializer<HLVariant>::serialize(HLVariant(value));
    }
};

我已经删除了多余的inlines，因为类主体中定义的所有函数都是隐式内联的，并且我重新定位了Serializer<HLVariant> 特化以确保它在被引用之前被正确声明。有一个只有静态成员函数的类有点傻；您可以更合理地将其实现为一组重载函数 (Live code)：

inline CByteArray serialize(const HLVariant& /* value */)
{
    return CByteArray();
}

template <typename T>
inline typename std::enable_if<std::is_pod<T>::value, CByteArray>::type
serialize(const T& /* value*/)
{
    static_assert(std::is_pod<T>::value, "Not a POD type");
    return CByteArray();
}

template <typename T>
inline typename std::enable_if<!std::is_pod<T>::value, CByteArray>::type
serialize(const T& value)
{
    return serialize(HLVariant(value));
}

int main()
{
    int i = 0;
    serialize(i);
    serialize(CByteArray());
    serialize(HLVariant());
}

鉴于 SFINAE 使用妨碍代码可读性，我更愿意在这种情况下使用标签调度。不要使用 SFINAE 管理两个函数的重载解决方案，而是使用第三个函数调用 POD 或非 POD 的适当实现 (Yet more live code)：

inline CByteArray serialize(const HLVariant& /* value */)
{
    return CByteArray();
}

template <typename T>
inline CByteArray serialize(std::true_type, const T& /* value*/)
{
    static_assert(std::is_pod<T>::value, "Not a POD type");
    return CByteArray();
}

template <typename T>
inline CByteArray serialize(std::false_type, const T& value)
{
    return serialize(HLVariant(value));
}

template <typename T>
inline CByteArray serialize(const T& value)
{
    return serialize(std::is_pod<T>{}, value);
}

SFINAE 功能强大，但也有足够的危险性，可以安全地锁起来解决您可以使用更简单的工具解决的问题。