Modern C++ skill for Claude Code

Done well means: every resource has exactly one owner and is released by a destructor, no raw new/delete in application code, function signatures state ownership, the build uses targets (not global flags), warnings are errors in CI, and the test suite passes under AddressSanitizer + UndefinedBehaviorSanitizer.

Before changing anything

1. Find the real standard and toolchain: CMAKE_CXX_STANDARD, cxx_std_* features, compiler versions in CI. Do not use a C++23 feature the oldest supported compiler lacks.
2. Check the library: libstdc++ (GCC), libc++ (Clang/Apple), or MSVC STL. Feature support differs per library, not per compiler front end. Confirm on the cppreference “compiler support” page or with feature-test macros (__cpp_lib_expected, __cpp_lib_print, __cpp_lib_ranges_to_container).
3. Build once with sanitizers before refactoring so you know the baseline is clean.

Feature baseline (verify against your CI compilers)

Feature	Std	Rough minimum
Concepts, ranges, std::span, <=>, designated init	20	GCC 10+, Clang 13+ (full ranges: GCC 12, Clang 16), MSVC 17.0
std::format	20	GCC 13, libc++ 17, MSVC 16.10
std::expected, std::optional::and_then	23	GCC 12, libc++ 16, MSVC 17.3
std::print / std::println	23	GCC 14, libc++ 18, MSVC 17.7
std::ranges::to, views::enumerate, views::zip	23	GCC 14 (enumerate 13), libc++ 17-19 varies
Deducing this	23	GCC 14, Clang 18, MSVC 17.2
import std;	23	Experimental; needs CMake 3.30+ and recent toolchains. Do not adopt in shared libraries yet

If a row is borderline, guard with the feature-test macro or fall back (fmt library for std::format/std::print, tl::expected for std::expected).

Ownership in signatures

Parameter intent	Type
Read, never null	const T& (or T if cheap to copy: ints, string_view, span)
Read, may be absent	const T* or std::optional<std::reference_wrapper<const T>>
Modify caller’s object	T&
Read a contiguous range	std::span<const T>
Read a string	std::string_view (never store it past the call)
Take ownership	std::unique_ptr<T> by value, or T by value then std::move into a member
Share ownership (truly)	std::shared_ptr<T> by value; const std::shared_ptr<T>& only if you might copy
Return a new object	T by value (RVO); std::unique_ptr<T> for polymorphic types

class Session {
public:
    explicit Session(std::string user, std::unique_ptr<Transport> t)
        : user_(std::move(user)), transport_(std::move(t)) {}
    void send(std::span<const std::byte> payload);   // borrows
private:
    std::string user_;
    std::unique_ptr<Transport> transport_;           // owns
};
auto s = Session{"ada", std::make_unique<TcpTransport>(addr)};

• std::make_unique / std::make_shared always; never shared_ptr<T>(new T).
• shared_ptr is a design decision (lifetime genuinely shared across owners), not a default. Cycles need std::weak_ptr on one edge.
• Raw T* means “non-owning, may be null”. Never delete through it.

RAII and the rule of zero

• Classes that only hold RAII members declare none of the five special members.
• A class that owns a raw handle (fd, FILE*, C library object) gets a dedicated wrapper, then everything else composes it:

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

FilePtr open_file(const char* path, const char* mode) {
    FilePtr f{std::fopen(path, mode)};
    if (!f) throw std::system_error(errno, std::generic_category(), path);
    return f;
}

• If you must write special members, write all five or = delete copy explicitly, and mark move operations and destructors noexcept (containers fall back to copying otherwise).
• Locks: std::scoped_lock lk(m1, m2); (deadlock-free for multiple mutexes), never call the mutex’s lock and release members by hand.
• Polymorphic base classes: virtual ~Base() = default; or a protected non-virtual destructor.

Error handling decision

Situation	Use
Expected, frequent failure the caller handles locally (parse, lookup, validation)	std::expected<T, E> with an enum or small struct E
Rare failure that unwinds several layers (I/O failure, out of memory, broken invariant in ctor)	Exceptions
Codebase built with -fno-exceptions (games, embedded)	std::expected everywhere, std::optional for absence
Programmer error / violated precondition	assert or a contract check that aborts, not an error value

enum class ParseError { empty, bad_digit, overflow };

std::expected<int, ParseError> parse_port(std::string_view s) {
    if (s.empty()) return std::unexpected(ParseError::empty);
    int v{};
    auto [ptr, ec] = std::from_chars(s.data(), s.data() + s.size(), v);
    if (ec == std::errc::result_out_of_range || v > 65535) return std::unexpected(ParseError::overflow);
    if (ec != std::errc{} || ptr != s.data() + s.size()) return std::unexpected(ParseError::bad_digit);
    return v;
}

Mark functions that cannot throw noexcept; mark results that must be checked [[nodiscard]].

Ranges and views without dangling

• Views are lazy and non-owning. A view over a temporary container dangles: auto v = make_vec() | std::views::filter(pred); is caught by std::ranges::dangling only for some algorithms. Store the container in a named variable first.
• Materialize with std::ranges::to<std::vector>() (C++23) when the result outlives its source, or crosses an API boundary.
• views::filter caches begin(); do not mutate elements in a way that changes the predicate result while iterating, and do not iterate the same filter view from two threads.
• Prefer range algorithms with projections: std::ranges::sort(users, {}, &User::age);.
• Returning std::string_view or std::span into a local or a temporary is a use-after-free. Return owned types.

Templates and concepts

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

template <std::ranges::input_range R>
    requires Hashable<std::ranges::range_value_t<R>>
void index(R&& items);

• Use standard concepts first (std::integral, std::invocable, std::ranges::range).
• Replace enable_if / SFINAE with requires; error messages become readable.
• Put constexpr on functions that can be evaluated at compile time; use consteval only when a call must never happen at runtime.
• if constexpr replaces tag dispatch for small branches.

Build: target-based CMake

cmake_minimum_required(VERSION 3.28)
project(app LANGUAGES CXX)

add_library(core src/core.cpp)
target_compile_features(core PUBLIC cxx_std_23)
set_target_properties(core PROPERTIES CXX_EXTENSIONS OFF)
target_include_directories(core PUBLIC include)

add_library(project_warnings INTERFACE)
if(MSVC)
  target_compile_options(project_warnings INTERFACE /W4 /permissive- /utf-8)
else()
  target_compile_options(project_warnings INTERFACE
    -Wall -Wextra -Wpedantic -Wshadow -Wconversion -Wsign-conversion
    -Wnon-virtual-dtor -Wold-style-cast -Woverloaded-virtual -Wimplicit-fallthrough)
endif()
target_link_libraries(core PRIVATE project_warnings)

add_executable(app src/main.cpp)
target_link_libraries(app PRIVATE core project_warnings)

• Never include_directories(), add_definitions() or CMAKE_CXX_FLAGS += for per-project settings; use target_* with PRIVATE/PUBLIC/INTERFACE.
• Dependencies: vcpkg manifest mode (vcpkg.json + toolchain file) or Conan 2; small header-only deps via FetchContent pinned to a tag or commit hash.
• Put configurations in CMakePresets.json (dev, asan, tsan, release) so CI and humans run identical builds. Export compile_commands.json (CMAKE_EXPORT_COMPILE_COMMANDS=ON) for clang-tidy and clangd.

Sanitizers and hardening

cmake --preset asan     # or configure manually:
cmake -B build-asan -G Ninja -DCMAKE_BUILD_TYPE=Debug \
  -DCMAKE_CXX_FLAGS="-fsanitize=address,undefined -fno-sanitize-recover=all -fno-omit-frame-pointer -g"
cmake --build build-asan && ctest --test-dir build-asan --output-on-failure

# Data races: separate build, TSan cannot combine with ASan
cmake -B build-tsan -DCMAKE_CXX_FLAGS="-fsanitize=thread -g -O1"

• UBSAN_OPTIONS=print_stacktrace=1:halt_on_error=1, ASAN_OPTIONS=detect_leaks=1 (LeakSanitizer is unavailable on macOS arm64 Apple clang; use Linux CI or leaks).
• Debug/CI library assertions: -D_GLIBCXX_ASSERTIONS (libstdc++) or -D_LIBCPP_HARDENING_MODE=_LIBCPP_HARDENING_MODE_FAST (libc++ 18+). These catch out-of-bounds operator[] and bad iterator use; the FAST mode is cheap enough for production.
• Release hardening on GCC/Clang Linux: -O2 -D_FORTIFY_SOURCE=3 -fstack-protector-strong (GCC 14+ offers -fhardened as a bundle).

Static analysis

clang-tidy -p build src/*.cpp
run-clang-tidy -p build -j 8        # whole project

Start from .clang-tidy with bugprone-*,cppcoreguidelines-*,modernize-*,performance-*,readability-* minus noisy checks (modernize-use-trailing-return-type, readability-identifier-length, cppcoreguidelines-avoid-magic-numbers). Treat new findings as errors only for changed files (clang-tidy-diff.py) on legacy code.

Undefined behavior: the ones that ship

• Signed integer overflow, shifting by >= width, and out-of-range float->int casts.
• Reading an object after std::move assumes more than “valid but unspecified”.
• Iterator, reference or string_view invalidation after push_back, insert, erase, or rehash. Reserve or use indices.
• Lambdas capturing [&] or this stored in callbacks that outlive the scope.
• Strict aliasing: reinterpret_cast<float*>(int_ptr); use std::bit_cast or memcpy.
• Uninitialized members: initialize at declaration (int count_ = 0;).
• Data races on non-atomic shared state, including shared_ptr object reassignment from two threads (the control block is atomic; the pointer variable is not).

For the full UB catalog with detection method and fix for each case, read references/ub-catalog.md when a sanitizer report or crash does not match the list above.

Modernizing legacy code, in this order

- [ ] 1. Get it building with warnings on and sanitizers clean (fix real bugs first)
- [ ] 2. Raw owning pointers -> unique_ptr / containers; delete manual destructors
- [ ] 3. Out-parameters + bool returns -> return values / std::optional / std::expected
- [ ] 4. Pointer+length pairs -> std::span; const std::string& params that only read -> string_view
- [ ] 5. Hand loops -> range algorithms where it reads better (not everywhere)
- [ ] 6. SFINAE / enable_if -> concepts
- [ ] 7. Run clang-tidy modernize-* with fixes, review diff by hand

Keep each step a separate commit with tests green; never mix a behavior change into a modernization commit.

Verification

1. Clean build with the warnings target and -Werror (or /WX) on every CI compiler.
2. ctest passes under the ASan+UBSan preset and, for concurrent code, the TSan preset.
3. clang-tidy reports nothing new on changed files.
4. grep -nE '\bnew |delete |malloc\(|free\(' src/ returns only documented wrappers.
5. For performance-motivated changes, benchmark Release builds (Google Benchmark or hyperfine), never Debug.