Virtual method only works for base class pointers

Question

Below is the perhaps most simple example of a virtual function in C++:

#include <iostream>

class A {
public:
    virtual void f() {
        std::cout << "A";
    }
};

class B : public A {
public:
    void f() {
        std::cout << "B";
    }
};


int main() {
    {
        // calls f() in derived class
        A* a = new B();
        a->f();
    }
    {
        // calls f() in base class
        A a = B();
        a.f();
    }
}

The output of this program is BA. I expected it to be BB, i.e. call the base class in any case. Why does using a base class pointer make a difference here? I didn't find the explanation in the standard.

I believe this is a different problem than slicing. Here, it appears to be a misunderstanding of inheritance, polymorphism and runtime dispatch. He also missed the fact that it works with both 'base class pointers' and 'base class references'. (And there's probably another SO question covering that topic). — jww, Jan 12 '14 at 00:26

score 11 · Answer 1 · answered Jan 11 '14 at 22:32

This is called slicing. A a = B(); creates a copy which is of type A. All information about its source being B is forgotten. The only way to exploit polymorphism is through references or pointers (or mechanisms that allow compile-time polymorphism, like templates or function overloading for example).

score 3 · Accepted Answer · answered Jan 11 '14 at 22:33

Polymorphism works with pointers because in the case of a pointer(or a reference) you can differentiate between the type of the pointer and the type of the object. Now in the following code:

A a = B();
a.f();

What is happening is called slicing. i.e. the object B() was sliced and its base A() is assigned to a.

Don't forget to make the destructor virtual!

score 0 · Answer 3 · answered Jan 11 '14 at 22:51

The order of function calls in the case of A a = B() is this:

Default constructor of class B is called.
- A temporary object of type B is created on the stack.
Conversion operator from B to A is called.
- A temporary object of type A is created on the stack.
Copy constructor of class A is called with the previous object's address as an argument.
- An non-temporary object of type A is created on the stack.
- This object will remain in the stack until the function returns.
- It is an object of type A, hence you get "A" printed and not "B".

To summarize this, here is the "full version" of the line above: A(B()->operator A())

Virtual method only works for base class pointers

3 Answers3