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

  • Sonotsugipaa@lemmy.dbzer0.com
    link
    fedilink
    English
    arrow-up
    12
    ·
    1 month 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.

    • Zangoose@lemmy.worldOP
      link
      fedilink
      arrow-up
      7
      arrow-down
      1
      ·
      edit-2
      1 month 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.com
        link
        fedilink
        English
        arrow-up
        2
        ·
        1 month 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
          link
          fedilink
          arrow-up
          6
          ·
          1 month 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.

    • azi@mander.xyz
      link
      fedilink
      arrow-up
      1
      ·
      1 month 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.com
        link
        fedilink
        English
        arrow-up
        2
        ·
        edit-2
        1 month 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
          link
          fedilink
          arrow-up
          2
          ·
          edit-2
          1 month 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.com
            link
            fedilink
            English
            arrow-up
            2
            ·
            1 month 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…