Binding

Binding refers to the linking of processor call to the code to be a executed in response to the call Dynamic Binding the means code associate with a given processor call is know untill the time of call and runtime. It is assocates with Polymorphism and Inheritance. There are two types of Binding.

1. Static Binding (Early Binding)
2. Dynamic Binding (Late Binding)

Static Binding (Early Binding)

Binding generally means linking. In a C++ Program choosing a function in a normal way during its compilation time is called as static binding. The static binding is also referred as Early binding or static linkage. we can say that the static binding an example of compile time binding. The below program show Static binding/early binding program.

/* C++ program to illustrate the concept of static binding*/

#include<iostream>
#include<conio.h>
using namespace std;
 
class base
{
    public:
 
    int sum(int x, int y) {
        return x + y;
    }
 
    int sum(int x, int y, int z) {
        return x + y + z;
    }
};
 
int main()
{
    base obj;
    cout << "C++ program to illustrate the concept of static binding\n\n";
    cout << "Sum is " << obj.sum(10, 20) << endl;
    cout << "Sum is " << obj.sum(10, 20, 30) << endl;
 	getch();
    return 0;
}

Dynamic Binding (Late Binding)

In contrast, virtual member functions are resolved dynamically (at run-time). That is, the member function is selected dynamically (at run-time) based on the type of the object, not the type of the pointer/reference to that object. This is called binding or late binding. Dynamic binding is a result of virtual functions. If the keyword virtual is used with the function declaration in the base class, the system will use dynamic binding, which is done at run time but if the keyword is not include, static binding will be used. The below program show dynamic binding/late binding program.

// C++ program to illustrate the concept of dynamic binding

#include<iostream>
#include<conio.h>

using namespace std;


class B
{
    public:
 
    // Virtual function
    virtual void f() {
        cout << "The base class function is called.\n";
    }
};
 
class D: public B
{
    public:
    void f() {
        cout << "The derived class function is called.\n";
    }
};
 
int main()
{
    B base;
    D derived;
 
    B *basePtr = &base;
    basePtr->f();
 
    basePtr = &derived;
    basePtr->f();
 
    return 0;
}

	Home
	Introduction to C++
	Variables & Constants
	Input/Ouput Statements
	C++ Operators
	Branching Statements
	Looping Statments
	Jumping Statement
	Arrays
	Classes & Objects
	Constructors
	Destructors
	Friend Classes
	Friend Functions
	Inheritance
	Virtual Functions
	Binding
	Polymorphism
	Function Overloading
	Operator Overloading

C++ Programming

Binding

Static Binding (Early Binding)

Dynamic Binding (Late Binding)

Related Post