Question

Sorry if this answer is already on this site, but I’ve looked all over and couldn’t find any solutions to my issue. It pertains to same-name functions from inherited classes. Here is my code:

class A
{
public:
    int foo(int c) { c = c+1; return c; };
};

class B : public A
{
public:
    int foo(int c) { c = c-1; return c; };
};

int main()
{
    A array[2];
    array[0] = A item1;
    array[1] = B item2;
    for (int n=0;n<2;n++)
    {
        cout << array[n].foo(10) << endl;
    }
    return 0;
}

I would expect an output of:

11    // foo() from A class  [10 + 1 = 11]
9     // foo() from B class  [10 - 1 = 9 ]

But instead I get

11
11

From testing this out, I have found that the foo() function in the B class does not get called within the for-loop. Instead, the foo() function in the A class is called, even on the B object at array[1].

Is this because I have defined the array as containing objects of the A class only? If so, is there a way I can have the foo() function from the B class be called on the second object within that for-loop?

Thank you in advance for any help!

Answer 1

I’ll forget that array[0] = A item1; isn’t valid C++ and just assume that you’re assigning an object of type A to array[0] and an object of type B to array[1]. Okay, so you have two problems.

The first is known as object slicing. When you copy an object of type B to an object of type A, you only copy the A part of that object. So what you have in array[1] is not a B at all, it’s just an A. If you want polymorphism (which you do), then you need to use either pointers or references which provide polymorphic behaviour. That means make your array an A* array[2]; and do array[0] = &item1; array[1] = &item2;.

Now, when you call a function on a pointer to A that points to a B it will still only call As foo member function. Why? Because by default, the function will be looked up on the static type of the object. That static type is A. If you want to tell the compiler to look up your function on the dynamic type of your object – the true type of your object, which is B – you need to make that member function virtual. So in A, do:

virtual int foo(int c) { c = c+1; return c; };

Now when your compiler see that you’re calling foo on an A*, it’ll see that it’s virtual and say “Oh okay, I should look up this function dynamically” and it’ll find B‘s implementation of foo.