Question

i am pretty sure this is a simple question for a long time c++ user, this should be a pattern or the problem should be solved in any other way but given i am Python developer and a total novice with c++ i don’t know how it’s usually done.

Suppose that i have a class where i want to store a pointer to an object that can be of 1 of two different classes that respects an interface, for example:

class AllPlayers
{
  public:
  virtual void play();
};

class VlcPlayer: public AllPlayers
{
  public:
  virtual void play();
};

class Mplayer: public AllPlayers
{
  public:
  virtual void play();
};

class MyMediaPlayer
{
  public:
  MyMediaPLayer(int playerType);
  AllPlayers m_player;
};

MyMediaPlayer::MyMediaPlayer(int PlayerType)
{
  if (PlayerType == 0) {
    VlcPlayer tmp_player;
    m_player = static_cast<AllPlayers> (tmp_player);
  }
  else {
    Mplayer tmp_player;
    m_player = static_cast<AllPlayers> (tmp_player);
  }
}

MyMediaPlayer test(0);
test.play();

First, i know this would not work and that it seems pretty normal why but how could i get this effect? i would like to have a member of a class for what i am going to use ever the same methods, implemented using a interface and i would like to avoid trying to cast to every of the derived classes every time i am going to use one of his methods.

Answer 1

C++ is value-based, i.e., if you create an object of a given type you really have an object of this type. This doesn’t play nicely with dynamic polymorphism. To get dynamic polymorphism you use a pointer or a reference to the actual object. To also get the life-time straight you typicslly allocate the corresponding object on the stack (make sure your base class has a virtual destructor if you ever release an object of a derived type using a pointer to the base). With this, you should be all set: just call a virtual function of the base class through a pointer to rhe base: When you overridethe function in the derived class this is the function which is called.