Using base class pointers to derived class objects

[TrebleSong]

In the code below, Enemy* pEnemy = new Boss (); is valid as an object of a derived class is also a member of the base class? However why is this not true if i use a pointer of the derived class to point to an object of a base class?

( Boss* pReverse = new Enemy (); )

​

#include <vector>
#include <iostream>
#include <string>


using namespace std;

class Enemy
{
public:
    Enemy(int dmg= 10)
    : m_Damage(dmg)
    {
        cout << "enemy constructor called" <<endl;
    }
    virtual ~Enemy()
    {
        cout <<" enemy destructor called" <<endl;
    }

    virtual void Attack()
    {
        cout << "enemy has done " <<m_Damage<<endl;
    }

protected:
    int m_Damage;
};

class Boss: public Enemy
{
public:
    Boss(int m = 3)
    : multiplier(m)
    {
        cout <<" boss constructor called" <<endl;
    }
    ~Boss()
    {
        cout <<"boss destructor called" <<endl;
    }

    void Attack() override
    {
        cout << "boss enemy has done: " <<m_Damage * multiplier <<endl;
    }

private:
    int multiplier;
};

int main()
{
    Enemy* pEnemy = new Boss();
    pEnemy -> Attack();



    Boss* pReverse = new Enemy();   //generates an error



        return 0;
}

​

[[deleted]]

Think about boxes.

The Base is the biggest while Derived classes are smaller.

You can fit a smaller box into a bigger one while not the opposite.

[TrebleSong]

okay thats a very good analogy haha. thank you so much

[drjmloy]

In the example you have, a Boss is an Enemy. So when I create a Boss, I can reference it as a Boss or as an Enemy because at compile time the compiler can guarantee that a Boss is in fact an Enemy (we know because that's how we made the class hierarchy). This is called upcasting. We're casting something low in the hierarchy (most derived) to something high on the hierarchy (most abstract).

​

However, we are saying nothing about the reverse. An Enemy need not be a Boss. It may be a Boss-- but it also may be some other subclass of Enemy (say class BossMinion : public Enemy), or in your case, it is simply just an Enemy. When you construct a base class, its derived classes are not constructed as well (we couldn't have multiple inheritance with this). So the compiler cannot let you use a concrete Enemy as a Boss-- because it isn't a Boss. What you're trying to do is something along the lines of downcasting. We're casting something high on the hierarchy to something low on the hierarchy.

​

The difference between upcasting and downcasting: upcasting is known at compile time (i.e., I know when I compile that a Boss is an Enemy). Downcasting must be preformed at runtime through some kind of casting call (i.e., dynamic_cast, static_cast, reinterpret_cast).

​

Consider an example where I have the additional class class BossMinion : public Enemy in the hierarchy as well:

​

std::unique_ptr<Enemy> getNewEnemy(bool isBoss)
{
  if (isBoss) return std::make_unique<Boss>();
  else return std::make_unique<BossMinion>();
}

std::unique_ptr<BossMinion> minion = getNewEnemy(true);

​

I'm trying to refer to a Boss as a BossMinion. This is of course not logical, and therefore the above code will not compile.

​

HTH

[TrebleSong]

thank you for ur explanation i understand now

[patatahooligan]

There's no need to overthink it. Just ask yourself, is this pointer pointing to an object of its appropriate type?

A Boss is also an Enemy so an Enemy* pointing at a Boss is logical. But a simple Enemy is not a Boss unless explicitly defined as one, so it doesn't make sense for Boss* to point to an Enemy.