Early and late binding + polymorphism in c++

Question

Say there was no Hello function and we simply called ob.display in main then it calls the display function of class B and not class A.

Call of the function display() is being set once by the compiler as the version defined in the base class. This is called static resolution of the function call, or static linkage - the function call is fixed before the program is executed. This is also sometimes called early binding because the display() function is set during the compilation of the program.

Now how can it call the display function of the derived class without using the virtual keyword(late binding) before the display function in the base class?

Now in this program, Passing the object as call by value,call by pointer and call by reference to the Hello function works fine. Now if we use Polymorphism and want to display the member function of the derived class if it is called we have to add the virtual keyword before display function in the base. If we pass the object value by call by pointer and call by reference it call the function in the derived class but if we pass the object by value it doesn't why is it so?>

class A
{
   public:
      void display();                       // virtual void display()
       {
        cout << "Hey from A" <<endl;
       }
};

class B : public A
{
    public:
        void display()
        {
            cout << "Hey from B" <<endl;
        }
};

void Hello(A ob) // &ob  //*ob
{
   ob.display();       // ob->display()
}

int main()
{
    B obj;
    Hello(obj); // obj   //&ob
    return 0;
}

possible duplicate of [What is object slicing?](http://stackoverflow.com/questions/274626/what-is-object-slicing) — Wintermute, Apr 06 '15 at 11:52

score 5 · Accepted Answer · answered Apr 06 '15 at 11:56

Now how can it call the display function of the derived class without using the virtual keyword(late binding) before the display function in the base class?

A non-virtual function is simply resolved by the compiler, according to the static type of the object (or reference or pointer) it's called on. So given an object of the derived type, and a reference to its sub-object:

B b;
A & a = b;

you'd get different results from calling a non-virtual function:

b.display();  // called as B
a.display();  // called as A

If you know the real type, then you could specify that you want to call that version:

static_cast<B&>(a).display();  // called as B

but that would go horribly wrong if the object that a refers to doesn't have type B.

Now if we use Polymorphism and want to display the member function of the derived class if it is called we have to add the virtual keyword before display function in the base.

Correct. If you make the function virtual, then it's resolved at runtime according to the dynamic type of the object, even if you use a different type of reference or pointer to access it. So both the above examples would call it as B.

If we pass the object value by call by pointer and call by reference it call the function in the derived class but if we pass the object by value it doesn't why is it so?

If you pass it by value, then you're slicing it: copying just the A part of the object, to make a new object of type A. So, whether or not the function is virtual, calling it on that object would choose the A version, since it's an A and nothing but an A.

If you pass by reference or pointer, then you're still accessing the original object, with its dynamic type B. So the virtual function call would resolve to the B version.

wikipedia says that object slicing happens because there is no place to store the additional members of the derived class in the superclass so it is sliced off. why object slicing does not happen if we pass it by reference or pointer? How come the superclass gets additional space to store it? — Stack, Apr 07 '15 at 14:21
@Stack: If you pass a reference or pointer, you're not creating a new object. It refers to an existing object, of the derived type, which already has enough space to store itself. — Mike Seymour, Apr 07 '15 at 14:25

πάντα ῥεῖ · Answer 2 · 2015-04-06T12:01:25.947

Now how can it call the display function of the derived class without using the virtual keyword(late binding) before the display function in the base class?

You can provide a templated base class like this

template<typename Derived>
class A {
   public:
      void display() {
        // call Derived first
        static_cast<Derived*>(this)->display();
        cout << "Hey from A" <<endl;
      }
};

class B : public A<B> {
public:
    void display() {
        cout << "Hey from B" <<endl;
    }
};

This is a well known pattern, called CRTP and Static Polymorphism.

Early and late binding + polymorphism in c++

2 Answers2