使用SFINAE检测

时间：2019-05-06 04:20:10

标签： c++ sfinae typetraits

我正在使用自定义序列化程序创建自定义，模板繁重的序列化库。我希望能够使用SFINAE在我的库中检测并执行Serializer概念（我无法访问支持概念的C ++ 20编译器）：

class CustomSerializer
{
    static T Serialize(S);
    static S Deserialize(T);
};

这里的想法是Serialize的输入类型必须等于Deserialize的输出类型，反之亦然

这可能吗？如果可以，怎么办？

我尝试研究std::invoke_result_t，但随后需要提供参数类型。但是Deserialize的参数类型是Serialize的调用结果，要获取Serialize的调用结果，...

我希望您在这里看到圆形图案，这使我想知道这是否有可能。

2 个答案:

答案 0 :(得分：3)

简单的解决方案-检查函数指针是否相互依赖

通过模式匹配，这实际上非常简单。我们可以编写一个constexpr函数，我将其称为checkInverse，如果类型反转，则返回true，否则返回false：

template<class S, class T>
constexpr bool checkInverse(S(*)(T), T(*)(S)) {
    return true;   
}

template<class S, class T, class Garbage>
constexpr bool checkInverse(S(*)(T), Garbage) {
    return false;
}

由于第一种情况更特殊，如果满足，则该函数将返回true，否则将返回false。

然后我们可以使用它来检查类的Serialize和Deserialize方法是否彼此匹配：

template<class T>
constexpr bool isValidPolicy() {
    return checkInverse(T::Serialize, T::Deserialize); 
}

如果我们不确定类是否具有Serialize和Deserialize方法怎么办？

我们可以扩展isValidPolicy来使用SFINAE进行检查。现在，仅当这些方法存在并且它们满足类型依赖关系时，它才会返回true。

如果我呼叫isValidPolicy<Type>(0)，它将尝试使用int重载。如果Serialize和Deserialize不存在，它将退回到long重载，并返回false。 

template<class Policy>
constexpr auto isValidPolicy(int)
    -> decltype(checkInverse(Policy::Serialize, Policy::Deserialize))
{
    return checkInverse(Policy::Serialize, Policy::Deserialize); 
}
template<class Policy>
constexpr auto isValidPolicy(long) 
    -> bool
{
    return false; 
}

此解决方案有什么弊端？

表面上，这确实是一个不错的解决方案，尽管它确实存在一些问题。如果将Serialize和Deserialize用作模板，则将无法进行到函数指针的转换。

此外，将来的用户可能希望编写Deserialize方法，这些方法返回可以转换为序列化类型的对象。这对于将对象直接构建为向量而不进行复制会非常有用，从而提高了效率。此方法不允许以这种方式编写Deserialize。

高级解决方案-检查特定类型是否存在Serialize，并且是否可以将Deserialize返回的值转换为该类型

此解决方案更通用，最终更有用。它在写入Serialize和Deserialize的方式上提供了很大的灵活性，同时确保了某些约束条件（即Deserialize(Serialize(T))可以转换为T）。

检查输出是否可以转换为某种类型

我们可以使用SFINAE进行检查，并将其包装到is_convertable_to函数中。 

#include <utility>
#include <type_traits>

template<class First, class... T>
using First_t = First; 

template<class Target, class Source>
constexpr auto is_convertable_to(Source const& source, int) 
    -> First_t<std::true_type, decltype(Target(source))>
{
    return {};
}

template<class Target, class Source>
constexpr auto is_convertable_to(Source const& source, long) 
    -> std::false_type
{
    return {}; 
}

检查类型是否代表有效的序列化器

我们可以使用上面的转换检查器来执行此操作。这将检查给定类型，必须将其作为参数传递给模板。结果以静态布尔常数给出。 

template<class Serializer, class Type>
struct IsValidSerializer {
    using Serialize_t = 
        decltype(Serializer::Serialize(std::declval<Type>())); 
    using Deserialize_t = 
        decltype(Serializer::Deserialize(std::declval<Serialize_t>()));

    constexpr static bool value = decltype(is_convertable_to<Type, Deserialize_t>(std::declval<Deserialize_t>(), 0))::value; 
};

惰性反序列化器的示例

我之前提到过，可以依靠覆盖转换运算符来进行序列化/反序列化。这是一个非常强大的工具，可以用来编写惰性序列化器和反序列化器。例如，如果序列化的表示形式是std::array的{​​{1}}，我们可以这样编写惰性反序列化器：

char

有了这些，编写适用于任何普通可复制类型的template<size_t N> struct lazyDeserializer { char const* _start; template<class T> operator T() const { static_assert(std::is_trivially_copyable<T>(), "Bad T"); static_assert(sizeof(T) == N, "Bad size"); T value; std::copy_n(_start, N, (char*)&value); return value; } }; 策略就相对简单了：

Serialize

答案 1 :(得分：1)

对一组重载函数或模板函数的自省是相当有限的。但是在Serialize和Deserialize不会重载的情况下，可以获取这些函数的返回类型和参数类型，例如：

template<class Arg,class Ret>
auto get_arg_type(Ret(Arg)) -> Arg;
template<class Arg,class Ret>
auto get_ret_type(Ret(Arg)) -> Ret;

class CustomSerializer
{
    public:
    static int Serialize(double);
    static double Deserialize(int);
};

//Concept check example:
static_assert(std::is_same_v<decltype(get_arg_type(CustomSerializer::Serialize))
                            ,decltype(get_ret_type(CustomSerializer::Deserialize))>);
static_assert(std::is_same_v<decltype(get_ret_type(CustomSerializer::Serialize))
                            ,decltype(get_arg_type(CustomSerializer::Deserialize))>);

我认为该解决方案是不够的，因为该概念由于错误的原因而失败（当Serialize或Deserialize是模板和/或重载时）。

缓解措施可能是使用特征，因此，当特征类型提供您的库中未考虑的功能时，用户便可以专门化特征：

class CustomSerializer
{
    public:
    static int Serialize(double);
    static int Serialize(char);
    static double Deserialize(int);
};

template<class T>
struct serialize_from{
  using type = decltype(get_arg_type(T::Serialize));
  };
template<class T>
using serialize_from_t = typename serialize_from<T>::type;

template<>
struct serialize_from<CustomSerializer>{
    using type = double;
};

//The concept check use the trait:
static_assert(std::is_same_v<decltype(CustomSerializer::Deserialize(
                               CustomSerializer::Serialize(
                                 std::declval<const serialize_from_t<CustomSerializer>&>())))
                            ,serialize_from_t<CustomSerializer>>);
//N.B.: You should also provide a serialize_to trait, here the concept
//check a convertibility where you expect a type equality... but the code
//would be too long for this answer.
相关问题
最新问题