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?

@LightnessRacesinOrbit true, but I guessed I had a misconception of C++ that would be obvious. — gdforj, Jan 01 '17 at 22:09
Do not guess. Present a [MCVE], and a clear problem description, so as not to waste our time! These instructions are clearly laid out in the Help Centre. — Lightness Races in Orbit, Jan 01 '17 at 22:10
@LightnessRacesinOrbit If I may ask a quick meta question: in such cases, should a reviewer simplify the example code without change in behaviour, here with `struct` and inline function definitions? — Quentin, Jan 01 '17 at 22:23
@Quentin: I probably would, but I think it's borderline and don't suggest taking my opinion here as a useful guideline without further opinions :) — Lightness Races in Orbit, Jan 01 '17 at 23:26
@Quentin: Of course you would then have to update/replace the error message with the new line numbers (and whatever else has changed), after reproducing it on your own system. It starts to get a bit sticky for not _too_ much gain. — Lightness Races in Orbit, Jan 01 '17 at 23:27

Quentin · Accepted Answer · 2017-01-01T22:21:02.060

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;
};

Thanks for the quick answer, going from one language to another is complicated... :) — gdforj, Jan 01 '17 at 22:12
@Arsleust my pleasure! Java prevents you from seeing most of what is happening that C++ requires you to grasp, but once you get them C++ gets really fun :) — Quentin, Jan 01 '17 at 22:15

score 2 · Answer 2 · edited May 23 '17 at 12:13

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

Thank you very much for the answer, can't put two answers as "accepted" tho so I'm sad :/ — gdforj, Jan 01 '17 at 22:11

Store derived in base assignement then call base function

2 Answers2