Question

what is the best way to share different objects between some classes in a generic manner?

For example class A can store an object o with a string as a key in a register and class B can access it using the key.

My first idea was to create a register (singleton) which has a hashtable as a member using a string as the key and a void pointer as the value. But there must be a better solution for this?

Answer 1

From your clarification:

template <typename OB>
class A {
  std::unordered_map<std::string, OB> hash;
public:
  OB const& get(std::string const&) const;
  void add(OB const& object, std::string const&);
};

That is to say, A<int> is a class that stores int objects by name, and A<std::set<float>> is a class that stores sets of floats by name. You can’t mix them. That’s in line with the basic C++ philosophy: the type of theA.get("foo") is determined at compile time, not by what you put in at runtime.

In C++, you can however “mix” multiple derived types, if you’d need this for your particular case. That’s a bit more complicated:

template <typename Base>
class A {
  std::unordered_map<std::string, std::unique_ptr<Base>> hash;
public:
  Base const& get(std::string const&) const;
  template<typename Derived> void add(std::string const& name, Derived const& object)
  {
    std::unique_ptr<Base> copy(new Derived(object));
    hash.emplace(std::make_pair(name, std::move(copy)));
  }
};

There’s some slight trickery here as hash should be the only owner of the copy, but it’s constructed outside and therefore needs to be moved it. (For extra-fancy, I could add a Derived&& overload that eliminates that copy too)