基于 SFINAE 的序列化解决方案无法在 C++ 中实例化重载的模板函数

Question

我正在尝试或多或少地序列化模板化的 class MState<T>。为此，我有一个父抽象 class MVariable，它以这种形式实现了几个序列化函数：

template <class Serializer, class SerializedType>
void serialize(Serializer& s, const SOME_SPECIFIC_TYPE &t) const;

我想让T成为几乎任何东西。序列化在 JSON 到 RapidJSON::Writer 中完成。因此，我需要使用特定的成员函数（例如 Writer::String、Writer::Bool、Writer::Uint...）以便为每种类型 T 获取正确的格式。

基本类型和 STL 容器的序列化将由 MVariable 提供。但是，我没有提供每一种类型（例如，将 SOME_SPECIFIC_TYPE 替换为 float、double、bool 等），而是尝试实现一个基于 SFINAE 的解决方案，它似乎有一些瑕疵。

我有一组 typedef 定义和序列化函数，如下所示：

class MVariable 
{
    template <class SerT> using SerializedFloating = 
         typename std::enable_if<std::is_floating_point<SerT>::value, SerT>::type;
    template <class SerT> using SerializedSeqCntr = 
         typename std::enable_if<is_stl_sequential_container<SerT>::value, SerT>::type;
    /* ... and many others. */

    /* Serialization of float, double, long double... */
    template <class Serializer, class SerializedType>
    void serialize(Serializer& s, const SerializedFloating<SerializedType> &t) const {
        s.Double(t);
    }

    /* Serialization of vector<>, dequeue<>, list<> and forward_list<> */
    template <class Serializer, class SerializedType>
    void serialize(Serializer& s, const SerializedSeqCntr<SerializedType> &t) const {
        /* Let's assume we want to serialize them as JSON arrays: */
        s.StartArray();
        for(auto const& i : t) {
            serialize(s, i);    // ----> this fails to instantiate correctly.
        }
        s.EndArray();
    }

    /* If the previous templates could not be instantiated, check 
     * whether the SerializedType is a class with a proper serialize
     * function: 
     **/
    template <class Serializer, class SerializedType>
    void serialize(Serializer&, SerializedType) const
    {
        /*  Check existance of:
         *  void SerializedType::serialize(Serializer&) const;
         **/
        static_assert(has_serialize<
           SerializedType,  
           void(Serializer&)>::value, "error message");
        /* ... if it exists then we use it. */
    }
};

template <class T>
class MState : public MVariable
{
    T m_state;

    template <class Serializer>
    void serialize(Serializer& s) const {
        s.Key(m_variable_name);
        MVariable::serialize<Serializer, T>(s, m_state);
    }
};

is_stl_sequential_container的实现基于this and the implementation of has_serialize is borrowed from here。两者都经过检查并且似乎可以正常工作：

MState<float> tvar0;
MState<double> tvar1;
MState<std::vector<float> > tvar2;

rapidjson::StringBuffer str_buf;
rapidjson::PrettyWriter<rapidjson::StringBuffer> writer(str_buf);
writer.StartObject();
tvar0.serialize(writer);  /* --> First function is used. Ok! */
tvar1.serialize(writer);  /* --> First function is used. Ok! */
tvar2.serialize(writer);  /* --> Second function is used, but there's
                           *     substitution failure in the inner call. 
                           **/
writer.EndObject();

但是，第二个函数中的递归 serialize 调用无法实例化。编译器从这个开始抱怨：

In instantiation of ‘void MVariable::serialize(Serializer&, SerializedType) const 
[with Serializer = rapidjson::PrettyWriter<... blah, blah, blah>; 
      SerializedType = float]’:

该消息继续显示静态断言错误，表明所有先前的重载模板函数在替换时都失败了，或者最后一个是最佳选择。

为什么在此处用 "failing" 替换 float 而不是在我尝试序列化 tvar0 或 tvar1 时？

Answer 1

问题...

您的代码中至少有两个问题。

首先，您在 MState::serialize():

中明确指定了模板参数

MVariable::serialize<Serializer, T>(s, m_state);

但是你在 SerializedSeqCntr-constrained 重载中调用模板类型推导（通过 serialize(s, i);）；这是行不通的，因为那些 SFINAE 检查是 非推导上下文 (*)，也就是说，它们不参与类型推导，编译器无法推导 SerializedType类型。

显式传递参数，如

serialize<Serializer,std::decay_t<decltype(i)>>(s, i);

或添加推导的 SerializedType const& 参数和 sfinae 约束的虚拟默认参数或 return 类型 (**)。

第二个问题是 'fallback' 重载应该在可能调用它的约束重载之前：

template <class Serializer, class SerializedType>
void serialize(Serializer&, SerializedType) const:

template <class Serializer, class SerializedType>
void serialize(Serializer& s, const SerializedSeqCntr<SerializedType> &t);

...

否则，名称查找将无法在 SerializedSeqCntr-constrained 重载中找到正确的 serialize()。是的，作为依赖名称的函数，名称查找确实发生在实例化点；但是，仅考虑在函数体上下文中可见的名称（除非 ADL 启动）。

可能还有第三个问题；回退重载并不优于约束重载，因为前者按值采用 SerializedType；如果这不是本意，您还需要进一步限制回退。

...和一些理论：

(*) 详细说明一下，当您调用函数模板时，您要么显式传递模板参数（如 foo<bar>()），要么让编译器从函数参数的类型中推导出它们（如在 foo(some_bar)）。有时，这个过程无法成功。

这可能出于三个原因：

存在替换失败；也就是说，模板参数 T 已被成功推导或给出 ，但它也出现在如果拼写会发生错误的表达式中在函数签名之外；函数重载被简单地忽略；这就是 SFINAE 的意义所在。
在实例化需要执行替换的类型和函数时出错；该函数未被忽略，程序格式错误（如果这听起来令人困惑，这个 answer 可能会有所帮助）。
无法推导模板实参，忽略函数重载；一个明显的例子是当模板参数没有出现在任何函数参数中但没有明确指定时；另一个例子是当它出现的函数参数恰好是 非推导上下文 时，请参阅此 answer 以获取解释；你会看到这个论点，比如说 const SerializedFloating<SerializedType>& 确实是非推导的。

(**) 如前所述，SFINAE 约束通常是非推导的；所以，如果你需要类型推导才能工作，你应该将要推导的参数传递给它自己的、可推导的参数；这通常通过添加虚拟默认参数或通过 return 类型来完成：

template<typename T>
result_type
foo( T arg, std::enable_if_t<std::is_floating_point<T>::value>* = 0 );

template<typename T>
std::enable_if_t<std::is_floating_point<T>::value, result_type>
foo( T arg );

基于 SFINAE 的序列化解决方案无法在 C++ 中实例化重载的模板函数

SFINAE-based serialization solution failing to instantiate an overloaded templated function in C++

c++

templates

serialization

sfinae

rapidjson

问题...

...和一些理论：