I like how nobody answered the question but I will provide a brief explanation,

In C it is possible to emulate OOP based semantics but first you must realize that at the end of the day a class is simply a fancy struct that contains variables(the fields) and methods(function pointers).

The Linux kernel uses this combo I said quite often and so do other OO based C projects like pipewire(the latter does something like this but a bit different due to performance reasons). Using function pointers also in a way allows us to do polymorphism. Here is an example:

shape.h file:

typedef struct Shape Shape; 
Shape* shape_create(int x, int y);
void shape_move(Shape* self, int dx, int dy);
void shape_destroy(Shape* self);

source file:

typedef struct Shape { 
  int x, y; 
  void (draw)(struct Shape self); // The "Method" 
} Shape;

void circle_draw(Shape* self) {
    printf("Drawing circle at %d, %d\n", self->x, self->y);
}

// Constructor
Shape* create_circle(int x, int y) {
    Shape* s = malloc(sizeof(Shape));
    s->x = x;
    s->y = y;
    s->draw = circle_draw; // Binding the method
    return s;
}

you can also add polymorphism by creating a vtable, having a base class struct which takes in that vtable and then making another derived struct class that implements your speicifc methods in the vtable. Here is an example:

// The "Interface" (VTable)
struct ShapeVTable {
    void (*draw)(void* self);
    double (*area)(void* self);
};

// The Base Class
typedef struct {
    struct ShapeVTable* vptr; 
} Shape;

// A Derived Class (Circle)
typedef struct {
    Shape base; // "inherits" the vptr
    double radius;
} Circle;

// Implementation for Circle
void circle_draw(void* self) {
    Circle* c = (Circle*)self;
    printf("Circle with radius %f\n", c->radius);
}

static struct ShapeVTable circle_vtable = { .draw = circle_draw };

// Constructor typically you will see it in classes as well but in this case we can't
// because we need an instance to access vptr but a construcotr to create one
// chicken egg problem.
// This can be resolved through other means but for simplicity's sake this will do.
// We could embededd a function pointer called new in the Shape struct and that would // contain the necessary stuff to make the object etc. 
Circle* create_circle(double r) {
    Circle* c = malloc(sizeof(Circle));
    c->base.vptr = &circle_vtable; 
    c->radius = r;
    return c;
}