4 ms·

You're not wrong but for some reason this style is easier for me to work with I know logically/semantically they're equivalent. The v-table function generated

You're not wrong but for some reason this style is easier for me to work with I know logically/semantically they're equivalent. The v-table function generated if the method is moved inside the class/struct winds up being identical. Dunno what it is, some kind of familiarity bias with the way the code is laid out I guess, not coming from OOP languages

thelopa 4y ago
Note: it wouldn’t generate a vtable entry unless the method was declared virtual.
- gavinray 4y ago
  Ahh, what do you call the method table thing for non-virtual classes?
  - cornstalks 4y ago
    There is no table if no ‘virtual’ is involved.
    - adrian_b 4y ago
      To be more clear, when no "virtual" method is declared, then no table is generated because none is needed. In this case, the addresses of all the methods are known at compile time and the compiler knows which to choose when anyone is invoked in the source code, based on the type of the object and on the types of the method arguments. When there is at least one "virtual" method and you have a pointer to an object, the type of the object cannot be known at compile-time, so the compiler cannot determine which method to invoke. That is why the compiler needs to create a table with pointers to the virtual methods for each class with such methods, and each object of those classes must include a pointer to the corresponding vtable, so that the correct method to invoke can be determined at run time (from the index of the virtual method).
  - webstrand 4y ago
    C++ uses name mangling to give names to non-virtual methods. They are no different than a C function that takes a pointer, except they may use a different calling convention. Even if the method is virtual, C++ compilers make an effort to call methods directly without indirection through a vtable wherever possible.
    - tialaramex 4y ago
      The interesting thing is that you can't call the "function that takes a pointer". Accessing it as a method is the only thing which works. A long term ambition for C++ and more specifically for Bjarne has been UFCS, Universal Function Call Syntax, which a few other languages have. But C++ can't do this today.
      - cbsmith 4y ago
        Yeah, UFCS remains illusive, but tantalizingly close. It's pretty easy to make ``` struct foo { void bar(); } bar(foo* i) { assert(i != nullptr); i->bar(); } ``` work, but there's enough syntactic complexity in the language that it isn't as easy as it should be.
        kllrnohj 4y ago
        It's a 1-liner with std::mem_fn
        cbsmith 4y ago
        Indeed.
      - deleted 4y ago
        [deleted]
      - kllrnohj 4y ago
        std::mem_fn will effectively give you the underlying function that takes a pointer. Strictly speaking mem_fn is defined to generate the wrapper function, but in practice the optimizer is just going to strip that away and call the name-mangled function directly. Example: https://godbolt.org/z/6Y1raxMce https://godbolt.org/z/6Y1raxMce
  - protomolecule 4y ago
    Only classes with one or more virtual functions have virtual method table. Objects of such classes are called polymorphic objects and they (and only they) have hidden pointer to virtual method table. https://en.cppreference.com/w/cpp/language/object#Polymorphic_objects https://en.cppreference.com/w/cpp/language/object#Polymorphi...
cbsmith 4y ago
> The v-table function generated if the method is moved inside the class/struct winds up being identical. Unless you add some additional semantics/keywords, it's not going to create a vtable. > Dunno what it is, some kind of familiarity bias with the way the code is laid out I guess, not coming from OOP languages. I'm sure that's what it is.

thelopa 4y ago

Note: it wouldn’t generate a vtable entry unless the method was declared virtual.

gavinray 4y ago
Ahh, what do you call the method table thing for non-virtual classes?
- cornstalks 4y ago
  There is no table if no ‘virtual’ is involved.
  - adrian_b 4y ago
    To be more clear, when no "virtual" method is declared, then no table is generated because none is needed. In this case, the addresses of all the methods are known at compile time and the compiler knows which to choose when anyone is invoked in the source code, based on the type of the object and on the types of the method arguments. When there is at least one "virtual" method and you have a pointer to an object, the type of the object cannot be known at compile-time, so the compiler cannot determine which method to invoke. That is why the compiler needs to create a table with pointers to the virtual methods for each class with such methods, and each object of those classes must include a pointer to the corresponding vtable, so that the correct method to invoke can be determined at run time (from the index of the virtual method).
- webstrand 4y ago
  C++ uses name mangling to give names to non-virtual methods. They are no different than a C function that takes a pointer, except they may use a different calling convention. Even if the method is virtual, C++ compilers make an effort to call methods directly without indirection through a vtable wherever possible.
  - tialaramex 4y ago
    The interesting thing is that you can't call the "function that takes a pointer". Accessing it as a method is the only thing which works. A long term ambition for C++ and more specifically for Bjarne has been UFCS, Universal Function Call Syntax, which a few other languages have. But C++ can't do this today.
    - cbsmith 4y ago
      Yeah, UFCS remains illusive, but tantalizingly close. It's pretty easy to make ``` struct foo { void bar(); } bar(foo* i) { assert(i != nullptr); i->bar(); } ``` work, but there's enough syntactic complexity in the language that it isn't as easy as it should be.
      - kllrnohj 4y ago
        It's a 1-liner with std::mem_fn
        cbsmith 4y ago
        Indeed.
    - deleted 4y ago
      [deleted]
    - kllrnohj 4y ago
      std::mem_fn will effectively give you the underlying function that takes a pointer. Strictly speaking mem_fn is defined to generate the wrapper function, but in practice the optimizer is just going to strip that away and call the name-mangled function directly. Example: https://godbolt.org/z/6Y1raxMce https://godbolt.org/z/6Y1raxMce
- protomolecule 4y ago
  Only classes with one or more virtual functions have virtual method table. Objects of such classes are called polymorphic objects and they (and only they) have hidden pointer to virtual method table. https://en.cppreference.com/w/cpp/language/object#Polymorphic_objects https://en.cppreference.com/w/cpp/language/object#Polymorphi...

cbsmith 4y ago

> The v-table function generated if the method is moved inside the class/struct winds up being identical. Unless you add some additional semantics/keywords, it's not going to create a vtable. > Dunno what it is, some kind of familiarity bias with the way the code is laid out I guess, not coming from OOP languages. I'm sure that's what it is.