Understanding & Avoiding Undefined Behavior

#include <vector>
#include <iostream>
#include <cstdint>

// 1. SIGNED INTEGER OVERFLOW
void signed_overflow() {
    int x = INT32_MAX;
    int y = x + 1;        // UB! Signed overflow is undefined
    // unsigned overflow is well-defined (wraps around)
    unsigned u = UINT32_MAX;
    unsigned v = u + 1;   // OK: v == 0 (well-defined wrap)
}

// 2. NULL POINTER DEREFERENCE
void null_deref(int* ptr) {
    int val = *ptr;       // UB if ptr is null
    if (ptr == nullptr) { // Compiler may remove this check!
        // The compiler reasons: "ptr was already dereferenced above,
        // which would be UB if null. Since UB cannot happen in a
        // correct program, ptr must be non-null. This check is dead code."
        std::cout << "null!\n";
    }
}

// 3. OUT-OF-BOUNDS ACCESS
void out_of_bounds() {
    int arr[5] = {1, 2, 3, 4, 5};
    int bad = arr[10];    // UB! No bounds checking on raw arrays
    // std::vector::operator[] is also UB if out of bounds
    // Use .at() for bounds-checked access (throws std::out_of_range)
}

// 4. USE-AFTER-FREE / DANGLING REFERENCES
int& dangling_reference() {
    int local = 42;
    return local;         // UB! Reference to destroyed local
}

// 5. DATA RACES
// int shared = 0;
// Thread 1: shared++;    // UB if concurrent with Thread 2
// Thread 2: shared++;    // UB! Data race on non-atomic variable

# AddressSanitizer (ASan) — detects:
#   - Buffer overflow (stack, heap, global)
#   - Use-after-free, use-after-return
#   - Double-free, memory leaks
g++ -fsanitize=address -fno-omit-frame-pointer -g -O1 program.cpp -o program

# UndefinedBehaviorSanitizer (UBSan) — detects:
#   - Signed integer overflow
#   - Null pointer dereference
#   - Out-of-bounds array access
#   - Misaligned memory access
#   - Type punning violations
g++ -fsanitize=undefined -fno-omit-frame-pointer -g program.cpp -o program

# ThreadSanitizer (TSan) — detects:
#   - Data races between threads
#   - Lock order inversions (potential deadlocks)
g++ -fsanitize=thread -g program.cpp -o program

# MemorySanitizer (MSan) — detects:
#   - Reads of uninitialized memory
#   (Clang-only, not available in GCC)
clang++ -fsanitize=memory -fno-omit-frame-pointer -g program.cpp -o program

# Combine ASan + UBSan (common in CI pipelines)
g++ -fsanitize=address,undefined -fno-omit-frame-pointer -g -O1 \
    -Wall -Wextra -Werror program.cpp -o program

# CMake integration
# In CMakeLists.txt:
# target_compile_options(myapp PRIVATE -fsanitize=address,undefined)
# target_link_options(myapp PRIVATE -fsanitize=address,undefined)

# Recommended warning flags for all C++ projects
g++ -std=c++23 \
    -Wall           # Enable most warnings \
    -Wextra         # Enable additional warnings \
    -Wpedantic      # Strict ISO C++ compliance \
    -Werror         # Treat warnings as errors \
    -Wconversion    # Warn on implicit narrowing conversions \
    -Wshadow        # Warn when a variable shadows another \
    -Wnon-virtual-dtor  # Warn on classes with virtual functions but non-virtual dtor \
    -Wold-style-cast    # Warn on C-style casts \
    -Wcast-align    # Warn on potentially misaligned casts \
    -Wunused        # Warn on unused variables/functions \
    -Woverloaded-virtual  # Warn when a derived class hides a base virtual function \
    -Wnull-dereference   # Warn on potential null dereferences (GCC) \
    -Wdouble-promotion   # Warn when float is implicitly promoted to double \
    -Wformat=2      # Warn on printf/scanf format string issues \
    program.cpp -o program

# For Clang, add:
#   -Weverything    # Enable ALL warnings (then selectively disable)
#   -Wno-c++98-compat  # Disable C++98 compatibility warnings