Constexpr & Compile-Time Programming

#include <iostream>
using namespace std;

// 'constexpr' on a function means: "this CAN run at compile time."
// If every argument is known to the compiler, the answer is worked out
// during the build and baked straight into the program as a constant.
constexpr int factorial(int n) {
    if (n <= 1) return 1;          // base case
    return n * factorial(n - 1);   // 5 * 4 * 3 * 2 * 1
}

int main() {
    // 'constexpr' on a variable means: "compute this at compile time."
    // The compiler ru
...

#include <iostream>
using namespace std;

// 🎯 YOUR TURN — fill in the blanks marked ___ then press "Try it Yourself".

// 1) Make this a function that CAN run at compile time.
___ int square(int x) {     // 👉 replace ___ with the keyword constexpr
    return x * x;
}

int main() {
    // 2) Force this to be computed at compile time.
    ___ int nine = square(3);   // 👉 replace ___ with constexpr   (nine == 9)

    cout << "3 squared = " << nine << endl;

    // 3) Prove it was a compile-time
...

#include <iostream>
using namespace std;

// consteval (C++20) = "MUST run at compile time." Calling it with a
// runtime value is a hard error — there is no runtime fallback.
consteval int cube(int x) { return x * x * x; }

int main() {
    int runtimeValue = 5;          // not known to the compiler in advance

    // 'const' = "this never changes after it is set." It can be set
    // from a RUNTIME value — const says nothing about WHEN it is known.
    const int a = runtimeValue;    // OK: va
...

#include <iostream>
#include <type_traits>
#include <string>
using namespace std;

// 'if constexpr' picks a branch at COMPILE time, based on the type T.
// The branch that is NOT taken is removed entirely — it never has to
// even compile for that type. A plain 'if' could not do this safely.
template <typename T>
string describe(const T& value) {
    if constexpr (is_integral_v<T>) {
        // Only compiled when T is a whole-number type (int, long, bool...)
        return "Integer: " + to_stri
...

#include <iostream>
#include <type_traits>
using namespace std;

// 🎯 YOUR TURN — fill in the blanks marked ___ then run it.

// This function should double integers but halve floating-point numbers.
template <typename T>
T transform(T value) {
    // 1) Make this a COMPILE-TIME branch (a normal 'if' won't do here).
    if ___ (is_integral_v<T>) {   // 👉 replace ___ with constexpr
        return value * 2;         // integers get doubled
    } else {
        return value / 2;         // everyt
...