A screenshot from the linked article titled "Reflection in C++26", showing reflection as one of the bullet points listed in the "Core Language" section

you are viewing a single comment's thread
view the rest of the comments

[–] Zangoose@lemmy.world 3 points 2 months ago* (last edited 2 months ago) (2 children)

See my other comment for more detials but it kind of destroys the type safety of the language. In Java for example, it lets you modify private/protected fields and call private/protected methods.

It's also slower than accessing a field normally since you need to do a string lookup (but slightly faster than a hashmap/dictionary) so if you use it over a large enough list it'll cause slowdowns.

Most use cases for it in Java/C# revolve around testing, serialization, and dynamic filtering/sorting. And most of those cases can be handled more safely using macros/attributes (EDIT: and templates as well, though those are also pretty painful to deal with) because that gets handled at compile-time in C/C++.

[–] rimjob_rainer@discuss.tchncs.de 5 points 2 months ago

You have to see it as "root"-mode, it gives you the means to do stuff you need to do but cannot do otherwise. Most times it's for workarounds for problems you can't solve. If you use reflection you are fully responsible.

Of course you normally shouldn't use it, in 10 years I used it maybe one or two times. It's more of a last resort.

[–] BatmanAoD@programming.dev 1 points 2 months ago (1 children)

What macros or attributes provide serialization in C++?

[–] Zangoose@lemmy.world 1 points 2 months ago (1 children)

My bad, that's on me, it looks like the C++ libraries I found use either templates or boost's reflection. There might be a way to do it with macros/metaprogramming but I'm not good enough at C/C++ to know.

I'm learning rust and C at the same time and was mixing up rust's features with C's. Rust's answer to reflection is largely compile-time macros/attributes and I mistakenly assumed C's attributes worked similarly since they have the same name.

[–] BatmanAoD@programming.dev 3 points 2 months ago

Ah. Rust's macros and the C preprocessor's exist in vastly different universes. The C preprocessor is literally just a fancy programmatic copy-and-paste tool. Rust macros read the input source code and then execute other source code (the macro definition) to generate new source code that the compiler then reads.

I love Rust, but Rust macros are arguably more of a footgun than compile-time reflection would be, and as amazing as serde is (and no, there's nothing comparable in standard-compliant C++ yet), there's a strong argument that compile-time reflection would be a preferable technique for deriving serialization, argument-parsing, and similar feature.