CODEWITHSUNDEEP
c++bindingpolymorphism
Stack
Stack

Reputation: 235

Early and late binding + polymorphism in c++

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

Upvotes: 3

Views: 1845

Answers (2)

πάντα ῥεῖ
πάντα ῥεῖ

Reputation: 1

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.

Upvotes: 0

Mike Seymour
Mike Seymour

Reputation: 254461

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.

Upvotes: 5

Related Questions