Persona Adopted: Senior Systems Architect & C++ Modernization Consultant

Review Group: This material is best reviewed by a Technical Steering Committee (TSC) or Senior Software Engineering Leads tasked with migrating legacy codebases to modern standards. It is also highly relevant for Performance Engineers and Library Maintainers looking to reduce boilerplate and improve compile-time safety.

Abstract:

This technical session, presented at Meeting C++ 2025, addresses the practical adoption of C++20 beyond its heavily publicized "Big Four" features (Concepts, Ranges, Modules, and Coroutines). Alex Dathskovsky argues that while standard adoption lags—with only 43% of developers utilizing C++20—the "minor" features of the standard offer the most immediate value for daily productivity, code safety, and maintenance.

The talk provides a deep dive into language refinements such as the Three-Way Comparison (Spaceship) operator, which significantly reduces boilerplate for comparison logic, and [[no_unique_address]] for memory optimization. Dathskovsky also explores enhancements to template meta-programming, including Non-Type Template Parameters (NTTP) for classes and strings, and the integration of consteval and constinit. The session concludes with an overview of essential library additions, specifically focusing on std::span, the <bit> header for low-level bit manipulation, and new concurrency primitives like std::jthread, semaphores, and barriers.

C++20 Value Realization: Beyond the Big Four

• 0:48 Adoption Statistics: While C++17 has reached majority use, C++20 adoption remains at 43%, representing a significant lag in utilizing modern safety and productivity features.
• 9:42 Abbreviated Function Templates: C++20 allows the use of auto in function parameters, implicitly creating templates. This simplifies generic programming, though Dathskovsky warns of the lack of homogeneity without explicit concepts.
• 14:53 std::remove_cvref_t Utility: A new type trait that simplifies the removal of const, volatile, and reference qualifiers, replacing the more verbose and error-prone "decay" methods used in earlier standards.
• 15:23 Ergonomic Initializers: Designated initializers bring C-style struct initialization to C++, allowing members to be skipped for better readability. Additionally, range-based for loops now support initialization statements, preventing variable leakage outside the loop scope.
• 18:48 The Spaceship Operator (<=>): Implements three-way comparison, automatically generating all relational operators. Dathskovsky notes this can eliminate thousands of lines of boilerplate code in large projects while providing strong, weak, or partial ordering semantics.
• 26:25 Memory Optimization with [[no_unique_address]]: This attribute allows empty member subobjects to occupy zero space, facilitating better memory alignment and more compact data structures, particularly in networking or embedded contexts.
• 29:58 Enhanced Lambdas: Lambdas now support capturing variadic parameter packs and explicit template parameter lists, enabling more complex generic programming within local scopes.
• 34:24 Immediate Functions (consteval): consteval ensures a function is evaluated at compile-time, providing stricter guarantees than constexpr. The talk also highlights constinit for ensuring static variables are initialized at compile-time to prevent initialization order fiascos.
• 37:24 Relaxed NTTP Rules: Non-Type Template Parameters now support floating-point types and literal classes (e.g., fixed strings), enabling compile-time string manipulation and safer template-based DSLs.
• 42:02 Constexpr Polymorphism: C++20 permits virtual functions to be constexpr, allowing traditional polymorphic designs to be executed entirely during compilation.
• 43:31 Library Safety & Performance: Introduction of std::cmp_equal and related functions to prevent signed/unsigned comparison bugs. The session also covers std::span for safe, contiguous memory views and the <bit> header for portable, constexpr bit manipulation (e.g., popcount, endianness checks).
• 56:05 Modern Concurrency Primitives: std::jthread provides RAII-based joining and cooperative cancellation. New synchronization objects include semaphores, latches (single-use countdowns), and barriers (reusable synchronization points with completion callbacks).