C++: Smart Pointers, STL, Concurrency Reference Guide

# Compilers
brew install llvm                       # clang++ (macOS)
sudo apt install g++ clang              # Linux
# Windows: use MSVC via Visual Studio, or w64-mingw / clang via winget

# Build systems
brew install cmake ninja                # the modern default
brew install meson                      # alternative
brew install vcpkg                      # Microsoft's dep manager

# Compile a single file
g++ -std=c++23 -O2 -Wall -Wextra main.cpp -o app

# CMake skeleton
mkdir build && cd build
cmake -G Ninja -DCMAKE_BUILD_TYPE=Release ..
ninja
./myapp

# Daily commands
ctest --output-on-failure               # run tests via CMake
clang-format -i src/*.cpp               # format
clang-tidy src/*.cpp                    # lint
valgrind ./app                          # leak check (Linux)
asan: g++ -fsanitize=address,undefined  # Address + UB sanitizers

#include 
#include 
#include 
#include 

struct Connection {
    std::string url;
    Connection(std::string u) : url(std::move(u)) { std::cout << "open " << url << "\n"; }
    ~Connection()                                  { std::cout << "close " << url << "\n"; }
};

// unique_ptr — sole owner, transferred via std::move
std::unique_ptr open_db(const std::string& url) {
    return std::make_unique(url);
}

// Pass by raw pointer/reference when ownership isn't shared
void ping(Connection& c) { std::cout << "ping " << c.url << "\n"; }

int main() {
    auto db = open_db("postgres://localhost");
    ping(*db);                                     // borrow

    // shared_ptr — reference-counted shared ownership
    std::shared_ptr a = std::make_shared("redis://x");
    std::shared_ptr b = a;             // use_count == 2
    std::cout << "uses: " << a.use_count() << "\n";

    // weak_ptr — non-owning observer, breaks cycles
    std::weak_ptr w = a;
    if (auto live = w.lock()) ping(*live);
}
// Connections close in reverse order — deterministic RAII

#include 
#include 
#include 
#include 
#include 

// Constrained generic — C++20 concepts
template 
T max_of(const std::vector& xs) {
    return *std::ranges::max_element(xs);
}

// Auto-deduced parameters via abbreviated function templates
auto sum(std::ranges::range auto&& xs) {
    using T = std::ranges::range_value_t;
    T total{};
    for (auto&& x : xs) total += x;
    return total;
}

// Class template + deduction guide
template 
struct Stack {
    std::vector data;
    void push(T v) { data.push_back(std::move(v)); }
    T pop()        { T v = std::move(data.back()); data.pop_back(); return v; }
};

int main() {
    std::vector v{3, 7, 1, 9, 2};
    std::cout << "max = " << max_of(v) << "\n";
    std::cout << "sum = " << sum(v)    << "\n";

    Stack s{};
    s.push(1); s.push(2); s.push(3);
    std::cout << s.pop() << "\n";
}

// C++20. Build:
//   g++ -std=c++20 -O2 -pthread main.cpp -o app

#include 
#include 
#include 
#include 
#include 
#include 
#include 

// Parallel sum using futures: split, sum locally, reduce
long long parallel_sum(const std::vector& v, std::size_t threads) {
    std::vector> parts;
    const auto chunk = v.size() / threads;

    for (std::size_t i = 0; i < threads; ++i) {
        auto begin = v.begin() + i * chunk;
        auto end   = (i + 1 == threads) ? v.end() : begin + chunk;
        parts.push_back(std::async(std::launch::async, [begin, end] {
            return std::accumulate(begin, end, 0LL);
        }));
    }

    long long total = 0;
    for (auto& p : parts) total += p.get();         // wait + accumulate
    return total;
}

int main() {
    std::vector v(1'000'000);
    std::iota(v.begin(), v.end(), 1);               // 1..N

    const auto threads = std::max(1u, std::thread::hardware_concurrency());
    std::cout << "threads = " << threads << "\n";
    std::cout << "sum     = " << parallel_sum(v, threads) << "\n";
}