Quali sono le regole per il casting di puntatori di tipi diversi nel linguaggio C, quali sono i rischi del casting di void* ad altri tipi e viceversa, e come evitare errori di gestione della memoria durante la conversione dei puntatori?

Risposta

Il casting dei puntatori è un'operazione comune nel linguaggio C, che consente di utilizzare interfacce generiche, ad esempio, lavorare con la memoria tramite void* o implementare strutture dati universali. Tuttavia, il casting dei tipi di puntatori comporta determinati rischi e segue standard rigorosi.

• void* in C memorizza un indirizzo, ma non conosce il tipo del contenuto a cui punta. Qualsiasi altro puntatore (ad esempio, int*, char*, struct mytype*) può essere esplicitamente (o implicitamente) convertito in void* e viceversa senza perdita di informazioni (se non avviene "riduzione").
• Tuttavia, se si esegue il casting di un puntatore di un tipo a un altro (non a void*), è necessario assicurarsi che all’indirizzo ci sia effettivamente un valore di tipo compatibile.
• Lavorare con indirizzi allocati per un tipo ma ottenuti tramite un puntatore "estraneo" è pericoloso: può sorgere un problema di allineamento, comportamento indefinito o addirittura un errore di esecuzione.

Esempio

void process(void *data) {
    int *arr = (int*)data;
    // utilizziamo arr come array di int
}

int main() {
    double x = 10;
    process(&x); // PERICOLOSO: castiamo double* a int*, UB
}

Domanda trabocchetto

"Qualsiasi puntatore può essere convertito in modo sicuro in void* e viceversa senza perdite?"

Molti rispondono "sì" — poiché lo standard C garantisce la conversione di qualsiasi puntatore a oggetti in void* e viceversa senza perdite. Ma è importante ricordare: se converti un puntatore non a oggetto (ad esempio, un puntatore a funzione) in void* o mescoli diverse architetture (le dimensioni dei puntatori differiscono tra funzioni e dati), otterrai un comportamento indefinito.

void foo() {}
void *p = (void*)foo; // UB! non puoi convertire un puntatore a funzione in questo modo

Esempi di errori reali dovuti a ignoranza delle sottigliezze dell'argomento

---

Storia

In un progetto con un sottosistema di elaborazione dati multipiattaforma, è stato utilizzato un gestore che convertiva un puntatore a struttura in void*, poi di nuovo nel tipo originale. Quando si è passati a un'architettura in cui int* e double* avevano diversi allineamenti, il tentativo di convertire void* in un tipo errato ha portato a un "bus error" (terminazione anomala).

---

Storia

In un progetto embedded, un programmatore ha implementato un buffer circolare con un'interfaccia universale in void*, ma ha dimenticato i rigorosi requisiti di allineamento (ha allocato memoria per un array di char, passato come int*). Su alcune piattaforme, i dati sono diventati "incomprensibili per l'hardware" — si sono verificati errori di lettura e un funzionamento instabile.

---

Storia

In una collezione dinamica, sono stati utilizzati indirizzi memorizzati come void*, ma è stato dimenticato che un puntatore a funzione non può essere convertito in void*. Tentare di memorizzare e passare un gestore di eventi (callback) attraverso un campo del genere ha portato a crash solo su alcune piattaforme, e catturare l'errore era estremamente difficile.