Modern Cpp

作者 trailofbits82fe82262526無授權條款7.4K 個星標收錄於 2026年10月8日更新於 2026年10月8日儲存庫昨天更新

Guides C++ code toward modern idioms (C++20/23/26). Use when writing new C++ code, modernizing legacy patterns, or working on security-critical C++. Replaces raw pointers with smart pointers, SFINAE with concepts, printf with std::print, error codes with std::expected.

僅含說明Software Development Security

AI 產生的概覽

引導 C++ 程式碼採用現代 C++20/23/26 慣用語法，取代舊式寫法並加入編譯器強化。

功能: 這個技能提供撰寫與現代化 C++ 程式碼的指引，採用 C++20、C++23 與 C++26 慣用語法。它提供反模式替換表、決策樹、依實際可用性排序的功能分層、編譯器強化旗標、sanitizer 建議以及最佳實務檢查清單。它也指向涵蓋反模式、標準功能與安全慣用語法的參考文件。
適用情境: 適用於撰寫新的 C++ 函式、類別或函式庫，現代化 C++20 之前的程式碼，在舊式與現代做法之間做選擇，或處理安全關鍵的 C++ 程式碼。不適用於純 C 程式碼、建置系統設定，或明確要求舊標準的專案。
執行需求: 不含指令碼，僅有說明與參考文件。它假定已有 C++ 工具鏈；強化指引部分涉及 GCC 或 Clang 等編譯器與 sanitizer，但技能本身不會安裝或執行任何內容。

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.md

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.md

Feature 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=zero
Hardened libc++ — -D_LIBCPP_HARDENING_MODE=_LIBCPP_HARDENING_MODE_FAST for ~0.3% overhead bounds-checking
Sanitizers in CI — ASan + UBSan as minimum; TSan for concurrent code
Warning flags — -Wall -Wextra -Wpedantic -Werror

See compiler-hardening.md.

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 than assert(), 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,now

-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,now

Clang-Specific

Hardened libc++ (Clang/libc++ only)

Google 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

來源與署名

來源：trailofbits/skills位於plugins/modern-cpp/skills/modern-cpp提交82fe822

授權條款：無授權條款

內容歸原作者所有。SourceWeft 從公開儲存庫中收錄這些內容。

檢舉或申請下架

Modern Cpp

Modern C++

When to Use This Skill

When NOT to Use This Skill

Anti-Patterns to Avoid

Decision Tree

Feature Tiers

Tier 1: Use Today (C++20/23, solid compiler support)

Tier 2: Deploy Now (no standard bump needed)

Tier 3: Plan For (C++26, worth restructuring around)

Tier 4: Watch (C++26, needs maturation)

Compiler Hardening Quick Reference

Essential Flags (GCC + Clang)

Clang-Specific

Hardened libc++ (Clang/libc++ only)

Rationalizations to Reject

Best Practices Checklist

Read Next

來源與署名

更多來自 trailofbits/skills 的技能

Vector Forge

Wycheproof

Ruzzy

Ossfuzz

Libfuzzer

Trailmark

更多Software Development技能

Playground

M5 Onboard

Cardputer Buddy

Web Design Guidelines

Vercel React Native Skills

Vercel React Best Practices