Passing derived classes inside map to function in C++

Question

I would like to have a function that accepts a std::map containing a (pointer to a) base class, but I can't get it to work. Here is my minimal and simplified example:

struct Entity {
  int i;

  Entity(const int i_) : i(i_) {}
  virtual ~Entity() {}
};

struct A : public Entity {
  bool a;
  A(const int i_, const bool a_) : Entity(i_), a(a_) {}
};

void efunc(const std::map<int, std::shared_ptr<Entity>>& m) {
  for (auto& it : m) {
    std::cout << it.second->i << std::endl;
  }
}

int main() {
  std::map<int, std::shared_ptr<A>> aMap;
  std::shared_ptr<A> myA = std::make_shared<A>(1, true);
  aMap.insert({myA->i, myA});

  // efunc(aMap);  // DOES NOT WORK
}

Obviously simply passing the map this way is not allowed, but how can I make it work?

As a bonus, how would I detect the type in the map so that I can execute code specific to that subclass?

Thank you in advance!

Update: Using templates seems to do the trick, this is what I'm using right now:

template <class T>
void tfunc(const std::map<int, std::shared_ptr<T>>& m) {
  for (auto& it : m) {
    std::cout << it.second->i << std::endl;
  }
}

It does feel a bit strange, since I loose IntelliSense and I don't understand why the compiler is not giving me an error. I feel like concepts might help (e.g. to make sure T inherits Entity), but this is beyond what I need right now.

Thank you again for all the responses!

Update 2: Alright, here it is using concepts to ensure that the template containst the member i:

template <class T>
concept hasI = requires(T a) { a.i; };

template <class T>
concept inheritsEntity = std::derived_from<T, Entity>;

template <hasI T>  
/// alternative: template<inheritsEntity T>
void tfunc(const std::map<int, std::shared_ptr<T>>& m) {
  for (auto& it : m) {
    std::cout << it.second->i << std::endl;
  }
}

Answer 1

You can make aMap a std::map<int, std::shared_ptr<Entity>> and still hold shared pointers to instances of A.

In the code below myA which will be stored in the map is of type std::shared_ptr<Entity> but is initialized with a shared pointer to an instance of class A. This is OK because A is derived from Entity.

//----------------------------VVVVVV--------
std::map<int, std::shared_ptr<Entity>> aMap;

//--------------VVVVVV-------------------------V-----------
std::shared_ptr<Entity> myA = std::make_shared<A>(1, true);

aMap.insert({ myA->i, myA });

efunc(aMap);  // Works now.

As commented below, myA can also be std::shared_ptr<A> and still be stored in aMap:

std::shared_ptr<A> myA = std::make_shared<A>(1, true);

---

Alternatively, if using efunc is quite rare, you can keep aMap as std::map<int, std::shared_ptr<A>>.
Then whenever you need to call efunc, create a temporary std::map<int, std::shared_ptr<Entity>> containing a copy of the content of aMap and use it to call efunc.
The shared pointers will still refer to your original objects.
It's inefficient, but if you don't use efunc frequently it might be sufficient.

Answer 2

To answer your first question, you could use template programming; the compiler will generate the code specific to the required type for you:

template <class EntityType> 
void efunc_template(const std::map<int, std::shared_ptr<EntityType>>& m) {
  for (auto& it : m) {
    std::cout << it.second->i << std::endl;
  }
}

The function can then be called in your main function using:

efunc_template<A>(aMap); 

Regarding your second question (how to execute code specific to your type), check can be done at compile time using:

template <class EntityType> 
void efunc_template(const std::map<int, std::shared_ptr<EntityType>>& m) {
  for (auto& it : m) {
    if constexpr (std::is_same_v<A, EntityType>) {
      std::cout << "Type is A" << std::endl;
    } else {
      std::cout << "Other type: " << typeid(EntityType).name() << std::endl;
    }
    std::cout << it.second->i << std::endl;
  }
}

Answer 3

Change the declaration of your std::map variable from :

std::map<int, std::shared_ptr<A>> aMap;

to :

std::map<int, std::shared_ptr<Entity>> aMap;

This way, the map matches what's expected by your efunc function.

Using inheritance as you did, you can indeed insert in your aMap data structure instances of type Entity as well as instances whose the type derivates from Entity. This is the case for struct A.

To detect the type in the map, you can either use a scoped enum as member within the Entity struct, or using the typeid operator, which returns an instance of std::type_info, with which you can get the name of the type.

However, the returned name is not guaranteed to be the same across implementations.

======== output from Clang ========

myint has type: i

mystr has type: NSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE

======== output from MSVC ========

myint has type: int

mystr has type: class std::basic_string<char,struct > std::char_traits,class std::allocator >

For this reason, you might want to use dynamic_cast instead, such as :

class Base {
    public:
        virtual ~Base() {}
};

class T1Base : public Base {};
class T2Base : public Base {};

template <typename T> class T1 : public T1Base {};
template <typename T> class T2 : public T2Base {};

int main()
{
    Base *b = find_by_name();

    if (dynamic_cast<T1Base*>(b))
        cout << "T1" << endl;
    else if (dynamic_cast<T2Base*>(b))
        cout << "T2" << endl;
    else
        cout << "unknown" << endl;

    delete b;

    return 0;
}