
Object oriented programming in C (2007) - fanf2
http://ldeniau.web.cern.ch/ldeniau/cos.html
======
memco
Casey Muratori recently gave a great talk during a Q&A talking about the way
he uses C to achieve some of the same things people typically think of as
object oriented (starts around 19:39)[0]. It doesn’t cover everything that
makes up OO design but I like it because highlights how C is powerful and
capable of things like polymorphism in a cleaner way than C++.

[0][https://hero.handmade.network/episode/chat/chat014#1179](https://hero.handmade.network/episode/chat/chat014#1179)

~~~
unkown-unknowns
Direct link to video at 19:39
[https://www.youtube.com/watch?v=EhtxDXlrJ6Y&t=19m39s](https://www.youtube.com/watch?v=EhtxDXlrJ6Y&t=19m39s)

------
teporxahor
There's also the book from Axel T. Schreiner:
[https://www.cs.rit.edu/~ats/](https://www.cs.rit.edu/~ats/)

------
catnaroek
This isn't surprising. All that you need to write object-oriented programs
(not necessarily in a convenient manner) is some form of dynamically
dispatched procedure calls.

~~~
theyregreat
Yup. Pointers to functions and call equivalence of functions and pointers to
functions are that in C. Prototype interfaces (ie plugins) are trivially had
with a struct containing pointers to such common API functions. The plugin
just needs an init function that returns a pointer to such a const structure,
and you’re in business.

Another popular trick is to use opaque structs for private data contained in
the public struct in the header. Then, the private code defines the private
struct. It’s not perfect information hiding but it separates what is intended
public and what is intended to be private.

    
    
        /* foo.h */
        #ifndef FOO_H
        #define FOO_H
    
        typedef struct _foo_ctx_t {
                int timeout;
                void *priv;
        } foo_ctx_t;
    
        #ifdef _cplusplus
        extern “C” {
        #endif
    
        foo_ctx_t *foo_init(foo_ctx_t *self);
        int foo_bar(foo_ctx_t *self);
    
        #ifdef _cplusplus
        }
        #endif
    
        #endif /* FOO_H */
    
    
        /* foo.c */
        #include “foo.h”
    
        #include <stdlib.h>
    
        #define PRIVATE(var) ((foo_private_ctx_t *)(self->priv)->(var))
    
        typedef struct _foo_private_ctx_t {
                int whatever;
        } foo_private_ctx_t;
    
        foo_ctx_t *
        foo_init(foo_ctx_t *self) {
                self->timeout = 1000;
                self->priv = malloc(sizeof(ctx_private_ctx_t));
                if (!self->priv) return NULL;
                PRIVATE(whatever) = 0;
                return self;
        }
    
        int
        foo_bar(foo_ctx_t *self) {
                PRIVATE(whatever) += self->timeout;
                return 1;
        }

------
thisisadumb
just use c++ dude

~~~
novium
There are still a few reasons to use C even to this day and I'd add that the
page was last updated in 2007.

~~~
CyberDildonics
Unless it's compile speed or not having an updated C++ compiler for your
platform, I'm not sure what that would be.

Edit: Is it the new thing to hate on C++? Downvotes aren't arguments

~~~
wruza
It was never a new thing, afaicr.

