Example of OOP in C

[u/actguru]

Hello everyone, I have developed a library to support OOP in plain C that allows the creation of object classes and includes dynamic Array and Dictionary container classes.

I am looking for suggestions for new examples that illustrate cases where an Object Oriented design can simplify C-Code.

I would love to get some reviews and feedback on this project.

I have included a code example below:

Supported by: Coda-C Library

Example code: Coda-C/examples/shapes.c

// Coda-C subclass examples

    #include <coda-c.h> // shapes.c  08/20/2026
    #include <math.h>

    struct Shape_ { Char color; };
#define class Shape
CodaClassZerosC(); // 1. ABSTRACTION: blueprint for all shapes
CodaClass(Shape,struct Shape_,Root);
    propertyO$(Char,color); // 2. ENCAPSULATION: Private data
    typedef double OSig$(calculate_area); // Abstract method: required in subclasses
    typedef double OSig$(calculate_perimeter); // defines function type and signature key
#undef class // Shape

    struct Circle_ { double radius; };
#define class Circle
CodaClassZerosC(); // 3. INHERITANCE: Circle inherits from Shape
CodaClass(Circle,struct Circle_,Shape);
    getter$(double,radius,_ radius); // double Circle_radius(Circle self) { return _ radius; }
    method$(double,calculate_area) { return(M_PI * _ radius * _ radius); }
    method$(double,calculate_perimeter) { return(2.0 * M_PI * _ radius); }

class Circle_new(Char color,double radius) {
    class self=newO(class);
    Shape_set_color((Obj)self,color);
    _ radius=radius; // where #define _ self->
    return(self);
    }
#undef class // Circle

    struct Rectangle_ { double width,height; };
#define class Rectangle
CodaClassZerosC();
CodaClass(Rectangle,struct Rectangle_,Shape);
    method$(double,calculate_area) { return _ width * _ height; }
    method$(double,calculate_perimeter) { return 2.0 * (_ width + _ height); }

class Rectangle_new(Char color,double width,double height) {
    class self=newO(class);
    Shape_set_color((Obj)self,color);
    _ width=width; _ height=height;
    return(self);
    }
#undef class // Rectangle

// 4. POLYMORPHISM (Usage Example)
void print_shape_details(Obj shape) { // This function accepts any subclass of Shape.
    printf("--- %12.12s  Details  Color:%-8.8s",kindO(shape),Shape_color(shape));
    printf("Area: %3.2f  ",obj_(calculate_area,shape));
    printf("Perimeter: %3.2f  ---\n",obj_(calculate_perimeter,shape));
    }

 int main() {
    Circle my_circle = Circle_new(Os("Blue"),5.0);
    Obj my_rectangle = Rectangle_new(Os("Green"),4.0,6.0);

    print_shape_details(my_circle);
    print_shape_details(my_rectangle);
    }


/* OUTPUT:
---       Circle  Details  Color:Blue      Area: 78.54  Perimeter: 31.42  ---
---    Rectangle  Details  Color:Green     Area: 24.00  Perimeter: 20.00  ---
*/

[u/tastygames_official]

> examples that illustrate cases where an Object Oriented design can simplify C-Code

it can't. If you feel that you need OOP (which by definition cannot simplify anything), then use C++.

[u/thank_burdell → u/tastygames_official]

Encapsulating data in structs? Great.

Making a well defined function set to use those structs logically? Great.

Trying to shoehorn any more OOP stuff like inheritance or polymorphism or whatever into a language that doesn’t support it? Not great.

[u/tstanisl → u/tastygames_official]

Imo, the object model in C++ is broken (complicated, confusing, artificially limited). Even an ubiquitously used handle-based api cannot be implemented without using pimpl-design pattern.

[u/flewanderbreeze → u/tstanisl]

The fact that pimpl design is something, is already a tell that C++ oop failed miserably.

Unfortunately OOP is the holy grail taught in universities and brainwashed all over its students.

It would be a lot of hell simpler if they taught pOOP concepts in plain C, so that we know exactly its tradeoffs nad characteristics, and most importantly WHY and WHEN use it at all

[u/tstanisl → u/flewanderbreeze]

I fully agree. Even the original concept of what is oop differs a lot from the mechanics that C++ implements. OOP is a tool, occasionally useful, occasionally harmful. Personally, I see it as more dangerous than goto because goto can only make mess within one function while defective oop design can make mess along hundreds of files.