When a function is called in your code, program control is bound to the memory location where the bind was defined. It is most important to understand the idea of binding itself to understand static binding and dynamic binding.
When we make a function, we have two main parts in the function.
- Function Definition: This describes what the function will do when it is used, like a recipe.
- Function Call: This is like using the recipe to perform the task of the function.
Different memory locations are used to store these definitions and calls. We need a way to correctly match each call to each function’s definition because programs often require many functions to run smoothly.
Let us take an example to clarify our concept of Binding in C++.
| Binding In C++ |
| // Class Definition.class Car {
public: // Function Definition 1 void startEngine( ) { cout << “Engine started! \n”; } // Function Definition 2 void stopEngine( ) { cout << “Engine stopped. Silence.\n”; } }; // Driver Code int main() { Car myCar; myCar.startEngine(); // Calling the startEngine function myCar.stopEngine(); // Calling the stopEngine function return 0; } |
Output
| Engine started!
Engine stopped. Silence. |
If the binding were not present, then both functions would have mixed up, creating confusion and undesired result. Hence, we need binding to correctly link a function call with its function definition.
Connecting a specific function call to its right function definition is called binding. But why is this so important? The advantages of binding are big, and they come in two main types: static and dynamic.
Static Binding
Static Binding is also known as Compile Time Binding.
Static binding occurs when the connection between a function call and its definition is set when your program is being prepared for running, called Compile Time.
Think of default settings as how something works, like how a tool behaves when you use it. In programming, the default way of connecting a function call to its definition in C++ is called Static Binding. It’s like having a pre-set rule that says, “Hey, link these things together when the program is being made.”
Static binding is all about making this link between a function call and its definition while the program is being prepared, usually before it starts running. This is why it’s also called Compile time binding or Early Binding.
You can think of it as putting labels on things beforehand. You can match things up quickly if you know what the labels on the items say.
Static binding is used automatically for regular function calls in your program. It is also used when using multiple iterations of a function or when using operators in unique ways.
When methods are marked as static, private, or final, their linking is always done during compile-time. This is because the class type is known beforehand, so the connection between calls and definitions can be decided immediately.
Some of the advantages of using the Static Binding are as follows:
- Static binding is faster than dynamic binding. The program runs faster because the computer is already aware of all the methods in a class. This also implies that the computer will not require additional time to make sense of things while running the program.
- Programs run more quickly and efficiently because they are faster.
However, static binding has a small downside and is a bit less flexible. Before the program executes, all decisions about the function’s call and input values are made. Changing anything while the program is running is difficult.
Examples of Static Binding are:
- Function Overloadin
- Operator Overloading
Dynamic Binding
When the connection between a function call and its definition happens while the program is running, this is called Dynamic Binding.
At compile time or during the preparation of our program, the computer sometimes cannot understand all the information in a function call. Instead, it sorts things out while the program is actually running. This kind of linking is known as dynamic binding.
It is also known as Run time binding or Late binding because everything is decided while the program is running.
Some of the advantages of using dynamic binding are given here.
- The fact that the same function can handle a variety of objects gives it a lot of flexibility.
- It can help make programs smaller and easier to understand.
There exist a drawback to it as well, as all the calculations must be made while the program is running, which can slow down operations. This is one of the less desirable aspects of dynamic binding.
Examples of dynamic binding is:
- Virtual Function
Static Binding VS Dynamic Binding
In this table, some major differences between static binding and dynamic binding are given.
| Static Binding | Dynamic Binding |
|
|
Static Binding VS Dynamic Binding FAQs
What is the use of binding in programming?
Binding in programming is connecting a function call to its corresponding function definition. It ensures that the program knows which code to execute when a function is called.
What is the difference between a function definition and a function call?
A function definition describes what a function does, while a function call is when you actually use that recipe to perform the function's task.
What is static binding, and when does it occur?
The connection between a function call and its definition is made during program compilation time with the help of static binding. It is also referred to as compile-time binding.
What is dynamic binding, and when does it occur?
Run-time binding, also called dynamic binding, links a function call to its definition while the program runs. This technique is used when the program is created and some necessary data is missing.
What makes dynamic binding preferable?
Dynamic binding is more flexible, allowing a single function to handle various objects. Also, it can make programs more compact and easier to understand. However, it can slow down operations since decisions are made while the program is running, but it adds much needed flexibility.
