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?

Question

Ryan McCombe · Accepted Answer

To serialize and deserialize objects of a class that doesn't have a default constructor using cereal, you can use the load_and_construct function. Here's how you can do it:

Step 1: Include the necessary cereal headers:

1#include <cereal/access.hpp>
2#include <cereal/types/string.hpp>

Step 2: In your Weapon class, define a load_and_construct function:

1class Weapon {
2 public:
3  Weapon(const std::string& name, int damage)
4    : name(name), damage(damage) {}
5
6 private:
7  friend class cereal::access;
8
9  std::string name;
10  int damage;
11
12  template <class Archive>
13  void save(Archive& ar) const {
14    ar(name, damage);
15  }
16
17  template <class Archive>
18  static void load_and_construct(
19    Archive& ar,
20    cereal::construct<Weapon>& construct
21  ) {
22    std::string name;
23    int damage;
24    ar(name, damage);
25    construct(name, damage);
26  }
27};

In the load_and_construct function, you deserialize the necessary data members and then use the construct object to call the appropriate constructor of the Weapon class.

Step 3: Serialize and deserialize the Weapon object as usual:

1#include <cereal/archives/binary.hpp>
2#include <fstream>
3#include <memory>
4
5int main() {
6  // Serialization
7  auto weapon = std::make_unique<Weapon>(
8    "Sword", 50);
9  std::ofstream outputFile("weapon.dat");
10  cereal::BinaryOutputArchive outputArchive(
11    outputFile);
12  outputArchive(weapon);
13
14  // Deserialization
15  std::unique_ptr<Weapon> deserializedWeapon;
16  std::ifstream inputFile("weapon.dat");
17  cereal::BinaryInputArchive inputArchive(
18    inputFile);
19  inputArchive(deserializedWeapon);
20}

By using the load_and_construct function, cereal will be able to deserialize and reconstruct objects of your Weapon class even though it doesn't have a default constructor.

Note: Make sure to use smart pointers like std::unique_ptr or std::shared_ptr when serializing and deserializing objects that are dynamically allocated to ensure proper memory management.

A complete example is below:

1// Suppress compilation warnings
2#define _SILENCE_CXX23_ALIGNED_STORAGE_DEPRECATION_WARNING
3
4#include <cereal/archives/binary.hpp>
5#include <cereal/types/string.hpp>
6#include <cereal/types/memory.hpp>
7#include <fstream>
8#include <iostream>
9#include <memory>
10
11class Weapon {
12 public:
13  Weapon(const std::string& name, int damage)
14    : name(name), damage(damage) {}
15
16  std::string name;
17  int damage;
18
19 private:
20  friend class cereal::access;
21  template <class Archive>
22  void save(Archive& ar) const {
23    ar(name, damage);
24  }
25
26  template <class Archive>
27  static void load_and_construct(Archive& ar,
28    cereal::construct<Weapon>& construct) {
29    std::string name;
30    int damage;
31    ar(name, damage);
32    construct(name, damage);
33  }
34};
35
36int main() {
37  // Serialization
38  auto weapon = std::make_unique<Weapon>(
39    "Sword", 50);
40  {
41    std::ofstream outputFile("weapon.dat");
42    cereal::BinaryOutputArchive outputArchive(
43      outputFile);
44    outputArchive(weapon);
45  }
46
47  // Deserialization
48  std::unique_ptr<Weapon> deserializedWeapon;
49  {
50    std::ifstream inputFile("weapon.dat");
51    cereal::BinaryInputArchive inputArchive(
52      inputFile);
53    inputArchive(deserializedWeapon);
54  }
55
56  std::cout << "Deserialized Weapon:\n";
57  std::cout << "Name: "
58    << deserializedWeapon->name << "\n";
59  std::cout << "Damage: "
60    << deserializedWeapon->damage << "\n";
61}

1Deserialized Weapon:
2Name: Sword
3Damage: 50

Binary Serialization using Cereal

Serializing Non-Default-Constructible Classes with Cereal

Binary Serialization using Cereal

Professional C++

Questions & Answers