How do I serialize a class with private members in cereal?

You must declare the serialize function as a friend or provide public getters/setters, as cereal cannot access private members directly without explicit permissions in the serialization template.

Is cereal faster than Protocol Buffers for C++?

cereal can be faster for in-memory serialization due to no protocol overhead, but Protocol Buffers offer better cross-language support and built-in versioning, making them more suitable for heterogeneous systems.

Can cereal handle circular references in object graphs?

No, cereal does not natively support circular references; developers need to manage cycles manually, such as by using std::shared_ptr with careful serialization or breaking the references.

How to save data to a JSON file using cereal?

Use cereal::JSONOutputArchive with an std::ofstream to write JSON, and cereal::JSONInputArchive with std::ifstream to read it back, following a pattern similar to the binary archive example in the README.

What are the main differences between cereal and Boost.Serialization?

cereal is header-only and dependency-free, focusing on simplicity and lightweight integration, while Boost.Serialization is part of the larger Boost library with more features but requires external dependencies.

Does cereal support C++17 features like std::optional?

cereal is based on C++11, so support for newer standard library types may require custom serialization functions or community extensions, as it doesn't automatically handle post-C++11 features.

Open-Awesome

Cereal

BSD-3-ClauseC++v1.3.2

A header-only C++11 serialization library for converting data types to binary, XML, or JSON formats.

GitHub

4.7k stars843 forks0 contributors

What is Cereal?

cereal is a header-only C++11 serialization library that converts arbitrary C++ data types into different representations like binary, XML, or JSON, and can reversibly restore them. It solves the problem of persisting and transferring complex C++ objects in a lightweight, dependency-free manner.

Target Audience

C++ developers working on applications that require data persistence, network communication, or configuration storage, particularly those using modern C++11 or later.

Value Proposition

Developers choose cereal for its simplicity, header-only design with no external dependencies, support for multiple output formats, and ease of extending to custom types, making it a versatile and efficient serialization solution.

Overview

A C++11 library for serialization

Use Cases

Best For

Serializing C++ objects to binary for efficient storage or transmission
Converting C++ data structures to JSON for web APIs or configuration files
Persisting complex C++ state in games or simulations
Saving and loading application settings or user data in C++ projects
Implementing network communication with serialized C++ objects
Creating portable data formats for cross-platform C++ applications

Not Ideal For

Projects requiring automatic serialization of polymorphic types without manual intervention
Systems needing robust data versioning and backward compatibility out of the box
Applications where minimal binary size and fast compilation are critical priorities
Interoperability-focused projects that rely on standardized, cross-language serialization formats

Pros & Cons

Pros

Header-Only Design

As a header-only library with no external dependencies, cereal can be dropped into any C++ project instantly, simplifying integration and deployment as highlighted in the README's quick installation steps.

Multiple Archive Formats

cereal supports binary, XML, and JSON serialization, providing flexibility for different use cases from compact storage to human-readable configs, directly mentioned in its key features.

Standard Library Support

Built-in serialization for common C++ standard library types like std::unordered_map and std::shared_ptr reduces boilerplate code, as shown in the provided code example.

Easy Extensibility

Adding serialization for custom types is done via simple template functions, such as the serialize method in MyRecord, making it straightforward to adapt to user-defined data structures.

Cons

Template Bloat

The extensive use of C++ templates can lead to significantly increased compilation times and larger executable sizes, especially in complex projects with many serialized types.

No Built-in Versioning

cereal lacks mechanisms for handling schema evolution, forcing developers to manually manage backward compatibility when data structures change, a common need in long-term projects.

Cryptic Error Messages

Serialization errors often produce hard-to-decipher template instantiation messages during compilation, making debugging more challenging compared to libraries with runtime error handling.

Frequently Asked Questions

Related Projects

imgui

Dear ImGui: Bloat-free Graphical User interface for C++ with minimal dependencies

A curated list of awesome C++ (or C) frameworks, libraries, resources, and shiny things. Inspired by awesome-... stuff.

Stars72,398

Forks8,320

Last commit5 days ago

ProtoBuf

Protocol Buffers - Google's data interchange format

Stars71,621

Forks16,200

Last commit17 hours ago

JSON for Modern C++

Stars50,198

Forks7,437