Fundamentals

# One file, debug build with every safety net
g++ -std=c++23 -Wall -Wextra -Wpedantic -Wconversion \
    -g -fsanitize=address,undefined main.cpp -o main
./main
 
# Optimized release build
clang++ -std=c++23 -O2 -DNDEBUG main.cpp -o main

cmake_minimum_required(VERSION 3.28)
project(app LANGUAGES CXX)
 
set(CMAKE_CXX_STANDARD 23)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)  # for clangd
 
add_executable(app src/main.cpp src/geometry.cpp)
target_compile_options(app PRIVATE -Wall -Wextra)

cmake -S . -B build -G Ninja -DCMAKE_BUILD_TYPE=Debug
cmake --build build
./build/app

#include <print>    // std::println (C++23)
#include <string>
#include <vector>
 
namespace geo {
double area(double w, double h) { return w * h; }
}  // namespace geo
 
int main(int argc, char* argv[]) {
    std::vector<std::string> args(argv, argv + argc);
    std::println("{} args, area {}", args.size(),
                 geo::area(2.0, 3.5));
    return 0;  // optional in main; 0 means success
}

#pragma once  // include guard
#include <string>
 
namespace geo {
struct Rect {
    double w{}, h{};
    double area() const;  // declared here
};
std::string describe(const Rect& r);
}  // namespace geo

#include "geometry.hpp"
#include <format>
 
namespace geo {
double Rect::area() const { return w * h; }
 
std::string describe(const Rect& r) {
    return std::format("{}x{}", r.w, r.h);
}
}  // namespace geo

#include <cstdint>
#include <limits>
 
auto a = 42;             // int
auto b = 42u;            // unsigned int
auto c = 2.0f;           // float
const auto& d = a;       // const int&: auto drops & and
                         // const, so write them yourself
std::int64_t big = std::numeric_limits<std::int32_t>::max();
big += 1;                // fine in 64 bits
 
constexpr int kSize = 16;   // compile-time constant
const int n = read_int();   // runtime value, never changes

int a;            // indeterminate: reading it is UB
int b{};          // 0  (value-initialized)
int c{7};         // brace init: refuses narrowing
int d = 7.9;      // compiles, d == 7 (silent truncation)
// int e{7.9};    // error: narrowing conversion
 
std::vector<int> v1(3, 1);  // {1, 1, 1}   size 3, value 1
std::vector<int> v2{3, 1};  // {3, 1}      initializer_list!
 
struct Point { int x{}, y{}; };
Point p{.x = 1, .y = 2};    // designated init (C++20)
 
Widget w();       // most vexing parse: declares a function
Widget w2{};      // an object

// if with an initializer (C++17): `it` is scoped to the if
if (auto it = m.find(key); it != m.end()) {
    use(it->second);
} else {
    std::println("missing {}", key);
}
 
for (int i = 0; i < n; ++i) { /* classic */ }
 
for (const auto& name : names) { /* read each */ }
for (auto& x : values) x *= 2;   // modify in place
 
for (auto [key, val] : m) { /* structured bindings */ }
 
switch (dir) {
case Dir::up:
    ++y;
    break;                 // no break → falls through
case Dir::down:
    --y;
    [[fallthrough]];       // intentional: silences warning
default:
    log();
}
 
while (running) { if (done()) break; }
do { line = read(); } while (!line.empty());

int add(int a, int b) { return a + b; }
double add(double a, double b) { return a + b; }  // overload
 
void greet(std::string_view name, bool loud = false);
 
auto square(auto x) { return x * x; }   // generic (C++20)
 
[[nodiscard]] int parse(std::string_view s);  // must use

std::vector<int> evens(int n) {
    std::vector<int> out;
    for (int i = 0; i < n; i += 2) out.push_back(i);
    return out;  // no copy
}
 
struct MinMax { int lo, hi; };
MinMax bounds(std::span<const int> xs);
auto [lo, hi] = bounds(v);  // several results: return a
                            // struct, unpack with bindings

int base = 10;
auto add_base = [base](int x) { return x + base; };  // copy
auto bump = [&base] { ++base; };                      // ref
auto by_val = [=] { return base; };  // copy all used
auto by_ref = [&] { return base; };  // reference all used
 
auto counter = [n = 0]() mutable { return ++n; };
auto owner = [p = std::move(ptr)] { return *p; };  // move in
 
std::ranges::sort(people, [](const auto& a, const auto& b) {
    return a.age < b.age;
});
 
std::function<int(int)> f = add_base;  // type-erased holder

int x = 1;
int& r = x;     // r is another name for x
r = 5;          // x == 5
 
int* p = &x;    // p holds x's address
*p = 7;         // x == 7
p = nullptr;    // p now points nowhere
 
const int* pc = &x;        // pointer to const int
int* const cp = &x;        // const pointer to int
const int* const both = &x;

int& bad_ref() { int local = 1; return local; }  // dangles
 
std::string_view bad_view() {
    std::string s = "temp";
    return s;              // view of a destroyed string
}
 
std::vector<int> v{1, 2, 3};
int& first = v[0];
v.push_back(4);            // may reallocate: `first` dangles

#include <fstream>
#include <memory>
#include <mutex>
 
void save(const std::string& path, std::string_view text) {
    std::ofstream out(path);   // opens
    out << text;
}                              // closes, even on exception
 
std::mutex m;
void critical() {
    std::scoped_lock lock(m);  // locks
    // ...
}                              // unlocks

struct Node {
    int value{};
    std::unique_ptr<Node> next;  // owns the rest of the list
};
 
auto head = std::make_unique<Node>(1);
head->next = std::make_unique<Node>(2);
auto moved = std::move(head);    // head is now nullptr
 
auto cfg = std::make_shared<Config>();
std::weak_ptr<Config> watch = cfg;
if (auto c = watch.lock()) use(*c);  // still alive?

class Account {
public:
    explicit Account(std::string owner, long cents = 0)
        : owner_{std::move(owner)}, cents_{cents} {}
 
    void deposit(long c) {
        if (c <= 0) throw std::invalid_argument("amount");
        cents_ += c;
    }
    long balance() const { return cents_; }  // read-only
    const std::string& owner() const { return owner_; }
 
    bool operator==(const Account&) const = default;
    auto operator<=>(const Account&) const = default;
 
private:
    std::string owner_;
    long cents_{};
    static inline int count_ = 0;  // one per class
};
 
Account a{"ada", 500};
// Account b = "bob";  // error: constructor is explicit

class Shape {
public:
    virtual ~Shape() = default;       // required: see below
    virtual double area() const = 0;  // pure virtual
};
 
class Circle final : public Shape {
public:
    explicit Circle(double r) : r_{r} {}
    double area() const override {
        return 3.14159 * r_ * r_;
    }
private:
    double r_;
};
 
std::vector<std::unique_ptr<Shape>> shapes;
shapes.push_back(std::make_unique<Circle>(2.0));
for (const auto& s : shapes) std::println("{}", s->area());

std::string a = "a long string that is heap allocated";
std::string b = a;             // copy: a is untouched
std::string c = std::move(a);  // move: a is now empty-ish
a = "reuse";                   // OK: assign before reuse
 
std::vector<std::string> names;
std::string n = read_name();
names.push_back(std::move(n));  // no copy of the buffer
names.emplace_back("built in place");
 
auto p = std::make_unique<int>(1);
// auto q = p;              // error: unique_ptr can't copy
auto q = std::move(p);      // ownership transferred

#include <concepts>
 
template <typename T>
T max_of(T a, T b) { return a < b ? b : a; }
 
max_of(3, 7);          // T = int
max_of<double>(3, 7.5);
 
template <typename T, std::size_t N>
struct FixedStack {
    std::array<T, N> items{};
    std::size_t size = 0;
    void push(const T& x) { items.at(size++) = x; }
};
FixedStack<int, 8> s;
 
// Concepts (C++20) constrain T and give readable errors
template <std::integral T>
T gcd(T a, T b) { return b == 0 ? a : gcd(b, a % b); }
 
template <typename T>
concept Shape = requires(const T& s) {
    { s.area() } -> std::convertible_to<double>;
};
 
template <std::ranges::range R>
    requires Shape<std::ranges::range_value_t<R>>
double total(const R& shapes);
 
void log_all(const auto&... args) {   // variadic
    (std::print("{} ", args), ...);    // fold expression
}

#include <map>
#include <optional>
#include <print>
#include <unordered_map>
#include <vector>
 
std::vector<int> v{5, 3, 8};
v.push_back(1);
v.size();          // 4 (std::size_t)
v[0];              // unchecked: out of range is UB
v.at(10);          // throws std::out_of_range
v.reserve(100);    // pre-allocate capacity
std::erase_if(v, [](int x) { return x > 4; });  // C++20
 
std::unordered_map<std::string, int> ages{{"ada", 36}};
ages["bob"] = 41;          // [] inserts if missing!
if (ages.contains("ada")) { /* C++20 */ }
if (auto it = ages.find("eve"); it != ages.end())
    std::println("{}", it->second);
 
std::map<std::string, int> sorted(ages.begin(), ages.end());
for (const auto& [name, age] : sorted)
    std::println("{:<6}{:>4}", name, age);
 
std::optional<int> find_id(std::string_view name);
if (auto id = find_id("ada")) std::println("{}", *id);
int id = find_id("x").value_or(-1);

#include <algorithm>
#include <numeric>
#include <ranges>
 
namespace rv = std::views;
 
std::ranges::sort(v);                    // ascending
std::ranges::sort(v, std::greater{});    // descending
auto it = std::ranges::find(v, 8);
bool neg = std::ranges::any_of(v, [](int x) {
    return x < 0;
});
int sum = std::accumulate(v.begin(), v.end(), 0);
auto [lo, hi] = std::ranges::minmax(v);
 
auto squares = v
    | rv::filter([](int x) { return x % 2 == 0; })
    | rv::transform([](int x) { return x * x; })
    | std::ranges::to<std::vector>();    // C++23
 
for (auto [i, x] : rv::enumerate(v))     // C++23
    std::println("{}: {}", i, x);
for (int i : rv::iota(0, 5)) { /* 0..4 */ }

#include <expected>
#include <stdexcept>
 
double safe_div(double a, double b) {
    if (b == 0) throw std::domain_error("divide by zero");
    return a / b;
}
 
try {
    safe_div(1, 0);
} catch (const std::domain_error& e) {   // catch by const&
    std::println("math: {}", e.what());
} catch (const std::exception& e) {      // base class
    std::println("other: {}", e.what());
}
 
enum class ParseErr { empty, bad_digit };
 
std::expected<int, ParseErr> to_int(std::string_view s) {
    if (s.empty()) return std::unexpected(ParseErr::empty);
    int n = 0;
    for (char c : s) {
        if (c < '0' || c > '9')
            return std::unexpected(ParseErr::bad_digit);
        n = n * 10 + (c - '0');  // (no overflow check)
    }
    return n;
}
 
if (auto r = to_int("42")) std::println("{}", *r);
else if (r.error() == ParseErr::empty) { /* ... */ }

#include <atomic>
#include <mutex>
#include <thread>
 
std::atomic<int> hits{0};
std::mutex m;
std::vector<int> shared;
 
{
    std::jthread t1([&] { hits++; });  // joins on scope exit
    std::jthread t2([&] {
        std::scoped_lock lock(m);
        shared.push_back(1);
    });
}  // both threads joined here

#include <fstream>
#include <stdexcept>
#include <string>
#include <vector>
 
std::vector<std::string> read_lines(const std::string& p) {
    std::ifstream in(p);
    if (!in) throw std::runtime_error("cannot open " + p);
    std::vector<std::string> lines;
    for (std::string line; std::getline(in, line);)
        lines.push_back(std::move(line));
    return lines;
}

#include <ranges>
#include <string_view>
 
std::vector<std::string_view> split(std::string_view s,
                                    char sep) {
    std::vector<std::string_view> out;
    for (auto part : s | std::views::split(sep))
        out.emplace_back(part.begin(), part.end());
    return out;  // views into `s`: keep `s` alive
}

#include <charconv>
#include <optional>
 
std::optional<int> parse_int(std::string_view s) {
    int value{};
    const char* end = s.data() + s.size();
    auto [ptr, ec] = std::from_chars(s.data(), end, value);
    if (ec != std::errc{} || ptr != end)
        return std::nullopt;
    return value;
}

std::unordered_map<std::string, int> counts;
for (std::string w; std::cin >> w;) ++counts[w];
 
std::vector<std::pair<std::string, int>> top(
    counts.begin(), counts.end());
auto k = std::min<std::size_t>(5, top.size());
std::ranges::partial_sort(top, top.begin() + k,
    [](const auto& a, const auto& b) {
        return a.second > b.second;
    });
for (auto& [w, n] : top | std::views::take(k))
    std::println("{:>5} {}", n, w);

#include <variant>
 
template <class... Fs> struct overloaded : Fs... {
    using Fs::operator()...;
};
 
using Json = std::variant<std::nullptr_t, bool, double,
                          std::string>;
 
std::string show(const Json& j) {
    return std::visit(overloaded{
        [](std::nullptr_t) { return std::string{"null"}; },
        [](bool b) -> std::string {
            return b ? "true" : "false";
        },
        [](double d) { return std::format("{}", d); },
        [](const std::string& s) { return '"' + s + '"'; },
    }, j);
}

#include <chrono>
 
auto t0 = std::chrono::steady_clock::now();
run_work();
auto dt = std::chrono::steady_clock::now() - t0;
std::println("{}", std::chrono::duration_cast<
    std::chrono::milliseconds>(dt));   // e.g. "12ms"

#include <random>
 
std::mt19937 rng{std::random_device{}()};
std::uniform_int_distribution<int> die{1, 6};
std::normal_distribution<double> noise{0.0, 1.0};
int roll = die(rng);
double eps = noise(rng);

#include <cstdio>
#include <memory>
 
struct FileCloser {
    void operator()(std::FILE* f) const { std::fclose(f); }
};
using File = std::unique_ptr<std::FILE, FileCloser>;
 
File open_file(const char* path, const char* mode) {
    return File{std::fopen(path, mode)};  // null on error
}