Using C++20 and C++23

High-value features to adopt early

• Concepts for clearer template constraints
• Ranges for composable sequence operations
• std::span for non-owning array views
• std::jthread for safer thread lifetime management
• std::expected for explicit success-or-error return values

These are good first targets because they usually improve readability immediately without demanding a full architecture rewrite.

Example: std::span

void print_all(std::span<const int> values) {
    for (int value : values) {
        std::cout << value << '\n';
    }
}

std::span lets one function accept arrays, vectors, and other contiguous ranges without taking ownership.

Example: concepts

template <typename T>
concept Printable = requires(T value) {
    std::cout << value;
};

Concepts turn implicit template assumptions into explicit API rules, which is one of the highest-value changes in modern generic code.

Adoption strategy

Add modern features where they improve readability immediately. Do not rewrite stable code just to chase newer syntax.

Fast wins in ordinary code

Replace pointer-plus-size pairs with std::span

void process(std::span<const std::byte> bytes);

Replace manual thread ownership with std::jthread

std::jthread worker([](std::stop_token token) {
    while (!token.stop_requested()) {
        poll_once();
    }
});

Replace ad hoc parse status codes with std::expected

std::expected<int, std::string> parse_count(std::string_view text) {
    if (text.empty()) {
        return std::unexpected("empty input");
    }
    return 42;
}

More library features worth knowing

• std::optional, std::variant, and std::expected for value-based APIs
• std::format and std::print for cleaner text output
• std::source_location for diagnostics without manual file and line plumbing
• std::chrono calendar/time-zone facilities when you need real-world dates and times

Example: three-way comparison

struct Version {
    int major{};
    int minor{};
    auto operator<=>(const Version&) const = default;
};

With a defaulted <=>, the compiler can synthesize the normal relational operators for you. This is one of the cleaner modern features because it removes repetitive comparison boilerplate.

Example: std::source_location

void log_message(std::string_view text,
                 std::source_location where = std::source_location::current()) {
    std::cout << where.file_name() << ':' << where.line() << " " << text << '\n';
}

This is a practical upgrade over hand-passing file and line macros through your own logging APIs.

Feature selection by problem

• Safer borrowing across APIs: std::span, std::string_view
• Cleaner generic interfaces: concepts
• Safer thread lifetime: std::jthread
• Better formatting and diagnostics: std::format, std::source_location
• Explicit local error handling: std::expected

Upgrade by layer

The cleanest rollout is usually bottom-up.

• update leaf utility functions first with std::span, std::string_view, and [[nodiscard]]
• improve generic helpers with concepts once the surrounding signatures are already clearer
• adopt std::jthread, std::expected, or std::format where they reduce real friction in services, parsing, logging, or worker code
• leave modules and coroutines for the stage where toolchain and architectural needs justify them

This keeps the early changes cheap and local instead of mixing low-risk upgrades with toolchain-heavy ones.

Before-and-after style upgrades

Old pointer-plus-size

void process(const int* values, std::size_t count);

New borrowed range

void process(std::span<const int> values);

Old manual thread join

std::thread worker(run);
worker.join();

New owned thread

std::jthread worker(run);

Example: std::expected

std::expected<int, std::string> parse_count(std::string_view text) {
    if (text.empty()) {
        return std::unexpected("empty input");
    }
    return 42;
}

The point is not that expected replaces every exception. It gives you a strong option when failure is part of normal control flow and callers should branch on the result directly.

Modules and coroutines

These two features are real parts of modern C++, but they require more build-system and library support than features like std::span or concepts. Adopt them deliberately rather than mechanically.

Where expected does and does not fit

std::expected works best when callers are supposed to branch locally on failure.

• parsing a request payload
• validating configuration
• returning a result from a helper that commonly fails in routine ways

It is usually a worse fit when every caller would just forward the error upward, or when the failure is exceptional enough that unwinding is the clearer design.

That means expected and exceptions often coexist in the same codebase. Use each where its calling pattern is natural.

Practical rollout order

1. std::string_view, std::span, [[nodiscard]]
2. concepts, ranges, std::format
3. std::jthread, std::expected, std::source_location
4. modules and coroutines once toolchain and surrounding libraries are ready

Exercise ideas

• Replace one pointer-plus-length API with std::span.
• Replace one status-code-returning helper with std::expected.
• Identify one thread-owning class that would become simpler with std::jthread.

Practical migration checklist

• confirm compiler and standard library support for the feature set you plan to use
• prefer targeted refactors over broad style-only rewrites
• verify API boundaries, ownership, and error-flow semantics before changing signatures
• keep each migration small enough to test and review on its own