Question

The problem is: I want to use unordered_map to store keys and values, where the key can be either class A or class B, depending on the users options. Both classes A and B inherit from the same class P.

class A: public P {...}
class B: public P {...}

I would like to define the map with the abstract P class and later, depending on runtime options, assign there a map with A or with B as a key:

unordered_map< P, CValue, P::hash, P::equal_to> * pmap = new unordered_map< A, CValue, A::hash, A::equal_to>;

but I will get error:

 cannot convert ... in initialization

How can I declare such a “virtual” map?

Answer 1

Here’s an example how you can make the map keyed on P* but still use different implementations in the derived classes:

struct P
{
  virtual size_t hash_self() const = 0;
  virtual bool equal(const P &) const = 0;
};

struct A : public P
{
  inline bool operator==(const A & other) const { return false; /*Implement!*/}
  size_t hash_self() const { return 1; /*Implement!*/ }
  bool equal(const P & p) const { return *this == dynamic_cast<const A &>(p); }
};

struct PHash
{
  size_t operator()(const P * const p) const { return p->hash_self(); }
};

struct PEqual
{
  bool operator()(const P * const p, const P * const q) const { return p->equal(*q); }
};


#include <unordered_map>

std::unordered_map<P *, double, PHash, PEqual> pmap{{ new A, .5 }};

The dynamic cast is valid because you promise only to compare pointers of the same derived type.

If you wanted to be cleaner, you could probably specialise std::hash<P*> and std::equal_to<P*>:

namespace std
{
  template<> struct hash<P*>
  { size_t operator()(P * const & p) const { return p->hash_self(); } };

  template<> struct equal_to<P*> : public binary_function<P*, P*, bool>
  { bool operator()(P * const & p, P * const & q) const { return p->equal(*q); } };
}

std::unordered_map<P *, int> qmap{{new A, -11}}; // just works!