Сериализация данных в C++ с библиотекой Cereal

Привет, Хабр!

Сегодня рассмотрим библиотеку Cereal в C++, которая позволяет сохранять и загружать состояние объектов, не теряя производительности.

Cereal — это заголовочная библиотека для C++, предназначенная для сериализации данных. Она поддерживает XML и JSON. Помимо этого поддерживает практически все стандартные типы данных в C++ и имеет инструменты для работы с пользовательскими типами. В отличие от, например, библиотек Boost, Cereal не требует сложных настроек и имеет интуитивно понятный синтаксис, знакомый юзерам Boost.

Установим

Cкачаем последнюю версию библиотеки с GitHub:

git clone https://github.com/USCiLab/cereal.git

После скачивания переходим в папку include/cereal в корневом каталоге проекта. Копируем эту папку в директорию, доступную для проекта.

Cereal является заголовочной библиотекой, поэтому дополнительная компиляция не требуется!

Cereal требует компилятора, поддерживающего стандарт C++11. Список поддерживаемых компиляторов:

• GCC 4.7.3 или новее

• Clang 3.3 или новее

• MSVC 2013 или новее

Основной синтаксис

Функции serialize

Функция serialize — основной метод для определения, какие члены класса должны быть сериализованы. Обычно её определяют внутри класса:

struct MyRecord {     uint8_t x, y;     float z;      template <class Archive>     void serialize(Archive& ar) {         ar(x, y, z);     } };

Здесь функция serialize принимает объект архива и передает ему члены класса для сериализации.

Функции save и load

Когда нужно разделить процесс сериализации на загрузку и сохранение, можно юзать функции save и load. Мастхев, когда требуется выполнять доп. действия при загрузке или сохранении данных:

struct SomeData {     int32_t id;     std::shared_ptr<std::unordered_map<uint32_t, MyRecord>> data;      template <class Archive>     void save(Archive& ar) const {         ar(data);     }      template <class Archive>     void load(Archive& ar) {         static int32_t idGen = 0;         id = idGen++;         ar(data);     } };

Функция save должна быть const, т.к она не должна изменять состояние объекта.

Функции save_minimal и load_minimal

Эти функции позволяют минимизировать выходные данные, представляя объект в виде одного примитива или строки. Полезно для упрощения человекочитаемых архивов:

struct MyData {     double d;      template <class Archive>     double save_minimal(Archive const&) const {         return d;     }      template <class Archive>     void load_minimal(Archive const&, double const& value) {         d = value;     } };

Умные указатели

Cereal поддерживает сериализацию умных указателей std::shared_ptr и std::unique_ptr. Так можно ериализовать объекты, на которые ссылаются умные указатели, без лшних усилий:

#include <cereal/types/memory.hpp>  struct DataHolder {     std::shared_ptr<MyRecord> record;      template <class Archive>     void serialize(Archive& ar) {         ar(record);     } };

Наследование

Есть функции cereal::base_class и cereal::virtual_base_class, которые помогают корректно сериализовать базовые и производные классы:

#include <cereal/types/base_class.hpp>  struct Base {     int x;      template <class Archive>     void serialize(Archive& ar) {         ar(x);     } };  struct Derived : public Base {     int y;      template <class Archive>     void serialize(Archive& ar) {         ar(cereal::base_class<Base>(this), y);     } };

Архивы и их типы

Cereal поддерживает несколько типов архивов: бинарные, XML и JSON архивы. Каждый из них используется для сериализации данных в различных форматах.

Бинарные архивы

#include <cereal/archives/binary.hpp>  std::ofstream os("data.cereal", std::ios::binary); cereal::BinaryOutputArchive archive(os); archive(someData);

XML архивы

#include <cereal/archives/xml.hpp>  std::ofstream os("data.xml"); cereal::XMLOutputArchive archive(os); archive(someData);

JSON архивы

#include <cereal/archives/json.hpp>  std::ofstream os("data.json"); cereal::JSONOutputArchive archive(os); archive(someData);

Версионирование типов

Для управления версиями типов есть макрос CEREAL_CLASS_VERSION, который позволяет задавать версию для каждого типа данных:

#include <cereal/types/base_class.hpp> #include <cereal/types/polymorphic.hpp>  struct MyType {     int x;      template <class Archive>     void serialize(Archive& ar, const std::uint32_t version) {         ar(x);     } };  CEREAL_CLASS_VERSION(MyType, 1);

Примеры использования

Сохранение и загрузка конфигурации приложения

Часто Cereal юзают для сериализация конфигурационных файлов. Рассмотрим пример, где конфигурация приложения хранится в JSON файле, и хотелось бы её сохранять и загружать при запуске приложения:

#include <cereal/archives/json.hpp> #include <cereal/types/map.hpp> #include <cereal/types/string.hpp> #include <fstream> #include <iostream>  struct AppConfig {     std::map<std::string, std::string> settings;      template <class Archive>     void serialize(Archive& ar) {         ar(settings);     } };  void saveConfig(const AppConfig& config, const std::string& filename) {     std::ofstream os(filename);     cereal::JSONOutputArchive archive(os);     archive(config); }  AppConfig loadConfig(const std::string& filename) {     std::ifstream is(filename);     cereal::JSONInputArchive archive(is);     AppConfig config;     archive(config);     return config; }  int main() {     AppConfig config;     config.settings["username"] = "admin";     config.settings["theme"] = "dark";      saveConfig(config, "config.json");      AppConfig loadedConfig = loadConfig("config.json");     std::cout << "Username: " << loadedConfig.settings["username"] << "\n";     std::cout << "Theme: " << loadedConfig.settings["theme"] << "\n";      return 0; }

Сохранение состояния игры

В игрушках было бы хорошо сохранять состояние игры, чтобы игрок мог продолжить с того места, где остановился. Можно легко сохранять и загружать данные игры с помощью Cereal:

#include <cereal/archives/binary.hpp> #include <cereal/types/vector.hpp> #include <fstream>  struct GameState {     int level;     int score;     std::vector<int> inventory;      template <class Archive>     void serialize(Archive& ar) {         ar(level, score, inventory);     } };  void saveGameState(const GameState& state, const std::string& filename) {     std::ofstream os(filename, std::ios::binary);     cereal::BinaryOutputArchive archive(os);     archive(state); }  GameState loadGameState(const std::string& filename) {     std::ifstream is(filename, std::ios::binary);     cereal::BinaryInputArchive archive(is);     GameState state;     archive(state);     return state; }  int main() {     GameState state{3, 4500, {1, 2, 3}};     saveGameState(state, "game.sav");      GameState loadedState = loadGameState("game.sav");     std::cout << "Level: " << loadedState.level << "\n";     std::cout << "Score: " << loadedState.score << "\n";     std::cout << "Inventory: ";     for (int item : loadedState.inventory) {         std::cout << item << " ";     }     std::cout << "\n";      return 0; }

Сериализация данных для сетевого обмена

В распределенных системах и сетевых приложениях в основном нужно сериализовать данные для передачи по сети.

Пример:

#include <cereal/archives/binary.hpp> #include <cereal/types/string.hpp> #include <cereal/types/vector.hpp> #include <sstream> #include <iostream>  struct Message {     std::string sender;     std::string content;     std::vector<int> attachments;      template <class Archive>     void serialize(Archive& ar) {         ar(sender, content, attachments);     } };  std::string serializeMessage(const Message& message) {     std::ostringstream oss;     cereal::BinaryOutputArchive archive(oss);     archive(message);     return oss.str(); }  Message deserializeMessage(const std::string& data) {     std::istringstream iss(data);     cereal::BinaryInputArchive archive(iss);     Message message;     archive(message);     return message; }  int main() {     Message msg = {"Alice", "Hello, Bob!", {1, 2, 3}};     std::string serializedData = serializeMessage(msg);      Message deserializedMsg = deserializeMessage(serializedData);     std::cout << "Sender: " << deserializedMsg.sender << ", Content: " << deserializedMsg.content << std::endl;      return 0; }

---

Как разработчику на С++ организовать кроссплатформенную разработку? Об этом расскажет Арсений Черенков. Встречаемся на бесплатном практическом уроке «Менеджер пакетов Conan для С++проектов» от OTUS.