CC++序列化反序列化之Tuple
⼀、对象序列化通常⽤于两个⽬的：
（1）将对象存储于硬盘上，便于以后反序列化使⽤
（2）在⽹络上传送对象的字节序列
  例如：有⼀个数据结构，⾥⾯存储的数据是经过很多其它数据通过⾮常复杂的算法⽣成的，由于数据量很⼤，算法⼜复杂，因此⽣成该数据结构所⽤数据的时间可能要很久（也许⼏个⼩时，甚⾄⼏天），⽣成该数据结构后⼜要⽤作其它的计算，那么你在调试阶段，每次运⾏个程序，就光⽣成数据结构就要花上这么长的时间，⽆疑代价是⾮常⼤的。如果你确定⽣成数据结构的算法不会变或不常变，那么就可以通过序列化技术⽣成数据结构数据存储到磁盘上，下次重新运⾏程序时只需要从磁盘上读取该对象数据即可，所花费时间也就读⼀个⽂件的时间，可想⽽知是多么的快，节省了我们的开发时间。
⼆、C++对象序列化的四种⽅法
1、Google Protocol Buffers（protobuf）
  Google Protocol Buffers (GPB)是Google内部使⽤的数据编码⽅式，旨在⽤来代替XML进⾏数据交换。可⽤于数据序列化与反序列化。主要特性有：
⾼效
语⾔中⽴(Cpp, Java, Python)
可扩展
2、Boost.Serialization
  Boost.Serialization可以创建或重建程序中的等效结构，并保存为⼆进制数据、⽂本数据、XML或者有⽤户⾃定义的其他⽂件。该库具有以下吸引⼈的特性：
代码可移植（实现仅依赖于ANSI C++）。
深度指针保存与恢复。
可以序列化STL容器和其他常⽤模版库。
数据可移植。
⾮⼊侵性。
3、 MFC Serialization
  Windows平台下可使⽤MFC中的序列化⽅法。MFC 对 CObject 类中的序列化提供内置⽀持。因此，所有从 CObject 派⽣的类都可利⽤CObject 的序列化协议。
4、Net Framework
  .NET的运⾏时环境⽤来⽀持⽤户定义类型的流化的机制。它在此过程中，先将对象的公共字段和私有字段以及类的名称（包括类所在的程序集）转换为字节流，然后再把字节流写⼊数据流。在随后对对象进⾏反序列化时，将创建出与原对象完全相同的副本。
---->[⽐较]这⼏种序列化⽅案各有优缺点，各有⾃⼰的适⽤场景。其中MFC和.Net框架的⽅法适⽤范围很窄，只适⽤于Windows下，且.Net框架⽅法还需要.Net的运⾏环境。从序列化时间、反序列化时间和产⽣数据⽂件⼤⼩这⼏个⽅⾯⽐较了前三种序列化⽅案，得出结论如下（仅供参考）：
Google Protocol Buffers效率较⾼，但是数据对象必须预先定义，并使⽤protoc编译，适合要求效率，允许⾃定义类型的内部场合使⽤。
Boost.Serialization 使⽤灵活简单，⽽且⽀持标准C++容器。
相⽐⽽⾔，MFC的效率较低，但是结合MSVS平台使⽤最为⽅便。
  为了考虑平台的移植性、适⽤性和⾼效性，推荐⼤家使⽤Google的protobuf和Boost的序列化⽅案。
三、C++11中的tuple（元组）：
#include "Common.hpp"
#define META(...) auto Meta()->decltype(std::tie(__VA_ARGS__)){return std::tie(__VA_ARGS__);}
struct Person
{
int age;
std::string name;
std::string city;
META(age, name, city)
};
//宏替换后就是
struct Person
{
int age;
std::string name;
std::string city;
//准确的说是返回std::tuple<int&, std::string&, std::string&>
std::tuple<int, std::string, std::string> Meta()
{
return std::tie(age, name, city);
}
};
  tuple看似简单，其实它是简约⽽不简单，可以说它是c++11中⼀个既简单⼜复杂的东东，关于它简单的⼀⾯是它很容易使⽤，复杂的⼀⾯是它内部隐藏了太多细节，要揭开它神秘的⾯纱时⼜⽐较困难。
  tuple是⼀个固定⼤⼩的不同类型值的集合，是泛化的std::pair。和c#中的tuple类似，但是⽐c#中的tuple强⼤得多。我们也可以把他当做⼀个通⽤的结构体来⽤，不需要创建结构体⼜获取结构体的特征，在某些情况下可以取代结构体使程序更简洁，直观。
1、基本⽤法
  （1）构造⼀个tuple：tuple<const char*, int>tp = make_tuple(sendPack,nSendSize); //构造⼀个tuple
这个tuple等价于⼀个结构体struct A {  　char* p;  　int len; };
  ⽤tuple<const char*, int>tp就可以不⽤创建这个结构体了，⽽作⽤是⼀样的，是不是更简洁直观了。还有⼀种⽅法也可以创建元组，⽤std::tie，它会创建⼀个元组的左值引⽤。
auto tp = return std::tie(1, "aa", 2);
//tp的类型实际是：
std::tuple<int&,string&, int&>
  （2）再看看如何获取它的值：
const char* data = std::get<0>();  //获取第⼀个值
int len = std::get<1>();      //获取第⼆个值
  还有⼀种⽅法也可以获取元组的值，通过std::tie解包tuple
int x,y;
string a;
std::tie(x,a,y) = tp;
  通过tie解包后，tp中三个值会⾃动赋值给三个变量。解包时，我们如果只想解某个位置的值时，可以⽤std::ignore占位符来表⽰不解某个位置的值。⽐如我们只想解第三个值时：
std::tie(std::ignore, std::ignore, y) = tp; //只解第三个值了
  还有⼀个创建右值的引⽤元组⽅法：forward_as_tuple。它实际上创建了⼀个类似于std::tuple<int&&, std::string&&>类型的tuple。
std::forward_as_tuple(10),
std::forward_as_tuple(20, 'a'));
  我们还可以通过tuple_cat连接多个tupe
int main()
{
std::tuple<int, std::string, float> t1(10, "Test", 3.14);
int n = 7;
auto t2 = std::tuple_cat(t1, std::make_pair("Foo", "bar"), t1, std::tie(n));
n = 10;
print(t2);
}
输出结果：
(10, Test, 3.14, Foo, bar, 10, Test, 3.14, 10)
  到这⾥tuple的⽤法介绍完了，是不是很简单，也很容易使⽤，相信你使⽤它之后就离不开它了。我前⾯说过tuple是简约⽽不简单。它有很多⾼级的⽤法。它和模板元关系密切，要介绍它的⾼级⽤法的时候，读者需要⼀定的模板元基础，如果你只是把它当⼀个泛型的pair去使⽤时，这部分可以不看，如果你想⽤它⾼级⽤法的时候就往下看。让我们要慢慢揭开tuple神秘的⾯纱。
2、tuple的⾼级⽤法
  （1）获取tuple中某个位置元素的类型
  通过std::tuple_element获取元素类型。
template<typename Tuple>
void Fun(Tuple& tp)
{
  std::tuple_element<0,Tuple>::type first = std::get<0>(mytuple);
  std::tuple_element<1,Tuple>::type second = std::get<1>(mytuple);
}
  获取tuple中元素的个数：
  tuple t;
  int size = std::tuple_size<decltype(t))>::value;
  （2）遍历tuple中的每个元素
  因为tuple的参数是变长的，也没有for_each函数，如果我们想遍历tuple中的每个元素，需要⾃⼰写代码实现。⽐如我要打印tuple中的每个元素。
template<class Tuple, std::size_t N>
struct TuplePrinter {
static void print(const Tuple& t)
{
TuplePrinter<Tuple, N - 1>::print(t);
std::cout << ", " << std::get<N - 1>(t);
}
};
template<class Tuple>
struct TuplePrinter<Tuple, 1>{
static void print(const Tuple& t)
{
std::cout << std::get<0>(t);
}
define的基本用法};
template& Args>
void PrintTuple(const std::tuple&>& t)
{
std::cout << "(";
TuplePrinter<decltype(t), (Args)>::print(t);
std::cout << ")\n";
}
  （3）根据tuple元素值获取其对应的索引位置
namespace detail
{
template<int I, typename T, Args>
struct find_index
{
static int call(std::tuple&> const& t, T&& val)
{
return (std::get<I - 1>(t) == val) ? I - 1 :
find_index<I - 1, T, >::call(t, std::forward<T>(val));
}
};
template<typename T, Args>
struct find_index<0, T, >
{
static int call(std::tuple&> const& t, T&& val)
{
return (std::get<0>(t) == val) ? 0 : -1;
}
};
}
template<typename T, Args>
int find_index(std::tuple&> const& t, T&& val)
return detail::find_index<0, (Args) - 1, T, >::
call(t, std::forward<T>(val));
}
int main()
{
std::tuple<int, int, int, int> a(2, 3, 1, 4);
std::cout << find_index(a, 1) << std::endl; // Prints 2
std::cout << find_index(a, 2) << std::endl; // Prints 0
std::cout << find_index(a, 5) << std::endl; // Prints -1 (not found)
}
  （4）展开tuple，并将tuple元素作为函数的参数。这样就可以根据需要对tuple元素进⾏处理了#include <tuple>
#include <type_traits>
#include <utility>
template<size_t N>
struct Apply {
template<typename F, typename T, A>
static inline auto apply(F && f, T && t, A &&... a)-> decltype(Apply<N-1>::apply(
::std::forward<F>(f), ::std::forward<T>(t),
::std::get<N-1>(::std::forward<T>(t)),
::std::forward<A>(a)...
))
{
return Apply<N-1>::apply(::std::forward<F>(f),
:
:std::forward<T>(t),
::std::get<N-1>(::std::forward<T>(t)),
::std::forward<A>(a)...
);
}
};
template<>
struct Apply<0> {
template<typename F, typename T, A>
static inline auto apply(F && f, T &&, A &&... a)
-> decltype(::std::forward<F>(f)
(::std::forward<A>(a)...))
{
return ::std::forward<F>(f)(::std::forward<A>
(a)...);
}
};
template<typename F, typename T>
inline auto apply(F && f, T && t)
-> decltype(Apply< ::std::tuple_size<
typename ::std::decay<T>::type
>::value>::apply(::std::forward<F>(f),
:
:std::forward<T>(t)))
{
  return Apply< ::std::tuple_size < typename ::std::decay<T>::type
>::value>::apply(::std::forward<F>(f),
::std::forward<T>(t));
}
void one(int i, double d)
{
  std::cout << "function one(" << i << ", " << d << ");\n";
}
int two(int i)
{
  std::cout << "function two(" << i << ");\n";
  return i;
//测试代码
int main()
{
std::tuple<int, double> tup(23, 4.5);
apply(one, tup);
int d = apply(two, std::make_tuple(2));
return0;
}
  看到这⾥，想必⼤家对tuple有了⼀个全⾯的认识了吧，怎么样，它是简约⽽不简单吧。对模板元不熟悉的童鞋可以不看tuple⾼级⽤法部分，不要为看不懂⽽捉急，没事的，⾼级部分⼀般⽤不到，知道基本⽤法就够⽤了。
tuple和vector⽐较：
  vector只能容纳同⼀种类型的数据，tuple可以容纳任意类型的数据；
vector和variant⽐较：
  ⼆者都可以容纳不同类型的数据，但是variant的类型个数是固定的，⽽tuple的类型个数不是固定的，是变长的，更为强⼤。

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。