Modern Cpp
Trail of BitsOfficialPublished by Trail of Bits
- Skill
- Guidelines
- Software development
- CC-BY-SA-4.0
- No issues found
AutoGineer summary
Written by AutoGineer from the skill’s own files, not by the author
This skill provides a comprehensive framework for transitioning C++ codebases toward modern standards. It emphasizes patterns that eliminate common vulnerability classes, such as memory leaks and buffer overflows, by replacing legacy C-style constructs with modern, type-safe alternatives. The content includes migration tables for anti-patterns, compiler hardening configurations, and feature tiers based on practical usability.
What it does
- Provides migration paths from legacy C++ patterns to modern C++20/23/26 idioms.
- Lists specific anti-patterns and their safer, modern replacements.
- Details compiler hardening flags for GCC and Clang to improve security.
- Explains the use of hardened libc++ modes for bounds-checking.
- Categorizes C++ features by their current practical deployment readiness.
- Offers a checklist for adopting safe coding practices in new and existing projects.
When to use it
- When writing new C++ functions, classes, or libraries.
- When modernizing legacy C++ codebases to improve safety and maintainability.
- When working on security-critical or safety-sensitive C++ applications.
- When reviewing C++ code to ensure adoption of modern idioms.
- When configuring compiler and linker settings for enhanced security.
Advantages
- Reduces vulnerability classes like memory leaks and buffer overflows.
- Improves code readability and reduces boilerplate through modern language features.
- Provides actionable, security-focused compiler and linker configurations.
- Offers clear, evidence-based guidance on replacing legacy C-style constructs.
- Helps align code with current C++ standards for better long-term maintainability.
Usage examples
- “How should I replace raw pointers in my C++ code?”
- The skill recommends using std::unique_ptr for exclusive ownership or std::shared_ptr for shared ownership to ensure RAII semantics and eliminate manual memory management.
- “What are the recommended compiler flags for hardening a C++ project?”
- The skill provides a list of essential flags including -D_FORTIFY_SOURCE=3, -fstack-protector-strong, and -ftrivial-auto-var-init=zero, along with linker settings like -Wl,-z,relro,-z,now.
- “How can I replace printf in C++23?”
- The skill suggests using std::print or std::println, which are type-safe and avoid the format string vulnerabilities associated with printf.
- “What is the modern alternative to SFINAE?”
- The skill advises using C++20 Concepts and the requires clause to constrain templates, which provides more readable code and clearer error messages.
Install
Download the skill as a ZIP:
https://mp-staging.autogineer.com/agent-skills/trailofbits/modern-cpp/downloadUnzip it into the cross-client skills folder of your project:
mkdir -p .agents/skills && unzip modern-cpp.zip -d .agents/skills
Documentation by Trail of Bits
Modern C++
Guide for writing modern C++ using C++20, C++23, and C++26 idioms. Focuses on patterns that eliminate vulnerability classes and reduce boilerplate, with a security emphasis from Trail of Bits.
When to Use This Skill
Writing new C++ functions, classes, or libraries
Modernizing existing C++ code (pre-C++20 patterns)
Choosing between legacy and modern approaches
Working on security-critical or safety-sensitive C++
Reviewing C++ code for modern idiom adoption
When NOT to Use This Skill
User explicitly requires older standard: Respect constraints (embedded, legacy ABI)
Pure C code: This skill is C++-specific
Build system questions: CMake, Meson, Bazel configuration is out of scope
Non-C++ projects: Mixed codebases where C++ isn't primary
Anti-Patterns to Avoid
| Avoid | Use Instead | Why |
|---|---|---|
new/delete | std::make_unique, std::make_shared | Eliminates leaks, double-free |
| Raw owning pointers | std::unique_ptr, std::shared_ptr | RAII ownership semantics |
C arrays (int arr[N]) | std::array<int, N> | Bounds-aware, value semantics |
| Pointer + length params | std::span<T> | Non-owning, bounds-checkable |
printf / sprintf | std::format, std::print | Type-safe, no buffer overflow |
C-style casts (int)x | static_cast<int>(x) | Explicit intent, auditable |
#define constants | constexpr variables | Scoped, typed, debuggable |
SFINAE / enable_if | Concepts + requires | Readable constraints and errors |
| Error codes + out params | std::expected<T, E> | Composable, type-safe errors |
union | std::variant | Type-safe, no silent UB |
Raw mutex.lock()/unlock() | std::scoped_lock | Exception-safe, no deadlocks |
std::thread | std::jthread | Auto-join, stop token support |
assert() macro | contract_assert (C++26) | Visible to tooling, configurable |
| Manual CRTP | Deducing this (C++23) | Simpler, no template boilerplate |
| Macro code generation | Reflection (C++26) | Zero-overhead, composable |
See anti-patterns.md for the full table (30+ patterns).
Decision Tree
What are you doing?
|
+-- Writing new C++ code?
| +-- Use modern idioms by default (C++20/23)
| +-- Choose the newest standard your compiler supports
| +-- See Feature Tiers below
|
+-- Modernizing existing code?
| +-- Start with Tier 1 (C++20/23) replacements
| +-- Prioritize by security impact (memory > types > style)
| +-- See anti-patterns.md for the migration table
|
+-- Security-critical code?
| +-- Enable compiler hardening flags (see below)
| +-- Enable hardened libc++ mode
| +-- Run sanitizers in CI
| +-- See safe-idioms.md and compiler-hardening.md
|
+-- Using C++26 features?
+-- Reflection: YES, plan for it (GCC 16+)
+-- Contracts: cautiously, for new API boundaries
+-- std::execution: wait for ecosystem maturity
+-- See cpp26-features.mdFeature Tiers
Features are ranked by practical usability today, not by standard version.
Tier 1: Use Today (C++20/23, solid compiler support)
| Feature | Replaces | Standard |
|---|---|---|
Concepts + requires | SFINAE, enable_if | C++20 |
| Ranges + views | Raw iterator loops | C++20 |
std::span<T> | Pointer + length | C++20 |
std::format | sprintf, iostream chains | C++20 |
Three-way comparison <=> | Manual comparison operators | C++20 |
std::jthread | std::thread + manual join | C++20 |
| Designated initializers | Positional struct init | C++20 |
std::expected<T,E> | Error codes, exceptions at boundaries | C++23 |
std::print / std::println | printf, std::cout << | C++23 |
Deducing this | CRTP, const/non-const duplication | C++23 |
std::flat_map | std::map for read-heavy use | C++23 |
Monadic std::optional | Nested if-checks on optionals | C++23 |
See cpp20-features.md and cpp23-features.md.
Tier 2: Deploy Now (no standard bump needed)
These improve safety without changing your C++ standard version:
Compiler hardening flags —
-D_FORTIFY_SOURCE=3,-fstack-protector-strong,-ftrivial-auto-var-init=zeroHardened libc++ —
-D_LIBCPP_HARDENING_MODE=_LIBCPP_HARDENING_MODE_FASTfor ~0.3% overhead bounds-checkingSanitizers in CI — ASan + UBSan as minimum; TSan for concurrent code
Warning flags —
-Wall -Wextra -Wpedantic -Werror
Tier 3: Plan For (C++26, worth restructuring around)
Reflection is the single most transformative C++26 feature. It eliminates:
Serialization boilerplate (one generic function replaces per-struct
to_json)Code generators (protobuf codegen, Qt MOC)
Macro-based registration and enum-to-string hacks
GCC 16 (April 2026) has reflection merged. Plan new code to benefit from it.
Tier 4: Watch (C++26, needs maturation)
Contracts (
pre/post/contract_assert) — Better thanassert(), but no virtual function support and limited compiler support. Adopt cautiously for new API boundaries.std::execution (senders/receivers) — Powerful async framework, but steep learning curve, no scheduler ships with it, and poor documentation. Wait for ecosystem maturity.
See cpp26-features.md.
Compiler Hardening Quick Reference
Essential Flags (GCC + Clang)
-Wall -Wextra -Wpedantic -Werror
-D_FORTIFY_SOURCE=3
-fstack-protector-strong
-fstack-clash-protection
-ftrivial-auto-var-init=zero
-fPIE -pie
-Wl,-z,relro,-z,nowClang-Specific
-Wunsafe-buffer-usageHardened libc++ (Clang/libc++ only)
-D_LIBCPP_HARDENING_MODE=_LIBCPP_HARDENING_MODE_FASTGoogle deployed this across Chrome and their server fleet: ~0.3% overhead, 1000+ bugs found, 30% reduction in production segfaults.
See compiler-hardening.md for the full guide.
Rationalizations to Reject
| Rationalization | Why It's Wrong |
|---|---|
| "It compiles without warnings" | Warnings depend on which flags you enable. Add -Wall -Wextra -Wpedantic. |
| "ASan is too slow for production" | Use GWP-ASan for sampling-based production detection (~0% overhead). |
| "We only use safe containers" | Iterator invalidation and unchecked optional access are still exploitable. |
| "Smart pointers are slower" | std::unique_ptr has zero overhead vs raw pointers. Measure before claiming. |
| "Our code doesn't have memory bugs" | Google found 1000+ bugs when enabling hardened libc++. So did everyone else. |
| "C++26 features aren't available yet" | C++20/23 features are. Hardening flags work on any standard. Start there. |
| "Modern C++ is harder to read" | std::expected is more readable than checking error codes across 5 out-params. |
Best Practices Checklist
[ ] Use smart pointers for ownership, raw pointers only for non-owning observation
[ ] Prefer
std::spanover pointer + length for function parameters[ ] Use
std::expectedfor functions that can fail with typed errors[ ] Constrain templates with concepts, not SFINAE
[ ] Enable compiler hardening flags and hardened libc++ in all builds
[ ] Run ASan + UBSan in CI; add TSan for concurrent code
[ ] Use
constexpr/constevalwhere possible (UB-free by design)[ ] Mark functions
[[nodiscard]]when ignoring the return value is likely a bug[ ] Prefer value semantics; use
std::variantoverunion,enum classoverenum[ ] Initialize all variables at declaration
Read Next
anti-patterns.md — Full legacy-to-modern migration table (30+ patterns)
cpp20-features.md — Concepts, ranges, span, format, coroutines
cpp23-features.md — expected, print, deducing this, flat_map
cpp26-features.md — Reflection, contracts, memory safety improvements
compiler-hardening.md — Flags, sanitizers, hardened libc++
safe-idioms.md — Security patterns by vulnerability class
Files
- ATTRIBUTION.mdAdded by AutoGineer924 B
- LICENSELicence file added by AutoGineer19.7 KiB
- SKILL.md8.5 KiB
- references/anti-patterns.md5.5 KiB
- references/compiler-hardening.md7.3 KiB
- references/cpp20-features.md7.0 KiB
- references/cpp23-features.md7.0 KiB
- references/cpp26-features.md7.5 KiB
- references/safe-idioms.md8.1 KiB
references/anti-patterns.md
Anti-Patterns: Legacy to Modern C++
Comprehensive reference of legacy C++ patterns and their modern replacements. Each entry explains WHY the modern version is better — not just that it exists.
Memory Management
| Avoid | Use Instead | Standard | Why |
|---|---|---|---|
new T / delete p | std::make_unique<T>() | C++14 | Eliminates memory leaks, double-free; exception-safe construction |
new T[] / delete[] p | std::vector<T> or std::make_unique<T[]>(n) | C++14 | Automatic sizing, bounds-aware with .at() |
Raw owning T* | std::unique_ptr<T> | C++11 | RAII ownership; zero overhead vs raw pointer |
Raw shared T* | std::shared_ptr<T> via std::make_shared | C++11 | Reference-counted lifetime; thread-safe refcount |
C arrays int arr[N] | std::array<int, N> | C++11 | Value semantics, .size(), no decay to pointer |
malloc/free | Containers or smart pointers | C++11 | Type-safe, exception-safe, RAII |
memcpy(dst, src, n) | std::copy(src, src+n, dst) or container assignment | C++98 | Type-safe, works with non-trivial types |
memset(buf, 0, n) | Value initialization or std::fill | C++98 | No risk of zeroing non-trivially-constructible types |
| Pointer + length parameter pairs | std::span<T> | C++20 | Carries size, bounds-checkable with hardened mode |
const char* for non-owning strings | std::string_view | C++17 | Carries length, no null-terminator assumption |
Nullable T* for optional values | std::optional<T> | C++17 | Explicit intent, no null dereference risk |
Type Safety
| Avoid | Use Instead | Standard | Why |
|---|---|---|---|
C-style cast (int)x | static_cast<int>(x) | C++98 | Explicit intent, greppable, won't silently reinterpret |
reinterpret_cast for type punning | std::bit_cast<T>(x) | C++20 | Defined behavior, constexpr-compatible |
union for variants | std::variant<A, B, C> | C++17 | Type-safe access via std::visit, no silent UB |
void* type erasure | std::any, std::variant, or templates | C++17 | Type-safe, no manual casting |
Plain enum | enum class | C++11 | Scoped, no implicit int conversion |
NULL or 0 | nullptr | C++11 | Unambiguous null pointer, no overload confusion |
| Implicit single-arg constructors | Mark explicit | C++98 | Prevents surprising implicit conversions |
| Unchecked return values | [[nodiscard]] | C++17 | Compiler warns when return value is ignored |
= delete without message | = delete("reason") | C++26 | Documents why the overload is forbidden |
Error Handling
| Avoid | Use Instead | Standard | Why |
|---|---|---|---|
| Error codes + out-params | std::expected<T, E> | C++23 | Composable with .and_then(), .transform(), .or_else() |
assert() macro | contract_assert | C++26 | Visible to tooling, configurable enforcement modes |
Unchecked errno | std::expected or exceptions | C++23 | Forces caller to handle the error path |
| Throwing in constructor for expected failures | Factory returning std::expected | C++23 | No exception overhead for expected failure paths |
I/O and Formatting
| Avoid | Use Instead | Standard | Why |
|---|---|---|---|
printf / sprintf | std::format / std::print | C++20/23 | Type-safe, no format string vulnerabilities |
snprintf for string building | std::format | C++20 | Returns std::string, no buffer management |
std::cout << a << b << c | std::println("{} {} {}", a, b, c) | C++23 | Readable, no stream state issues, faster |
Concurrency
| Avoid | Use Instead | Standard | Why |
|---|---|---|---|
mutex.lock() / mutex.unlock() | std::scoped_lock | C++17 | Exception-safe, supports multiple mutexes (no deadlock) |
std::thread + manual .join() | std::jthread | C++20 | Auto-joins on destruction, supports stop tokens |
volatile for thread sync | std::atomic<T> | C++11 | Actually guarantees atomic operations and memory ordering |
| Manual condition variable notify | std::latch, std::barrier | C++20 | Higher-level, less error-prone synchronization |
| Hand-rolled atomic CAS loops | std::atomic::fetch_max/fetch_min | C++26 | Standard, correct, optimized |
Metaprogramming
| Avoid | Use Instead | Standard | Why |
|---|---|---|---|
std::enable_if / SFINAE | Concepts + requires | C++20 | Readable constraints, clear error messages |
| CRTP for static polymorphism | Deducing this | C++23 | No template boilerplate, works with lambdas |
| Macros for code generation | Static reflection | C++26 | Zero-overhead, composable, type-safe |
std::tuple_element for pack access | Pack indexing T...[N] | C++26 | Direct access, no recursive template machinery |
std::function for non-owning callbacks | std::function_ref | C++26 | No allocation, passable in registers |
Containers
| Avoid | Use Instead | Standard | Why |
|---|---|---|---|
std::map for read-heavy lookups | std::flat_map | C++23 | Cache-friendly, 8-17x faster lookup for small-medium maps |
boost::static_vector | std::inplace_vector | C++26 | Standard, no Boost dependency, fallible API |
std::function (when non-owning) | std::function_ref | C++26 | Zero allocation overhead |
| Raw pointer polymorphism | std::indirect<T>, std::polymorphic<T> | C++26 | Value semantics, copyable, no manual lifetime management |
| Manual iterator loops | std::ranges:: algorithms + views | C++20 | Composable, lazy, no off-by-one |
Requirements and compatibility
Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta
“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.
Security
No issues found by our static scan· No issues found
A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.
Attribution and licence
- Published by
- Trail of Bits
- Publisher
- Trail of Bits (Official)
- Source
- trailofbits/skills · plugins/modern-cpp/skills/modern-cpp · commit e4dd0bb
- Licence
- Creative Commons Attribution-ShareAlike 4.0 International (redistribution allowed)
- LICENSE (added by AutoGineer from LICENSE)
- ATTRIBUTION.md (written by AutoGineer)
- Synced
AutoGineer is not affiliated with or endorsed by Trail of Bits.
Related skills
Implement
Matt Pocock· Community
A structured workflow for implementing software tasks from specifications or tickets.
Software developmentClaude CodeClaude appsOpenAI Codex+14 moreMITGitHub stars of the source repository317.5k
Source Driven Development
Addy Osmani· Community
A rigorous process for grounding code implementation in official, version-specific documentation to ensure accuracy and avoid outdated patterns.
Software developmentClaude CodeClaude appsOpenAI Codex+14 moreMITGitHub stars of the source repository113.9k
Write Swift
Emil Kowalski· Community
A comprehensive guide to writing modern, safe, and performant Swift code following the language's latest idioms and concurrency models.
Software developmentClaude CodeClaude appsOpenAI Codex+14 moreMITGitHub stars of the source repository54.3k
Cardputer Buddy
AnthropicOfficial
Iterate on the Cardputer-Adv MicroPython app bundle (Claude Buddy, Snake, Hello) after the device is already provisioned via m5-onboard. Use when the user wants to add a new app, push a single changed .py without re-flashing, watch device serial logs, or run a one-shot REPL command. Trigger on "add an app", "push to the cardputer", "tail the device", "run on the device", or follow-up work after /maker-setup.
Software developmentClaude CodeClaude appsOpenAI Codex+14 moreApache-2.0GitHub stars of the source repository46.3k
Typescript Pro
Seth Hobson· Community
An expert TypeScript persona focused on advanced typing, enterprise architecture, and strict type safety.
Software developmentClaude CodeMITGitHub stars of the source repository42.3k
Scala Pro
Seth Hobson· Community
An expert Scala engineer persona specializing in functional programming, distributed systems, and enterprise-grade architecture.
Software developmentClaude CodeMITGitHub stars of the source repository42.3k
Download ZIP
The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download modern-cpp.zip