C++ inheritance and inherit variable inside the class

Question

Let's say that I have class named MasterClass that has some children like ChildA, ChildB etc with public inheritance.

Also MasterClass has a var called MVar that is from type AnimalClass and obviously there are some children like DogClass, CatClass etc

MasterClass has that AnimalClass but ChildA has DogClass, ChildB has CatClass etc.

How I can make a function that is defined only in master but uses the inherit one throught its child I mean:

ChildA ca; ca.emitSound();

and emitSound just calls something like MVar.makeSound();

Where emitSound is only defined on AnimalClass and its behaviour depends on child's type.

My problem is that it seems that emitSound is always calling AnimalClass emitSound not DogClass emitSound.

Obviously if I define a emitSound in ChildA, ChildB etc it works fine but I just wanna make the code smaller.

Of course my real life issue is more complex that this stupid example but I think that the problem is pretty much the same, ie. emitSound could be a virtual one to allow some children to overwrite its behaviour etc.

Regards!

CODE:

AnimalClass 
{
public:
      AnimalClass();
      virtual void makeSound(){ printf("nosound";}        
}


DogClass: public AnimalClass 
{
public:
      DogClass();
      void makeSound(){ printf("bufff";}        
}


MasterClass 
{
public:
      MasterClass();
      AnimalClass *ani;
      void emitSound(){ani->makeSound();}     
}

ChildAClass: public MasterClass
{           
public:
      ChildAClass(){ani=new DogClass();}
      DogClass *ani;
}

main()
{
    ChildAClass c;
    c.emitSound();
}

The problem is that it prints "nosound" instead "bufff"

Answer 1

The code you have provided does not compile so it is hard to know exactly what you are doing wrong in your real code. But it looks like you have an ani pointer in your derived class shadowing your ani pointer in your base class so the pointer in the base class is never initialized.

You need to ensure that the constructor of the derived class somehow initializes the pointer in the base class. For example the ChildAClass could have an instance of a DogClass and pass a reference to MasterClass constructor.

#include <cstdio>

class AnimalClass 
{
public:
    virtual void makeSound(){ printf("nosound");}        
};

class DogClass: public AnimalClass 
{
public:
    void makeSound() override { printf("bufff");}        
};

class MasterClass 
{
    AnimalClass *ani;
public:
    MasterClass(AnimalClass& animal) : ani(&animal) {}
    void emitSound(){ani->makeSound();}     
};

class ChildAClass: public MasterClass
{      
    DogClass dog;
public:
    ChildAClass() : MasterClass(dog){}
};

int main()
{
    ChildAClass c;
    c.emitSound();
}

Live demo.

Answer 2

The thing that happens is that AnimalClass::makeSound is called. This is because in child class you have two members ani in ChildAClass i.e.: ChildAClass::ani, and MasterClass::ani. The first one shadows the latter, but it still is there.

Now, even though you call emitSound through ChildAClass what is called is MasterClass::emitSound. So you need to look at things from this perspective. And from there you are calling makeSound from AnimalClass pointer not the DogClass, because AnimalClass::makeSound does not know anything about the derived class. In other words, members do not get "virtualized".

What you should have done is to have one member ani of type AnimalType* (or a reference) in the base class and initialize it properly in the derived class.

Answer 3

#include <iostream>

class Animal
{
public:
    virtual void sound()
    {
        std::cout << "Animal sound" << std::endl;
    }
    virtual ~Animal(){}
};
class Dog : public Animal
{
    void sound() //override
    {
        std::cout << "Dog sound" << std::endl;
    }
};

class Master
{
private:
    Animal *animal;
public:
    Master(Animal *a)
    {
        animal = a;
    }
    void emitSound()
    {
        animal->sound();
    }
    ~Master()
    {
        delete animal;
    }
};
class A : public Master
{
public:
    A(Dog *d) : Master(d){}
};

int main()
{
    A a(new Dog());
    a.emitSound();

    return 0;
}
OUTPUT: Dog sound