How can Inheritance be modelled using C?

Modelling Inheritance in C: A Deep Dive into Object-Oriented Concepts

Explore how the fundamental principles of object-oriented inheritance can be effectively simulated and implemented in the C programming language, despite its lack of native OOP features.

C is a powerful procedural programming language, renowned for its performance and low-level control. While it doesn't natively support object-oriented programming (OOP) concepts like classes, objects, and inheritance, it's entirely possible to model these paradigms using C's features. This article will guide you through the techniques to simulate inheritance, enabling you to write more modular, reusable, and maintainable C code that mimics an OOP style. We'll cover struct embedding, function pointers, and constructor/destructor patterns to achieve this.

The Foundation: Struct Embedding and Polymorphism

At the heart of C-style inheritance lies the concept of struct embedding. By including a 'base' struct as the first member of a 'derived' struct, we can achieve a form of 'is-a' relationship. This structural arrangement is crucial for simulating polymorphism through pointer casting. When a pointer to the derived struct is cast to a pointer to the base struct, it effectively points to the embedded base struct, allowing us to treat derived objects as base objects. This technique is particularly powerful when combined with function pointers for method overriding.

Struct Embedding for Inheritance in C

#ifndef BASE_H
#define BASE_H

typedef struct Base Base;

struct Base {
    void (*greet)(Base*);
    // Other base members
};

void Base_init(Base* self);
void Base_greet(Base* self);

#endif // BASE_H

Definition of the Base struct and its interface.

#ifndef DERIVED_H
#define DERIVED_H

#include "base.h"

typedef struct Derived Derived;

struct Derived {
    Base super;
    void (*sayGoodbye)(Derived*);
    // Other derived members
};

void Derived_init(Derived* self);
void Derived_greet(Base* self); // Overriding base method
void Derived_sayGoodbye(Derived* self);

#endif // DERIVED_H

Definition of the Derived struct, embedding Base.

Implementing Virtual Functions with Function Pointers

To achieve polymorphic behavior—where a function call invokes different implementations based on the object's actual type—we utilize function pointers. Each struct can contain function pointers as members, which act like virtual methods. The 'constructor' (initialization function) of each struct will assign the appropriate function implementation to these pointers. For derived structs, we can either inherit the base's function pointer assignment or override it with a derived-specific implementation, mimicking method overriding in OOP languages.

#include <stdio.h>
#include "base.h"

void Base_greet_impl(Base* self) {
    printf("Hello from Base!\n");
}

void Base_init(Base* self) {
    self->greet = Base_greet_impl;
}

void Base_greet(Base* self) {
    self->greet(self);
}

Implementation of Base's initialization and greet method.

#include <stdio.h>
#include "derived.h"

void Derived_greet_impl(Base* self) {
    printf("Hello from Derived!\n");
}

void Derived_sayGoodbye_impl(Derived* self) {
    printf("Goodbye from Derived!\n");
}

void Derived_init(Derived* self) {
    Base_init((Base*)self); // Call base constructor
    self->super.greet = Derived_greet_impl; // Override base method
    self->sayGoodbye = Derived_sayGoodbye_impl;
}

void Derived_greet(Base* self) {
    self->greet(self);
}

void Derived_sayGoodbye(Derived* self) {
    self->sayGoodbye(self);
}

Implementation of Derived's initialization and methods, including overriding.

Using the Inheritance Model

With the base and derived structs defined, we can now demonstrate how to instantiate and use these objects, showcasing the polymorphic behavior. We'll create instances of both Base and Derived, initialize them, and then call their 'methods' through base pointers to illustrate how the correct overridden function is invoked.

#include <stdio.h>
#include <stdlib.h>
#include "base.h"
#include "derived.h"

int main() {
    // Create a Base object
    Base* baseObj = (Base*)malloc(sizeof(Base));
    Base_init(baseObj);
    printf("Calling Base object's greet:\n");
    Base_greet(baseObj);

    // Create a Derived object
    Derived* derivedObj = (Derived*)malloc(sizeof(Derived));
    Derived_init(derivedObj);
    printf("\nCalling Derived object's greet (overridden):\n");
    Base_greet((Base*)derivedObj); // Polymorphic call
    printf("Calling Derived object's specific method:\n");
    Derived_sayGoodbye(derivedObj);

    // Demonstrate calling derived method through base pointer is not directly possible without explicit casting
    // Base* genericObj = (Base*)derivedObj;
    // genericObj->sayGoodbye(genericObj); // This would be a compile-time error or runtime issue

    free(baseObj);
    free(derivedObj);

    return 0;
}

Demonstration of using Base and Derived objects with inheritance.

1. Step 1

Define your base struct with common members and function pointers for 'virtual' methods.

2. Step 2

Implement initialization functions (constructors) for the base struct to assign default method implementations.

3. Step 3

Define your derived struct, ensuring the base struct is its very first member to enable safe pointer casting.

4. Step 4

Implement initialization functions for the derived struct, calling the base constructor and then overriding specific function pointers as needed.

5. Step 5

Use explicit casting from derived pointers to base pointers to leverage polymorphism when calling 'virtual' methods.