PPrrooggrraamm SSttrruuccttuurree

// One Definition Rule: each entity defined EXACTLY once
// across the entire program (with exceptions).

// ❌ VIOLATION — variable definition in a shared header
// header.h:
int counter = 0;   // two TUs include → duplicate symbol

// ✅ FIX 1: constexpr (implies inline since C++17)
constexpr int MAX = 100;   // no ODR violation in headers

// ✅ FIX 2: inline variable (C++17)
inline int counter = 0;    // single logical def, safe in headers

// ✅ FIX 3: extern + one definition
// header.h:  extern int counter;
// one .cpp:  int counter = 0;

// ODR-use: "using" a variable in a context that requires its address
constexpr int N = 5;
int arr[N];   // NOT ODR-used (value only, no address needed)
const int* p = &N;  // ODR-used → a definition of N is required

// Functions: templates and inline functions may be defined
// in multiple TUs, but all definitions must be IDENTICAL.

// ── C++17: inline static data members ──────────────────
// Pre-C++17: out-of-line definition required in exactly one .cpp

// ❌ Pre-C++17 — definition must live in impl.cpp
struct Config {
  static int counter;           // declaration in header
};
// impl.cpp: int Config::counter = 0;   (required)

// ✅ C++17 — definition lives in the header
struct Config {
  inline static int counter  = 0;           // definition
  static inline constexpr int MAX = 256;    // common idiom
  inline static const std::string name = "cfg";
};

// Namespace scope (header-only libraries)
inline int g_requestCount = 0;   // ODR-safe across TUs

// constexpr variables are IMPLICITLY inline since C++17
constexpr double TAU = 6.28318530718;  // safe in any header

// Important: inline means "may appear in multiple TUs" —
// it does NOT mean "always inlined by the optimizer".

#include <type_traits>

template<typename T>
std::string describe(T val) {
  if constexpr (std::is_integral_v<T>) {
    // Only compiled when T is an integer type
    return "int:" + std::to_string(val);
  } else if constexpr (std::is_floating_point_v<T>) {
    return "float:" + std::to_string(val);
  } else if constexpr (std::is_same_v<T, std::string>) {
    return "str:" + val;
  } else {
    // Parsed but NOT instantiated — static_assert OK here
    static_assert(always_false<T>, "Unsupported type");
  }
}

// Helper to defer static_assert evaluation
template<typename> inline constexpr bool always_false = false;

// ── Why it matters ──────────────────────────────────────
// Regular if: BOTH branches compile for every T (often fails)
// if constexpr: only the matching branch is instantiated

// std::is_integral_v<T> is shorthand for
// std::is_integral<T>::value   (C++17 variable template)

// Structured bindings (C++17) decompose any aggregate/tuple-like

// std::pair and std::tuple
auto [key, val] = std::make_pair("pi", 3.14159);
auto [x, y, z]  = std::make_tuple(1, 2.0f, "hi");

// Aggregate struct (binds in declaration order)
struct Pixel { uint8_t r, g, b, a; };
auto [r, g, b, a] = Pixel{255, 128, 0, 255};

// C-style array
int rgb[3] = {255, 0, 128};
auto& [red, green, blue] = rgb;   // & → modifies original

// Map iteration — most common real-world use
std::map<std::string, int> freq;
for (auto& [word, count] : freq) {
  count++;   // modifies map in-place
}

// const binding (both bindings are const)
const auto [lo, hi] = std::make_pair(0, 100);

// Bindings to bit-fields NOT allowed (can't take address)
// Customization: implement get<N>(), tuple_size, tuple_element

// Static Initialization Order Fiasco (SIOF):
// Globals in different TUs may initialize in any order.

// file a.cpp
int Registry::count = 0;          // initialized… when?

// file b.cpp (may run before a.cpp)
extern int Registry::count;
int Derived::extra = Registry::count + 1;  // ⚠ possibly 0

// ── Solution 1: Meyers Singleton (function-local static) ──
int& getCount() {
  static int count = 0;   // initialized on first call (C++11: thread-safe)
  return count;
}
int& getRegistry() {
  static Registry r;  // r init guaranteed before first use
  return r;
}

// ── Solution 2: constexpr globals (zero-init phase) ───
constexpr int MAX_THREADS = 16;  // constant initialization — before any
                                  // dynamic init, safe everywhere

// ── Solution 3: constinit (C++20) ─────────────────────
// constinit int limit = computeLimit();  // error if not constexpr

// All valid main() signatures per ISO C++
int main() {}
int main(int argc, char*  argv[]) {}
int main(int argc, char** argv)   {}   // equivalent

// argc — count of arguments INCLUDING program name (≥1)
// argv[0] — program name/path (implementation-defined)
// argv[argc] == nullptr  (guaranteed by the standard)
// argv[1..argc-1] — command-line arguments

// Return value
#include <cstdlib>
return EXIT_SUCCESS;   // expands to 0
return EXIT_FAILURE;   // expands to 1 (non-zero)
return 42;             // any non-zero = failure by convention

// Implicit return 0 (C++11, ONLY for main)
int main() { }    // well-defined: equivalent to return 0;

// Cleanup hooks
std::atexit([]{ flushLogs(); });      // runs on normal exit
std::at_quick_exit([]{ /* ... */ });  // runs on std::quick_exit()

// Environment (implementation-defined)
#include <cstdlib>
if (const char* p = std::getenv("HOME")) { /* use p */ }

#include <cstddef>   // std::byte

// std::byte: opaque representation of a raw byte
// NO arithmetic — only bitwise operations defined
std::byte b{0xFF};
std::byte mask{0x0F};

std::byte r1 = b & mask;      // AND  → 0x0F
std::byte r2 = b | mask;      // OR   → 0xFF
std::byte r3 = b ^ mask;      // XOR  → 0xF0
std::byte r4 = ~b;            // NOT  → 0x00
std::byte r5 = b << 2;        // left shift
std::byte r6 = b >> 1;        // right shift

// Explicit conversions required
int val = std::to_integer<int>(b);   // → 255
std::byte c = static_cast<std::byte>(42);

// Why not char or uint8_t?
// char:    may be signed; aliasing rules differ
// uint8_t: arithmetic operators defined — accidents compile silently
//   e.g., uint8_t x = 200; x + 100 overflows silently
// std::byte: b + 1 is a COMPILE ERROR → bugs surface early