#include <cstdint>

int8_t   x1;  // exactly 8 bits, signed
uint8_t  x2;  // exactly 8 bits, unsigned
int16_t  x3;  // exactly 16 bits
int32_t  x4;  // exactly 32 bits
int64_t  x5;  // exactly 64 bits
size_t   x6;  // unsigned, for sizes/indices (platform word-size)

int a;          // default — UNINITIALIZED for built-in types (garbage value!)
int b = 5;      // copy initialization
int c(5);       // direct initialization
int d{5};       // brace/uniform initialization (PREFERRED ✓)

auto x = 42;           // int
auto y = 3.14;         // double
auto s = std::string("hello");  // std::string
auto& ref = x;         // int& (reference)
const auto& cref = x;  // const int&

// Especially useful with complex types
auto it = myMap.begin();  // instead of std::map<std::string, int>::iterator

// if-else
if (x > 0) {
    // positive
} else if (x < 0) {
    // negative
} else {
    // zero
}

// C++17: if with initializer (limits scope of variable)
if (auto it = m.find(key); it != m.end()) {
    // use it->second — 'it' only exists in this scope
}

// switch
switch (day) {
    case 1: std::cout << "Monday"; break;
    case 2: std::cout << "Tuesday"; break;
    default: std::cout << "Other"; break;
}

// Ternary
int abs_val = (x >= 0) ? x : -x;

// for loop
for (int i = 0; i < n; ++i) {
    // prefer ++i over i++ for non-primitive types (avoids temporary copy)
}

// range-based for (C++11) — PREFERRED for iterating containers
std::vector<int> v = {1, 2, 3, 4, 5};
for (int x : v) { /* copy of each element */ }
for (int& x : v) { /* reference — can modify */ }
for (const int& x : v) { /* const ref — no copy, no modify */ }
for (const auto& x : v) { /* even better — type deduced */ }

// while
while (condition) { /* ... */ }

// do-while (executes at least once)
do { /* ... */ } while (condition);

// Declaration (prototype) — tells the compiler the function exists
int add(int a, int b);

// Definition — provides the implementation
int add(int a, int b) {
    return a + b;
}

// Default arguments
void print(const std::string& msg, int times = 1) {
    for (int i = 0; i < times; ++i)
        std::cout << msg << "\n";
}

void byValue(int x);              // copies x — fine for small types
void byRef(int& x);               // modifies original
void byConstRef(const int& x);    // reads original, no copy, no modify
void byPointer(int* x);           // passes address

int    max(int a, int b)       { return (a > b) ? a : b; }
double max(double a, double b) { return (a > b) ? a : b; }
// Compiler chooses the correct version based on argument types at compile time

inline int square(int x) { return x * x; }
// Hint to compiler: substitute the function body at the call site
// Modern compilers inline automatically — use for short functions in headers

int arr[5] = {1, 2, 3, 4, 5};
int matrix[3][4] = {};             // zero-initialized

// PROBLEM: arrays decay to pointers when passed to functions
void func(int arr[]) {
    sizeof(arr);  // gives pointer size (8 bytes), NOT array size!
}

#include <array>
std::array<int, 5> arr = {1, 2, 3, 4, 5};
arr.size();    // 5 — knows its own size!
arr.at(2);     // bounds-checked access (throws on out-of-range)
arr[2];        // unchecked (faster, but no safety)

#include <string>
std::string s = "Hello";
s += " World";                  // concatenation
s.size();                       // 11
s.substr(0, 5);                 // "Hello"
s.find("World");                // 6
s.empty();                      // false

// String ↔ number conversions
int n = std::stoi("42");
double d = std::stod("3.14");
std::string ns = std::to_string(42);

#include <iostream>

// Output — prefer "\n" over std::endl (endl flushes the buffer = slow)
std::cout << "Value: " << x << "\n";

// Input
int n;
std::cin >> n;

// Read entire line (including spaces)
std::string line;
std::getline(std::cin, line);

// Fast I/O (essential for competitive programming)
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);

#include <iomanip>
std::cout << std::fixed << std::setprecision(2) << 3.14159;  // "3.14"
std::cout << std::setw(10) << std::right << 42;               // "        42"
std::cout << std::hex << 255;                                  // "ff"

// C++20: std::format (printf-like, type-safe)
#include <format>
std::cout << std::format("Hello {}, you are {} years old\n", name, age);

// Old-style enum (avoid — pollutes namespace, implicit int conversion)
enum Color { RED, GREEN, BLUE };

// Scoped enum (C++11) — PREFERRED
enum class Direction : uint8_t {
    North, South, East, West
};
Direction d = Direction::North;
// int x = d;  // ERROR — no implicit conversion (type-safe!) ✓
int x = static_cast<int>(d);  // explicit conversion if needed

struct Point {
    double x;
    double y;
    
    double distance_to(const Point& other) const {
        double dx = x - other.x;
        double dy = y - other.y;
        return std::sqrt(dx * dx + dy * dy);
    }
};

Point p1{3.0, 4.0};                // aggregate initialization
Point p2{.x = 1.0, .y = 2.0};     // C++20 designated initializers
auto [px, py] = p1;                // C++17 structured bindings → px=3.0, py=4.0

#include <header>       // system header
#include "myheader.h"   // local header

#define PI 3.14159      // macro constant (prefer constexpr instead)
#define MAX(a,b) ((a)>(b)?(a):(b))  // macro function (prefer inline/template)

// Header guards — prevent double inclusion
#ifndef MY_HEADER_H
#define MY_HEADER_H
// ... declarations ...
#endif

// Or simply (widely supported, not technically standard):
#pragma once

// Conditional compilation
#ifdef DEBUG
    std::cout << "Debug mode\n";
#endif