Dynamic Binding in C++: Explanation, Functions & Implementation

Introduction

This article is going to walk you through the working of dynamic binding in C++. You are expected to have a basic knowledge of the working of inheritance and static binding in C++. This is because some limitations of static binding are removed by dynamic binding. We will show you, along with proper and simple codes, how dynamic binding is useful.

Check out our free courses to get an edge over the competition.

Explore Our Software Development Free Courses

What is Dynamic Binding?

Have you ever wondered what is c++ dynamic binding? By binding, we generally mean linking one object with another. In terms of programming languages, binding is not very different.

It is the linking of a function definition and a function call. But why ‘dynamic’? In simple words, dynamic binding is just delaying the choice or selection of which function to run until its runtime. Using dynamic binding in C++, we choose which function we can execute based on the underlying type of the object. 

Check out upGrad’s Java Bootcamp

This flexibility was not afforded to programmers with static binding. The static binding used to happen at compile time and not run time. Additionally, static binding made linkage of function call and definition during compile time, whereas, as you now know, dynamic binding does not do that until run time.

Dynamic binding allows us to ignore the type differences by providing us with the flexibility in choosing which type of function we need at that instant of runtime. On examining this statement, we can understand that dynamic binding allows us to handle different objects using just a single function name. This reduces code complexity and also enables the programmer to have an easier time while debugging. Hope with this, we have clarified your doubt about what is C++ Dynamic binding. 

Check out upGrad’s Full Stack Development Bootcamp (JS/MERN)

How is Dynamic binding C++ different from static binding?

Now that you have a basic understanding of what is dynamic binding C++, let’s take a look at some of the key aspects of dynamic binding. These aspects will highlight the key points that differentiate it from static binding. 

• Also referred to as early and late binding, static binding occurs during the compile time, whereas dynamic binding happens during runtime. 
• During static binding, the function definition and function call are linked together. However, that is not the case in dynamic binding. During dynamic binding, the function calls are not resolved until runtime. 
• The dynamic binding uses virtual functions, whereas static binding requires normal function calls and operator overloading. 
• Static binding is often known for its faster execution of a program. This is because the necessary information required for a function call is already available before runtime. Contrary to this, dynamic binding can result in a somewhat slower execution of code. However, that said, dynamic binding is known for its flexibility, allowing a single function to handle different types of objects during runtime. 

Explore our Popular Software Engineering Courses

upGrad’s Exclusive Software and Tech Webinar for you –

SAAS Business – What is So Different?

Virtual Functions

We have talked about dynamic binding in C++ a lot. But how to proceed with that? To implement dynamic binding in your C++ code, you need to use ‘virtual functions’. So what are virtual functions?

This article will not be going extensively into virtual functions as they are important enough for a separate article. But you will be provided with enough information about virtual functions to understand dynamic binding clearly.

Virtual functions are special member functions to which calls made through a pointer (or reference) are resolved at run time, based on the object’s type with the pointer. In simple words, if you define a virtual function in a base class, you can override the function in derived classes.

This is the power of virtual functions. In C++, you define a virtual function using the keyword ‘virtual’ at the beginning of the function definition. You may not have to repeat the keyword virtual for every derived class of a base class because once a function is declared ‘virtual’, it will remain ‘virtual’ in all of the derived classes.

In-Demand Software Development Skills

C++ Implementation

That’s about virtual functions. Now let us look into a program to understand dynamic binding in C++ :

Program #1:

We see two classes:- Class A is the ‘base’ class, whereas Class B is the ‘derived class’. Inside both the classes, are one function with the same name ‘display’. In parent class, there is another function named final_print() calling the display() function. In the main() function, we make two different objects for two different classes, calling the same display() function.

Let us see the output of the above program.

Output for Program #1:

As expected, the output executes the base class’s display() function two times as it is defined at compile time (static binding). But this is not the output we wanted. 

Now to convert the above code into a dynamic binding one, we need to use virtual functions. Let us see how to do that.

Program #2:

We just add the ‘virtual’ keyword for both of our display() functions in Class A and Class B, thus making them virtual functions. That is the only change needed. Just like before, we call the same final_print() function using two different objects. Let us see what output we get now.

Output for Program #2:

This is the output we wanted, and we got it using the dynamic binding of the functions. 

Learn Software Courses online from the World’s top Universities. Earn Executive PG Programs, Advanced Certificate Programs, or Masters Programs to fast-track your career.

Read our Popular Articles related to Software Development

Conclusion

In this article, we went through the concept of dynamic binding in C++. To summarize, the dynamic binding allows us flexibility by calling a single function to handle different objects. As evident from our code, we called the same function display() by making two different objects to give us two different outputs. This is possible because dynamic binding happens at runtime, unlike static binding which happens at compile time. We hope this blog offers clarity on what is dynamic binding and its various functions.

If you’re interested to learn more about full-stack development, check out upGrad & IIIT-B’s Executive PG Program in Full-stack Software Development which is designed for working professionals and offers 500+ hours of rigorous training, 9+ projects and assignments, IIIT-B Alumni status, practical hands-on capstone projects & job assistance with top firms.

Prepare for a Career of the Future

Apply Now for Executive PG Program in Full Stack Development