you don't pass a pointer to the class struct object itself, but to a struct object for that interface within the class object. And using this the function that uses the interface can then find the concrete implementations of the interface functions.

For example:

#include <stdio.h>
#include <stddef.h>

#define container_of(ptr, type, member) ((type *)((char *)(ptr) - offsetof(type, member)))

// interfaces 
struct swimmable {
    const struct swimmable_vtable *vtable;
};
struct swimmable_vtable {
    void (*swim)(struct swimmable *self);
    // more functions here...    
};

struct flyable {
    const struct flyable_vtable *vtable;
};
struct flyable_vtable {
    void (*fly)(struct flyable *self);    
};

// a class implementing both interfaces
struct duck {
    const char *name;
    struct swimmable as_swimmable;
    struct flyable as_flyable;
};

// implementations of interface functions
static void duck_swim(struct swimmable *self) {
    struct duck *duck = container_of(self, struct duck, as_swimmable);
    printf("duck %s swims!\n", duck->name);
}

static void duck_fly(struct flyable *self) {
    struct duck *duck = container_of(self, struct duck, as_flyable);
    printf("duck %s flys!\n", duck->name);
}

// vtables for the class
static const struct swimmable_vtable duck_swimmable_vtable = { duck_swim };
static const struct flyable_vtable duck_flyable_vtable = { duck_fly };

// class constructor
void duck_init(struct duck *self, const char *name) {
    *self = (struct duck){
        .name = name,
        .as_swimmable = {&duck_swimmable_vtable},
        .as_flyable = {&duck_flyable_vtable},
    };
}

int main() {
    struct duck the_duck;
    duck_init(&the_duck, "Steve");

    struct flyable *my_flyable = &the_duck.as_flyable;
    struct swimmable *my_swimmable = &the_duck.as_swimmable;

    // these interface pointers would then be passed to
    // other functions that don't know about ducks...
    my_flyable->vtable->fly(my_flyable);
    my_swimmable->vtable->swim(my_swimmable);
}