Strutture dati (struct) e Union

Come rappresentare un record e le sue varianti

Finora abbiamo raggruppato più dati usando i vettori (array), che hanno però un limite rigido: tutti gli elementi di un vettore devono essere dello stesso tipo (tutti int, oppure tutti double, oppure tutti char).

Ma nel mondo reale gli oggetti che vogliamo rappresentare sono quasi sempre composti da dati eterogenei (di tipi diversi): uno Studente ha una matricola (int), un cognome (char[32]) e una media dei voti (double); un Punto nel piano ha due coordinate (double x, y); una Data ha giorno, mese e anno.

Per raggruppare variabili di tipi diversi sotto un unico “tetto” logico, il linguaggio C fornisce due costrutti fondamentali:

  1. struct (Struttura o Record): alloca ogni campo uno dopo l’altro in memoria, così che tutti i campi esistano contemporaneamente.
  2. union (Unione): fa condividere la stessa identica area di memoria a tutti i suoi campi, permettendo di risparmiare spazio quando sappiamo che in ogni istante verrà usato un solo campo alla volta.

Le Strutture (struct): Definizione, Inizializzazione e Accesso

1. Definizione di una struct (con e senza typedef)

/* Modo 1: Con tag 'struct Punto' */
struct Punto {
    double x;
    double y;
};
/* Per dichiarare una variabile bisogna scrivere: struct Punto p1; */
 
/* Modo 2 (Consigliato): Combinando typedef struct per creare il tipo 'Studente' */
typedef struct {
    int matricola;
    char nome[32];
    double media;
} Studente;
/* Ora possiamo dichiarare direttamente: Studente s1; */

2. Inizializzazione (Posizionale e con Designated Initializers C99/C11)

Una struttura può essere inizializzata al momento della dichiarazione in due modi:

/* a) Inizializzazione posizionale (nell'ordine esatto dei campi): */
Studente s1 = {987654, "Anna Rossi", 28.5};
 
/* b) Designated Initializers (C99/C11: nominando esplicitamente i campi con '.campo ='):
      più leggibile, indipendente dall'ordine, e azzera a 0 i campi non specificati! */
Studente s2 = {
    .matricola = 123456,
    .media = 29.0,
    .nome = "Marco Bianchi"
};

3. Accesso ai campi: Operatore Punto . vs Operatore Freccia ->

Come si legge o si modifica un singolo campo di una struttura? Dipende se abbiamo in mano la variabile struttura stessa oppure un puntatore alla struttura:

  • Operatore Punto (. — Accesso diretto da variabile struct):

    s1.media = 29.5;
    printf("Matricola: %d\n", s1.matricola);
  • Operatore Freccia (-> — Accesso indiretto tramite puntatore a struct):
    Se abbiamo un puntatore Studente *p = &s1;, per accedere al campo media potremmo dereferenziare prima p e poi usare il punto: (*p).media.(Attenzione: le parentesi in `(p).mediasono obbligatorie perché l'operatore.ha precedenza più alta dell'asterisco! Scrivere p.mediasignificherebbe(p.media)`, che è un errore!).
    Poiché scrivere (*p).campo è scomodo, il C ha introdotto l’elegantissimo operatore freccia ->:

Studente *p = &s1;
p->media = 30.0; /* Equivalente a (*p).media = 30.0; -> modifica s1.media! */

Operazioni sulle struct, Annidamento e Passaggio a Funzioni

1. Assegnamento diretto (s2 = s1) vs Confronto (== NON esiste!)

  • L’assegnamento = tra due struct dello stesso tipo È CONSENTITO!
    Scrivere Studente copia = s1; copia automaticamente byte per byte tutti i campi di s1 dentro copia (inclusi eventuali array contenuti dentro la struct, come char nome[32]!).
  • Il confronto con == o != tra due struct NON È CONSENTITO!
    Scrivere if (s1 == s2) produce un errore di compilazione (a causa dei byte di padding che vedremo tra poco). Per verificare se due strutture sono uguali bisogna scrivere una funzione che confronti i singoli campi uno per uno (s1.matricola == s2.matricola && strcmp(s1.nome, s2.nome) == 0 && ...).

2. Strutture annidate e Vettori di struct

Una struct può contenere al suo interno un’altra struct (es. Studente che contiene un campo Data data_nascita;, a cui si accede con s1.data_nascita.anno), e possiamo creare vettori di strutture per gestire tabelle di dati:

Studente aula[100];
aula[0].matricola = 1001;

3. Passaggio di struct a Funzioni: Per Valore vs Per Puntatore (const)

A differenza dei vettori, quando passiamo una struct a una funzione (void f(Studente s)), il C copia l’intera struttura per valore sullo Stack!

  • Se la struttura è grande (es. contiene stringhe o vettori), copiarla a ogni chiamata spreca tempo e memoria.
  • Buona pratica professionale:
    • Se la funzione deve modificare la struttura, passa un puntatore: void promuovi(Studente *s).
    • Se la funzione deve solo leggere una struttura grande senza modificarla, passa un puntatore costante: void stampa_studente(const Studente *s) e usa s->campo!

Allineamento in Memoria e Padding (sizeof(struct))

Domanda classica d’esame: La dimensione sizeof di una struct è sempre uguale alla somma delle dimensioni sizeof dei suoi singoli campi?
Risposta: NO! Può essere MAGGIORE a causa del Padding (riempimento di allineamento)!

Perché il compilatore inserisce dei byte “vuoti” (padding) tra i campi di una struct?
I processori moderni a 32/64 bit leggono la RAM in blocchi allineati: un int da 4 byte viene letto in un solo ciclo di clock solo se il suo indirizzo di memoria è un multiplo di 4 (es. 0x1000, 0x1004, 0x1008).
Guarda cosa accade in questa struttura:

typedef struct {
    char c;   /* 1 byte  (offset 0) */
              /* + 3 byte di PADDING inseriti dal compilatore (offset 1, 2, 3)! */
    int n;    /* 4 byte  (offset 4..7 -> multiplo di 4!) */
    char d;   /* 1 byte  (offset 8) */
              /* + 3 byte di PADDING finale (offset 9, 10, 11) per allineare la struct a multiplo di 4! */
} EsempioPadding;

La somma dei campi sarebbe , ma sizeof(EsempioPadding) vale 12 byte!
Se invece riordiniamo i campi mettendo vicini quelli della stessa dimensione (int n; char c; char d;), i due char condividono lo stesso blocco da 4 byte e la struttura occupa solo 8 byte!

flowchart LR
    subgraph S1["struct { char c; int n; char d; } -> sizeof = 12 byte!"]
        direction LR
        B0["char c\n(1B)"] --- P1["PADDING\n(3B vuoti)"] --- B4["int n\n(4B allineati)"] --- B8["char d\n(1B)"] --- P2["PADDING\n(3B vuoti)"]
    end
    style P1 fill:#eeeeee,stroke:#999999,stroke-dasharray: 5 5
    style P2 fill:#eeeeee,stroke:#999999,stroke-dasharray: 5 5

Le union (Unioni) e le Tagged Union

Una union ha la stessa identica sintassi di una struct, ma con una differenza radicale nel layout di memoria:

  • In una struct, ogni campo ha il proprio indirizzo distinto e sizeof(struct) .

  • In una union, tutti i campi partono dallo stesso identico indirizzo base (offset 0) e si sovrappongono nella stessa area di memoria! La dimensione di una union è quindi pari alla dimensione del suo campo più grande (più eventuale allineamento):

typedef union {
    int intero;      /* 4 byte */
    double reale;    /* 8 byte (il più grande!) */
    char lettera;    /* 1 byte */
} ValoreGenerico;    /* sizeof(ValoreGenerico) == 8 byte! */

Attenzione: poiché i campi condividono gli stessi byte, scrivere in v.reale = 3.14; sovrascrive e rende non più valido il valore precedentemente scritto in v.intero!
In pratica, una union si usa quasi sempre dentro una struct accompagnata da un campo enum che ricorda quale membro della union è attualmente attivo (Tagged Union o Variant):

typedef enum { TIPO_INT, TIPO_DOUBLE } TipoDato;
 
typedef struct {
    TipoDato tipo_attivo; /* Il "Tag" che dice quale campo della union leggere! */
    union {
        int i;
        double d;
    } dato;
} CellaFoglioCalcolo;

Esempio di copia di una struttura composta

Immaginiamo un ordine che contenga un indirizzo come struct Indirizzo, un array interno char codice[12] e un puntatore a una descrizione esterna. Con secondo = primo si copiano i valori dei membri, compresi la struttura annidata e l’array interno. Si copia anche il valore del puntatore. Le due descrizioni possono quindi riferirsi allo stesso oggetto. Se l’ordine viene passato per valore, cambiare codice[0] nella copia lascia intatto quello dell’originale. Scrivere tramite un puntatore copiato può invece modificare l’oggetto condiviso.

In un’unione con etichetta, per esempio un dato di sensore che contiene una temperatura o un codice di guasto, l’assegnazione del valore e quella del discriminante devono restare coerenti. Il codice che legge seleziona il membro tramite il discriminante. Un confronto tra record usa i campi significativi, perché padding e rappresentazione binaria non definiscono l’uguaglianza logica.


Esempi guidati

Esempio 1: Geometria nel piano con typedef struct e funzioni

#include <stdio.h>
 
typedef struct {
    double x;
    double y;
} Punto;
 
typedef struct {
    Punto basso_sx;
    Punto alto_dx;
} Rettangolo;
 
/* Passiamo un puntatore costante per efficienza e sicurezza */
double calcola_area(const Rettangolo *r) {
    double base    = r->alto_dx.x - r->basso_sx.x;
    double altezza = r->alto_dx.y - r->basso_sx.y;
    return base * altezza;
}
 
void trasla_punto(Punto *p, double dx, double dy) {
    p->x += dx;
    p->y += dy;
}
 
int main(void) {
    Rettangolo rett = {
        .basso_sx = {1.0, 2.0},
        .alto_dx  = {6.0, 5.0}
    };
 
    printf("Area iniziale: %.2f\n", calcola_area(&rett)); /* 5.0 * 3.0 = 15.00 */
    trasla_punto(&rett.alto_dx, 2.0, 0.0); /* Allarga la base di 2 */
    printf("Nuova area:    %.2f\n", calcola_area(&rett)); /* 7.0 * 3.0 = 21.00 */
    return 0;
}

Esempio 2: Gestione di un archivio di struct (Ricerca dello studente con media massima)

#include <stdio.h>
 
#define N_STUDENTI 3
 
typedef struct {
    int matricola;
    char nome[32];
    double media;
} Studente;
 
int indice_migliore(const Studente corso[], int n) {
    int idx_max = 0;
    for (int i = 1; i < n; i++) {
        if (corso[i].media > corso[idx_max].media) {
            idx_max = i;
        }
    }
    return idx_max;
}
 
int main(void) {
    Studente corso[N_STUDENTI] = {
        {101, "Luca Verdi",   26.4},
        {102, "Sara Neri",    29.8},
        {103, "Paolo Gialli", 27.1}
    };
 
    int top = indice_migliore(corso, N_STUDENTI);
    printf("Miglior studente: %s (Matricola %d) con media %.2f\n",
           corso[top].nome, corso[top].matricola, corso[top].media);
    return 0;
}

Errori frequenti

Errori da evitare

  1. Usare . su un puntatore o -> su una variabile normale
    • Se s è di tipo Studente, si usa s.campo.
    • Se p è di tipo Studente *, si usa p->campo (oppure (*p).campo).
  2. Scrivere *p.campo dimenticando le parentesi tonde attorno a *p
    Poiché . ha precedenza maggiore di *, *p.campo viene interpretato dal compilatore come *(p.campo), che fallisce se p è un puntatore! Usa sempre p->campo.
  3. Dimenticare il punto e virgola ; dopo la parentesi graffa di chiusura }; di una struct o union
    È un errore di sintassi molto comune che fa fallire la compilazione della riga successiva.

Esercizi di prova

Esercizio 1. Calcolo di sizeof in una struct vs union e Padding (Base)

Su un’architettura a 64 bit in cui sizeof(char) == 1, sizeof(int) == 4 (allineato a 4 byte) e sizeof(double) == 8 (allineato a 8 byte), determina la dimensione in byte (sizeof) di:

typedef struct {
    double a;
    int b;
    int c;
} StructA;
 
typedef union {
    double a;
    int b;
    char c[5];
} UnionB;

Esercizio 2. Operazioni su Numeri Complessi con typedef struct (Base)

Definisci un tipo Complesso con due campi double re (parte reale) e double im (parte immaginaria). Scrivi due funzioni:
a) Complesso somma_complessi(Complesso z1, Complesso z2) che restituisce .
b) Complesso prodotto_complessi(Complesso z1, Complesso z2) che restituisce .

Esercizio 3. Sovrascrittura di memoria in una union (Intermedio)

Determina cosa stampa il seguente programma e spiega perché:

#include <stdio.h>
typedef union {
    unsigned int Parola32;
    unsigned char Byte[4];
} Ispettore;
 
int main(void) {
    Ispettore u;
    u.Parola32 = 0;
    u.Byte[0] = 5;
    printf("u.Byte[0] = %u | u.Parola32 != 0 ? %d\n",
           u.Byte[0], u.Parola32 != 0);
    return 0;
}

Esercizio 4. Confronto di uguaglianza tra due strutture Data (Intermedio)

Definisci typedef struct { int giorno, mese, anno; } Data; e scrivi una funzione int confronta_date(Data d1, Data d2) che restituisca:

  • 0 se le due date sono identiche;
  • -1 se d1 precede cronologicamente d2;
  • +1 se d1 segue cronologicamente d2.

Esercizio 5. Ordinamento di un vettore di struct (Avanzato)

Dato un vettore Prodotto magazzino[N] dove typedef struct { int codice; double prezzo; } Prodotto;, scrivi una funzione void ordina_per_prezzo(Prodotto v[], int n) che ordini l’array di strutture in ordine crescente di prezzo usando Selection Sort.

Esercizio 6. Tagged Union per Figure Geometriche eterogenee (Avanzato)

Progetta una Tagged Union Figura capace di rappresentare un Cerchio (caratterizzato da double raggio) oppure un Rettangolo (caratterizzato da double base, altezza), e scrivi una funzione double area_figura(const Figura *f) che calcoli l’area corretta in base al tag.


Provenienza del materiale

  • Slide e dispensa ufficiale del corso: C1PROG1U3L5_Strutture_dati_e_Union.pdf (Unità 3, Lezione 5 — Strutture dati struct, typedef, padding di memoria e union).
  • Marco Anisetti, Funzioni, Appunti_di_Fine_Unità_3.pdf, capp. 5–6.
  • WG14, bozza C11 N1570, §§ 6.2.6.1, 6.5.2.3 e 6.5.16.1.