Modern C++ skill for Codex

Modern C++ code has no owning raw pointers, no manual delete, no unchecked lifetime assumptions hidden behind string_view or span, and compiles cleanly with high warning levels on every compiler the project supports. New features are used only when every target toolchain has them.

Before changing code

1. Read AGENTS.md, CMakeLists.txt (or Meson/Bazel files), CMakePresets.json, .clang-format, .clang-tidy.
2. Find the language standard (CMAKE_CXX_STANDARD, target_compile_features, -std=) and the compiler matrix in CI (GCC, Clang, MSVC versions). The oldest compiler decides which library features you may use.
3. Build once before editing so pre-existing warnings are not attributed to you.

Feature availability check

Library support lags the language. Check before using:

Feature	Header / syntax	Notes
Concepts, requires	C++20	solid in GCC 10+, Clang 10+, MSVC 19.28+
Ranges, views	<ranges>	usable in GCC 10+, MSVC; Clang/libc++ caught up around 15-16
std::format	<format>	GCC 13+, Clang/libc++ 17+, MSVC 19.29+; else use fmtlib
std::expected	<expected> C++23	GCC 12+, libc++ 16+, MSVC 19.33+
std::print / println	<print> C++23	GCC 14+, MSVC 19.37+, recent libc++; probe before relying on it
std::ranges::to, views::zip, enumerate	C++23	GCC 14 is the practical floor; check per view
Deducing this	C++23	GCC 14+, Clang 18+, MSVC 19.32+
Modules, import std;	C++20/23	needs CMake 3.28+ and a recent toolchain; do not introduce casually

Verify with a feature-test macro when in doubt (#if __cpp_lib_expected >= 202202L) or compile a one-line probe with each CI compiler. Keep a fallback (fmtlib, tl::expected) when the matrix includes older toolchains.

Ownership rules

Situation	Use
Single owner	std::unique_ptr<T> via std::make_unique
Shared ownership with a real lifetime reason	std::shared_ptr via std::make_shared; break cycles with weak_ptr
Non-owning, non-null reference	T&
Non-owning, maybe null	T* (raw pointer means “does not own”)
Read-only string parameter	std::string_view
Contiguous buffer parameter	std::span<const T> / std::span<T>
Take ownership in a sink	pass by value and std::move into the member
Optional value	std::optional<T>
Operation that can fail with a reason	std::expected<T, E> (or the project’s error type)

Rule of zero: a class that only holds RAII members declares no destructor, copy or move operations. If you must write one of the five, write or = delete all five deliberately.

class Connection {
public:
    static std::expected<Connection, std::error_code> open(std::string_view host);
    std::expected<std::size_t, std::error_code> send(std::span<const std::byte> data);

private:
    explicit Connection(unique_fd fd) : fd_(std::move(fd)) {}
    unique_fd fd_;   // RAII wrapper; Connection gets correct move and no copy for free
};

Wrap C handles with a unique_ptr and a custom deleter when no wrapper exists:

struct FileCloser { void operator()(std::FILE* f) const noexcept { if (f) std::fclose(f); } };
using unique_file = std::unique_ptr<std::FILE, FileCloser>;

unique_file f{std::fopen(path.c_str(), "rb")};
if (!f) return std::unexpected(std::error_code(errno, std::generic_category()));

Ranges and algorithms

auto active_names(std::span<const User> users) -> std::vector<std::string> {
    auto names = users
        | std::views::filter([](const User& u) { return u.active; })
        | std::views::transform(&User::name);
    return {names.begin(), names.end()};          // C++23: std::ranges::to<std::vector>()
}

• Prefer std::ranges::sort(v, {}, &User::age) (projection) over custom comparators.
• Views are lazy and usually non-owning: never return a view over a local container.
• views::filter caches begin(); iterating a filter view, then mutating the underlying elements so the predicate changes, is undefined behaviour territory. Materialise when in doubt.

Concepts instead of SFINAE

template <typename T>
concept Hashable = requires(const T& t) {
    { std::hash<T>{}(t) } -> std::convertible_to<std::size_t>;
};

template <Hashable Key, typename Value>
class Cache { /* ... */ };

Replace std::enable_if_t overload sets with constrained templates or if constexpr; error messages improve and intent is visible.

Other defaults

• auto for iterator and long template types; spell the type when it documents intent (std::size_t count = ...).
• enum class over plain enums; std::to_underlying (C++23) for conversions.
• constexpr functions for compile-time-computable values; consteval only when a runtime call must be an error.
• Mark single-argument constructors explicit; mark functions [[nodiscard]] when ignoring the result is a bug (error codes, expected).
• noexcept on move constructors and move assignment, or std::vector will copy instead of move on reallocation.
• Designated initializers for aggregates: Options{.timeout = 5s, .retries = 3}.
• std::jthread over std::thread (joins on destruction, has a stop token).

Lifetime traps to check in review

• std::string_view or std::span stored as a member, or returned, while pointing at a temporary or a local.
• auto& x = vec[0]; then vec.push_back(...): reference invalidated.
• Lambdas capturing [&] or this that outlive the scope (callbacks, threads, async).
• Range-for over a temporary’s member: for (auto& x : get_obj().items()) dangles before C++23 lifetime extension fixes; bind the object first.
• std::move from a const object silently copies.
• Moved-from objects: only assign to or destroy them.

Verification

cmake --preset dev && cmake --build --preset dev
ctest --preset dev --output-on-failure

• Compile with -Wall -Wextra -Wpedantic -Wconversion -Wshadow (GCC/Clang) or /W4 /permissive- (MSVC); new code adds no warnings.
• Run tests under AddressSanitizer and UndefinedBehaviorSanitizer (-fsanitize=address,undefined -fno-omit-frame-pointer -g); separately ThreadSanitizer for concurrent code.
• clang-tidy -p build <files> with modernize-*, bugprone-*, cppcoreguidelines-owning-memory, performance-* as the project configures.
• clang-format --dry-run --Werror on changed files.
• Build on the oldest compiler in the CI matrix before claiming a feature is safe.

When modernising legacy code, change one pattern at a time (all owning raw pointers in a module, then all output parameters) with tests between, and report what was converted and what was left for a follow-up.