Basics

#include <iostream>   // include standard library header
#include <string>
#include <vector>

int main() {          // entry point; returns int to OS
    std::cout << "Hello, World!\n";
    return 0;         // 0 = success; omittable in main
}

#include <cstdint>
int8_t  a = -128;
uint8_t b = 255;
int16_t c;  int32_t d;  int64_t e;
uint16_t f; uint32_t g; uint64_t h;

int x;            // declared, indeterminate (don't read before writing)
int y = 10;       // copy-initialization
int z(10);        // direct-initialization
int w{10};        // brace (uniform) initialization — preferred (prevents narrowing)
int a{};          // zero-initialized: a == 0
double pi{3.14159};

auto n = 42;      // type deduced: int
auto d = 3.14;    // double
auto s = std::string{"hello"};

const int MAX = 100;        // runtime constant, must be initialized
constexpr int SZ = 1 << 10; // compile-time constant

// Integer
42        // int
42u       // unsigned int
42l       // long
42ll      // long long
42ull     // unsigned long long
0xFF      // hex: 255
0b1010    // binary (C++14): 10
0777      // octal: 511
1'000'000 // digit separators (C++14)

// Floating-point
3.14      // double
3.14f     // float
3.14l     // long double
1e6       // 1000000.0 (double)

// Character
'A'       // char
L'A'      // wchar_t
u8'A'     // char8_t since C++20 (was char in C++17)
u'A'      // char16_t
U'A'      // char32_t

// String
"hello"         // const char[]
L"hello"        // const wchar_t[]
u8"hello"       // UTF-8 literal (const char8_t[] since C++20)
R"(raw\nstring)" // raw string literal — backslash is literal

// Implicit (widening is safe, narrowing may warn/truncate)
int i = 3;
double d = i;    // int → double: fine
int j = 3.9;     // double → int: truncates to 3 (narrowing, no brace-init)

// Explicit casts
double x = 3.7;
int a = static_cast<int>(x);         // preferred C++ cast: 3
char c = static_cast<char>(65);      // 'A'

// Dangerous casts (avoid unless necessary)
int* p = reinterpret_cast<int*>(some_ptr);  // bit-level reinterpretation
const int ci = 5;
int* mp = const_cast<int*>(&ci);            // removes const (UB to write)

// C-style cast (avoid — does not distinguish intent)
int b = (int)x;

int global = 1;          // namespace scope, static storage, external linkage

static int file_only = 2; // internal linkage (visible only in this TU)

void f() {
    int local = 3;       // block scope, automatic storage
    static int count = 0; // local static: persists across calls, init once
    ++count;
}

namespace MyNS {
    int val = 10;        // accessed as MyNS::val
}

extern int other;        // declaration only — defined elsewhere

auto x = 42;             // int
auto& r = x;             // int&
const auto cx = x;       // const int

decltype(x) y = 0;       // y is int (same type as x)
decltype(x + 0.0) z;     // z is double

// Type aliases
using Vec = std::vector<int>;     // preferred (C++11)
typedef std::vector<int> Vec2;    // old style

template<typename T>
using Pair = std::pair<T, T>;     // alias template

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

#define PI 3.14159        // macro constant (prefer constexpr)
#define SQ(x) ((x)*(x))  // macro function (prefer inline or template)
#undef PI

#ifdef NDEBUG             // if macro is defined
#endif
#ifndef GUARD_H           // header guard pattern
#define GUARD_H
// ... header contents ...
#endif

#pragma once              // non-standard but universally supported header guard

#if defined(__cplusplus) && __cplusplus >= 201703L
// C++17 or later
#endif

namespace Geom {
    struct Point { double x, y; };
    double dist(Point a, Point b);
}

// Definition outside namespace
double Geom::dist(Geom::Point a, Geom::Point b) { /* ... */ }

// Using declarations
using Geom::Point;         // bring one name in
using namespace Geom;      // bring all in (avoid in headers)

// Anonymous namespace — internal linkage (replaces file-static)
namespace {
    void helper() {}
}

// Inline namespace (C++11) — members visible in enclosing namespace
namespace Lib {
    inline namespace v2 { struct Widget {}; }
}
Lib::Widget w;   // works