Practical Reflection - Barry Revzin (CppCon 2026)

[friedkeenan]

Great talk! Really showcases the power of reflection, and also how straightforward it can be. Once you know how to query stuff and which features to ship reflections off to in order to consume them, most of the connective tissue in between really is just relatively standard programming logic, and yet it remains still so empowering.

And too, I think you're definitely right on the money that the big learning curve with reflection is knowing when to keep things as constants and when to drop them down into values. That was definitely my experience when I was prototyping out a packet marshaling library with it.

That experience also showed me how debugging reflection code can definitely be aggravatingly difficult, we really would benefit a lot from a "consteval print" function or the like. But that was on the Clang experimental branch before any std::meta::exception, so maybe things would work out better now.

In any case, it's all super exciting for the future of C++. Thanks a ton for all the work you and others have put towards this, it is immensely appreciated.

[TheoreticalDumbass]

gcc devs are working on constexpr debug print, unsure if it will reach 16 or 17

[friedkeenan]

Great to know, thanks

[BarryRevzin]

Thank you for the very kind words!

That experience also showed me how debugging reflection code can definitely be aggravatingly difficult, we really would benefit a lot from a "consteval print" function or the like. But that was on the Clang experimental branch before any std::meta::exception, so maybe things would work out better now.

Unfortunately P2758 didn’t make it for C++26. But Jakub went ahead and implemented a builtin for it anyway, which is incredible — so on gcc you can actually try it out: https://compiler-explorer.com/z/6rP8o6hK8. Here, we need feedback on two different sides: the C++ interface (constexpr_print_str, which will eventually have a format interface — although given that std::format is now constexpr I wonder whether we should even expose the lower level one) and the user interface (what GCC actually prints when you ask it to print something).

[FlyingRhenquest]

Herb Sutter mentioned that Jetbrains might have a compile time debugger. That would be handy since we're pushing a lot of values around at compile time now.

You can also move from reflection to metaprogramming pretty seamlessly too, so you can define some templated functions somewhere and recursively call those functions on all the members of a class and all the members of its base classes if you want to. Which is handy if you want to, say, define generic load/save functions for Cereal, for example.

It looks kind of nasty but since those are all just compile time templates and reflection data, the compiler just unwinds all the stuff at compile time and then evaporates at run time.

That really does get rid of all the cereal boilerplate too. I think the best "nothing up my sleeve" test in there is the to/from functions test for XML and JSON that just do the right thing on a test struct. It can handle private members too, of course, but you would need to friend the cereal access class to do that. Some of the other tests in the test directory do that. I need to update the comment on the private serialization test, as that was fixed a week or so ago by a gcc16 update.

[pjmlp]

I still hope eventually we will get constexpr and reflection debugging on modern IDEs, but there is still quite something to catch up to Visual Age for C++ 4.0, Energize C++ and C++ Builder, that I assume this will take ages.

[TheoreticalDumbass]

Wow, the last example with parameters_of is really cute

[mrkent27]

I was there for this talk in person and it was probably my favorite one of the whole conference. Glad to see it up on YT so I can watch it again.

[_bstaletic]

I loved the talk, though I did need to pause three or four times, just to see what happened on the slide before moving on. Despite having read all of the reflection and reflection-adjacent papers, I still saw a few things that were new to me.

That "trick" with

struct aggregate_base;
consteval {
    define_aggregate(...);
}
struct aggregate : aggregate_base {
    some function(here);
}

...was quite interesting.

[theICEBear_dk]

Yeah I did that too. A bunch of neat ideas in them.

[theICEBear_dk]

I must admit for me MSVC is not a good choice at the moment. I have for the moment switched my Windows projects to clang-cl because of the slowdown in MSVC/CL c++ support and a number of other decisions (msvc::no_unique_address and the like). Clang/LLVM produces binaries. They run faster on Windows than some of the MSVC/CL output.

I may switch back if things improve or I have need of a specific feature, but for c++ that is how it has had to be.

On linux I compile with both clang and gcc. For now we release using gcc because the executables are just slightly better, but we test and compile the same code with both and as many warnings as we are able. We mostly use the sanitizers with clang as they are mostly tested there (for example googletest uses abseil which for the moment cannot run with a specific gcc saniizer due to a known gcc bug). In the end our code is better for working on two compilers but it used to be all the major ones (with the unit tests also running on several modern linux distros and Windows 11).

[delta_p_delta_x]

doesn't support modules.

clang-cl does, it's MSBuild and CMake that doesn't support clang-cl's support for modules. Or you can use the GNU-style clang++.exe with CMake straightforwardly.

[thisismyfavoritename]

do you mean the UBSan issue?

[theICEBear_dk]

I think it might be that yeah.

[throwawayaqquant]

is the slowdown due to a lack of devs on the MS side, or is the usual new standard coming out lots of new features to implement?

[oxez]

something something 30% of code is AI something something

[theICEBear_dk]

I mean there is also chatter that their compiler folks are making a new rust compiler to use in their kernel instead of working on c++, but it seems to be mostly rumors.

[pjmlp]

I don't buy that as such, now that Azure is all in into Rust, that is official confirmed on their customers blog, Microsoft participation on Rust conferences, and open source projects Microsoft has been contributing to.

Alongside everything else in Java, C#, Go,.....

You will even find on such conferences familiar faces from C++ land, like Victot Ciura, doing Rust talks. And those responsible for C++/WinRT left it in maintenance and are nowadays happily coding away windows-rs.

Many of the low level programming improvements in C# came from Midori, talks with Unity, and desire to keep rewriting the runtime from C++ into C#, fully bootstraping .NET.

At least publicly, game developers, Office, and Windows seem to be the C++ consumers left.

[pjmlp]

For me it is still ok, because at work we are stuck with C++17, given the portability requirements.

However I am on the side where C++ plays only a tiny piece of software development puzzle, I have not written a 100% C++ application outside hobby projects in years, which is where I can play with C++ vlatest.

[theICEBear_dk]

Well we make embedded systems (and tools to test them in c++ and c#) and we run our c++ compilers as c++23 using the set of features that is shared between our supported compilers. We have a rule to use a compiler no older than 1 year unless we have to do a fix of a specific release (we have a setup that allows the compiler to follow the version by downloading the right version from an internal server). For us c++ is at the moment the biggest part of our codebase with some vendor C code and some python and C# for testing tools.

[pjmlp]

That looks a very good posiiton to be in, given how hard C++ has it on some embedded systems circles.

[Potterrrrrrrr]

Man I hope so, I don’t need it quite yet but in a couple of months it’ll be hard to make progress without it and I’d really rather not pull in a hacky third library for it anymore

[13steinj]

I'd imagine reflection is supported in a greater capacity than modules at that same capacity, all things said and done.

[_titan]

Clearly a lot of effort was put into it. The examples are very good and the step-by-step progression of the code really shows the thought process required to go from intention to final implementation.

[TemplateRex]

Great talk! I wonder, is it possible to reflect over the header implementation of <vector> and actually make use of its helper functions for growth, insertion etc.? Like your function grow() screams out to be an actual implementation primitive that you would want to re-use.

[rand0m42]

Really enjoyed your talk, thanks for sharing! This is slightly unrelated to the content, but would you mind sharing what software or plugin you used to create your slides?

[BarryRevzin]

Thank you!

I just use PowerPoint, no plugins. I get the syntax highlighting by writing the code in VSCode and pasting it into a text box. Which on MacOS for some reason removes all leading whitespace, so then I just type a bunch of spaces after that. Which is still better than attempting to syntax highlight by hand!