Source

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

  • rimjob_rainer@discuss.tchncs.de
    1·
    12 days ago

    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.

  • Sonotsugipaa@lemmy.dbzer0.comEnglish
    1·
    12 days ago

    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.

    • azi@mander.xyz
      1·
      6 days ago

      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(); }) {
    // ...
}
      • Sonotsugipaa@lemmy.dbzer0.comEnglish
        2·
        5 days ago

        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;
        • azi@mander.xyz
          2·
          5 days ago

          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 place

          • Sonotsugipaa@lemmy.dbzer0.comEnglish
            2·
            5 days ago

            Oh, 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…

    • Zangoose@lemmy.worldOP
      0·
      12 days ago

      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.

      • Sonotsugipaa@lemmy.dbzer0.comEnglish
        0·
        12 days ago

        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.

        • BatmanAoD@programming.dev
          1·
          12 days ago

          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.

    • JakenVeina@lemm.eeEnglish
      0·
      12 days ago

      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.

        • Zangoose@lemmy.worldOP
          0·
          12 days ago

          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.

          • BatmanAoD@programming.dev
            1·
            12 days ago

            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.

  • key@lemmy.keychat.orgEnglish
    0·
    12 days ago

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