Сериализация и десериализация переменных и объектов - процедура настолько частая, что, сохраняя что-то вычисленное на диске, записывая вывод программы в текстовый файл или отдавая в сетевой интерфейс, мы даже не думаем, что мы это сериализуем.

Хотя инструментов для сериализации существует достаточно много, я предлагаю вашему вниманию ещё один. Он не лучше и не хуже других, и был создан с акцентом на простоту (кто бы мог подумать?) и компактность (опять же!), не сильно влияющую на производительность работы с ранее сериализованными данными.

Привет! Я Андрей Коваленко (Keva). Я занимаюсь лингвистическими задачами и делаю поисковые движки. Первый Апорт!, движок Rambler образца 2000 года и украинская <META> - мои разработки. Недавно завершил работу над большой корпоративной поисковой системой МойОфис.

Поскольку я активно строю и использую словари того или иного вида - а оглавление поискового индекса по сути своей тоже есть словарь, задачи сериализации, десериализации и работы с сериализованными данными без их явной десериализации решаю постоянно. Так что неудивительно, что сериализатор был выделен в отдельную библиотеку - один заголовочный файл.

Инструмент исполнен как набор шаблонных методов, поддерживающих наиболее распространённые типы и классы данных, и может дополняться в коде проекта короткими определениями для отправки результатов в тот или иной коллектор. Всего декларируются 4 шаблонных метода в глобальном пространстве имён, где T - сериализуемый тип, O - коллектор, а s - источник:

template <class T> size_t  GetBufLen( const T& );
template <class O,
          class T> O*      Serialize( O*, const T& );
template <class S,
          class T> S*      FetchFrom( S*, T& );
template <class S,
          class T> S*      SkipToEnd( S*, const T* );

GetBufLen( ... ) возвращает количество байт, которое потребует сериализация переданного объекта - например, для резервирования места или построения релокаций в сериализованных данных, если такие нужны.

Serialize( O* o, const T& t ) записывает объект t в коллектор, типизированный указатель на который передаётся первым параметром.

FetchFrom( S* s, T& t ) извлекает из источника s объект t.

SkipToEnd( S* s, const T* ) проматывает объект заданного типа T без его создания, переходя к следующему сериализованному объекту. В данном случае T* используется лишь для указания типа, и обычное его использование - передача (const T*)nullptr.

Для накопителей "память (char*)" и "c-style файл (FILE*)" примитивы заданы сразу:

template <> auto  Serialize( char* o, const void* p, size_t l ) -> char*
  {  return o != nullptr ? l + (char*)memcpy( o, p, l ) : nullptr;  }
template <> auto  Serialize( FILE* o, const void* p, size_t l ) -> FILE*
  {  return o != nullptr && fwrite( p, sizeof(char), l, o ) == l ? o : nullptr;  }

template <> auto  FetchFrom( const char* s, void* p, size_t l ) -> const char*
  {  return s != nullptr ? (memcpy( p, s, l ), l + s) : nullptr;  }
template <> auto  FetchFrom( FILE* s, void* p, size_t l ) -> FILE*
  {  return s != nullptr && fread( p, sizeof(char), l, s ) == l ? s : nullptr;  }

template <> auto  SkipBytes( const char* s, size_t l ) -> const char*
  {  return s != nullptr ? s + l : s;  }
template <> auto  SkipBytes( FILE* s, size_t l ) -> FILE*
  {  return s != nullptr && fseek( s, l, SEEK_CUR ) == 0 ? s : nullptr;  }

Если требуется определить другой накопитель или источник, достаточно в собственном проекте доопределить тройку примитивов сериализации, чтения и прыжка-через. Например, чтобы отправить объект в пустоту, определим эту самую пустоту и метод работы с ней:

class blackhole {};

template <> auto  Serialize( blackhole* o, const void*, size_t ) -> blackhole*
  {  return o;  }

Библиотека содержит примитивы кросплатформенной записи и чтения базовых типов (за исключением float и double - они пишутся as is), а также многих классов из стандартной библиотеки - vector, string, map, list, pair, tuple. Для собственных классов достаточно создать одноимённые методы, и они также будут успешно обрабатываться:

class storable
{
  int i;
  std::string s;
public:
  template <class O> O* Serialize( O* o ) const
  {
    return ::Serialize( ::Serialize( o, i ), s );
  }
  template <class S> S* FetchFrom( S* s )
  {
    return ::FetchFrom( ::FetchFrom( s, i ), this->s );
  }
};

...

storable object;

::Serialize( stdout, object );

Целочисленные значения от двух байт (uint16_t и выше) сериализуются с базовой компрессией - порциями по 7 бит для ненулевой части бит. То есть uint32_t(127) займёт 1 байт, а 128 уже два, а вот 65535 (16 значимых бит) уже 3 байта. На круг получается компактнее. Так, результатом сериализации вектора из пяти тридцатидвухбитных целых в примере ниже будет семибайтная последовательность:

  auto  my_vec = std::vector<uint32_t>{ 10, 20, 70, 100, 130 };
  char  serial[0x100];
  auto  endptr = ::Serialize( serial, my_vec );

  fprintf( stdout, "array of %u bytes: [", unsigned(endptr - serial) );

  for ( auto prefix = "", p = (const char*)serial; p != endptr; ++p, prefix = ", " )
    fprintf( stdout, "%s\\x%02x", prefix, (uint8_t)*p );

  fputs( "]\n", stdout );

array of 7 bytes: [\x05, \x0a, \x14, \x46, \x64, \x82, \x01]

В ней первый байт - размерность сериализованного вектора (5) и значения 10, 20, 70 и 100 занимают по 1 байту, а 130 (0x0102 = 128 + 2) записано двумя - младшим байтом (2 с флагом продолжения 0x80) и старшим (0x01).

Типизация в коллекторах не предусмотрена - это ответственность самой программы - знать, что читать. Поэтому при желании можно сериализовать std::vector<int>, а десериализовать std::list<int>; сериализовать const char[] = "...", а десериализовать std::string.

Про сериализацию данных произвольной структуры, в том числе и потенциально неполных, на днях напишу отдельно.

Ну а код доступен на github.