Target Audience: Systems Architecture Review Board

The ideal group to review this material would be a Systems Architecture Review Board or a Technical Steering Committee. These senior stakeholders are responsible for evaluating the stability, performance gains, and maintenance costs of migrating enterprise codebases to new language standards (C++23).

Abstract:

This technical presentation by Alex Dathskovsky at Meeting C++ 2025 evaluates the practical implementation and performance implications of the C++23 standard. The discourse shifts from the foundational changes of C++20 to the refinement-focused features of C++23, specifically targeting performance optimization, reduced boilerplate, and modernized asynchronous programming. Key language enhancements discussed include explicit object parameters ("deducing this"), multi-dimensional subscript operators, and static call operators to eliminate this pointer overhead. On the library side, the focus remains on the standardization of high-utility tools like std::print, std::expected, and the std::generator for coroutines. The speaker argues for immediate adoption, citing significant improvements in code safety (e.g., dangling reference detection) and a drastic reduction in coroutine-related complexity.

Review of C++23 Implementation and Architectural Enhancements

• 0:44 Adoption Strategy: Current data shows only 26% C++23 adoption. Architects are encouraged to skip C++20 in favor of C++23 for non-MISRA environments to leverage improved safety and performance "postmodern" features.
• 4:13 Advanced Feature Testing: C++23 expands the macro-based feature testing system, allowing developers to detect specific library and language capabilities (e.g., __cpp_lib_constexpr_string) to maintain cross-compiler compatibility.
• 7:27 Preprocessor Modernization: The introduction of #elifdef and #elifndef eliminates "arrow pattern" nested conditionals. The addition of #warning allows for non-fatal diagnostic messaging during the build process.
• 9:11 Multi-dimensional Subscripting: operator[] now supports multiple arguments. This resolves the performance overhead of "peeling" nested arrays and replaces the syntactically ambiguous use of operator() for tensor and matrix access.
• 14:02 Static Operator Overloading: Functors and lambdas can now define static operator(). This eliminates the implicit this pointer, reducing assembly instructions (Risk-5 example) by avoiding unnecessary stack pushes and effective address loading.
• 18:19 Lambda Attribute Support: Lambdas now support both prefix and postfix attributes, enabling features like [[nodiscard]] on the call operator itself.
• 20:10 Decaying Copy (auto(x)): The auto(x) and auto{x} syntax forces a PR value copy/conversion. This is critical for ensuring performance with non-trivial types and resolving syntax ambiguities where the compiler might misinterpret expressions as function declarations.
• 23:32 New Literal Suffixes: The standard introduces uz for size_t and z for signed size_t (ssize_t), facilitating more portable and readable integer literals.
• 25:07 Safety in Moves and Returns: C++23 mandates compiler errors for returning dangling references to locals in specific scenarios and simplifies Named Value Return (NVR) rules, ensuring implicit moves occur even when parenthesized.
• 32:00 Language-Level Constant Evaluation: The if consteval statement replaces the library-based std::is_constant_evaluated(). This prevents common logic errors where if constexpr would always evaluate to true regardless of the runtime context.
• 34:05 Explicit Object Parameters ("Deducing This"): By specifying the this parameter explicitly (e.g., (this self, T value)), developers can:
  • Eliminate the "CRTP" (Curious Recurrent Template Pattern) in favor of simpler templates.
  • Remove massive amounts of boilerplate for const/non-const/ref-qualified overloads.
  • Enable recursive lambdas by passing the lambda to itself.
  • Optimize small class performance by passing by value rather than through a pointer.
• 43:40 Coroutine Lambda "Fiasco" Fix: Using explicit object parameters by value in coroutines prevents lifetime issues where captured variables in lambdas would expire before the coroutine completed its execution.
• 48:19 Coroutine Generators: The std::generator<T> type reduces the implementation of custom iterators from ~200 lines of boilerplate to roughly 5 lines, abstracting promise types and handle management.
• 51:10 Standardized I/O and Formatting: std::print and std::println are introduced to replace the overhead of iostream. These are based on the FMT library, providing compile-time string checking and faster execution.
• 52:04 Monadic Error Handling: std::expected provides a monadic interface for error propagation without exceptions. Monadic operations (.and_then(), .or_else()) are also backported to std::optional.
• 54:40 Diagnostics and Optimization: std::stacktrace allows for runtime inspection of the call stack. For memory-bound performance, std::flat_map and std::flat_set provide cache-friendly, contiguous-memory alternatives to node-based containers.
• 57:10 MDSpan Status: While std::mdspan is standardized for generic multi-dimensional views, current compiler support is lagging. Developers are advised to use the Kokkos library as a temporary polyfill.