Binary Serialization using Cereal

Versioning Serialized Game Save Files

I'm working on a game and want to ensure that save files from older versions can still be loaded in newer versions. How can I handle this using cereal's versioning features?

Abstract art representing computer programming

To handle backward compatibility for serialized game save files using cereal's versioning features:

Step 1: Define a version number for your serializable classes and increment it whenever you make changes that affect serialization:

1class Player {
2  // ...
3};
4CEREAL_CLASS_VERSION(Player, 1);
5
6class GameState {
7  // ...
8};
9CEREAL_CLASS_VERSION(GameState, 2);

Step 2: In your serialization functions, use the versioned save/load or serialize function signatures:

1template <class Archive>
2void Player::serialize(Archive& ar,
3  std::uint32_t version) {
4  ar(name, level);
5
6  if (version >= 1) {
7    ar(health);
8  }
9}
10
11template <class Archive>
12void GameState::serialize(Archive& ar,
13  std::uint32_t version) {
14  ar(players, score);
15
16  if (version >= 2) {
17    ar(difficulty);
18  }
19}

Step 3: When deserializing, check the version number and handle missing or added fields accordingly. Provide default values for fields that may not exist in older save files:

1template <class Archive>
2void Player::serialize(Archive& ar,
3  std::uint32_t version) {
4  ar(name, level);
5
6  if (version >= 1) {
7    ar(health);
8  } else {
9    // Default value for older versions
10    health = 100;
11  }
12}
13
14template <class Archive>
15void GameState::serialize(Archive& ar,
16  std::uint32_t version) {
17  ar(players, score);
18
19  if (version >= 2) {
20    ar(difficulty);
21  } else {
22    // Default value for older versions
23    difficulty = 1;
24  }
25}

Step 4: When loading a save file, cereal will automatically detect and pass the appropriate version number to your serialization functions. Your deserialization logic will handle the version differences.

By following this approach, newer versions of your game will be able to load and handle save files from older versions gracefully. Remember to increment the version number whenever you make changes to the serialization layout of your classes.

A complete example is provided below:

1#include <cereal/archives/binary.hpp>
2#include <cereal/types/vector.hpp>
3#include <cereal/types/string.hpp>
4#include <fstream>
5#include <iostream>
6#include <vector>
7
8class Player {
9 public:
10  std::string name;
11  int level;
12  int health;
13
14 private:
15  friend class cereal::access;
16
17  template <class Archive>
18  void serialize(Archive& ar,
19    std::uint32_t version) {
20    ar(name, level);
21
22    if (version >= 1) {
23      ar(health);
24    } else {
25      // Default value for older versions
26      health = 100;
27    }
28  }
29};
30
31CEREAL_CLASS_VERSION(Player, 1);
32
33class GameState {
34 public:
35  std::vector<Player> players;
36  int score;
37  int difficulty;
38
39 private:
40  friend class cereal::access;
41
42  template <class Archive>
43  void serialize(Archive& ar,
44    std::uint32_t version) {
45    ar(players, score);
46
47    if (version >= 2) {
48      ar(difficulty);
49    } else {
50      // Default value for older versions
51      difficulty = 1;
52    }
53  }
54};
55
56CEREAL_CLASS_VERSION(GameState, 2);
57
58int main() {
59  GameState gameState;
60  gameState.players.emplace_back(Player{
61    "Alice", 10, 80});
62  gameState.players.emplace_back(Player{
63    "Bob", 20, 70});
64  gameState.score = 1000;
65  gameState.difficulty = 2;
66
67  {
68    std::ofstream file("savegame.dat");
69    cereal::BinaryOutputArchive archive(file);
70    archive(gameState);
71  }
72
73  GameState loadedGameState;
74
75  {
76    std::ifstream file("savegame.dat");
77    cereal::BinaryInputArchive archive(file);
78    archive(loadedGameState);
79  }
80
81  std::cout << "Loaded Game State:\n";
82  std::cout << "Score: "
83    << loadedGameState.score << "\n";
84  std::cout << "Difficulty: "
85    << loadedGameState.difficulty << "\n";
86  std::cout << "Players:\n";
87  for (const auto& player :
88    loadedGameState.players) {
89    std::cout << "  " << player.name
90      << " (Level " << player.level
91      << ", Health " << player.health << ")\n";
92  }
93}

1Loaded Game State:
2Score: 1000
3Difficulty: 2
4Players:
5  Alice (Level 10, Health 80)
6  Bob (Level 20, Health 70)

This Question is from the Lesson:

Binary Serialization using Cereal

A detailed and practical tutorial for binary serialization in modern C++ using the cereal library.

Answers to questions are automatically generated and may not have been reviewed.

4 months ago

This Question is from the Lesson:

Binary Serialization using Cereal

A detailed and practical tutorial for binary serialization in modern C++ using the cereal library.

Part of the course:

Professional C++

Comprehensive course covering advanced concepts, and how to use them on large-scale projects.

Free, unlimited access

This course includes:

124 Lessons
550+ Code Samples
96% Positive Reviews
Regularly Updated
Help and FAQ

Free, Unlimited Access

Professional C++

Comprehensive course covering advanced concepts, and how to use them on large-scale projects.

Contact|Privacy Policy|Terms of Use

Versioning Serialized Game Save Files

I'm working on a game and want to ensure that save files from older versions can still be loaded in newer versions. How can I handle this using cereal's versioning features?

Binary Serialization using Cereal

How can I serialize a vector of my custom Player objects using cereal?

I have a `std::map` where the value type is a pointer to the base Character class, but it actually points to derived Monster objects. How can I serialize and deserialize this map correctly?

I want to serialize private member variables of my Player class using cereal. How can I accomplish this?

I have a Weapon class that requires parameters in its constructor and doesn't have a default constructor. How can I serialize and deserialize objects of this class using cereal?

I have an enum class called State in my game. How can I serialize and deserialize variables of this enum class type using cereal?

Binary Serialization using Cereal

Professional C++

This course includes:

Professional C++

Versioning Serialized Game Save Files

I'm working on a game and want to ensure that save files from older versions can still be loaded in newer versions. How can I handle this using cereal's versioning features?

Binary Serialization using Cereal

How can I serialize a vector of my custom Player objects using cereal?

I have a std::map where the value type is a pointer to the base Character class, but it actually points to derived Monster objects. How can I serialize and deserialize this map correctly?

I want to serialize private member variables of my Player class using cereal. How can I accomplish this?

I have a Weapon class that requires parameters in its constructor and doesn't have a default constructor. How can I serialize and deserialize objects of this class using cereal?

I have an enum class called State in my game. How can I serialize and deserialize variables of this enum class type using cereal?

Binary Serialization using Cereal

Professional C++

This course includes:

Professional C++

I have a `std::map` where the value type is a pointer to the base Character class, but it actually points to derived Monster objects. How can I serialize and deserialize this map correctly?