Question

why overriding is resolved at runtime whereas overloading is resolved at compile time ?
is there any reason that overriding cant be resolved at compile time.

Answer 1

is there any reason that overriding cant be resolved at compile time.

Assuming you’re talking about polymorphism, i.e.

#include <iostream>

class Base
{
public:
    virtual void Foo()
    {
        std::cout << "Base::Foo()" << std::endl;
    }
};

class Derived : public Base
{
public:
    virtual void Foo()
    {
        std::cout << "Derived::Foo()" << std::endl;
    }
};

The above code allows something like this to work as expected:

void CallFoo(Base& b)
{
    b.Foo(); 
}

int main()
{
    Base b;
    Derived d;
    CallFoo(b); // calls Base::Foo()
    CallFoo(d); // Calls Derived::Foo();
}

It is important to realize that CallFoo() knows nothing about what b actually is (it could be referring to a Base instance or to a Derived instance). All CallFoo() gets is a reference to Base, which tells nothing about what it actually refers to, so there’s no way a compiler can tell what it is when it compiles CallFoo(). Therefore, determining whether Base::Foo() or Derived::Foo() should be called is necessarily a runtime decision.

Removing the virtual keywords (to disable overriding) would cause the above code to print out Base::Foo() twice, not Base::Foo() then Derived::Foo(). This is because without the virtual keyword the compiler would simply resolve the call to Base::Foo() at compile time.

That being said, because virtual functions incur some overhead (after all, the right function that needs to be called is a runtime decision), compilers will try their best to figure out the actual type of b in CallFoo() if it can. In that case, it becomes a compile-time decision. It is, however, an implementation detail.