Store derived in base assignement then call base function

Question

I am from Java and a bit new to C++. In Java I would have the possibility to do this: link to code

I create an abstract base class Mother, with one pure virtual function used in a public function of that same base class.

I tried this :

class Mother {
    private:
        virtual void bar() = 0;
    public:
        void foo();
};

void Mother::foo() {
    // ... some code
    bar();
}

class Child0: public Mother {
    private:
        void bar();
};

void Child0::bar() {
    std::cout << "Child0" << std::endl;
}

class Child1: public Mother {
    private:
        void bar();
};

void Child1::bar() {
    std::cout << "Child1" << std::endl;
}

// main code
int main() {
    Mother mother;
    if(condition) {
        Child0 child;
        mother = child;
    } else {
        Child1 child;
        mother = child;
    }
    mother.foo();
}

But I get a compiler error:

main.cpp:35:12: fatal error: variable type 'Mother' is an abstract class
    Mother mother;
           ^
main.cpp:5:22: note: unimplemented pure virtual method 'bar' in 'Mother'
        virtual void bar() = 0;
                     ^

What am I missing?

Answer 1

C++, unlike Java, has value semantics and no implicit pointers: when you declare Mother mother; you get an actual instance of Mother. No more, no less. Except in your case, where Mother is abstract: you can't have an instance of Mother!
Doing mother = child; later just assigns the Mother part of the child into mother. This is called "object slicing", because the child part you expected to copy as well is sliced off.

To fix this, you need to use either pointers or references, which can both refer to objects whose dynamic type differ from their static type (e.g, a Mother that is actually a Child0). I'll use the simplest owning pointer, std::unique_ptr:

int main() {
    std::unique_ptr<Mother> mother;

    if(condition) {
        mother = std::make_unique<Child0>();
    } else {
        mother = std::make_unique<Child1>();
    }

    // At this point, *mother is of static type Mother,
    // but of dynamic type Child0 or Child1.

    mother->foo();
}

Note that I have also switched to dynamic allocation: Your two children instances were automatic variables, which means that they die at the end of their scope {}. std::make_unique constructs an object with dynamic lifetime: it will only die when the unique_ptr holding it does.

As noted in the other answer, since your child object will be destructed polymorphically, through the type of Mother, Mother's destructor should be virtual to be dispatched correctly.

class Mother {
    // ...
public:
    virtual ~Mother() = default;
};

Answer 2

You are missing the object slicing trap, and also have undefined behavior: when you assign

mother = child;

child gets "sliced" down to mother, with any polymorphic behavior removed.

If you wish to retain polymorphism, use pointers:

Mother *mother;
if(condition) {
    mother = new Child0;
} else {
    mother = new Child1;
}
mother->foo();
delete mother;

Make sure Mother has a virtual destructor.

Note that you can no longer use objects from inner scope, because the pointer would become invalid as soon as the scope ends:

// Do not do this!
Mother *mother;
if(condition) {
    Child0 child;
    mother = &child;
}
mother->foo(); // <<<=== This is undefined behavior