> C STANDARDS DIFFERENCES

/* K&R — nessun tipo nei parametri */
int somma(a, b)
    int a;
    int b;
{
    return a + b;
}

/* C89 — prototipi ANSI */
int somma(int a, int b) {
    return a + b;
}

/* C89 — dichiarazioni solo in cima al blocco */
void f(void) {
    int x = 10;
    int y = 20;
    printf("%d\n", x + y);
}

/* C99 — dichiarazioni ovunque nel blocco */
void f(void) {
    printf("inizio\n");
    int x = 10;      // dichiarazione dopo statement
    int y = 20;
    printf("%d\n", x + y);
}

/* C89 */
int i;
for (i = 0; i < 10; i++) { ... }

/* C99 — dichiarazione nel for */
for (int i = 0; i < 10; i++) { ... }

void f(int n) {
    int arr[n];   // C99: dimensione determinata a runtime
    // Allocato sullo stack — attenzione a n grandi!
}

/* Il compilatore può assumere che p e q non si sovrappongono */
void copia(int *restrict dest, const int *restrict src, size_t n) {
    for (size_t i = 0; i < n; i++)
        dest[i] = src[i];
}

#include <stdint.h>     // int8_t, int16_t, int32_t, int64_t
#include <inttypes.h>   // macro di formato: PRId32, PRIx64, ecc.

int32_t  x = 42;
uint64_t y = 0xDEADBEEF;
printf("x = %" PRId32 "\n", x);

/* C89 — solo commenti blocco */
int x = 42; /* commento */

// C99 — commenti stile C++
int x = 42; // commento in linea

/* C89 — ordine posizionale obbligatorio */
int arr[5] = {0, 0, 0, 7, 0};

/* C99 — designated initializers */
int arr[5] = { [3] = 7 };

struct Point p = { .x = 10, .y = 20 };

/* Crea un oggetto temporaneo senza nome */
draw_point( (struct Point){.x = 3, .y = 4} );

/* Array temporaneo */
int *p = (int[]){1, 2, 3};

/* C99: suggerimento al compilatore per inlining */
static inline int max(int a, int b) {
    return (a > b) ? a : b;
}

struct Buffer {
    size_t len;
    char   data[];  // C99: membro flessibile (ultimo campo)
};

struct Buffer *b = malloc(sizeof(struct Buffer) + 1024);
b->len = 1024;

/* C99: macro con numero variabile di argomenti */
#define LOG(fmt, ...) \
    fprintf(stderr, "[LOG] " fmt "\n", __VA_ARGS__)

LOG("valore: %d", 42);

/* C89: #pragma non utilizzabile dentro macro */

/* C99: _Pragma come operatore */
#define PACK_BEGIN  _Pragma("pack(push,1)")
#define PACK_END    _Pragma("pack(pop)")

#include <stdatomic.h>

_Atomic int counter = 0;

/* Oppure con la macro */
atomic_int counter = ATOMIC_VAR_INIT(0);

atomic_store(&counter, 42);
int val = atomic_load(&counter);
atomic_fetch_add(&counter, 1);

#include <threads.h>

int worker(void *arg) {
    printf("Thread %d\n", *(int*)arg);
    return 0;
}

int main(void) {
    thrd_t t;
    int id = 1;
    thrd_create(&t, worker, &id);
    thrd_join(t, NULL);
}

#define type_name(x) _Generic((x),           \
    int:         "int",                     \
    float:       "float",                   \
    double:      "double",                  \
    char*:       "char*",                   \
    default:     "altro")

printf("%s\n", type_name(42));       // "int"
printf("%s\n", type_name(3.14));     // "double"

/* Esempio pratico: abs() type-generic */
#define generic_abs(x) _Generic((x),   \
    int:     abs,                           \
    long:    labs,                          \
    float:   fabsf,                         \
    double:  fabs)(x)

/* C11 — richiede messaggio stringa */
_Static_assert(sizeof(int) >= 4, "int deve essere almeno 32 bit");

/* C23 — messaggio opzionale */
static_assert(sizeof(int) >= 4);

#include <stdnoreturn.h>  // macro noreturn -> _Noreturn

_Noreturn void fatal(const char *msg) {
    fprintf(stderr, "FATAL: %s\n", msg);
    abort();
}

/* Allocazione dinamica allineata (C11) */
void *p = aligned_alloc(64, 256);  // 256 byte allineati a 64
/* size deve essere multiplo di alignment */
free(p);

#include <uchar.h>

char16_t c16 = u'A';        // UTF-16
char32_t c32 = U'A';        // UTF-32
const char16_t *s16 = u"ciao";
const char32_t *s32 = U"ciao";

struct Registro {
    int tipo;
    union {              // C11: union anonima
        int    i_val;
        float  f_val;
        char  *s_val;
    };                    // accesso diretto: r.i_val
};

/* C23: typeof come keyword (era estensione GNU) */
int x = 42;
typeof(x) y = x;          // y è int

/* typeof_unqual — rimuove qualificatori */
const int c = 10;
typeof_unqual(c) m = c;   // m è int (non const int)

#include <stddef.h>

/* C89-C17: NULL è tipicamente (void*)0 o 0 */
int *p = NULL;

/* C23: nullptr è un vero null pointer constant */
int *q = nullptr;

/* nullptr_t è il tipo di nullptr */
nullptr_t n = nullptr;

/* C23: interi con esattamente N bit */
_BitInt(128) big  = 0;
unsigned _BitInt(256) huge = 0;

/* Utile per crittografia, hashing, ecc. */

/* C99-C17: bool è macro in <stdbool.h> */
#include <stdbool.h>
bool flag = true;

/* C23: bool, true, false sono keyword native */
bool flag = true;  // nessun #include necessario

/* C23: sintassi attributi [[...]] (come C++) */
[[noreturn]] void fatal(const char *msg);

[[deprecated("usa nuova_api()")]]
void vecchia_api(void);

[[maybe_unused]] int debug_var;

[[nodiscard]] int alloca_risorsa(void);

[[fallthrough]];  // in un case senza break

/* C23: oggetti constexpr — valutazione a compile-time */
constexpr int MAX = 100;
constexpr double PI = 3.14159265358979;

/* Utilizzabile dove serve un'espressione costante */
int arr[MAX];

/* NB: solo per oggetti, NON per funzioni (a differenza di C++) */

/* C23: prefisso 0b / 0B per binario */
int mask = 0b11001010;

/* C23: separatore ' per leggibilità */
long pop  = 60'000'000;
int  hex  = 0xFF'A0'00;
int  bin  = 0b1111'0000'1010'0101;

/* C89-C17: un label deve precedere uno statement */
end: ;  // serviva uno statement vuoto

/* C23: label può precedere dichiarazioni o stare a fine blocco */
end:
    int result = 0;  // OK in C23
}

/* C23: {} inizializza a zero qualsiasi tipo */
int x = {};
struct Point p = {};   // equivalente a {0} ma più chiaro
int arr[10] = {};       // tutto zero

/* C23: auto con inizializzatore deduce il tipo */
auto x = 42;          // int
auto pi = 3.14;       // double
auto p = malloc(64);  // void*

/* NB: non come C++ auto — solo per variabili con inizializzatore */

/* C23: prefisso u8 per stringhe e char UTF-8 */
const char *s = u8"Ciao mondo";    // char[] con encoding UTF-8
unsigned char c = u8'A';           // char8_t in pratica

/* #elifdef / #elifndef — combinano #elif + defined */
#ifdef LINUX
    /* codice Linux */
#elifdef WINDOWS
    /* codice Windows */
#elifndef EMBEDDED
    /* codice non embedded */
#endif

/* #warning — emette un warning (era estensione, ora standard) */
#warning "Questa feature è sperimentale"

/* #embed — include dati binari come array */
const unsigned char icon[] = {
    #embed "icon.png"
};

/* Problema C99: virgola in eccesso senza argomenti variadic */
#define LOG_OLD(fmt, ...) printf(fmt, __VA_ARGS__)
LOG_OLD("test");  // errore: printf("test", ) ← virgola extra

/* C23: __VA_OPT__ gestisce il caso zero-argomenti */
#define LOG(fmt, ...) printf(fmt __VA_OPT__(,) __VA_ARGS__)
LOG("test");       // OK: printf("test")
LOG("%d", 42);    // OK: printf("%d", 42)