Conversione di tipo

Da Wikipedia, l'enciclopedia libera.

In informatica, con conversione di tipo (oppure impropriamente casting, dal nome di un suo sottotipo) ci si riferisce all'operazione di passaggio di una variabile da un tipo di dato ad un altro: questa conversione è effettuata per avvantaggiarsi di alcune caratteristiche delle gerarchie dei tipi. Per esempio, i valori di un intervallo limitato (come quello degli interi) possono essere immagazzinati in piccole quantità di memoria, per poi essere convertiti in un formato diverso che potenzialmente permette nuove operazioni, come la divisione con varie cifre decimali di precisione. Nei linguaggi di programmazione orientati agli oggetti, la conversione di tipo permette ai programmi di trattare gli oggetti come se fossero di un tipo antenato, ad esempio per semplificarne la manipolazione.

Esistono due tipi di conversione di tipo: implicita ed esplicita. Il termine utilizzato per riferirsi alla conversione implicita è coercion, mentre il metodo più comune di conversione esplicita è chiamato casting (sostantivo che, a volte, viene impropriamente usato per indicare il significato generale di conversione). La conversione esplicita può essere eseguita anche con delle funzioni di conversione definite separatemente, come i costruttori sovraccarichi.

[modifica] Conversione di tipo implicita

La conversione implicita di tipo, conosciuta anche con il nome inglese coercion, è svolta in maniera automatica dal compilatore. Alcuni linguaggi di programmazione, addirittura, richiedono che questa funzionalità sia implementata nel compilatore.

In un'espressione di tipo misto, a runtime, i dati di uno o più sottotipi possono essere convertiti in tipi più generici in maniera che l'espressione sia valutata correttamente. Per esempio, il codice C che segue è valido:

double  d;
long    l;
int     i;

if (d > i)      d = i;
if (i > l)      l = i;
if (d == l)     d *= 2;

Nonostante d, l ed i appartengano a tipi di dato diversi, essi vengono automaticamente convertiti nello stesso tipo ogni volta che viene eseguito un confronto od una assegnazione. Questo comportamento del linguaggio dovrebbe essere utilizzato con cautela, in quanto potrebbe portare a conseguenze inaspettate. Per esempio, se si tentasse di assegnare il valore di una variabile di tipo double ad una di tipo int, si verificherebbe una perdita di informazione: la parte decimale, infatti, verrebbe persa (ogni compilatore, se impostato al giusto livello di avvertimento, notificherebbe la situazione allo sviluppatore). Allo stesso modo, la conversione da un tipo intero ad uno decimale può far perdere precisione, a causa della granularità di quest'ultimo tipo di dato (per ulteriori informazioni, vedera la voce virgola mobile). Nel caso più comune, questo causa problemi quando devono essere confrontate (per verificarne l'uguaglianza) una variabile intera ed una in virgola mobile.

[modifica] Conversione di tipo esplicita

Un esempio di casting in un frammento di codice C:

int arrotonda(float value){
   return (int)(value + 0.5);
}

Questa semplice funzione (di rilevanza perlopiù didattica) implementa l'operazione di arrotondamento di un numero decimale positivo. Poiché il valore dell'espressione value + 0.5 è di tipo float, è necessario troncarne la parte decimale: per far questo viene utilizzata una conversione esplicita ad int. La conversione può avvenire anche in senso inverso, come nel codice che segue:

int a = 5;
int b = 3;
float c,d;

c = a / b;        /* c adesso contiene il valore 1 */
d = (float)a / b; /* d assume il valore atteso: 1.6666666 */

Nonostante c sia di tipo float, esso non assume il valore atteso, in quanto la divisione tra a e b (entrambi di tipo int) viene interpretata come divisione intera, nella quale viene scartata l'eventuale parte decimale del quoziente. Per ottenere il risultato atteso di 1.6666..., è necessario convertire esplicitamente a float almeno uno tra divisore e dividendo (in questo caso il dividendo), in maniera che anche l'altro operando sia automaticamente promosso (termine che indica la conversione da un sottotipo ad un tipo più generico) e l'espressione venga valutata come desiderato.

Esistono vari tipi di conversione esplicita:

controllata: Prima dell'esecuzione della conversione, a runtime, viene eseguito un controllo sulla validità della stessa. Se la conversione è illegale, viene sollevato un errore.
non controllata: Non viene effettuato alcun controllo: se il tipo di destinazione non può contenere il valore convertito, il risultato è indefinito.
bit pattern: Il dato non viene affatto interpretato, ma viene semplicemente copiata la sua rappresentazione binaria.

Ogni linguaggio di programmazione ha le proprie regole per le conversioni di tipo: in generale, essa è ammessa per oggetti e tipi fondamentali.