Question

我已经实现了一个template<typename T> Serializer，它适用于T类型的任何平易可复制的对象，只是序列化sizeof(T)个字节。

然后我为其他感兴趣的类型实现了一些（部分）特化，例如std::vector<T>和std::bacis_string<T>。对于其他类型，我触发static_assert(is_trivially_copyable<T>::type, "Unsupported type");。

这不是我想要的，因为我想避免序列化，例如使用裸指针的类型，例如：

struct C_style_vector{
    size_t size;
    int* ptr;
};

对于这种类型，我假设用户将定义一个特殊的专业化。相反，就目前而言，我的Serializer不适用于这样的类型：

struct Simple_type{
    double d;
    std::vector<int> v;
};

尽管Simple_type的每个成员都可以通过我的班级进行序列化。

那么，我怎样才能用裸指针捕捉类型？如何告诉序列化程序序列化仅由可序列化成员组成的类型，按成员序列化成员？

Answer 1

实际上并不简单，如果没有添加一些用户，就无法在C ++中完成，因为C ++中没有反射。

您可以使用boost :: fusion之类的东西，但在这种情况下，用户应该使用融合序列。最好的方法是使用boost :: serialization我认为，用户必须为自己的类型提供serialize/deserialize函数。

融合的例子。

template<bool Value, typename Next, typename Last>
struct is_serializable_impl
{
private:
   static const bool cvalue = !boost::is_pointer<
   typename boost::remove_reference<
   typename boost::fusion::result_of::deref<Next>::type>::type>::value;
public:
   static const bool value = Value && is_serializable_impl<
   cvalue, typename boost::fusion::result_of::next<Next>::type, Last>::value;
};

template<bool Value, typename Last>
struct is_serializable_impl<Value, Last, Last>
{
   static const bool value = Value;
};

template<typename T>
struct is_serializable :
is_serializable_impl<true, typename boost::fusion::result_of::begin<T>::type,
   typename boost::fusion::result_of::end<T>::type>
{
};

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

template<typename T>
struct serializer<T,
typename boost::enable_if<typename 
boost::fusion::traits::is_sequence<T>::type>::type>
{
   static_assert(is_serializable<T>::value, "Not serializable");
};

Live example

按成员序列化成员

1 个答案: