From C++​

#include <format>
#include <iostream>
#include <vector>

struct Vec2 {
    double x = 0.0;
    double y = 0.0;
    Vec2 operator+(const Vec2& o) const { return {x + o.x, y + o.y}; }
    Vec2 operator*(double s) const { return {x * s, y * s}; }
    Vec2& operator+=(const Vec2& o) { x += o.x; y += o.y; return *this; }
    bool operator==(const Vec2& o) const = default;
};

int main() {
    std::vector<Vec2> points = {{1.0, 2.0}, {3.0, 4.0}, {-2.0, 0.5}};
    const Vec2 velocity{0.5, -1.0};
    for (auto& p : points) { p += velocity * 2.0; }
    Vec2 first = points[0];                      // a copy
    first.x = 100.0;
    Vec2 sum;
    for (const auto& p : points) { sum = sum + p; }
    std::cout << std::format("{:.1f} {:.1f}\n", points[0].x, first.x);
    std::cout << std::format("{:.1f} {:.1f} {}\n", sum.x, sum.y, points[0] == Vec2{2.0, 0.0});
}

#include <iostream>
#include <memory>
#include <string>
#include <vector>

struct Node {
    std::string name;
    std::vector<std::shared_ptr<Node>> children;
    std::weak_ptr<Node> parent;
    explicit Node(std::string n) : name(std::move(n)) {}
    ~Node() { std::cout << "~" << name << "\n"; }
};

std::shared_ptr<Node> add_child(std::shared_ptr<Node> parent, std::string name) {
    auto child = std::make_shared<Node>(std::move(name));
    child->parent = parent;
    parent->children.push_back(child);
    return child;
}

int main() {
    std::weak_ptr<Node> watch;
    {
        auto root = std::make_shared<Node>("root");
        auto leaf = add_child(add_child(root, "branch"), "leaf");
        watch = leaf;
        std::shared_ptr<Node> up = leaf->parent.lock();
        std::cout << up->name << " " << leaf.use_count() << " " << root->children.size() << "\n";
    }
    std::cout << "expired: " << std::boolalpha << watch.expired() << "\n";
}

#include <format>
#include <iostream>
#include <memory>
#include <string>
#include <vector>

class Shape {
public:
    virtual ~Shape() = default;
    virtual std::string name() const { return "shape"; }
    virtual double area() const { return 0.0; }
    std::string describe() const { return std::format("{} {:.2f}", name(), area()); }
};
class Circle : public Shape {
public:
    explicit Circle(double r) : radius(r) {}
    std::string name() const override { return "circle"; }
    double area() const override { return 3.14159 * radius * radius; }
private:
    double radius;
};
class Rect : public Shape {
public:
    Rect(double w, double h) : width(w), height(h) {}
    double area() const override { return width * height; }
private:
    double width;
    double height;
};

int main() {
    std::vector<std::unique_ptr<Shape>> shapes;
    shapes.push_back(std::make_unique<Circle>(1.0));
    shapes.push_back(std::make_unique<Rect>(2.0, 3.5));
    double total = 0.0;
    for (const auto& s : shapes) {
        std::cout << s->describe() << "\n";
        total += s->area();
    }
    std::cout << std::format("total {:.2f}\n", total);
}

#include <functional>
#include <iostream>
#include <string>
#include <vector>

struct Button {
    std::string label;
    std::function<void(const std::string&)> on_click;
    void click() const { if (on_click) { on_click(label); } }
};

int main() {
    int clicks = 0;
    std::vector<std::string> log;
    Button ok{"ok"};
    ok.click();                                  // no handler yet
    ok.on_click = [&clicks, &log](const std::string& label) { clicks += 1; log.push_back(label); };
    ok.click();
    ok.click();

    int base = 10;
    auto add_base = [base](int v) { return v + base; };
    base = 99;                                   // the lambda keeps its copy

    auto counter = [n = 0]() mutable { n += 1; return n; };
    counter();
    auto copy = counter;                         // copies the lambda and its n
    counter();
    std::cout << clicks << " " << log.size() << " " << add_base(1) << " " << counter() << " " << copy() << "\n";
}

#include <iostream>
#include <map>
#include <stdexcept>
#include <string>

struct OutOfStock {
    std::string item;
    int wanted;
    int have;
};
struct Audit {
    std::string what;
    explicit Audit(std::string w) : what(std::move(w)) {}
    ~Audit() { std::cout << "audited " << what << "\n"; }
};

void take(std::map<std::string, int>& stock, const std::string& item, int wanted) {
    Audit audit{"take " + item};
    int& have = stock.at(item);                  // a missing key throws std::out_of_range
    if (have < wanted) { throw OutOfStock{item, wanted, have}; }
    have -= wanted;
}

int main() {
    std::map<std::string, int> stock = {{"rope", 2}, {"arrow", 20}};
    for (std::string item : {"arrow", "rope", "sword"}) {
        try {
            take(stock, item, 5);
        } catch (const OutOfStock& e) {
            std::cout << "wanted " << e.wanted << " " << e.item << ", have " << e.have << "\n";
        } catch (const std::out_of_range&) {
            std::cout << "no " << item << " at all\n";
        }
    }
    for (const auto& [item, count] : stock) { std::cout << item << "=" << count << "\n"; }
}

#include <format>
#include <iostream>
#include <memory>
#include <string>

struct Shape {
    std::string name;
    explicit Shape(std::string n) : name(std::move(n)) {}
    virtual ~Shape() = default;
    virtual double area() const { return 0.0; }
};
struct Square : Shape {
    double side;
    explicit Square(double s) : Shape("square"), side(s) {}
    double area() const override { return side * side; }
    Square operator+(const Square& o) const { return Square(side + o.side); }
};
enum class Dir { north, south = 5 };
void grow(Square& sq, double by) { sq.side += by; }
auto biggest(auto a, auto b) { return a > b ? a : b; }

int main() {
    Square sq{3.0};
    Shape& s = sq;                               // area() dispatches to Square
    std::shared_ptr<Shape> heap = std::make_shared<Square>(2.0);
    auto again = heap;                           // a second handle to one object
    grow(dynamic_cast<Square&>(*again), 3.0);
    try {
        throw (sq + sq).side;
    } catch (double e) {
        std::cout << std::format("{} {:.1f} {:.1f} {:.1f} {}\n", s.name, s.area(), heap->area(), e,
                                 biggest(std::string("ab"), std::string("b")));
    }
    Dir d = Dir::south;
    std::cout << std::format("{} {}\n", static_cast<int>(d), d == static_cast<Dir>(5));
}

#include <iostream>
#include <string>

struct Shape {
    virtual ~Shape() = default;
    virtual std::string kind() const { return "shape"; }
};
struct Circle : Shape {
    double r = 1.5;
    std::string kind() const override { return "circle"; }
};
void shout(std::string& text) { for (char& c : text) { c = static_cast<char>(std::toupper(c)); } std::cout << text << "\n"; }

int main() {
    Shape s = Circle();                              // sliced to a Shape
    int n = 0;
    auto count = [n]() mutable { n += 1; return n; };
    auto copy = count;                               // its own n
    count();
    std::string text = "a variable binds string&";   // shout("a literal") does not compile
    shout(text);
    int hits = 0;
    switch (1) {
        case 0:
        case 1: hits += 1;                           // falls through
        case 2: hits += 10;
    }
    double zero = 0.0;                               // 10 / 0 is undefined behavior
    std::cout << s.kind() << " " << copy() << " " << hits << " " << static_cast<int>(3.9) << " " << 1.0 / zero << "\n";
}

#include <iostream>

struct Node { int v = 0; Node* next = nullptr; };

int main() {
    Node* head = nullptr;
    double f = 3.9;
    int i = f;                                   // compiles; /W4 warns of a possible loss of data
    std::cout << (head == nullptr) << " " << i << "\n";
}