T* p = alloc.allocate(4); // 只有内存
std::construct_at(p, value); // 这里对象才真正构造

#include <memory>

template <class T>
struct MyAllocator {
    using value_type = T;

    MyAllocator() = default;

    template <class U>
    MyAllocator(const MyAllocator<U>&) {}

    T* allocate(std::size_t n) {
        return static_cast<T*>(::operator new(n * sizeof(T)));
    }

    void deallocate(T* p, std::size_t) {
        ::operator delete(p);
    }
};

std::vector<int, MyAllocator<int>> v;

#include <array>
#include <cstddef>
#include <iostream>
#include <memory_resource>
#include <string>
#include <string_view>
#include <utility>
#include <vector>

struct RequestData {
    std::pmr::vector<std::pmr::string> headers;

    explicit RequestData(std::pmr::memory_resource* mr)
        : headers(mr) {}

    void add_header(std::string_view key, std::string_view value) {
        std::pmr::string line{headers.get_allocator().resource()};
        line.append(key);
        line.append(": ");
        line.append(value);
        headers.push_back(std::move(line));
    }
};

void handle_request() {
    std::array<std::byte, 4096> buffer{};
    std::pmr::monotonic_buffer_resource arena{
        buffer.data(),
        buffer.size()
    };

    RequestData req{&arena};
    req.add_header("Host", "example.com");
    req.add_header("User-Agent", "demo-client");

    for (const auto& h : req.headers) {
        std::cout << h << "\n";
    }

    // handle_request 返回时，arena 整体释放本次请求的临时内存。
}

struct Pet {
    virtual ~Pet() = default;
    virtual void speak() = 0;
};

struct Cat : Pet {
    void speak() override { std::puts("meow"); }
};

struct Dog : Pet {
    void speak() override { std::puts("woof"); }
};

#include <memory>
#include <string>

std::unique_ptr<Pet> make_pet(const std::string& kind) {
    if (kind == "cat") return std::make_unique<Cat>();
    if (kind == "dog") return std::make_unique<Dog>();
    return nullptr;
}

struct Reducer {
    virtual ~Reducer() = default;
    virtual int init() const = 0;
    virtual int combine(int a, int b) const = 0;
};

struct SumReducer : Reducer {
    int init() const override { return 0; }
    int combine(int a, int b) const override { return a + b; }
};

struct MulReducer : Reducer {
    int init() const override { return 1; }
    int combine(int a, int b) const override { return a * b; }
};

#include <functional>
#include <memory>
#include <stdexcept>
#include <string>
#include <string_view>
#include <unordered_map>
#include <utility>

struct Shape {
    virtual ~Shape() = default;
    virtual double area() const = 0;
};

struct Circle : Shape {
    explicit Circle(double r) : r(r) {}
    double area() const override { return 3.14159 * r * r; }
    double r = 1.0;
};

struct Square : Shape {
    explicit Square(double side) : side(side) {}
    double area() const override { return side * side; }
    double side = 1.0;
};

class ShapeFactory {
public:
    using Creator = std::function<std::unique_ptr<Shape>(double)>;

    void register_type(std::string name, Creator creator) {
        creators_[std::move(name)] = std::move(creator);
    }

    std::unique_ptr<Shape> create(std::string_view name, double arg) const {
        auto it = creators_.find(std::string(name));
        if (it == creators_.end()) {
            throw std::runtime_error("unknown shape type");
        }
        return it->second(arg);
    }

private:
    std::unordered_map<std::string, Creator> creators_;
};

int main() {
    ShapeFactory factory;

    factory.register_type("circle", [](double r) {
        return std::make_unique<Circle>(r);
    });

    factory.register_type("square", [](double side) {
        return std::make_unique<Square>(side);
    });

    auto shape = factory.create("circle", 2.0);
    double a = shape->area();
}

std::vector<std::uint8_t> inbuf;

#include <cstdint>
#include <cstddef>
#include <optional>
#include <span>
#include <stdexcept>
#include <vector>

class FrameDecoder {
public:
    void append(std::span<const std::byte> bytes) {
        buffer_.insert(buffer_.end(), bytes.begin(), bytes.end());
    }

    std::optional<std::vector<std::byte>> next_frame() {
        if (buffer_.size() < header_size) {
            return std::nullopt;
        }

        std::uint32_t len = read_u32_be(buffer_.data());
        if (len > max_frame_size) {
            throw std::runtime_error("frame too large");
        }

        const std::size_t total = header_size + len;
        if (buffer_.size() < total) {
            return std::nullopt;
        }

        std::vector<std::byte> payload(
            buffer_.begin() + header_size,
            buffer_.begin() + static_cast<std::ptrdiff_t>(total)
        );

        buffer_.erase(
            buffer_.begin(),
            buffer_.begin() + static_cast<std::ptrdiff_t>(total)
        );

        return payload;
    }

private:
    static constexpr std::size_t header_size = 4;
    static constexpr std::uint32_t max_frame_size = 1024 * 1024;

    static std::uint32_t read_u32_be(const std::byte* p) {
        return (std::uint32_t(std::to_integer<unsigned char>(p[0])) << 24) |
               (std::uint32_t(std::to_integer<unsigned char>(p[1])) << 16) |
               (std::uint32_t(std::to_integer<unsigned char>(p[2])) << 8)  |
                std::uint32_t(std::to_integer<unsigned char>(p[3]));
    }

    std::vector<std::byte> buffer_;
};

FrameDecoder decoder;

// 每次 recv 得到一段 bytes 后：
decoder.append(bytes);

while (auto frame = decoder.next_frame()) {
    handle_message(*frame);
}

class GameConfig {
public:
    static GameConfig& instance() {
        static GameConfig cfg;
        return cfg;
    }

private:
    GameConfig() = default;
};

struct Monster;

struct State {
    virtual ~State() = default;
    virtual void update(Monster& m) = 0;
};

struct Command {
    virtual ~Command() = default;
    virtual void execute() = 0;
};

struct Character {
    virtual ~Character() = default;
    virtual void think() = 0;
    virtual void move() = 0;
    virtual void draw() = 0;

    void update() {
        think();
        move();
        draw();
    }
};

#include <optional>
#include <cstddef>
#include <vector>

struct Bullet {
    bool active = false;
    float x = 0.0f;
    float y = 0.0f;
    float vx = 0.0f;
    float vy = 0.0f;
    float life = 0.0f;
};

class BulletPool {
public:
    explicit BulletPool(std::size_t capacity)
        : bullets_(capacity) {}

    Bullet* spawn(float x, float y, float vx, float vy) {
        for (auto& b : bullets_) {
            if (!b.active) {
                b = Bullet{
                    .active = true,
                    .x = x,
                    .y = y,
                    .vx = vx,
                    .vy = vy,
                    .life = 2.0f,
                };
                return &b;
            }
        }

        return nullptr; // 池满，可以选择丢弃或扩容
    }

    void update(float dt) {
        for (auto& b : bullets_) {
            if (!b.active) {
                continue;
            }

            b.x += b.vx * dt;
            b.y += b.vy * dt;
            b.life -= dt;

            if (b.life <= 0.0f) {
                b.active = false;
            }
        }
    }

    const std::vector<Bullet>& bullets() const {
        return bullets_;
    }

private:
    std::vector<Bullet> bullets_;
};

std::optional<User> find_user(int id);
std::expected<User, ParseError> parse_user(std::string_view text);

#include <expected>
#include <string_view>

enum class ParseError {
    Empty,
    InvalidNumber
};

std::expected<int, ParseError> parse_int(std::string_view s) {
    if (s.empty()) {
        return std::unexpected(ParseError::Empty);
    }
    int value = 0;
    for (char ch : s) {
        if (ch < '0' || ch > '9') {
            return std::unexpected(ParseError::InvalidNumber);
        }
        value = value * 10 + (ch - '0');
    }
    return value;
}

int parse_int_or_throw(std::string_view s) {
    if (s.empty()) throw std::invalid_argument("empty");
    int value = 0;
    for (char ch : s) {
        if (ch < '0' || ch > '9') {
            throw std::invalid_argument("invalid number");
        }
        value = value * 10 + (ch - '0');
    }
    return value;
}

#include <expected>
#include <charconv>
#include <stdexcept>
#include <string>
#include <string_view>
#include <system_error>

enum class ParseError {
    empty,
    invalid_number,
    out_of_range,
};

std::expected<int, ParseError> parse_port(std::string_view text) {
    if (text.empty()) {
        return std::unexpected(ParseError::empty);
    }

    int value = 0;
    const char* first = text.data();
    const char* last = text.data() + text.size();

    auto [ptr, ec] = std::from_chars(first, last, value);
    if (ec != std::errc{} || ptr != last) {
        return std::unexpected(ParseError::invalid_number);
    }

    if (value <= 0 || value > 65535) {
        return std::unexpected(ParseError::out_of_range);
    }

    return value;
}

void load_endpoint(std::string_view port_text) {
    auto port = parse_port(port_text);
    if (!port) {
        report_parse_error(port.error());
        return;
    }

    connect_to_port(*port);
}

int parse_port_or_throw(std::string_view text) {
    auto port = parse_port(text);
    if (!port) {
        throw std::runtime_error("invalid port");
    }
    return *port;
}

#include <coroutine>

struct Task {
    struct promise_type {
        Task get_return_object() { return {}; }
        std::suspend_never initial_suspend() noexcept { return {}; }
        std::suspend_never final_suspend() noexcept { return {}; }
        void return_void() {}
        void unhandled_exception() { std::terminate(); }
    };
};

co_await something;

#include <coroutine>
#include <exception>
#include <iostream>
#include <utility>

class IntGenerator {
public:
    struct promise_type {
        int current = 0;

        IntGenerator get_return_object() {
            return IntGenerator{
                std::coroutine_handle<promise_type>::from_promise(*this)
            };
        }

        std::suspend_always initial_suspend() noexcept {
            return {};
        }

        std::suspend_always final_suspend() noexcept {
            return {};
        }

        std::suspend_always yield_value(int value) noexcept {
            current = value;
            return {};
        }

        void return_void() noexcept {}

        void unhandled_exception() {
            std::terminate();
        }
    };

    explicit IntGenerator(std::coroutine_handle<promise_type> h)
        : handle_(h) {}

    IntGenerator(const IntGenerator&) = delete;
    IntGenerator& operator=(const IntGenerator&) = delete;

    IntGenerator(IntGenerator&& other) noexcept
        : handle_(std::exchange(other.handle_, {})) {}

    ~IntGenerator() {
        if (handle_) {
            handle_.destroy();
        }
    }

    bool next() {
        if (!handle_ || handle_.done()) {
            return false;
        }

        handle_.resume();
        return !handle_.done();
    }

    int value() const {
        return handle_.promise().current;
    }

private:
    std::coroutine_handle<promise_type> handle_;
};

IntGenerator range(int begin, int end) {
    for (int i = begin; i < end; ++i) {
        co_yield i;
    }
}

int main() {
    auto gen = range(3, 7);

    while (gen.next()) {
        std::cout << gen.value() << "\n";
    }
}

void parse(char* data, int len);

[[nodiscard]] Config parse_config(std::string_view text);

struct User {
    std::string name;
    std::string email;
};

void print_user(const User& user) {
    std::cout << user.name << " <" << user.email << ">\n";
}

void print_user(User user);

void set_retry_count(int n);
void set_timeout(std::chrono::milliseconds timeout);

class Cache {
public:
    std::size_t size() const {
        return items_.size();
    }

    bool empty() const {
        return items_.empty();
    }

private:
    std::vector<int> items_;
};

std::size_t size();

class Text {
public:
    explicit Text(std::string s) : data_(std::move(s)) {}

    std::size_t word_count() const {
        if (!cached_) {
            cached_words_ = count_words(data_);
            cached_ = true;
        }
        return cached_words_;
    }

private:
    static std::size_t count_words(std::string_view text);

    std::string data_;
    mutable bool cached_ = false;
    mutable std::size_t cached_words_ = 0;
};

void log_message(std::string_view msg) {
    std::cout << msg << "\n";
}

log_message("hello");

std::string s = "world";
log_message(s);

std::string_view v = "cpp";
log_message(v);

class Bad {
public:
    void set_name(std::string_view name) {
        name_ = name; // 危险：name 可能指向临时字符串
    }

private:
    std::string_view name_;
};

class User {
public:
    void set_name(std::string name) {
        name_ = std::move(name);
    }

private:
    std::string name_;
};

double average(const double* data, std::size_t n);

#include <span>
#include <numeric>

double average(std::span<const double> xs) {
    if (xs.empty()) {
        return 0.0;
    }

    double sum = std::accumulate(xs.begin(), xs.end(), 0.0);
    return sum / static_cast<double>(xs.size());
}

std::vector<double> v{1.0, 2.0, 3.0};
std::array<double, 3> a{1.0, 2.0, 3.0};
double raw[] = {1.0, 2.0, 3.0};

average(v);
average(a);
average(raw);

class Person {
public:
    explicit Person(std::string name)
        : name_(std::move(name)) {}

    void rename(std::string name) {
        name_ = std::move(name);
    }

private:
    std::string name_;
};

std::string n = "Alice";
Person p(n); // 拷贝进参数，再 move 到成员

Person p("Alice");
Person q(std::string("Bob"));

class Port {
public:
    Port(int value) : value_(value) {}

private:
    int value_;
};

void connect(Port port);

connect(80); // 可以隐式把 int 转成 Port

class Port {
public:
    explicit Port(int value) : value_(value) {}

private:
    int value_;
};

connect(Port{80}); // 调用者明确表达意图

enum class Error {
    none,
    file_not_found,
    permission_denied,
};

[[nodiscard]] Error save_config(std::string_view path);

save_config("app.toml"); // 可能警告

if (auto err = save_config("app.toml"); err != Error::none) {
    report(err);
}

struct [[nodiscard]] Result {
    bool ok;
    std::string message;
};

Result load_user(int id);

#include <cstddef>
#include <utility>

class Buffer {
public:
    Buffer(Buffer&& other) noexcept
        : data_(std::exchange(other.data_, nullptr)),
          size_(std::exchange(other.size_, 0)) {}

private:
    int* data_ = nullptr;
    std::size_t size_ = 0;
};

void f() noexcept {
    may_throw(); // 如果真的抛出，会 std::terminate
}

enum Color {
    red,
    green,
};

int x = red; // 可以隐式转 int

enum class Color {
    red,
    green,
};

void paint(Color c);

paint(Color::red);

enum class HttpStatus : int {
    ok = 200,
    not_found = 404,
};

void on_debug_event([[maybe_unused]] int code) {
#ifdef DEBUG
    std::cout << code << "\n";
#endif
}

[[deprecated("use parse_config_v2 instead")]]
Config parse_config(std::string_view text);

switch (level) {
case 3:
    enable_verbose();
    [[fallthrough]];
case 2:
    enable_info();
    break;
default:
    break;
}

std::vector<int> make_ids();

class User {
public:
    const std::string& name() const noexcept {
        return name_;
    }

private:
    std::string name_;
};

const User* find_user(int id) const;

std::optional<User> find_user(int id) const;

#include <optional>
#include <span>
#include <string>
#include <string_view>
#include <vector>

enum class Role {
    admin,
    guest,
};

struct User {
    int id = 0;
    std::string name;
    Role role = Role::guest;
};

class UserStore {
public:
    explicit UserStore(std::vector<User> users)
        : users_(std::move(users)) {}

    [[nodiscard]] const User* find(int id) const noexcept {
        for (const auto& user : users_) {
            if (user.id == id) {
                return &user;
            }
        }
        return nullptr;
    }

    [[nodiscard]] std::vector<User> find_by_name(std::string_view name) const {
        std::vector<User> out;
        for (const auto& user : users_) {
            if (user.name == name) {
                out.push_back(user);
            }
        }
        return out;
    }

    void append(User user) {
        users_.push_back(std::move(user));
    }

    void append_all(std::span<const User> users) {
        users_.insert(users_.end(), users.begin(), users.end());
    }

private:
    std::vector<User> users_;
};