Compile-Time and Runtime in C++

Compile-Time vs Runtime in C++

---

Prerequisites

- Compile
- Runtime

---

1. What is difference between Compile-Time vs Runtime in C++

In C++, operations can be executed at either:

• Compile-time → before the program runs
• Runtime → while the program is running

👉 Understanding this difference is critical for performance, safety, and optimization

1. Is this computed at compile-time or runtime?
2. If runtime → can it be moved to compile-time?

Move as much work as possible to compile-time for better performance

Category	Compile-Time	Runtime
Timing	Before execution	During execution
Performance	Faster	Slower
Flexibility	Less flexible	More flexible
Safety	High	Depends

2. Compile-Time

Computed during compilation, no runtime cost

🔹 constexpr

constexpr int square(int x) 
{
    return x * x;
}

Evaluated at compile-time if inputs are known

🔹 const

const int x = 10;

Compile-time only if initialized with constant expression. If assigned from function → runtime

🔹 consteval (C++20)

consteval int square(int x) 
{
    return x * x;
}

Must be evaluated at compile-time

🔹 constinit (C++20)

constinit int x = 10;

Ensures static initialization at compile-time

🔹 Template

template<int N>
struct Square 
{
    static constexpr int value = N * N;
};

Fully compile-time computation

🔹 inline

Suggests compile-time expansion (not guaranteed)

🔹 Macro

#define SQUARE(x) ((x)*(x))

Preprocessor substitution (before compilation)

🔹 static_assert

static_assert(sizeof(int) == 4);

Compile-time validation

🔹 enum

enum { SIZE = 10 };

Compile-time constant

🔹 sizeof

sizeof(int);

Always compile-time

🔹 Array size

int arr[10];

Must be known at compile-time

🔹 typeid

typeid(int);

Compile-time (non-polymorphic types)

3. RunTime

Computed during program execution

🔹 Dynamic allocation

int* p = new int(10);

🔹 Virtual function

class Base 
{
public:
    virtual void foo() {}
};

Resolved via vtable at runtime

🔹 std::function

std::function<int(int)> f = [](int x){ return x * x; };

Type-erased, runtime overhead

🔹 Async / Thread

std::async(...);
std::thread(...);

🔹 dynamic_cast

dynamic_cast<Derived*>(basePtr);

Runtime type checking (RTTI)

🔹 reinterpret_cast

reinterpret_cast<int*>(ptr);

Unsafe, runtime reinterpretation

🔹 unknown function

int x = getValue(); // unknown at compile-time