Q:

What are the advantages of late binding? Give one example in context of function pointers in C++

Firstly, let me clarify this question doesn't explain my doubt clearly. To set the context clear. I'm asking this question specifically with regard to function pointers in C/C++.
I know the difference between early binding and late binding and how it works. What I would like to understand is the following with one example using function pointers in C/C++:
In many textbooks, it has been mentioned :

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.

Also, it mentions: 

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.

#include <iostream>
using namespace std;

int Add(int nX, int nY)
{
    return nX + nY;
}

int Subtract(int nX, int nY)
{
    return nX - nY;
}

int Multiply(int nX, int nY)
{
    return nX * nY;
}

int main()
{
    int nX;
    cout << "Enter a number: ";
    cin >> nX;

    int nY;
    cout << "Enter another number: ";
    cin >> nY;

    int nOperation;
    do
    {
        cout << "Enter an operation (0=add, 1=subtract, 2=multiply): ";
        cin >> nOperation;
    } while (nOperation < 0 || nOperation > 2);

    // Create a function pointer named pFcn (yes, the syntax is ugly)
    int (*pFcn)(int, int);

    // Set pFcn to point to the function the user chose
    switch (nOperation)
    {
        case 0: pFcn = Add; break;
        case 1: pFcn = Subtract; break;
        case 2: pFcn = Multiply; break;
    }

    // Call the function that pFcn is pointing to with nX and nY as parameters
    cout << "The answer is: " << pFcn(nX, nY) << endl;

    return 0;
}

here, there is no advantage of using late binding and early binding as in the example below should be preferred.
int nResult = 0;
switch (nOperation)
{
    case 0: nResult = Add(nX, nY); break;
    case 1: nResult = Subtract(nX, nY); break;
    case 2: nResult = Multiply(nX, nY); break;
}

cout << "The answer is: " << nResult << endl;

Could someone explain with an easy example like below where late binding is advantageous and why should someone choose it over early binding?

A:

OK, I'm going to skip over the whole "early binding vs late binding" definition question and pretend you asked "why would someone use function pointers instead of a switch statement?"
Because function pointers are more flexible. They aren't static. Let's take the business end of your code:
int InvokeOperation(int nOperation, int nX, int nY)
{
    switch (nOperation)
    {
        case 0: return Add(nX, nY);
        case 1: return Subtract(nX, nY);
        case 2: return Multiply(nX, nY);
    }
}

That's nice and functional. But it's not flexible. Why? Because all of the functions that can be called are defined by InvokeOperation; if you want to add a new operation, you have to be able to change InvokeOperation.
By contrast, if you used function pointers, you can build a whole registry of operations:
using Func = int(*)(int, int);
struct Op{Func func; std::string name;};
std::vector<Func> funcs =
{
    {&Add, "Add"},
    {&Subtract, "Subtract"},
    {&Multiply, "Multiply"},
};

int InvokeOperation(int nOperation, int nX, int nY)
{
    return funcs[nOperation].func(nX, nY);
}

Now, if you want to add more operations, just insert elements into funcs. If InvokeOperation were part of some library, you wouldn't necessarily have the right to change it. With static binding, you would have an inflexible system; what it supports is what it will always support.
With dynamic binding, you can add whatever stuff you want, whether you have the right to modify the library directly or not.

