Conversione di tipo

Da Wikipedia, l'enciclopedia libera.

In informatica, in particolare nella programmazione, la conversione di tipo (detta impropriamente casting, o typecasting, dal nome di uno dei modi in cui essa si manifesta) è l'operazione con cui si converte una variabile da un tipo di dato a un altro: questo passaggio è effettuato 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 semplificare l'interazione con questi oggetti.

Tipi di conversione[modifica | modifica wikitesto]

Esistono due tipi di conversione di tipo: implicita ed esplicita. Il termine utilizzato per riferirsi alla conversione implicita è coercion (it.: coercizione), 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 separatamente, come i costruttori sovraccarichi.

Conversione di tipo implicita[modifica | modifica wikitesto]

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.

Conversione di tipo esplicita[modifica | modifica wikitesto]

Un esempio di casting in un frammento di codice C:

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

Il codice definisce, a titolo puramente esemplificativo, una semplice funzione che 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 al tipo 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 sia 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.

Voci correlate[modifica | modifica wikitesto]

Informatica Portale Informatica: accedi alle voci di Wikipedia che trattano di Informatica