> C LANGUAGE REFERENCE MANUAL (C99)

# Compilazione + linking in un colpo
gcc -std=c99 -Wall -Wextra -pedantic main.c -o main

# Solo preprocessing (-E), compilazione (-S), assemblaggio (-c)
gcc -E main.c -o main.i       # output preprocessato
gcc -S main.c -o main.s       # output assembly
gcc -c main.c -o main.o       # output oggetto

# Più file sorgente
gcc -std=c99 main.c utils.c -o app

# Con librerie esterne
gcc main.c -lm -lpthread -o app   # -l linka la libreria

CC      = gcc
CFLAGS  = -std=c99 -Wall -Wextra -pedantic -g
LDFLAGS = -lm
SRC     = main.c utils.c
OBJ     = $(SRC:.c=.o)
TARGET  = app

$(TARGET): $(OBJ)
	$(CC) $(OBJ) $(LDFLAGS) -o $@

%.o: %.c
	$(CC) $(CFLAGS) -c $< -o $@

clean:
	rm -f $(OBJ) $(TARGET)

.PHONY: clean

/* myheader.h */
#ifndef MYHEADER_H
#define MYHEADER_H

int somma(int a, int b);
void print_info(const char *msg);

#endif /* MYHEADER_H */

Ogni file .c + i suoi #include forma un'unità di traduzione compilata indipendentemente. Il linker unisce i file .o nel binario finale.

Ogni tipo intero può essere signed (default per int/short/long) o unsigned.

void — tipo incompleto: nessun valore. Usato per funzioni senza ritorno, puntatori generici (void *), e cast espliciti.

sizeof(int)          // dimensione del tipo in byte
sizeof(arr)          // dimensione totale dell'array (se non decaduto)
sizeof(arr)/sizeof(arr[0])   // numero elementi array
sizeof(char)         // sempre 1 per definizione

42           // int decimale
042          // int ottale (= 34)
0x2A         // int esadecimale (= 42)
42L          // long
42LL         // long long (C99)
42U          // unsigned int
42ULL        // unsigned long long
3.14         // double
3.14f        // float
3.14L        // long double
1.5e3        // 1500.0 (notazione scientifica)
0x1.8p1     // hex float: 3.0 (C99)

'A'          // char (valore int = 65)
'\n'         // newline
'\t'         // tab
'\0'         // null terminator
'\\'         // backslash
'\x41'       // hex escape (= 'A')
'\077'       // octal escape (= '?')

"hello"      // string literal (const char[6])
"hello" " world"   // concatenazione automatica

#define PI       3.14159265358979
#define MAX_BUF  1024

const int MAX_SIZE = 100;     // non utilizzabile come dimensione array statico (pre-VLA)
enum { LIMIT = 256 };         // costante intera "vera" (compile-time)

a + b    a - b    a * b    a / b    a % b   // aritmetici
a == b   a != b   a < b    a > b             // relazionali
a <= b   a >= b                               // relazionali
!a       a && b   a || b                      // logici
a ? b : c                                     // ternario

a & b    // AND bit a bit
a | b    // OR bit a bit
a ^ b    // XOR bit a bit
~a       // NOT bit a bit (complemento a 1)
a << n   // shift sinistro
a >> n   // shift destro (aritmetico per signed, logico per unsigned)

a += b   a -= b   a *= b   a /= b   a %= b
a &= b   a |= b   a ^= b   a <<= b  a >>= b

int x = 5;
int a = x++;   // a = 5, poi x = 6  (post-incremento)
int b = ++x;   // x = 7, poi b = 7  (pre-incremento)

int x = (1, 2, 3);   // x = 3 (valuta tutto, restituisce l'ultimo)
for (int i=0, j=10; i < j; i++, j--)  // uso tipico nel for

Tipi più piccoli di int (char, short, _Bool, bitfield) vengono promossi a int (o unsigned int) prima di qualsiasi operazione aritmetica.

// Gerarchia: long double > double > float > unsigned long long > long long > ...
// L'operando di tipo inferiore viene convertito al tipo superiore

int    a = 5;
double b = 2.5;
double c = a + b;     // a promosso a double → 7.5

int      x = -1;
unsigned y = 1;
// x + y → x convertito a unsigned! -1 diventa UINT_MAX → BUG COMUNE

double d = 3.99;
int n = (int)d;              // troncamento → 3

void *p = malloc(100);
int *ip = (int *)p;          // cast da void* (in C non necessario ma usuale)

int a = 7, b = 2;
double r = (double)a / b;    // 3.5 (senza cast: 3)

if (x > 0) {
    printf("positivo\n");
} else if (x == 0) {
    printf("zero\n");
} else {
    printf("negativo\n");
}

switch (scelta) {
    case 1:
        printf("uno\n");
        break;
    case 2:
    case 3:
        printf("due o tre\n");
        break;
    default:
        printf("altro\n");
        break;
}

// Prototipo (dichiarazione) — tipicamente nell'header
int massimo(int a, int b);

// Definizione — nel file .c
int massimo(int a, int b) {
    return (a > b) ? a : b;
}

// Funzione void senza parametri: usare (void) esplicitamente in C
void stampa_banner(void) {
    puts("=== BANNER ===");
}

// Per valore — la funzione lavora su una copia
void raddoppia(int x) { x *= 2; }  // nessun effetto sul chiamante

// Per riferimento — si passa il puntatore
void raddoppia(int *x) { *x *= 2; } // modifica la variabile esterna

int val = 5;
raddoppia(&val);  // val = 10

// L'array decade a puntatore — si perde la dimensione
void stampa(int arr[], size_t n) {
    for (size_t i = 0; i < n; i++)
        printf("%d ", arr[i]);
}

// Equivalente a:
void stampa(int *arr, size_t n);

// Array multidimensionale — colonne fisse
void mat_print(int rows, int cols, int m[rows][cols]);  // C99 VLA param

// Funzione static: visibilità limitata all'unità di traduzione
static int helper(int x) { return x * 2; }

// Variabile static: persiste tra le chiamate
int contatore(void) {
    static int count = 0;   // inizializzata solo una volta
    return ++count;
}

int  x  = 42;
int *p  = &x;       // p punta a x
int  y  = *p;       // dereferenziazione: y = 42
*p = 100;            // x diventa 100

int **pp = &p;       // puntatore a puntatore
**pp = 200;          // x diventa 200

int *q = NULL;       // puntatore nullo — dereferenziare = UB

const int *p;         // puntatore a int costante (non si può modificare *p)
int *const p;         // puntatore costante a int (non si può modificare p)
const int *const p;  // entrambi costanti

void *generic = &x;
// Non si può dereferenziare direttamente — serve cast
int val = *(int *)generic;

// void* è il tipo di ritorno di malloc/calloc/realloc
// In C, la conversione void* ↔ T* è implicita (a differenza del C++)

int a[5];                          // non inizializzato (valori indefiniti)
int b[5] = {1, 2, 3};              // {1, 2, 3, 0, 0}
int c[5] = {0};                     // tutti zero
int d[]  = {10, 20, 30};             // dimensione dedotta: 3

// Designated initializers (C99)
int e[10] = {[0] = 1, [5] = 50, [9] = 99};

int mat[3][4];                        // 3 righe, 4 colonne
int mat[3][4] = {
    {1, 2, 3, 4},
    {5, 6, 7, 8},
    {9, 10, 11, 12}
};

// Accesso: mat[riga][col]
// In memoria: layout row-major (righe contigue)

int arr[5] = {10, 20, 30, 40, 50};
int *p = arr;          // arr decade a &arr[0]

arr[2]  == *(arr + 2)  // equivalenti
p[2]    == *(p + 2)    // equivalenti
&arr[2] == arr + 2     // equivalenti

#include <stdlib.h>

int cmp_int(const void *a, const void *b) {
    const int ia = *(const int *)a;
    const int ib = *(const int *)b;
    return (ia > ib) - (ia < ib);  // sicuro: nessun overflow
    // return ia - ib;  ← ⚠ overflow se ia e ib hanno segno opposto e valori grandi
}

int arr[] = {5, 2, 8, 1, 9};
qsort(arr, 5, sizeof(int), cmp_int);

// snprintf è più sicuro di sprintf (bounds-checked)
char buf[64];
snprintf(buf, sizeof(buf), "Nome: %s, Età: %d", nome, eta);

// Duplicazione stringa (POSIX, non standard C99)
char *copia = strdup(originale);  // malloc + strcpy — ricordarsi di free()

struct Rettangolo {
    struct Punto origine;
    double larghezza, altezza;
};

// Padding: il compilatore inserisce byte di allineamento
struct Bad  { char a; int b; char c; };  // sizeof = 12 (con padding)
struct Good { int b; char a; char c; };  // sizeof = 8  (meno padding)

/* globals.c */
int g_count = 0;          // definizione

/* globals.h */
extern int g_count;       // dichiarazione

/* main.c */
#include "globals.h"
g_count++;                  // usa la variabile definita in globals.c

// Matrice rows x cols
int **mat = malloc(rows * sizeof(*mat));
for (int i = 0; i < rows; i++)
    mat[i] = malloc(cols * sizeof(**mat));

// Deallocazione — ordine inverso
for (int i = 0; i < rows; i++)
    free(mat[i]);
free(mat);

// Alternativa: singola allocazione contigua (cache-friendly)
int *flat = malloc(rows * cols * sizeof(*flat));
// accesso: flat[i * cols + j]

#ifdef DEBUG
    printf("Debug: x = %d\n", x);
#endif

#if defined(__linux__)
    // codice Linux
#elif defined(_WIN32)
    // codice Windows
#elif defined(__APPLE__)
    // codice macOS
#else
    #error "Piattaforma non supportata"
#endif

printf("Hello %s, age %d\n", nome, eta);
putchar('A');          // stampa un carattere
puts("hello");          // stampa stringa + newline
fprintf(stderr, "Errore: %s\n", msg);   // output su stream
sprintf(buf, "x=%d", x);              // scrive in stringa (⚠ overflow)
snprintf(buf, sizeof(buf), "x=%d", x); // sicuro: limita a n byte

int n;
scanf("%d", &n);           // legge intero da stdin

char buf[100];
fgets(buf, sizeof(buf), stdin);   // legge una riga (incluso \n)

int c = getchar();        // legge un carattere (ritorna int o EOF)

sscanf(str, "%d %f", &n, &f);  // parsing da stringa

printf("%10d", x);      // allineamento destra, larghezza 10
printf("%-10d", x);     // allineamento sinistra
printf("%010d", x);     // padding con zeri
printf("%+d", x);       // mostra sempre il segno
printf("%.2f", f);      // 2 cifre decimali
printf("%.*f", n, f);   // precisione variabile (passata come argomento)
printf("%.5s", str);    // stampa al max 5 char della stringa
printf("%#x", x);       // prefisso 0x per esadecimale
printf("%#o", x);       // prefisso 0 per ottale

char *input = "42abc";
char *end;
long val = strtol(input, &end, 10);

if (end == input)
    printf("Nessun numero trovato\n");
else if (*end != '\0')
    printf("Parziale: %ld (residuo: '%s')\n", val, end);
else
    printf("Numero: %ld\n", val);

#include <stdint.h>
#include <inttypes.h>

int64_t big = INT64_MAX;           // 9223372036854775807
uint32_t u = UINT32_MAX;          // 4294967295

printf("val = %" PRId64 "\n", big);   // PRId64 = formato portabile per int64_t
printf("hex = %" PRIx32 "\n", u);    // PRIx32 per uint32_t in hex

sscanf(str, "%" SCNd64, &big);     // SCN* per scanf

#include <stdbool.h>

bool flag = true;
if (flag) { /* ... */ }
// bool, true, false sono macro per _Bool, 1, 0

#include <complex.h>

double complex z = 1.0 + 2.0 * I;
double re = creal(z);    // parte reale
double im = cimag(z);    // parte immaginaria
double m  = cabs(z);     // modulo

#include <tgmath.h>
// Usa automaticamente la versione corretta (float/double/long double)
float f = sqrt(2.0f);       // chiama sqrtf
double d = sqrt(2.0);       // chiama sqrt

// Impedisce al compilatore di ottimizzare l'accesso alla variabile
// Usato per: I/O mappato in memoria, signal handler, variabili condivise

volatile int *hw_reg = (volatile int *)0xFFFF0000;
while (*hw_reg == 0) { }   // il compilatore non elimina il loop

// Nei signal handler:
volatile sig_atomic_t flag = 0;

// Promessa al compilatore: il puntatore è l'unico modo di accedere a quell'area
// Permette ottimizzazioni più aggressive

void vec_add(int * restrict dst,
            const int * restrict a,
            const int * restrict b, size_t n) {
    for (size_t i = 0; i < n; i++)
        dst[i] = a[i] + b[i];  // il compilatore sa che non c'è aliasing
}

// memcpy usa restrict: src e dst non possono sovrapporsi
// memmove NON usa restrict: gestisce la sovrapposizione

#ifdef DEBUG
#define DBG(fmt, ...) \
    fprintf(stderr, "[DBG %s:%d] " fmt "\n", \
            __FILE__, __LINE__, ##__VA_ARGS__)
#else
#define DBG(fmt, ...) ((void)0)
#endif

DBG("valore di x = %d", x);
// Compilare con: gcc -DDEBUG ...

Ogni variabile/funzione con external linkage deve avere esattamente una definizione in tutto il programma. Più dichiarazioni (extern) sono permesse.

int x = 10;                 // file scope
void foo(void) {
    int x = 20;             // nasconde la x globale
    {
        int x = 30;         // nasconde la x locale esterna
        printf("%d\n", x); // 30
    }
    printf("%d\n", x);     // 20
}

# Sanitizer a compile-time (GCC/Clang)
gcc -fsanitize=undefined -fsanitize=address -g main.c
# UBSan: signed overflow, shift, null deref, alignment, ecc.
# ASan: buffer overflow, use-after-free, double free, leak

# Valgrind (a runtime, no ricompilazione)
valgrind --leak-check=full --track-origins=yes ./app

# Flag warning utili
gcc -Wall -Wextra -Wpedantic -Wshadow -Wconversion \
    -Wstrict-aliasing=2 -Wformat=2 -Wnull-dereference

// ❌ UB: signed overflow
if (a + b > INT_MAX) { ... }   // l'overflow è già avvenuto!

// ✓ Controllare PRIMA dell'operazione
if (b > 0 && a > INT_MAX - b) { /* overflow */ }
if (b < 0 && a < INT_MIN - b) { /* underflow */ }

// ✓ Usare unsigned per operazioni dove l'overflow è intenzionale
uint32_t hash = (hash * 31) + c;  // overflow unsigned = wrap-around (definito)

// ✓ GCC/Clang built-in
int result;
if (__builtin_add_overflow(a, b, &result)) {
    // overflow rilevato
}

// ❌ UNDEFINED BEHAVIOR — strict aliasing violation
float f = 3.14f;
int bits = *(int *)&f;      // UB! float* → int* deref

// ❌ Anche questo è UB
int i = 42;
short *sp = (short *)&i;
*sp = 7;                     // UB! int* → short* write

// ✓ Metodo 1: memcpy (il più portabile e sicuro)
float f = 3.14f;
uint32_t bits;
memcpy(&bits, &f, sizeof(bits));   // OK! nessuna violazione

// ✓ Metodo 2: union (definito in C99, UB in C++)
union {
    float    f;
    uint32_t u;
} pun;
pun.f = 3.14f;
uint32_t bits = pun.u;          // OK in C99 (type punning via union)

// ✓ Metodo 3: accesso via char* (sempre legale)
float f = 3.14f;
unsigned char *bytes = (unsigned char *)&f;
for (size_t i = 0; i < sizeof(f); i++)
    printf("%02x ", bytes[i]);   // OK! char* può aliasare qualunque tipo

// La funzione ritorna 0 = successo, -1 = errore (setta errno)
int read_config(const char *path, struct Config *out) {
    FILE *f = fopen(path, "r");
    if (!f) return -1;     // errno già settato da fopen
    // ...
    fclose(f);
    return 0;
}

typedef enum {
    RESULT_OK = 0,
    RESULT_ERR_NULL,
    RESULT_ERR_RANGE,
    RESULT_ERR_IO,
} Result;

Result parse_int(const char *s, int *out) {
    if (!s)   return RESULT_ERR_NULL;
    char *end;
    long val = strtol(s, &end, 10);
    if (*end != '\0') return RESULT_ERR_RANGE;
    *out = (int)val;
    return RESULT_OK;
}

// La funzione ritorna il puntatore (NULL = errore)
char *read_file(const char *path, size_t *out_len) {
    FILE *f = fopen(path, "rb");
    if (!f) return NULL;

    fseek(f, 0, SEEK_END);
    long len = ftell(f);
    rewind(f);

    char *buf = malloc(len + 1);
    if (!buf) { fclose(f); return NULL; }

    fread(buf, 1, len, f);
    buf[len] = '\0';
    fclose(f);

    if (out_len) *out_len = len;
    return buf;   // il chiamante deve fare free()
}

int process(const char *path) {
    int ret = -1;
    FILE *f = NULL;
    char *buf = NULL;

    f = fopen(path, "r");
    if (!f) goto out;

    buf = malloc(4096);
    if (!buf) goto out;

    // ... lavoro con f e buf ...
    ret = 0;   // successo

out:
    free(buf);     // free(NULL) è safe
    if (f) fclose(f);
    return ret;
}

// Lista generica con void*
typedef struct {
    void   **items;
    size_t   count;
    size_t   capacity;
} Vec;

void vec_push(Vec *v, void *item) {
    if (v->count >= v->capacity) {
        v->capacity = v->capacity ? v->capacity * 2 : 8;
        v->items = realloc(v->items, v->capacity * sizeof(void *));
    }
    v->items[v->count++] = item;
}

// Uso — nessuna type-safety
Vec v = {0};
int x = 42;
vec_push(&v, &x);
int *p = (int *)v.items[0];

// Vettore che copia gli elementi per valore
typedef struct {
    char   *data;       // buffer di byte
    size_t  elem_size;  // sizeof di un elemento
    size_t  count;
    size_t  capacity;
} GVec;

void gvec_push(GVec *v, const void *elem) {
    if (v->count >= v->capacity) {
        v->capacity = v->capacity ? v->capacity * 2 : 8;
        v->data = realloc(v->data, v->capacity * v->elem_size);
    }
    memcpy(v->data + v->count * v->elem_size, elem, v->elem_size);
    v->count++;
}

void *gvec_get(const GVec *v, size_t i) {
    return v->data + i * v->elem_size;
}

// Uso
GVec v = {.elem_size = sizeof(double)};
double val = 3.14;
gvec_push(&v, &val);
double *p = (double *)gvec_get(&v, 0);

// Genera un tipo vettore specifico per ogni tipo
#define DEFINE_VEC(T, Name) \
    typedef struct { \
        T      *data; \
        size_t  count; \
        size_t  capacity; \
    } Name; \
    \
    static inline void Name##_push(Name *v, T val) { \
        if (v->count >= v->capacity) { \
            v->capacity = v->capacity ? v->capacity * 2 : 8; \
            v->data = realloc(v->data, v->capacity * sizeof(T)); \
        } \
        v->data[v->count++] = val; \
    } \
    static inline T Name##_get(Name *v, size_t i) { \
        return v->data[i]; \
    }

// Istanziare per i tipi necessari
DEFINE_VEC(int,    IntVec)
DEFINE_VEC(double, DoubleVec)

// Uso — completamente type-safe
IntVec v = {0};
IntVec_push(&v, 42);
int x = IntVec_get(&v, 0);   // type-safe, nessun cast

// Il nodo di lista è DENTRO la struttura dell'utente
struct list_node {
    struct list_node *next;
    struct list_node *prev;
};

// Macro per risalire al contenitore
#define container_of(ptr, type, member) \
    ((type *)((char *)(ptr) - offsetof(type, member)))

// Struttura utente che CONTIENE il nodo
struct Task {
    int              id;
    char             name[32];
    struct list_node link;    // embedded
};

// Risalire da list_node a Task
struct list_node *n = /* ... */;
struct Task *t = container_of(n, struct Task, link);