Polymorphism (in C)

Polymorphism in C: Achieving Dynamic Behavior

Explore how polymorphism, a core OOP concept, can be effectively implemented in C using function pointers and void pointers to create flexible and extensible code.

Polymorphism, meaning "many forms," is a fundamental concept in Object-Oriented Programming (OOP) that allows objects of different classes to be treated as objects of a common base type. While C is not an object-oriented language, it's possible to simulate polymorphic behavior using its powerful features like function pointers, void pointers, and structs. This article will delve into the techniques to achieve polymorphism in C, enabling more flexible and maintainable code designs.

Understanding Polymorphism in C

In OOP languages, polymorphism is often achieved through inheritance and virtual functions. In C, we mimic this by defining a common interface (e.g., a struct with function pointers) that different data types can adhere to. Each "object" (a struct instance) can then provide its own implementation for these interface functions. When a function receives a generic pointer to this interface, it can invoke the appropriate implementation without knowing the exact underlying type at compile time. This dynamic dispatch is the essence of polymorphism.

Simulating Polymorphism in C using a common interface and function pointers.

Implementing Polymorphism with Function Pointers

The primary mechanism for polymorphism in C is the function pointer. By embedding function pointers within a struct, we can create a vtable-like structure, similar to how virtual functions work in C++. Each "object" of a specific type will have its struct initialized with pointers to functions that are appropriate for that type. When accessed through a generic pointer to the base struct, the correct function for the derived type is invoked.

#ifndef SHAPE_H
#define SHAPE_H

typedef struct Shape {
    void (*draw)(void*);
    double (*area)(void*);
} Shape;

#endif // SHAPE_H

Defining a generic Shape interface using function pointers.

#include <stdio.h>
#include <math.h>
#include "shape.h"

typedef struct Circle {
    Shape base;
    double radius;
} Circle;

void circle_draw(void* obj) {
    Circle* circle = (Circle*)obj;
    printf("Drawing Circle with radius %f\n", circle->radius);
}

double circle_area(void* obj) {
    Circle* circle = (Circle*)obj;
    return M_PI * circle->radius * circle->radius;
}

Circle* create_circle(double radius) {
    Circle* circle = (Circle*)malloc(sizeof(Circle));
    if (circle) {
        circle->base.draw = circle_draw;
        circle->base.area = circle_area;
        circle->radius = radius;
    }
    return circle;
}

Implementation for a Circle type, adhering to the Shape interface.

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

typedef struct Rectangle {
    Shape base;
    double width;
    double height;
} Rectangle;

void rectangle_draw(void* obj) {
    Rectangle* rect = (Rectangle*)obj;
    printf("Drawing Rectangle with width %f, height %f\n", rect->width, rect->height);
}

double rectangle_area(void* obj) {
    Rectangle* rect = (Rectangle*)obj;
    return rect->width * rect->height;
}

Rectangle* create_rectangle(double width, double height) {
    Rectangle* rect = (Rectangle*)malloc(sizeof(Rectangle));
    if (rect) {
        rect->base.draw = rectangle_draw;
        rect->base.area = rectangle_area;
        rect->width = width;
        rect->height = height;
    }
    return rect;
}

Implementation for a Rectangle type, also adhering to the Shape interface.

Using Polymorphic Objects

Once different types are defined with their respective function pointer implementations, they can be treated uniformly through a pointer to the base Shape struct. This allows you to write functions that operate on any Shape without needing to know its specific type, promoting code reuse and extensibility. For instance, an array of Shape pointers can hold various concrete shape types, and iterating through it to call draw or area will invoke the correct function for each object.

#include <stdio.h>
#include <stdlib.h>
#include "shape.h"
#include "circle.h"
#include "rectangle.h"

int main() {
    Shape* shapes[2];

    Circle* myCircle = create_circle(5.0);
    Rectangle* myRectangle = create_rectangle(4.0, 6.0);

    shapes[0] = (Shape*)myCircle;
    shapes[1] = (Shape*)myRectangle;

    for (int i = 0; i < 2; ++i) {
        printf("\n--- Processing Shape %d ---\n", i + 1);
        if (shapes[i] && shapes[i]->draw) {
            shapes[i]->draw(shapes[i]); // Polymorphic call
        }
        if (shapes[i] && shapes[i]->area) {
            printf("Area: %f\n", shapes[i]->area(shapes[i])); // Polymorphic call
        }
    }

    // Clean up memory
    free(myCircle);
    free(myRectangle);

    return 0;
}

Demonstrating polymorphic behavior with an array of Shape pointers.

Advantages and Disadvantages

Advantages:

• Flexibility and Extensibility: Easily add new types without modifying existing code that uses the generic interface.
• Code Reuse: Write generic functions that operate on multiple types.
• Dynamic Behavior: Decide which function to call at runtime based on the object's actual type.

Disadvantages:

• Increased Complexity: Requires careful management of function pointers and void pointers.
• Manual Type Management: C lacks automatic type checking for polymorphic calls, requiring explicit casts and careful design.
• Runtime Overhead: Function pointer calls can introduce a small overhead compared to direct function calls, though often negligible.

1. Step 1

Define a base struct (interface) containing function pointers for common operations.

2. Step 2

For each specific type (e.g., Circle, Rectangle), define a struct that embeds the base struct as its first member.

3. Step 3

Implement type-specific functions for each operation defined in the base struct.

4. Step 4

Create constructor-like functions for each specific type to allocate memory and initialize the base struct's function pointers to the type-specific implementations.

5. Step 5

When using, cast specific type pointers to the base struct pointer to achieve polymorphic calls.

Polymorphism in C, while not as syntactically straightforward as in OOP languages, is a powerful technique for building flexible and modular systems. By leveraging structs, void pointers, and especially function pointers, developers can design code that is adaptable to new requirements and promotes a higher degree of abstraction. Mastering these concepts is key to writing robust and maintainable C applications.