Mimicking function Overriding in C - c

Question

To be specific: Function overriding with the ability to call the base overridden methods.
There are two pieces to this. One is the pre-compiled library code (1), and the other is the User of the Library code (2). I'm implementing a smallest possible, classic Person and Employee example here.
Will highly appreciate a response from a hardcore C developer who knows OOP concepts. I'm developing both Library and User of the Library code, so I've control in both places.
1 A) Library Code (Pre-compiled)
person.h
typedef struct Person Person;
struct Person {
char* name;
void (*display)(const Person *self);
};
Person* PersonNew(char* name);
person.c
static void display(const Person *self) {
printf("Name: %s\n", self->name);
}
Person* PersonNew(char* name) {
Person* self = malloc(sizeof(Person));
if(self == NULL) return NULL;
self->name = strdup(name);
self->display = display;
return self;
}
1 B) Library can receive structs with composed Persons via pointers because it's library's responsibility to print these structs (therefore library doesn't know the existence of Employee struct)
void print(Person *person) {
person->display(person); // problem, can only print name, no company
}
2) The user of the Library Code
employee.h
typedef struct Employee Employee;
struct Employee {
Person super;
char* company;
void (*display)(const Employee *self);
};
Employee* EmployeeNew(char* name, char* company);
employee.c
static void display(const Employee *self) {
self->super.display(&self->super); // re-use super display
printf("Company: %s\n", self->company);
}
Employee* EmployeeNew(char* name char* company) {
Employee* employee = malloc(sizeof(Employee));
if(employee == NULL) return NULL;
free(employee->super); // I also have memory leak issue.
employee->super = *PersonNew(name); // library method to get struct with functions.
employee->company = strdup(company);
employee->display = display; // it's own version of display
return employee;
}
main.c
Employee *employee = EmployeeNew("John", "Acme");
print(employee); // problem, calls base method, prints name only
// employee->display(); // works fine, but the requirement is somehow enable library code to be able to call employee version of display.

Answer 1

Since you put Person at the beginning of Employee hence there is no issue, but if you move to other location, it might lead to exception.
The Employee struct will look like:
struct Employee {
char* name;
void (*display)(const Person *self);
char* company;
void (*display)(const Employee *self);
};
Hence when you pass to print, since the print accepts only upper part of Employee:
struct Employee {
char* name;
void (*display)(const Person *self);
};
the call of display will redirect to display of Person. hence there is only name printing.
To override Person's display, let change these two structs to:
struct Person {
void (*display)(const Person *self);
char* name;
};
struct Employee {
void (*display)(const Employee *self);
Person super;
char* company;
};
By moving all operands to beginning of struct, it will work -> but this is dangerous.

Answer 2

A quick and rather unsophisticated way to do it could be something like the following.
typedef struct Person Person;
typedef void (*DISPLAYPROC)(const Person* self);
struct Person {
char* name;
DISPLAYPROC display;
};
void ConstructPerson(Person* self, const char* name);
Person* NewPerson(const char* name);
void person_display(const Person* self);
void person_display(const Person* self) {
printf("Name: %s\n", self->name);
}
void ConstructPerson(Person* self, const char* name)
{
self->name = _strdup(name);
self->display = person_display;
}
Person* NewPerson(const char* name) {
Person* self = (Person *)malloc(sizeof(Person));
if (self == NULL) return NULL;
ConstructPerson(self, name);
return self;
}
void print(Person* person) {
person->display(person); // dispatched at runtime to the right 'display'
}
typedef struct Employee Employee;
struct Employee {
Person super;
char* company;
};
void ConstructEmployee(Employee* self, const char* name, const char* company);
Employee* NewEmployee(const char* name, const char* company);
void employee_display(const Employee* self);
void employee_display(const Employee* self) {
person_display((const Person*)self);
printf("Company: %s\n", self->company);
}
void ConstructEmployee(Employee* self, const char* name, const char* company)
{
ConstructPerson(&self->super, name);
self->super.display = (DISPLAYPROC)employee_display;
self->company = _strdup(company);
}
Employee* NewEmployee(const char* name, const char* company) {
Employee* self = (Employee *)malloc(sizeof(Employee));
if (self == NULL) return NULL;
ConstructEmployee(self, name, company);
return self;
}
int main()
{
Person* person = NewPerson("Bob");
print(person); // calls person_display
Employee* employee = NewEmployee("John", "Acme");
print((Person*)employee); // calls employee_display
free(person);
free(employee);
}
A few notes:
Person is embedded as a field (not a pointer) in Employee so that the casts are legal between Person* and Employee*;
the New/Construct functions separate the initialization from the allocation, which was mentioned in the comments before.
the display functions are made visible (not static) so that a "derived" class can call the "base" function.
Left for the reader to fill in:
Destruct functions paired with the Construct ones, so that the allocated strings get duly freed;
separation of data initialization from "vtable" initialization, so that for example the display pointer is not initialized twice in ConstructEmployee (once in the nested ConstructPerson then overwritten immediately after in ConstructEmployee).

Answer 3

Filling in Destruct function for the review only. Destruction of Derived class first before the Base class.
employee.c
void EmployeeDestruct(Employee *self) {
free(self->company); // destruct derived first
PersonDestruct(&self->super); // then destruct base
}
person.c
void PersonDestruct(Person *self) {
free(self->name);
// free(self); // removing since it'd fail badly for local stack vars
}