Mind palace

class Point {
public:
    constexpr Point(double x = 0, double y = 0) noexcept : x(x), y(y) {}

    constexpr double xValue() const noexcept { return x; }
    constexpr double yValue() const noexcept { return y; }

    constexpr void setX(double newX) noexcept { x = newX; }
    constexpr void setY(double newY) noexcept { y = newY; }

private:
    double x, y;
};

constexpr Point midpoint(const Point& p1, const Point& p2) noexcept {
    return {(p1.xValue() + p2.xValue()) / 2, (p1.yValue() + p2.yValue()) / 2};
}

constexpr Point reflection(const Point& p) noexcept {
    Point res;
    res.setX(-p.xValue());
    res.setY(-p.yValue());
    return res;
}

constexpr Point p1(9.4, 27.7);
constexpr Point p2(28.8, 5.3);
constexpr auto mid = midpoint(p1, p2);

constexpr auto reflectedMid = reflection(mid);

template<typename T>
void f(T&& param);

int x = 27;
const int cx = x;
const int& rx = x;
f(x); // x is lvalue, so T is int&, param's type is also int&
f(cx); // cx is lvalue, so T is const int&, param's type is also const int&
f(rx); // rx is lvalue, so T is const int&, param's type is also const int&
f(27); // 27 is rvalue, so T is int, param's type is therefore int&&

struct A {
    int &m;
    A(int &x) : m(x) {}
};

int main() {
    int x = 5;
    A a(x);
    cout << a.m << endl; // 5
    x = 6;
    cout << a.m << endl; // 6
    a.m = 7;
    cout << x << endl; // 7
    return 0;
}

class thread_guard {
public:
    explicit thread_guard(thread &t) : _t(t) {}
    ~thread_guard() {
        if (_t.joinable()) {
            _t.join();
        }
    }
    thread_guard(const thread_guard &) = delete;
    thread_guard &operator=(const thread_guard &) = delete;

private:
    thread &_t;
};

int main() {
    for (int i = 0; i < 10; ++i) {
        thread t{[](int x) { cout << x << endl; }, i};
        thread_guard tg{t};
    }
    return 0;
}

#include <iostream>
#include <thread>
#include <chrono>

using namespace std;
using namespace std::chrono;

struct A {
    A() { cout << "A::A()" << endl; }
    ~A() { cout << "A::~A() " << endl; }
};

void child() {
    A a;
    cout << "child" << endl;
    this_thread::sleep_for(chrono::seconds(3));
}

void parent() {
    cout << "parent" << endl;
    thread t{child};
    t.detach();
//    this_thread::sleep_for(chrono::seconds(1));
}

int main() {
    parent();
    cout << "main" << endl;
//    this_thread::sleep_for(chrono::seconds(5));
    return 0;
}