Trusted answers to developer questions
Trusted Answers to Developer Questions

Related Tags

c
c++

What are early binding and late binding functions in C++?

Behzad Ahmad

When we compile our program, all variables and functions are mapped to addresses in memory. These addresses are then used for reference in the program. This process of converting variables and functions into addresses is known as binding.

There are two types of binding. Let’s look at each one of them individually.

Early binding

Early binding is also called static binding. Early binding occurs when we make the explicit or direct function call in our program.

When the compiler encounters a function call in the program, it replaces that function call with a machine language instruction to go to that function.

Therefore, when the point of execution comes in that function call line, it reads that instruction and then jumps to the function given by memory address.

Consider the following code:

#include<iostream>
using namespace std;

void display(int x){
	cout << x;
}

int main(){
	
	display(5);
	return 0;
}

Late binding

Late binding is also called dynamic binding. Late binding occurs when we make implicit or indirect function calls in our program. An example of this is using function pointers or virtual functions when using classes. Here, the function call’s memory reference is not determined at compile-time, but rather at run-time.

A function pointer is a pointer that stores the memory address of a function instead of a variable.

Consider the following code:

#include<iostream>
using namespace std;

void display(int x){
	cout << x;
}

int main(){
	
	void (*ptrFunc)(int) = display;
	ptrFunc(5);
	return 0;
}

In this example, the compiler does not know which function is stored in that function pointer until the runtime, and therefore cannot do the early binding.

In this case, the compiler converts the function pointer into a machine language instruction and stores it in the next sequential available address.

When the line of execution comes at that machine language instruction, it goes to the memory address of that function pointer. The line of execution dereferences it, then makes the function call and goes to the body of the function.

Summary

If the compiler knows at the compile-time which function is called, it is called early binding.

If a compiler does not know at compile-time which functions to call up until the run-time, it is called late binding.

RELATED TAGS

c
c++

CONTRIBUTOR

Behzad Ahmad
Copyright ©2022 Educative, Inc. All rights reserved
RELATED COURSES

View all Courses

Keep Exploring