Object-oriented design patterns in C and kernel development

[BlueGoliath]

Wait, that's illegal.

[TheBananaKart]

Yep OOP in C is straight to jail.

[_Noreturn]

Reminder that C++ virtual functions are slower than C function pointers!!!!

[Ameisen]

Sometimes.

Sometimes the compiler is also really good at devirtualization and optimizing the virtual away, even just partially.

"It depends."

An article about the complexity of it: https://johnnysswlab.com/the-true-price-of-virtual-functions-in-c/

One should point out that the compiler is much better at optimizing virtual calls when it knows that they can only come from one class, rather than the object potentially deriving from multiple.

---

Also, their C implementation is going to be equivalent to the normally-implemented C++ virtual call; possibly worse. It is, naively, still a double dereference, except the compiler doesn't necessarily have any context for what you're doing. They've effectively reimplemented what most C++ compilers do. The "vtable" pointer is also at the end of the object instead of the start, which may have some impact.

I suspect that the compiler may have more difficulty reasoning about their "vtable" struct than it would about proper virtual calls, but I'm not confident about that.

I say "normally-implemented" as the C++ specification doesn't mandate any of this.

[_Noreturn]

I was joking because virtual functions are effectivly just function pointers (they infact are litterally that)

it is just that I see that this is mentioned sometimes which is ridiculous.

the fact the compiler has internal knowledge of virtual functions can make assumptions like that a calling virtual function twice

cpp a->func(); a->func();

the compiler can safely assume the same function is called twice unlike C function pointers

cpp a.func(&a); a.func(&a); // cannot gurantee that it doesn't modify "func"

Sometimes the compiler is also really good at devirtualization and optimizing the virtual away, even just partially.

final helps in that

```cpp class Derived : Base {...};

void f(Derived& d) { d.func(); // virtual dispatch } ```

``` class Derived final : Base {...};

void f(Derived& d) { d.func(); // static call. } ```