12.4 — Early binding and late binding

In this chapter and the next, we are going to take a closer look at how virtual functions are implemented. While this information is not strictly necessary to effectively use virtual functions, it is interesting. Nevertheless, you can consider both sections optional reading.

When a C++ program is executed, it executes sequentially, beginning at the top of main(). When a function call is encountered, the point of execution jumps to the beginning of the function being called. How does the CPU know to do this?

When a program is compiled, the compiler converts each statement in your C++ program into one or more lines of machine language. Each line of machine language is given it’s own unique sequential address. This is no different for functions — when a function is encountered, it is converted into machine language and given the next available address. Thus, each function ends up with a unique machine language address.

Binding refers to the process that is used to convert identifiers (such as variable and function names) into machine language addresses. Although binding is used for both variables and functions, in this lesson we’re going to focus on function binding.

Early binding

Most of the function calls the compiler encounters will be direct function calls. A direct function call is a statement that directly calls a function. For example:

Direct function calls can be resolved using a process known as early binding. Early binding (also called static binding) means the compiler is able to directly associate the identifier name (such as a function or variable name) with a machine address. Remember that all functions have a unique machine address. So when the compiler encounters a function call, it replaces the function call with a machine language instruction that tells the CPU to jump to the address of the function.

Let’s take a look at a simple calculator program that uses early binding:

Because Add(), Subtract(), and Multiply() are all direct function calls, the compiler will use early binding to resolve the Add(), Subtract(), and Multiply() function calls. The compiler will replace the Add() function call with an instruction that tells the CPU to jump to the address of the Add() function. The same holds true for for Subtract() and Multiply().

Late Binding

In some programs, it is not possible to know which function will be called until runtime (when the program is run). This is known as late binding (or dynamic binding). In C++, one way to get late binding is to use function pointers. To review function pointers briefly, a function pointer is a type of pointer that points to a function instead of a variable. The function that a function pointer points to can be called by using the function call operator (()) on the pointer.

For example, the following code calls the Add() function:

Calling a function via a function pointer is also known as an indirect function call. The following calculator program is functionally identical to the calculator example above, except it uses a function pointer instead of a direct function call:

In this example, instead of calling the Add(), Subtract(), or Multiply() function directly, we’ve instead set pFcn to point at the function we wish to call. Then we call the function through the pointer. The compiler is unable to use early binding to resolve the function call pFcn(nX, nY) because it can not tell which function pFcn will be pointing to at compile time!

Late binding is slightly less efficient since it involves an extra level of indirection. With early binding, the compiler can tell the CPU to jump directly to the function’s address. With late binding, the program has to read the address held in the pointer and then jump to that address. This involves one extra step, making it slightly slower. However, the advantage of late binding is that it is more flexible than early binding, because decisions about what function to call do not need to be made until run time.

In the next lesson, we’ll take a look at how late binding is used to implement virtual functions.

12.5 — The virtual table
12.3 — Virtual destructors, virtual assignment, and overriding virtualization

19 comments to 12.4 — Early binding and late binding

  • Arijit Chattopadhyay

    Good example.. Easy to understand

  • sssss

    very good example

  • gswrg

    Why do you use the “&” in the first example

    but not in the second example?

  • that’s bullshit… it doesn’t work… !! do you know programming at all????? !!!!

    • HJ

      Hey friend,
      please, be gentle on the guy. Atleast, he is doing something you are not doing-giving his idea. kindly state what you saw that is wrong and help others to see it instead of just insulting the guy. thanks

  • Max

    Nice and clear thank you.

  • mak

    the piece of code is an example of late binding itself. Put a code of Virtual functions. Virtual functions are perfect example of late binding or runtime polymorphism.

    these lines are clearly late binding example….

  • it is good example for C++ late binding and early binding

  • Ganesh

    Nice explanation, very easy to understand , I have already saved the web address.

  • nehemiah

    Woooohoooooo ALEX, Till now nobody cleared my doubt regarding even my college professors !!

    Thank you Alex for your mind blowing session !!

  • rahul nagar

    Hi Alex,

    In the tutorial you said that “The compiler is unable to use early binding to resolve the function call pFcn(nX, nY) because it can not tell which function pFcn will be pointing to at compile time!”

    I think the reason for late binding is that the allocation of function pointer pFcn(nX,nY) is at run time(as it is allocated from heap) and hence the function call cannot be resolved at compile time.

    If I change the code to below ::

    switch (nOperation)
    case 0: Add(nX,nY); break;
    case 1: Subtract(nX,nY); break;
    case 2: Multiply(nX,nY); break;

    Will this be late binding or early binding ??

    I feel this is early binding as compiler has the address of the functions and the control can move to the address based on choice of user at run time.

    Kindly suggest on the above.


  • Augustine P A

    Nice explanation, very easy to understand.. But my personal opinion is that function pointers are quite interesting than conventional programming. Function Pointers provide some extremely interesting, e?cient and elegant programming techniques. You can use them to replace switch/if-statements, to realize your own late-binding or to implement callbacks.

  • “The same holds true for for Subtract() and Multiply().”

  • tvyas


    I appreciate your efforts here.

    However, I think the example here is not one of late binding, since a compiler might already create 3 options/paths of codes based on the 3 options (0,1, & 2) at compile time! It is similar situation to the one asked by “Rahul Nagar”:

    In either cases, I believe it is early binding, not a late binding. Instead of this, if the end user is asked to input the address of one of the functions (assuming that their addresses are already output before somewhere), and if that address which is entered by the user is used for calling the function would definitely be a late binding example.

    Please feel free to comment/correct me if I am wrong.

    Thanks in advance.

    -Trilok Vyas.

  • smru

    precisely explained concept..was very useful..

Leave a Comment (Note: put C++ code inside [code][/code] brackets)




seven + seventeen =

You can use these HTML tags

<a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code class="" title="" data-url=""> <del datetime=""> <em> <i> <q cite=""> <strike> <strong> <pre class="" title="" data-url=""> <span class="" title="" data-url="">