Compiler & Runtime Binding

Compiler binding and runtime binding are two different mechanisms related to how programming languages handle function/method calls and binding them to their respective implementations. These mechanisms are crucial in understanding polymorphism and how function calls are resolved in compiled languages like C++.

1. Compiler Binding (Static Binding):

• Compiler binding, also known as static binding or early binding, occurs at compile time, before the program is executed.

• In statically typed languages like C++ and Java, the compiler determines which function or method to call based on the declared data types of variables, references, or pointers at compile time.

• The compiler resolves the function call to the specific function based on the static type information, and this binding is set during compilation.

• It is efficient but lacks flexibility because the decision is made before runtime.

Example in C++ (static binding):

class Animal {
public:
    void Sound() {
        cout << "Generic animal sound" << endl;
    }
};

class Dog : public Animal {
public:
    void Sound() {
        cout << "Woof! Woof!" << endl;
    }
};

int main() {
    Animal* myAnimal = new Dog();
    myAnimal->Sound(); // Calls Animal::Sound() at compile time, not Dog::Sound().
    delete myAnimal;
    return 0;
}

In this example, the function call to Sound() is resolved at compile time based on the static type (Animal*) of the pointer myAnimal. It calls Animal::Sound() and not Dog::Sound().

2. Runtime Binding (Dynamic Binding):

• Runtime binding, also known as dynamic binding or late binding, occurs at runtime, during program execution.

• In languages that support polymorphism (e.g., C++ with virtual functions), the decision about which method or function to call is deferred until the program is running, based on the actual type of the object.

• This mechanism allows for greater flexibility because it allows a function call to be resolved based on the actual type of the object, even if it is referred to through a base class pointer or reference.

• Dynamic binding is achieved using virtual functions in C++ and similar mechanisms in other languages.

Example in C++ (dynamic binding):

class Animal {
public:
    virtual void Sound() {
        cout << "Generic animal sound" << endl;
    }
};

class Dog : public Animal {
public:
    void Sound() override {
        cout << "Woof! Woof!" << endl;
    }
};

int main() {
    Animal* myAnimal = new Dog();
    myAnimal->Sound(); // Calls Dog::Sound() at runtime due to virtual function.
    delete myAnimal;
    return 0;
}

In this example, the function call to Sound() is resolved at runtime based on the actual type of the object pointed to by myAnimal. It calls Dog::Sound() because Sound() is declared as a virtual function in the base class Animal.

In summary, compiler binding (static binding) occurs at compile time based on static type information, while runtime binding (dynamic binding) defers the binding decision until runtime, allowing for greater flexibility and polymorphism. Dynamic binding is achieved through mechanisms like virtual functions in C++.