How virtual is this?

Question

Hi,

can you explain me why:

int main (int argc, char * const argv[]) {
    Parent* p = new Child();
    p->Method();
    return 0;
}

prints "Child::Method()", and this:

int main (int argc, char * const argv[]) {
    Parent p = *(new Child());
    p.Method();
    return 0;
}

prints "Parent::Method()"?

Classes:

class Parent {
public:
    void virtual Method() {
     std::cout << "Parent::Method()";
    }
};

class Child : public Parent {
public:
    void Method() {
     std::cout << "Child::Method()";
    }
};

Thanks, Etam.

Answer 1

In the first case you call the actual object is of Child class:

Parent* p = new Child(); // you new'ed Child class
p->Method(); // and a method of a Child class object is getting called

that's why Child::Method() is called. In the second case you copy the Child class object onto the Parent class object:

Parent p = *(new Child()); // you new'ed Child, then allocated a separate Parent object on stack and copied onto it
p.Method(); // now you have a Parent object and its method is called

and Parent::Method() is called.

Answer 2

In your second example, slicing occurs: the Child-instance is converted to a Parent-instance, which has no vtable entry for the Child-method. The Child-method is "sliced" off.

Answer 3

In the first case, you've got a 'Parent' pointer on a 'Child' object, which is somehow generic, since 'Child' inherits from 'Parent'. Hence the overloaded 'Child' method is called.

In the second case, you make an implicit cast of a 'Child' instance to the type 'Parent', hence you're calling the method on a 'Parent' object.

Hope this helps.

Answer 4

Your second code copies a Child object into a Parent variable. By a process called slicing it loses all information specific to Child (i.e. all private fields partial to Child) and, as a consequence, all virtual method information associated with it.

Also, both your codes leak memory (but I guess you know this).

You can use references, though. E.g.:

Child c;
Parent& p = c;
p.Method(); // Prints "Child::Method"

Answer 5

In your first example you call Method through a pointer:

p->Method();

In this case 'p' is a pointer to a Parent, and C++ knows that Parent has a v-table, so it uses that to find the actual method to call, which in this case as you state is Child::Method() because when C++ finds the v-table, it finds the v-table of the 'new' Child instance.

In the second example you call Method on an instance:

p.Method();

In this case 'p' is an instance of Parent and C++ assumes that it knows that the exact type is indeed 'Parent' and so it calls Parent::Method() without going through any v-tables.

I've just checked this with VS2008 and the above is actually what happens and there's no slicing, however, I think that slicing does occur, but you would only see it in the second case if you did:

Parent& q=p;
q.Method();

Then I see: Parent::Method() being printed. q.Method() must be a virtual call, but it can only find the v-table for Parent.

Answer 6

Virtual behaviour is only available when the virtual function is called via a pointer or a reference. When you say:

Parent p = *(new Child());
p.Method();

you have an actual Parent object, so Parent's method will always be called, no matter what you assign to p.

Answer 7

In the first case, the type of the object pointed by pointer p is of 'Child' type. Since child is overriding the virtual method defined in the base class, child's method is called. In the second case, you have copied the child object into a parent object. Here the object slicing occurs and the type of the resultant object is of type 'Parent'. Hence when you call the method, parent's method is called.

Answer 8

Polymorphism in C++ is only possible with pointers. The differentiation between the static and the dynamic type (in your first example p is of static type Parent*, but of dynamic type Child*, and this enables C++ to call the derived class' method) does not come into play with non-pointers.

Answer 9

What happens if you do this?

int main (int argc, char * const argv[]) {
    Parent &p = *(new Child());
    p.Method();
    return 0;
}

That has the same "syntactic" effect (p doesn't require dereferencing to use it), but the semantic effect is now completely different because you're no longer copying part of a Child into a Parent.

Answer 10

Your first case is simple. An instance of Child is created and asigned to p. So calling p->Method() calls Child::Method().

In the second case, four things happen:

1. An instance of the Child class, identified by a compiler-assigned temporary variable, is created.
2. An instance of of the Parent class, identified by the variable p is created.
3. The copy constructor Parent::Parent(Parent&) is called when p is instantiated to copy the Parent 'slice' of the state of the Child instance to p. Note that if you don't define this copy constructor then the compiler creates it for you.
4. You call Method() on p, which is an instance of Parent.

Try explicitly defining the copy constructor and you'll see that it is called.

Your possible confusion is probably because the assignments (=) in the two examples do different things. In the first example its simply setting one pointer equal to another, and there is only one object. In the second there are no pointers, so you're assigning (slicing) value. This invokes the copy constructor, and you get two objects (a Child and a Parent). The fact that the compiler is creating an invisible temporary variable doesn't help in understanding whats going on. You might check-out this article on copy constructors.

This is an easy mistake to make if you're used to languages like Java or C# where basically everything is a reference (aka a pointer).

As others have said, polymorphism only works with pointers and references, and these are not used in your second example.