Here is the abstract and summary for the provided transcript.

Abstract:

This blog post presents a technical exploration of the new C++26 Reflections feature (P2996) by demonstrating how to generate a PlantUML class diagram at compile time. The author walks through the process of creating a consteval function that recursively inspects a class's structure, including its data members and base classes. Key concepts covered include the ^^ (lift) operator for entering the "meta" space, the use of std::meta::info to represent reflected entities, and iterating over members with std::meta::nonstatic_data_members_of. A central challenge addressed is the inability to return a heap-allocated std::string from a compile-time function, which is solved by using the proposed std::define_static_string to create a static string literal containing the final UML code. The post serves as a practical example of the power and convenience that compile-time reflection brings to C++ metaprogramming.

Generating UML at Compile Time with C++26 Reflections

• (0:00) The Goal: Automated UML Generation. The author's motivation is to automate the tedious manual process of drawing UML class diagrams for a codebase. This experiment uses the new C++26 Reflections feature to generate the diagram programmatically.
• (0:00) Key Reflection Operators: ^^ and [: :]. The post introduces the core operators from the C++26 proposal P2996. The lift operator (^^) takes a type or variable and "lifts" it into a compile-time "meta" space as a std::meta::info object. The splice operator ([: :]) does the reverse.
• (0:00) Compile-Time String Generation. A key implementation detail is handling strings at compile time. A consteval function cannot return a standard std::string because it's allocated on the heap. The solution is to use std::define_static_string, a new utility that takes a compile-time string and creates a static string literal, which can then be returned and used at runtime.
• (0:00) Inspecting Classes with Reflection. The code uses std::meta::nonstatic_data_members_of to get a collection of a class's members. It then iterates through them to build the UML relationships (e.g., composition). This process requires a std::meta::access_context to define the visibility rules for the reflection query (e.g., public members only).
• (0:00) Recursive Diagram Construction. The function works recursively, analyzing the type of each data member to build out the full dependency graph. This involves helper functions to handle pointers and qualifiers (const/volatile) and using std::meta::is_type to check if a meta::info object represents a type or a value.
• (0:00) The Final Output. The end result of the consteval function is a single, complete string literal containing the PlantUML diagram code. This string is then printed to the console at runtime, demonstrating that the entire class structure was successfully analyzed and converted into a diagram before the program even started running.

Hacker News Discussion Highlights

The discussion on Hacker News presents a polarized debate on the utility and adoption of modern C++ features like reflection.

• The Case for Modern C++ & Reflection:

  • Essential for High-Performance Systems: Commenters from fields like high-frequency trading and critical data infrastructure state that their teams eagerly adopt new C++ features as they offer significant improvements in performance, reliability, and expressiveness.
  • Replaces Cumbersome Tooling: Reflection is seen as a "god-send" that will replace complex, error-prone solutions like custom code generators, macro-heavy libraries (e.g., for serialization), and managing separate Interface Description Languages (IDLs).
  • Standardization is Better: It provides a standardized, in-language way to achieve what places like CERN have been doing for decades with custom, ad-hoc reflection libraries (like reflex and cling).
  • Potential for Faster Compiles: Proponents argue that modern features like constexpr if and reflection can actually improve compile times compared to the convoluted template metaprogramming hacks they replace.

• The Case Against & Skepticism:

  • "Lego" vs. "Shipping Software": A major counter-argument is that "modern C++" enthusiasts are more interested in language features for their own sake ("playing with legos") rather than shipping practical software. The problem of reflection is considered "solved for years" by external tooling.
  • Compile Time & Stability Concerns: Skeptics predict that new features will increase compile times, introduce unpredictability, and take years to become stable and widely supported across compilers, making them unsuitable for production environments.
  • Slow Corporate Adoption: Many real-world projects and corporate coding standards are slow to adopt new standards, often sticking with older, more established versions like C++11 for stability and toolchain compatibility.
  • The "Two-Language Problem" is a Feature: Some argue that using a separate IDL as the "source of truth" for data structures is a deliberate and beneficial design choice, not a problem to be solved.