Pointers vs References Deep Dive

#include <iostream>
#include <utility>

// 1. Pointer swap requires null & self-aliasing guards
void swapByPtr(int* a, int* b) {
    if (!a || !b || a == b) return;
    int tmp = *a;
    *a = *b;
    *b = tmp;
}

// 2. Reference swap: compiler guarantees non-null binding
void swapByRef(int& a, int& b) {
    if (&a == &b) return; // Address identity check
    int tmp = a;
    a = b;
    b = tmp;
}

// 3. Pointer arithmetic & two-pointer array reversal
void reverseArray(int* begin, int* end) {
    if (!begin || !end || begin >= end) return;
    int* left = begin;
    int* right = end - 1; // STL half-open [begin, end)
    while (left < right) {
        swapByRef(*left, *right);
        ++left;
        --right;
    }
}

void inspectAddresses() {
    int x = 10;
    int& ref = x;
    int* ptr = &x;
    std::cout << "(&ref == &x): " << std::boolalpha << (&ref == &x) << '\n';
    std::cout << "(ptr == &x): " << std::boolalpha << (ptr == &x) << '\n';
    std::cout << "(*ptr == x): " << std::boolalpha << (*ptr == x) << '\n';
    std::cout << "(&ptr != &x): " << std::boolalpha << ((void*)&ptr != (void*)&x) << '\n';
}

int main() {
    std::cout << "--- Address Inspection ---\n";
    inspectAddresses();

    std::cout << "\n--- Pointer Swap ---\n";
    int a = 42, b = 99;
    std::cout << "Before swapByPtr: a=" << a << ", b=" << b << '\n';
    swapByPtr(&a, &b);
    std::cout << "After swapByPtr:  a=" << a << ", b=" << b << '\n';
    swapByPtr(&a, nullptr); // Null guard test: no-op, no crash
    std::cout << "After swapByPtr with nullptr: a=" << a << ", b=" << b << '\n';

    std::cout << "\n--- Reference Swap ---\n";
    swapByRef(a, b);
    std::cout << "After swapByRef:  a=" << a << ", b=" << b << '\n';

    std::cout << "\n--- Array Reversal via Pointer Arithmetic ---\n";
    int arr[] = {1, 2, 3, 4, 5};
    std::cout << "Before reversal: ";
    for (int v : arr) std::cout << v << ' ';
    std::cout << '\n';

    reverseArray(arr, arr + 5);

    std::cout << "After reversal:  ";
    for (int v : arr) std::cout << v << ' ';
    std::cout << '\n';

    return 0;
}

#include <cstdint>
#include <print>
#include <span>

// ============================================================================
// 1. POINTER SWAP vs REFERENCE SWAP
// Pointers can be null or identical; references are guaranteed non-null aliases.
// ============================================================================

// Pointer swap: MUST check for nullptr before dereferencing (*a), otherwise immediate UB!
void swapByPtr(int* a, int* b) noexcept {
    // Guard 1: Ignore null pointers safely
    // Guard 2: If both pointers point to the exact same address (a == b), nothing to do
    if (!a || !b || a == b) return;

    int tmp = *a; // Step 1: Read value from memory address 'a' into a temporary register
    *a = *b;      // Step 2: Overwrite memory address 'a' with the value from 'b'
    *b = tmp;     // Step 3: Overwrite memory address 'b' with the saved temporary value
}

// Reference swap: Guaranteed valid by the compiler — no null checks needed, zero overhead!
void swapByRef(int& a, int& b) noexcept {
    int tmp = a;  // Step 1: Read value from 'a' (directly compiled into registers)
    a = b;        // Step 2: Assign value of 'b' into 'a'
    b = tmp;      // Step 3: Assign saved value into 'b'
}

// ============================================================================
// 2. POINTER ARITHMETIC IN-PLACE REVERSAL
// Demonstrates that `ptr + 1` does NOT advance by 1 byte; it advances by sizeof(T)!
// ============================================================================
void reverseWithPtrs(int* begin, int* end) noexcept {
    if (!begin || !end) return;

    int* left = begin;     // Points to the very first element (index 0)
    int* right = end - 1;  // Points to the very last element (index N - 1)

    // Two-pointer loop meeting in the middle:
    while (left < right) {
        swapByRef(*left, *right); // Swap the values at the two boundary pointers
        ++left;   // Advances address forward by exactly sizeof(int) = 4 bytes!
        --right;  // Steps address backward by exactly sizeof(int) = 4 bytes!
    }
}

// ============================================================================
// 3. FUNCTION POINTER CALLBACKS
// Modern C++ passes executable code addresses using 8-byte function pointers.
// ============================================================================
using TransformFn = int (*)(int); // Type alias: pointer to a function taking int and returning int

int doubleVal(int x) { return x * 2; }
int squareVal(int x) { return x * x; }

// Applies the given transformation function to every element in the contiguous span
void applyTransform(std::span<int> data, TransformFn fn) {
    if (!fn) return; // Guard: protect against null function pointer call (prevents SIGSEGV)
    for (int& v : data) {
        v = fn(v);   // Indirect call: CPU jumps to the address of 'fn'
    }
}

int main() {
    // Test 1: Swapping via pointers vs references
    int x = 10, y = 25;
    swapByPtr(&x, &y); // Must pass explicit memory addresses using & operator
    std::println("After swapByPtr: x={}, y={}", x, y);

    swapByRef(x, y);   // Passed directly as variables; compiler treats them as aliases
    std::println("After swapByRef: x={}, y={}", x, y);

    // Test 2: Pointer distance & byte arithmetic
    int arr[] = {1, 2, 3, 4, 5};
    std::ptrdiff_t dist = (arr + 5) - arr; // Subtracting pointers yields element count (5), NOT bytes!
    std::println("Pointer distance (elements): {}, byte delta: {}",
                 dist,
                 reinterpret_cast<const char*>(arr + 5) - reinterpret_cast<const char*>(arr));

    // Test 3: Array reversal using two pointers
    reverseWithPtrs(arr, arr + 5);
    std::println("Reversed array: {} {} {} {} {}", arr[0], arr[1], arr[2], arr[3], arr[4]);

    // Test 4: Dynamic dispatch via function pointer
    applyTransform(arr, doubleVal);
    std::println("After doubleVal callback: {} {} {} {} {}", arr[0], arr[1], arr[2], arr[3], arr[4]);

    applyTransform(arr, squareVal);
    std::println("After squareVal callback: {} {} {} {} {}", arr[0], arr[1], arr[2], arr[3], arr[4]);
    return 0;
}