Pseudo -generics in C

In C, since the language itself does not directly support generic programming features, we often employ specific techniques to simulate generic programming, commonly referred to as "pseudo-generic programming." The primary approaches involve using macros and void pointers. Here, I will detail both methods with example code.

1. Macros

Macros enable code manipulation during the preprocessing stage, facilitating the generation of functions or structures for various data types. While this method has drawbacks such as poor type safety and potential for errors, it offers concise and clear implementation.

Example:

Define a macro for swapping the values of two variables, applicable to any data type:

c
#include <stdio.h>

#define SWAP(a, b, type) do { type temp = a; a = b; b = temp; } while (0)

int main() {
    int x = 10, y = 20;
    SWAP(x, y, int);
    printf("x = %d, y = %d\n", x, y);

    double a = 1.1, b = 2.2;
    SWAP(a, b, double);
    printf("a = %f, b = %f\n", a, b);

    return 0;
}

This macro swaps the values of two variables based on different data types (e.g., int or double).

2. void Pointers

void pointers can reference data of any type, enabling the creation of more versatile functions. However, using void pointers necessitates appropriate type casting at runtime, which may introduce runtime errors.

Example:

Implement a generic bubble sort function:

c
#include <stdio.h>
#include <string.h>

void generic_swap(void *a, void *b, size_t size) {
    char buffer[size];
    memcpy(buffer, a, size);
    memcpy(a, b, size);
    memcpy(b, buffer, size);
}

void bubble_sort(void *array, size_t n, size_t elem_size, int (*cmp)(const void *, const void *)) {
    char *arr = array;
    for (size_t i = 0; i < n - 1; ++i) {
        for (size_t j = 0; j < n - i - 1; ++j) {
            if (cmp(arr + j*elem_size, arr + (j+1)*elem_size) > 0) {
                generic_swap(arr + j*elem_size, arr + (j+1)*elem_size, elem_size);
            }
        }
    }
}

int int_cmp(const void *a, const void *b) {
    return (*(int *)a) - (*(int *)b);
}

int main() {
    int arr[] = {64, 34, 25, 12, 22, 11, 90};
    int n = sizeof(arr) / sizeof(arr[0]);
    bubble_sort(arr, n, sizeof(int), int_cmp);
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
    return 0;
}

In this example, the generic_swap and bubble_sort functions achieve sorting for any data type through void pointers and element size parameters.

By utilizing these two methods, we can implement functionality similar to generic programming in C, despite their respective trade-offs. Macros provide higher flexibility and conciseness but lack type checking; conversely, void pointers support more complex data operations but require careful type casting and memory management.