RAII and defer macros for C

What?

Basically you can get everything apart nasty inheritance hiercheries:

• Good perf post-OOP with structs, "methods" constructors, destructors
• RAII for your resources (not just memory)
• zig-style defer
• no dependencies, just defer.h and handle.h (or just one if you need both)

Examples

Zig-style defer:

#include "defer.h"
...
    void *ram = malloc(n);
    defer {
        free(ram);
        printf("%d bytes freed\n", n);
    };

C++ / Rust style constructor and destructor:

#include "handle.h"

struct Vektor {
    int count;
    int *v;
}; handle(Vektor) {
    switch(state) {
    case HANDLE_CREAT:
        self->count = *(int*) data;
        self->v = (int*) calloc(self->count, sizeof(int));
        break;
    case HANDLE_DESTR:
        if(self->v) free(self->v);
        break;
    }
}

RAII (with scope closing destructors in reverse order):

int n; scanf(" %d", n);
creat(Vektor, data, &n);
printf("data.count:%d\n", data.count);

Generics

Generic array using handle.h

#include <stdlib.h>
#include "handle.h"

/* Generic array macro */
#define Array(T,AT) struct AT { \
    size_t count; \
    T *v; \
}; handle(AT) { \
    if(state == HANDLE_CREAT) { \
        self->count = *(size_t*) data; \
        self->v = (T*) calloc(self->count, sizeof(T)); \
    } else if (state == HANDLE_DESTR){ \
        if(self->v) free(self->v); \
    } \
}

Usage:

#include "array.h"
Array(uint64_t, Array_uint64);
int main() {
    size_t n = 0;
    printf("Number of elements to sum: ");
    scanf(" %zu", &n);

    /* Create a 64 bit array of 'n' elements named 'data' */
    creat(Array_uint64, data, &n);
    ...
}

Compatibility

Ok this might be pain for you but this works only with gcc... At least it also works with C++ compilers so you can share your C codes later with C++.

LICENCE

CC-BY