Привет, Хабр!
Сегодня рассмотрим библиотеку 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.
