C++ cheat sheet

#include <algorithm>
#include <print>
#include <ranges>
#include <sstream>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
 
int main()
{
    std::string text = "the cat sat on the mat and the cat slept";
 
    std::unordered_map<std::string, int> counts;
    std::istringstream words(text);
    for (std::string word; words >> word;) {
        ++counts[word];  // a missing key starts at 0
    }
 
    // A hash map has no order, so copy it out to sort it:
    // most frequent first, then A to Z.
    std::vector<std::pair<std::string, int>> ranked(counts.begin(), counts.end());
    std::ranges::sort(ranked, [](const auto& a, const auto& b) {
        if (a.second != b.second) {
            return a.second > b.second;
        }
        return a.first < b.first;
    });
 
    for (const auto& [word, count] : ranked | std::views::take(3)) {
        std::println("{:<5} {}", word, count);
    }
    // the   3
    // cat   2
    // and   1
}

g++ -std=c++23 -Wall -Wextra -g -fsanitize=address,undefined words.cpp -o words
./words

#include <memory>
#include <numbers>
#include <print>
#include <string>
#include <vector>
 
class Shape {
public:
    virtual ~Shape() = default;  // deleting through a Shape* needs this
    virtual double area() const = 0;
    virtual std::string name() const = 0;
};
 
class Circle : public Shape {
public:
    explicit Circle(double radius) : radius_(radius) {}
    double area() const override { return std::numbers::pi * radius_ * radius_; }
    std::string name() const override { return "circle"; }
 
private:
    double radius_;
};
 
class Rectangle : public Shape {
public:
    Rectangle(double width, double height) : width_(width), height_(height) {}
    double area() const override { return width_ * height_; }
    std::string name() const override { return "rectangle"; }
 
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<Rectangle>(3.0, 4.0));
 
    double total = 0;
    for (const auto& shape : shapes) {
        std::println("{:<10} {:.2f}", shape->name(), shape->area());
        total += shape->area();
    }
    std::println("{:<10} {:.2f}", "total", total);
    // circle     3.14
    // rectangle  12.00
    // total      15.14
}

#include <algorithm>
#include <cstddef>
#include <print>
#include <utility>
 
class Buffer {
public:
    explicit Buffer(std::size_t size) : data_(new int[size]{}), size_(size) {}
 
    ~Buffer() { delete[] data_; }
 
    // Copy: allocate new memory and copy every element into it.
    Buffer(const Buffer& other) : data_(new int[other.size_]), size_(other.size_)
    {
        std::copy(other.data_, other.data_ + size_, data_);
    }
 
    Buffer& operator=(const Buffer& other)
    {
        Buffer copy(other);  // copy first, so a failed allocation changes nothing
        swap(copy);
        return *this;
    }
 
    // Move: take the other buffer's memory and leave it empty. No allocation.
    Buffer(Buffer&& other) noexcept
        : data_(std::exchange(other.data_, nullptr)),
          size_(std::exchange(other.size_, 0))
    {
    }
 
    Buffer& operator=(Buffer&& other) noexcept
    {
        Buffer moved(std::move(other));
        swap(moved);
        return *this;
    }
 
    void swap(Buffer& other) noexcept
    {
        std::swap(data_, other.data_);
        std::swap(size_, other.size_);
    }
 
    std::size_t size() const { return size_; }
 
private:
    int* data_;
    std::size_t size_;
};
 
int main()
{
    Buffer a(1000);
    Buffer b = a;             // copy: two separate arrays
    Buffer c = std::move(a);  // move: c takes a's array, a is left empty
 
    std::println("{} {} {}", a.size(), b.size(), c.size());  // 0 1000 1000
}

#include <concepts>
#include <print>
#include <vector>
 
template <typename T>
concept Numeric = std::integral<T> || std::floating_point<T>;
 
template <Numeric T>
T average(const std::vector<T>& values)
{
    if (values.empty()) {
        return T{};
    }
    T total{};
    for (T value : values) {
        total += value;
    }
    return total / static_cast<T>(values.size());
}
 
int main()
{
    std::vector<int> ints{1, 2, 3, 4};
    std::vector<double> doubles{1.5, 3.0};
 
    std::println("{}", average(ints));     // 2, because int division truncates
    std::println("{}", average(doubles));  // 2.25
    // average(std::vector<std::string>{"a"});  // error: std::string is not Numeric
}