Alt text:
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
can someone explain what reflections are, plz?
It’s the capability of a program to “reflect” upon itself, I.E. to inspect and understand its own code.
As an example, In C# you can write a class…
public class MyClass { public void MyMethod() { ... } }
…and you can create an instance of it, and use it, like this…
var myClass = new MyClass(); myClass.MyMethod();
Simple enough, nothing we haven’t all seen before.
But you can do the same thing with reflection, as such…
var type = System.Reflection.Assembly.GetExecutingAssembly() .GetType("MyClass"); var constructor = type.GetConstructor(Array.Empty<Type>()); var instance = constructor.Invoke(Array.Empty<Object>()); var method = type.GetMethod("MyMethod"); var delegate = method.CreateDelegate(typeof(Action), instance); delegate.DynamicInvoke(Array.Empty<object>());
Obnoxious and verbose and tossing basically all type safety out the window, but it does enable some pretty crazy interesting things. Like self-discovery and dynamic loading of plugins, or self-configuration of apps. Also often useful when messing with generics. I could dig up some practical use-cases, if you’re curious.
You can also optimize this a bit.
You can use Activator.CreateInstance instead of reflecting and invoking the constructor.
You can also call MethodInfo.Invoke, you don’t need to create a delegate.
Also worth noting that Source Generators have replaced the need for reflection in many cases.
Woah, that’s some meta shit. Neat. :D
It’s pretty cool when you use it right but it’s also really easy to shoot yourself in the foot with, even by C++ standards. For example, in other languages (I’m coming from Java/C# which both have it) it lets you access private/protected fields and methods when you normally wouldn’t be able to.
There’s also a noticeable performance penalty over large lists because you’re searching for the field with a string instead of directly accessing it.
For the times it is necessary (usually serialization-adjacent or dynamic filtering/sorting in a table) to use reflection, it’s faster at runtime than converting an object to a dictionary/hashmap. However, 99% of time it’s a bad call.
If you look at the proposal, this is specifically “static reflection”, i.e. compile-time reflection. So it doesn’t actually have any of the downsides you mention, as far as I can tell.
Not a C++ dev, but looking at Java, which has reflection: Reflection allows to inspect and modify runtime attributes of classes, interfaces, fields and methods. Even, when you don’t know their names at compile time.
Basically take any object and just ask “what are your (even private) fields?” and then happily modify them, or call these methods, or…
Java has reflection since version 1.1. It’s actually quite useful in situations and most popular frameworks use it. It depends on you if it turns into a footgun.
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++.
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.
What macros or attributes provide serialization in C++?
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.
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.
It’s good the core language now has to have a reason before it deletes shit. Speaking of, when do they add full garbage collection and call it c+++?
Garbage collection was at some point part of the spec but was removed in 23.
https://en.cppreference.com/w/cpp/memory/gc/declare_reachable
If wasn’t full garbage collection in the spec. It was some infrastructure support in the spec that would make it easier to write garbage collectors in C++.
There’s C++/CLI if you want to combine garbage collection with the pain of C++
This, however, is about diagnostics, i. e. annotating delete with a reason (message) to express developer intent when deleting a function, not about memory management.
I can see the footguns, but I can also see the huge QoL improvement - no more
std::enable_if
spam to check if a class type has a member, if you can just check for them.… at least I hope it would be less ugly than
std::enable_if
.There’s a pretty big difference though. To my understanding enable_if happens at compile time, while reflection typically happens at runtime. Using the latter would cause a pretty big performance impact over a (large) list of data.
Wouldn’t compilers be able to optimize runtime things out? I know that GCC does so for some basic RTTI things, when types are known at compile time.
For runtime reflection, no, you’d specifically be able to do things that would be impossible to optimize out.
But the proposal is actually for static (i.e. compile-time) reflection anyway, so the original performance claim is wrong.
Yeah, that’s what I was thinking of. I don’t know how C++ could reasonably have Java-like reflections anyway…
C++26 reflection is compiletime
You already can do that with C++20 concepts and the requires expression
template <typename T> concept has_member_foo = requires(T t) { t.foo(); }; // Will fail to instantiate (with nice error // message) if t.foo() is ill-formed template <has_member_foo T> void bar(T t) { // ... } // abbreviated form of above void baz(has_member_foo auto t) { // ... } // verbose form of above template <typename T> requires has_member_foo<T> void biz(T t) { // ... } // same as above but with anonymous concept template <typename T> requires requires(T t) { t.foo(); } void bom(T t) { // ... } // If already inside a function if constexpr (has_member_foo<T>) { // ... } // Same but with anonymous concept if constexpr (requires(T t) { t.foo(); }) { // ... }
I imagine reflections would make the process more straightforward, requires expressions are powerful but either somewhat verbose or possibly incomplete.
For instance, in your example
foo
could have any of the following declarations in a class:void foo();
int foo() const;
template <typename T> foo(T = { }) &&;
decltype([]() { }) foo;
I’m not sure if there’s anything
enable_if
can do that concepts can’t do somewhat better but yeah there’s definitely a lot of subtleties that reflection is going to make nicer or possible in the first placeOh,
std::enable_if
is straight up worse, they’re unreadable and don’t work when two function overloads (idk about variables) have the same signature.I’m not even sure enable_if can do something that constraints can’t at all…
When you are in feature-bloated language competition and your opponent is C++
Awesome, it’s fucking overdue!
-std=C++17
, check.