Estructures en C

Declaració i ús

struct Persona {
    char nom[20];
    int edat;
};

struct Persona p1 = {"Jordi", 16};

printf("%s té %d anys\n", p1.nom, p1.edat);

El bloc struct Persona { ... } no crea cap variable: defineix una plantilla. p1 és una variable d'aquest nou tipus, i s'hi accedeix amb el punt: p1.nom, p1.edat.

void aniversari(struct Persona p) {
    p.edat = p.edat + 1;
    printf("Dins: %s té %d anys\n", p.nom, p.edat);
}

Com que p és una còpia, incrementar p.edat dins la funció no toca la variable original — exactament el mateix comportament que vas veure amb incrementa(int n) al capítol de funcions. Ho veuràs en detall a l'execució pas a pas.

typedef struct {
    char nom[20];
    int edat;
} Persona;

Persona p1 = {"Jordi", 16};   // ja no cal escriure "struct Persona"

typedef crea un àlies per a un tipus. És purament una comoditat d'escriptura: el comportament és idèntic.

union Dada {
    int enter;
    float decimal;
};

union Dada d;
d.enter = 5;
printf("%d\n", d.enter);     // 5

d.decimal = 3.14;
printf("%.2f\n", d.decimal); // 3.14
// a partir d'aquí, d.enter ja no té cap sentit: s'ha sobreescrit

Una struct Dada amb els mateixos membres ocuparia l'espai d'un int més el d'un float; una union Dada només ocupa l'espai del més gran dels dos, perquè es reparteixen el mateix lloc. S'utilitzen quan saps que només et cal un valor o l'altre, mai els dos alhora.

Exemple

#include <stdlib.h>

int *v;
int n = 5;

v = malloc(n * sizeof(int));
if (v == NULL) {
    printf("Error reservant memòria\n");
    return 1;
}

// ... fer servir v[0], v[1], ... com un vector normal ...

free(v);

malloc(bytes) reserva aquest nombre de bytes i retorna un apuntador al principi; sizeof(int) et diu quants bytes ocupa un int en aquesta màquina, perquè mai cal donar-ho per fet. Si no hi ha prou memòria lliure, malloc retorna NULL — per això cal comprovar-ho sempre.

Molt important: tota memòria reservada amb malloc s'ha d'alliberar amb free quan ja no es fa servir. Oblidar-ho és una fuita de memòria (memory leak): el programa va consumint cada cop més memòria sense raó.

#include <stdlib.h>

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

int v[5] = {5, 2, 4, 1, 3};
qsort(v, 5, sizeof(int), compara);
// v ara és {1, 2, 3, 4, 5}

qsort (de <stdlib.h>) ja porta un algorisme d'ordenació fet — l'únic que li falta saber és com comparar dos elements, i per això li passes compara com a argument: una funció que rep dos apuntadors genèrics i diu quin dels dos és més petit.