c++ - 使用SFINAE检测共同依赖功能的模式

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

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

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

这可能吗？如果是这样，怎么办？

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

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

最佳答案

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

通过模式匹配，这实际上非常简单。我们可以编写一个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方法，该怎么办？

我们可以使用SFINAE扩展isValidPolicy进行检查。现在，仅当这些方法存在并且它们满足类型依赖关系时，它才会返回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方法，这些方法返回可以转换为序列化类型的对象。这对于将对象直接构建为 vector 而不进行复制会非常有用，从而提高了效率。此方法不允许以这种方式编写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 {};
}

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

我们可以使用上面的转换检查器来做到这一点。这将检查给定类型，必须将其作为参数传递给模板。结果以静态 bool 常数给出。

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的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策略就相对简单了:

#include <array>
#include <algorithm>

class SerializeTrivial {
   public:
    template<class T>
    static std::array<char, sizeof(T)> Serialize(T const& value) {
        std::array<char, sizeof(T)> arr;
        std::copy_n((char const*)&value, sizeof(T), &arr[0]);
        return arr;
    }

    template<size_t N>
    static auto Deserialize(std::array<char, N> const& arr) {
        return lazyDeserializer<N>{&arr[0]};
    }
};

关于c++ - 使用SFINAE检测共同依赖功能的模式，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/55998766/