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++.

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.

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(); }) {
    // ...
}