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?

Question

Ryan McCombe · Accepted Answer

To correctly serialize and deserialize a std::map where the value type is a base class pointer (Character*) pointing to derived class objects (Monster), follow these steps:

Step One: Include the necessary cereal headers:

1#include <cereal/archives/binary.hpp>
2#include <cereal/types/map.hpp>
3#include <cereal/types/polymorphic.hpp>

Step Two: In your derived Monster class, ensure you have the serialize function defined and register the polymorphic relationship:

1class Monster : public Character {
2  // ...
3
4  template <class Archive>
5  void serialize(Archive& ar) {
6    ar(cereal::base_class<Character>(this));
7    // ...
8  }
9};
10
11CEREAL_REGISTER_TYPE(Monster);
12CEREAL_REGISTER_POLYMORPHIC_RELATION(Character, Monster);

Step Three: Create your map with base pointers to derived objects:

1std::map<int, std::unique_ptr<Character>> enemies;
2enemies[1] = std::make_unique<Monster>();
3enemies[2] = std::make_unique<Monster>();

Step Four: Serialize the map using a cereal output archive:

1std::ofstream file("enemies.dat");
2cereal::BinaryOutputArchive archive(file);
3archive(enemies);

Step Five: Deserialize the map using a cereal input archive:

1std::ifstream file("enemies.dat");
2cereal::BinaryInputArchive archive(file);
3std::map<int, std::unique_ptr<Character>> loadedEnemies;
4archive(loadedEnemies);

After deserialization, loadedEnemies will contain pointers to the correct derived Monster objects, even though the map's value type is std::unique_ptr<Character>. Cereal's polymorphic serialization handles the type restoration.

Note: Make sure to use smart pointers like std::unique_ptr in the map to avoid manual memory management and resource leaks.

A complete example is below:

1#include <cereal/archives/binary.hpp>
2#include <cereal/types/map.hpp>
3#include <cereal/types/polymorphic.hpp>
4#include <fstream>
5#include <iostream>
6#include <map>
7#include <memory>
8
9class Character {
10 public:
11  virtual ~Character() = default;
12
13  std::string name;
14
15 protected:
16  friend class cereal::access;
17
18  template <class Archive>
19  void serialize(Archive& ar) {
20    ar(name);
21  }
22};
23
24class Monster : public Character {
25 public:
26  int health;
27
28 private:
29  friend class cereal::access;
30
31  template <class Archive>
32  void serialize(Archive& ar) {
33    ar(cereal::base_class<
34      Character>(this), health);
35  }
36};
37
38CEREAL_REGISTER_TYPE(Monster);
39CEREAL_REGISTER_POLYMORPHIC_RELATION(Character,
40  Monster);
41
42int main() {
43  std::map<int, std::unique_ptr<
44    Character>> enemies;
45  enemies[1] = std::make_unique<Monster>();
46  enemies[1]->name = "Goblin";
47  dynamic_cast<Monster*>(
48    enemies[1].get())->health = 50;
49  enemies[2] = std::make_unique<Monster>();
50  enemies[2]->name = "Orc";
51  dynamic_cast<Monster*>(
52    enemies[2].get())->health = 100;
53
54  {
55    std::ofstream file("enemies.dat");
56    cereal::BinaryOutputArchive archive(file);
57    archive(enemies);
58  }
59
60  std::map<int, std::unique_ptr<
61    Character>> loadedEnemies;
62
63  {
64    std::ifstream file("enemies.dat");
65    cereal::BinaryInputArchive archive(file);
66    archive(loadedEnemies);
67  }
68
69  for (const auto& [id, enemy] : loadedEnemies) {
70    std::cout << "ID: " << id << ", Name: "
71      << enemy->name;
72    if (auto monster = dynamic_cast<Monster*>(
73      enemy.get())) {
74      std::cout << ", Health: "
75        << monster->health;
76    }
77    std::cout << "\n";
78  }
79}

1ID: 1, Name: Goblin, Health: 50
2ID: 2, Name: Orc, Health: 100

Binary Serialization using Cereal

Serializing Maps of Polymorphic Objects

Binary Serialization using Cereal

Professional C++

Questions & Answers