Answer

Static Binding (early binding, compile time):

• Happens at compile time.
• Functions are called directly, the address of the function is known to the compiler.
• Example: regular (non-virtual) class members, global functions.

void greet() { std::cout << "Hello!"; }

Dynamic Binding (late binding, run time):

• Determined at runtime through a virtual function table (vtable).
• Used for virtual functions, supporting polymorphism.

class Animal {
public:
    virtual void speak() { std::cout << "Animal"; }
};
class Dog : public Animal {
public:
    void speak() override { std::cout << "Woof"; }
};
void foo(Animal* a) { a->speak(); } // dynamic binding

When to use:

• Static binding — for small, frequently called functions where polymorphism is not required. Less overhead.
• Dynamic — if you need to change the behavior of child objects at runtime when the exact type of the object cannot be known in advance.

Tricky Question

Will the use of the override keyword speed up virtual function calls?

Answer: No, the override keyword is only used to explicitly inform the compiler that a function should override a virtual base function. It does not affect performance or how functions are called.

class A {
public:
    virtual void func();
};
class B : public A {
public:
    void func() override; // for compiler checking, but does not change call speed
};

Examples of real errors due to lack of knowledge about the nuances of the topic

---

Story

In a high-load trading library, the team used virtual methods for most operations, even when polymorphism was not necessary. As a result, the system performed slower than expected — the main bottleneck was in vtable lookups.

---

Story

In a project with extensible algorithms, employees used regular methods instead of virtual ones. Later it turned out that when passing objects through base pointers, behavior did not change, leading to incorrect calculations; bugs were fixed only by rewriting the interface.

---

Story

In a media file analysis project, developers confused static and virtual methods. Some functions for different formats were forgotten to be declared as virtual and not overridden in descendants, causing file processing to go through the wrong path and results to be cached incorrectly.