const Correctness & Type Qualifiers

#include <cstddef>
#include <iostream>
#include <stdexcept>

class ConstBuffer {
    int data_[4]{10, 20, 30, 40};
    std::size_t size_{4};

public:
    ConstBuffer() noexcept = default;

    // 1. Const accessor: called on const instances (read-only view)
    const int& operator[](std::size_t idx) const {
        if (idx >= size_) throw std::out_of_range("Index out of bounds");
        return data_[idx];
    }

    // 2. Non-const accessor: called on mutable instances
    int& operator[](std::size_t idx) {
        if (idx >= size_) throw std::out_of_range("Index out of bounds");
        return data_[idx];
    }

    // 3. Const member function: 'this' is 'const ConstBuffer* const'
    std::size_t size() const noexcept {
        return size_;
    }
};

void demoConstPointerMechanics() {
    int val = 100, other = 200;
    // Pointer to const data: data locked, pointer can advance
    const int* pData = &val;
    // *pData = 105; // COMPILE ERROR: read-only location
    pData = &other;  // OK: address can change
    std::cout << "pData points to other: " << *pData << '\n';

    // Const pointer to mutable data: address locked, data mutable
    int* const pAddr = &val;
    *pAddr = 105;    // OK: data mutates
    // pAddr = &other; // COMPILE ERROR: pointer is const
    std::cout << "pAddr points to mutated val: " << *pAddr << '\n';
}

int main() {
    std::cout << "--- Const Pointer Mechanics ---\n";
    demoConstPointerMechanics();

    std::cout << "\n--- Mutable ConstBuffer Access ---\n";
    ConstBuffer buf;
    std::cout << "Initial buf[1]: " << buf[1] << '\n';
    buf[1] = 99; // Invokes non-const operator[]
    std::cout << "Mutated buf[1]: " << buf[1] << '\n';

    std::cout << "\n--- Read-Only (Const) ConstBuffer Access ---\n";
    const ConstBuffer& cbuf = buf;
    std::cout << "cbuf.size(): " << cbuf.size() << '\n';
    std::cout << "cbuf[1]: " << cbuf[1] << '\n'; // Invokes const operator[]

    try {
        std::cout << "Accessing cbuf[10]: ";
        std::cout << cbuf[10] << '\n';
    } catch (const std::out_of_range& e) {
        std::cout << "Caught expected exception: " << e.what() << '\n';
    }

    return 0;
}

#include <array>
#include <cstddef>
#include <numeric>
#include <optional>
#include <print>

// ============================================================================
// 1. LOGICAL CONSTNESS & THE 'mutable' KEYWORD
// Bitwise constness (bitwise identical bits in RAM) vs. Logical constness
// (the object appears immutable to callers, but updates internal caches/metrics).
// ============================================================================

class ConstAwareBuffer {
    // Underlying storage holding 5 integer elements (20 bytes contiguous)
    std::array<int, 5> data_{};

    // 'mutable' members: allowed to be modified inside 'const' member functions!
    // Hardware / compiler mechanic: 'this' pointer is 'const ConstAwareBuffer*',
    // but the compiler omits the read-only check for members flagged 'mutable'.
    mutable std::size_t readCount_{0};                  // Metric counter for profiling
    mutable std::optional<int> cachedChecksum_{std::nullopt}; // Lazy-evaluated memoized cache

public:
    // Step 1: Explicit constructor prevents unexpected implicit conversions
    constexpr explicit ConstAwareBuffer(std::array<int, 5> init) noexcept : data_(init) {}

    // Step 2: Non-const operator[] — allows in-place mutation of elements.
    // Invariant: any mutation MUST invalidate our cached checksum!
    int& operator[](std::size_t idx) noexcept {
        cachedChecksum_.reset(); // Reset cache: old sum is now stale
        return data_[idx];       // Return mutable lvalue reference
    }

    // Step 3: Const operator[] — read-only view for const references.
    // Increments readCount_ (legal because readCount_ is mutable).
    const int& operator[](std::size_t idx) const noexcept {
        ++readCount_;            // Thread metrics / audit logging without violating const contract
        return data_[idx];       // Return read-only reference
    }

    // Step 4: Const member function with lazy evaluation (Logical Constness).
    // Computes sum only once on first access, then returns cached value on future calls.
    int getChecksum() const noexcept {
        if (!cachedChecksum_.has_value()) {
            // Expensive calculation deferred until actually requested (lazy evaluation)
            cachedChecksum_ = std::accumulate(data_.begin(), data_.end(), 0);
        }
        return *cachedChecksum_;
    }

    [[nodiscard]] std::size_t getReadCount() const noexcept { return readCount_; }
    [[nodiscard]] std::size_t size() const noexcept { return data_.size(); }
};

// ============================================================================
// 2. CONSTEXPR COMPILE-TIME EVALUATION
// Guarantees zero runtime execution cost: values computed during compilation.
// ============================================================================

// Compile-time lookup table helper: runs at compile time if arguments are constant expressions
constexpr int compileTimeLookup(int idx) noexcept {
    constexpr std::array<int, 5> table = {10, 20, 30, 40, 50};
    return table[idx]; // Zero memory load at runtime; compiled into immediate CPU instruction
}

constexpr int precomputedSquare(int val) noexcept {
    return val * val;
}

int main() {
    // ========================================================================
    // Part 1: Pointer Constness Variations (Clockwise / Spiral / East-Const rule)
    // Read from right to left:
    // const int*       -> pointer to CONST data (pointer can move, data cannot change)
    // int* const       -> CONST pointer to mutable data (pointer is frozen, data can change)
    // const int* const -> CONST pointer to CONST data (everything frozen)
    // ========================================================================
    int a = 10;
    int b = 20;

    // Case A: Pointer to const data
    const int* ptrToConst = &a; // Target is read-only through this pointer
    ptrToConst = &b;             // Rebinding pointer to a different address is LEGAL

    // Case B: Const pointer to mutable data
    int* const constPtr = &a;   // Address stored in pointer is FROZEN at initialization
    *constPtr = 15;             // Mutating target value is LEGAL (changes 'a' to 15)

    // Case C: Const pointer to const data (fully immutable)
    const int* const constPtrToConst = &a;

    std::println("Pointer constness: a={}, *ptrToConst={}, *constPtr={}, *constPtrToConst={}",
                 a, *ptrToConst, *constPtr, *constPtrToConst);

    // ========================================================================
    // Part 2: Logical Constness in Action with ConstAwareBuffer
    // ========================================================================
    ConstAwareBuffer buf({1, 2, 3, 4, 5});
    buf[0] = 10; // Calls non-const operator[], invalidating cache
    std::println("Mutated non-const buf[0]={}", buf[0]);

    // Bind to const reference: only 'const' member functions are now callable
    const ConstAwareBuffer& constRef = buf;
    std::println("Read via constRef: [0]={}, [1]={}", constRef[0], constRef[1]);
    std::println("Read count through constRef={}", constRef.getReadCount());

    // First call calculates and stores in mutable cachedChecksum_
    std::println("Computed checksum={}", constRef.getChecksum());
    // Second call hits cached optional instantly (0 CPU addition instructions)
    std::println("Cached checksum (2nd call)={}", constRef.getChecksum());

    // ========================================================================
    // Part 3: Compile-Time Verification via static_assert
    // ========================================================================
    constexpr int valAt2 = compileTimeLookup(2);
    static_assert(valAt2 == 30, "Compile-time lookup failed");

    constexpr int sq = precomputedSquare(6);
    static_assert(sq == 36, "Compile-time square failed");

    std::println("constexpr results: valAt2={}, sq={}", valAt2, sq);
    return 0;
}