constexpr in C++ — Compile-Time Computation, Internals & Pitfalls

#include <iostream>
#include <array>

// A constexpr function: can be called at compile time OR runtime
// The compiler decides based on HOW the result is used
constexpr long long factorial(int number) {
    // C++14+ allows loops inside constexpr functions
    long long result = 1;
    for (int i = 2; i <= number; ++i) {
        result *= i;
    }
    return result;
}

// This variable MUST be computed at compile time:
// it's used as a template argument (array size), which demands
// a compile-time constant. If factorial() had UB, this line fails.
constexpr long long compile_time_factorial = factorial(12);

int main() {
    // Case 1: Forced compile-time evaluation
    // The array size must be a compile-time constant.
    // The compiler proves factorial(6) == 720 during compilation.
    std::array<int, factorial(6)> lookup_table{};
    std::cout << "Array size (6!): " << lookup_table.size() << "\n";

    // Case 2: Also compile-time — constexpr variable in a constant context
    static_assert(compile_time_factorial == 479001600LL,
                  "Factorial of 12 must be 479001600");
    std::cout << "12! = " << compile_time_factorial << "\n";

    // Case 3: Runtime call — the argument isn't known at compile time
    int user_input = 7; // pretend this came from std::cin
    long long runtime_result = factorial(user_input);
    std::cout << "7! (runtime) = " << runtime_result << "\n";

    // Inspect what the compiler actually embedded:
    // Open the binary with `objdump -d` and you won't find a loop
    // for the first two cases — just the literal value 720 or 479001600.
    return 0;
}

#include <iostream>

// constexpr function: CAN be called at compile time or runtime
constexpr int celsius_to_fahrenheit(int celsius) {
    return celsius * 9 / 5 + 32;
}

// consteval function (C++20): MUST be called at compile time
// Attempt to pass a runtime variable → compiler error
consteval int parse_bitmask(unsigned int mask) {
    // In real code this might validate bit patterns at compile time
    return static_cast<int>(mask & 0xFF);
}

// constinit: initialised at compile time, but NOT const — can be mutated
// Prevents static-initialisation-order-fiasco for globals
constinit int global_retry_limit = parse_bitmask(0b00000101); // = 5

int main() {
    // constexpr variable: type-safe compile-time constant (unlike #define)
    constexpr int boiling_point_f = celsius_to_fahrenheit(100);
    std::cout << "Boiling point (F): " << boiling_point_f << "\n";

    // const variable: initialised at runtime — this is NOT a constexpr
    int runtime_temp = 37; // imagine this came from a sensor
    const int body_temp_f = celsius_to_fahrenheit(runtime_temp); // runtime call
    std::cout << "Body temp (F): " << body_temp_f << "\n";

    // consteval: the argument must be a compile-time constant
    constexpr int hw_flags = parse_bitmask(0b11001010);
    std::cout << "Hardware flags (low byte): " << hw_flags << "\n";

    // constinit global can be changed at runtime (unlike constexpr global)
    global_retry_limit = 10;
    std::cout << "Updated retry limit: " << global_retry_limit << "\n";

    // This would be a compile error — consteval rejects runtime arguments:
    // int dynamic_mask = 0b101;
    // int result = parse_bitmask(dynamic_mask); // ERROR: not a constant expression

    return 0;
}

#include <iostream>
#include <array>
#include <cstdint>

// --- Compile-time CRC-8 table generator ---
// CRC-8 with polynomial 0x07 (used in ATM, SMBUS)
// Normally you'd ship this as a hand-crafted 256-byte C array.
// With constexpr, the compiler generates the identical table for you.

constexpr uint8_t crc8_polynomial = 0x07;

constexpr uint8_t compute_crc8_entry(uint8_t byte_value) {
    uint8_t crc = byte_value;
    for (int bit = 0; bit < 8; ++bit) {
        // Standard CRC shift-and-XOR algorithm
        if (crc & 0x80) {
            crc = static_cast<uint8_t>((crc << 1) ^ crc8_polynomial);
        } else {
            crc = static_cast<uint8_t>(crc << 1);
        }
    }
    return crc;
}

// Build the full 256-entry CRC table at compile time
// The compiler runs compute_crc8_entry for each index [0..255]
// during compilation — no runtime cost whatsoever
constexpr std::array<uint8_t, 256> build_crc8_table() {
    std::array<uint8_t, 256> table{};
    for (int index = 0; index < 256; ++index) {
        table[index] = compute_crc8_entry(static_cast<uint8_t>(index));
    }
    return table;
}

// This is the key line: a constexpr variable captures the fully built table.
// In the compiled binary, this is just 256 bytes of raw data in the .rodata
// section — no initialisation function is called at startup.
constexpr auto crc8_table = build_crc8_table();

// Now use the pre-built table to compute CRC-8 over a byte buffer at runtime
uint8_t compute_crc8(const uint8_t* data, size_t length) {
    uint8_t crc = 0x00;
    for (size_t i = 0; i < length; ++i) {
        // Single table lookup per byte — O(n), extremely fast
        crc = crc8_table[crc ^ data[i]];
    }
    return crc;
}

int main() {
    // Verify a known value — CRC-8 of {0x31, 0x32, 0x33} = 0xA4 per spec
    const uint8_t test_payload[] = {0x31, 0x32, 0x33};
    uint8_t checksum = compute_crc8(test_payload, sizeof(test_payload));
    std::cout << "CRC-8 of {0x31,0x32,0x33}: 0x"
              << std::hex << std::uppercase
              << static_cast<int>(checksum) << "\n";

    // Prove the table was built at compile time — this is a compile-time check
    static_assert(crc8_table[0]   == 0x00, "CRC table entry 0 is wrong");
    static_assert(crc8_table[1]   == 0x07, "CRC table entry 1 is wrong");
    static_assert(crc8_table[255] == 0xE0, "CRC table entry 255 is wrong");
    std::cout << "All compile-time CRC table assertions passed.\n";

    // Spot-check the table in code — these are just array reads, not computations
    std::cout << "Table[7]   = 0x" << static_cast<int>(crc8_table[7])   << "\n";
    std::cout << "Table[128] = 0x" << static_cast<int>(crc8_table[128]) << "\n";

    return 0;
}

#include <iostream>
#include <type_traits>
#include <limits>

// --- Edge Case 1: UB at compile time is a hard error ---
constexpr int safe_multiply(int a, int b) {
    // At runtime, signed overflow is UB but 'works' on x86
    // At compile time, the compiler DETECTS the overflow and refuses
    // This function is safe because we check first
    if (a > 0 && b > std::numeric_limits<int>::max() / a) {
        return -1; // signal overflow — in real code use std::optional
    }
    return a * b;
}

// --- Edge Case 2: if constexpr in templates ---
// This is a template that behaves differently based on the type T
template <typename NumericType>
constexpr NumericType absolute_value(NumericType value) {
    // if constexpr: the else branch is DISCARDED at compile time for unsigned types
    // Without `if constexpr`, the compiler would try to compile `value < 0`
    // for an unsigned type and warn/error about a comparison that's always false
    if constexpr (std::is_unsigned_v<NumericType>) {
        return value; // unsigned types are always non-negative
    } else {
        return value < 0 ? -value : value;
    }
}

// --- Edge Case 3: constexpr does NOT guarantee compile-time in all contexts ---
constexpr double hypotenuse(double a, double b) {
    // Note: std::sqrt is NOT constexpr in C++17 standard library
    // In C++20 it became constexpr. In C++17 this function can only be
    // evaluated at runtime even though it's marked constexpr.
    // We simulate with a known Pythagorean triple to avoid std::sqrt here.
    return a * a + b * b; // returning squared for demo safety across standards
}

int main() {
    // Edge Case 1: overflow check at compile time
    constexpr int safe_result   = safe_multiply(1000, 1000);
    constexpr int overflow_check = safe_multiply(std::numeric_limits<int>::max(), 2);
    std::cout << "1000 * 1000 = " << safe_result << "\n";
    std::cout << "Overflow detected, returned: " << overflow_check << "\n";

    // Uncommenting this line would give a compile-time error, NOT silent UB:
    // constexpr int bad = std::numeric_limits<int>::max() + 1; // ERROR

    // Edge Case 2: if constexpr branch selection
    constexpr int   signed_abs   = absolute_value(-42);
    constexpr unsigned int uint_abs = absolute_value(42u);
    static_assert(signed_abs == 42,  "Signed absolute value wrong");
    static_assert(uint_abs   == 42u, "Unsigned absolute value wrong");
    std::cout << "abs(-42) = " << signed_abs << "\n";
    std::cout << "abs(42u) = " << uint_abs   << "\n";

    // Edge Case 3: constexpr variable forced to be compile-time
    // Only works because our hypotenuse() avoids non-constexpr std::sqrt
    constexpr double squared_hypotenuse = hypotenuse(3.0, 4.0);
    static_assert(squared_hypotenuse == 25.0, "3-4-5 triangle check failed");
    std::cout << "3^2 + 4^2 = " << squared_hypotenuse
              << " (hypotenuse = 5.0)\n";

    return 0;
}