Type-Generic Programming

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

// A type-agnostic dynamic array: element size and a copy of the bytes.
struct AnyVec {
    unsigned char *data;
    size_t element_size;
    size_t count;
    size_t capacity;
};

static bool anyvec_init(struct AnyVec *v, size_t element_size)
{
    if (element_size == 0) {
        return false;
    }
    v->data = nullptr;
    v->element_size = element_size;
    v->count = 0;
    v->capacity = 0;
    return true;
}

static bool anyvec_push(struct AnyVec *v, const void *element)
{
    if (v->count == v->capacity) {
        size_t new_capacity = v->capacity ? v->capacity * 2 : 4;
        unsigned char *grown = realloc(v->data, new_capacity * v->element_size);
        if (grown == nullptr) {
            return false;
        }
        v->data = grown;
        v->capacity = new_capacity;
    }

    memcpy(v->data + v->count * v->element_size, element, v->element_size);
    ++v->count;
    return true;
}

static void *anyvec_at(struct AnyVec *v, size_t index)
{
    return v->data + index * v->element_size;
}

int main(void)
{
    struct AnyVec v;
    if (!anyvec_init(&v, sizeof(double))) {
        return EXIT_FAILURE;
    }

    for (int i = 0; i < 3; ++i) {
        double value = i * 1.5;
        if (!anyvec_push(&v, &value)) {
            free(v.data);
            return EXIT_FAILURE;
        }
    }

    printf("%zu elements, [2] = %g\n", v.count, *(double *)anyvec_at(&v, 2));
    free(v.data);
    return 0;
}

#include <stdio.h>

// Map a type to a printf conversion specifier.
#define FORMAT_OF(x) _Generic((x),          \
    char:               "%c",               \
    signed char:        "%hhd",             \
    unsigned char:      "%hhu",             \
    short:              "%hd",              \
    int:                "%d",               \
    unsigned int:       "%u",               \
    long:               "%ld",              \
    unsigned long:      "%lu",              \
    long long:          "%lld",             \
    unsigned long long: "%llu",             \
    float:              "%g",               \
    double:             "%g",               \
    long double:        "%Lg",              \
    char *:             "%s",               \
    const char *:       "%s",               \
    void *:             "%p",               \
    default:            "%p")

#define PRINT(x) printf(FORMAT_OF(x), (x)), putchar('\n')

// A type name, for diagnostics.
#define TYPE_NAME(x) _Generic((x),  \
    int:      "int",                \
    double:   "double",             \
    char *:   "char *",             \
    default:  "something else")

int main(void)
{
    int i = 42;
    double d = 3.5;
    const char *s = "text";

    PRINT(i);
    PRINT(d);
    PRINT(s);

    printf("%s %s %s\n", TYPE_NAME(i), TYPE_NAME(d), TYPE_NAME(1.0f));
    return 0;
}

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

static int abs_int(int v)          { return v < 0 ? -v : v; }
static long abs_long(long v)       { return v < 0 ? -v : v; }
static double abs_double(double v) { return fabs(v); }

// One name, three implementations, resolved at compile time with no run-time cost.
#define ABS(x) _Generic((x),    \
    int:    abs_int,            \
    long:   abs_long,           \
    float:  abs_double,         \
    double: abs_double)(x)

int main(void)
{
    printf("%d %ld %g %g\n", ABS(-5), ABS(-5L), ABS(-5.5), ABS(-5.5f));
    return 0;
}

#include <stdio.h>
#include <tgmath.h>

int main(void)
{
    float f = 2.0f;
    double d = 2.0;
    long double ld = 2.0L;

    // One name; sqrtf, sqrt or sqrtl is selected by the argument's type.
    printf("%g %g %Lg\n", (double)sqrt(f), sqrt(d), sqrt(ld));
    printf("%g %g\n", (double)pow(f, 2.0f), fabs(-d));
    return 0;
}

#include <stdio.h>

// A safe MAX: each argument is evaluated exactly once, because each gets its own
// temporary of the correct type. This is what typeof buys you.
#define MAX(a, b)                       \
    ({                                  \
        typeof(a) max_a_ = (a);         \
        typeof(b) max_b_ = (b);         \
        max_a_ > max_b_ ? max_a_ : max_b_; \
    })

// typeof_unqual strips const/volatile/_Atomic -- needed to declare a WRITABLE copy.
#define COPY_OF(x) ((typeof_unqual(x))(x))

int main(void)
{
    int i = 3;
    int m = MAX(i++, 2);                // i is incremented once
    printf("%d, i = %d\n", m, i);

    const int ci = 7;
    typeof_unqual(ci) writable = ci;    // int, not const int
    writable = 8;

    typeof(&i) pointer_to_int = &i;     // int *
    typeof(main) *fn = main;            // pointer to this function's type

    printf("%d %d %p\n", writable, *pointer_to_int, (void *)fn);
    printf("%d\n", COPY_OF(ci));
    return 0;
}

#include <stdio.h>

int main(void)
{
    auto count = 42;                    // int
    auto ratio = 1.5;                   // double
    auto text = "hello";                // char *
    auto sum = count * ratio;           // double

    // The real use: naming an unwieldy type without repeating it.
    int values[3] = { 1, 2, 3 };
    auto p = &values[0];                // int *

    for (auto i = 0u; i < 3u; ++i) {    // unsigned int
        printf("%d ", p[i]);
    }
    putchar('\n');

    printf("%d %g %s %g\n", count, ratio, text, sum);
    return 0;
}