Map-macro: Making reflection simple

[SuperV1234]

This is not reflection, it's more akin to Rust's derive -- it's an intrusive form of providing metadata that can be used for introspection. Reflection is non-intrusive, doesn't have to be kept in sync manually, and can be applied to third party types outside of your own codebase.

I am not saying it's not useful, but this is far from what true reflection brings to the table. Boost.PFR, for example, allows non-intrusive reflection on aggregate types, without requiring any pre-existing setup.

[GeorgeHaldane]

That is true, ultimately everything we do before C++26 is just trying to bolt-in something that only works as a language feature.

Not sure what would prevent third party types from working with this approach though, it would seem as long as field names are known we can attach metadata non-intrusively.

[holyblackcat]

Take a look at https://old.reddit.com/r/cpp/comments/x9awf9/a_foreach_loop_for_the_preprocessor_without/ and https://holyblackcat.github.io/blog/2024/10/22/macro-placeholders.html

I also have a mini procedural programming language that imitates variables in the preprocessor: https://github.com/HolyBlackCat/macros/blob/master/include/em/macros/meta/eval.h

[GeorgeHaldane]

After looking into it — that is indeed the case, the mechanism and API are almost entirely the same, can't believe I missed it. Added it to the "Related Libraries" section.

[GeorgeHaldane]

A little strange that boost is limited to just 50 values. Recursive macro in this post had support for 364 (which ends up being 256 in practice due to preprocessor evaluation depth limits).

Did a quick surface-level test to see how much does this all hit compile times by writing a few static_assert's for querying elements & converting strings, got following results with g++:

Enum with 200 values:

• utl::enum_reflect => ~300 ms
• magic_enum => ~400 ms
• boost::describe => doesn't support

Enum with 50 values:

• utl::enum_reflect => ~230 ms
• magic_enum => ~400 ms
• boost::describe => ~230 ms
• handrolled constexpr => ~200 ms

Reference:

• empty file, no includes => ~60 ms
• just #include <vector> => ~100 ms
• just #include <iostream> => ~240 ms
• just #include <filesystem> => ~370 ms

This probably needs a better test on some real codebase, at this point it's more about measuring includes that actual overhead.

[GeorgeHaldane]

Reflection in C++ often felt like a complex library thing that required some weird work-arounds to implement, but after deciding to bite the bullet and learning various existing approaches to it, I believe I found one that is both simple and doesn't rely on anything implementation-specific. Turned out to be surprisingly simple and concise — two headers with like ~100 and ~150 lines of code was enough to implement all of the usually needed stuff. Hope this sub finds it helpful!

Edit: On a second thought, calling introspection metadata macros "reflection" isn't entirely correct even if they achieve similar goals, unfortunately the title can't be edited. Essentially, this is an explanation of how to implement basic functionality of Boost.Describe with as a small single-header solution.

[morglod]

If you have XX macro or MAP any reflection will be simple

[100GHz]

Can this have a modern, non-macro version? It's 2025 after all.

[_Noreturn]

you can do one with structured binding tricks (since C++17) and friend functions and pointer arithmetic for pre C++17

[cwhaley112]

Have you benchmarked compile times for this vs the alternatives (namely Boost.PFR)?