Laboratorio di Informatica

Transcript

1 -- Conversione di tipo in C (V) -- Laboratorio di Informatica Ingegneria Meccanica Lezione 7, 22 novembre 2007 versione 24 novembre 2007 Renato Menicocci <rmenicocci@fub.it> <menicocci@die.uniroma1.it> Conversione esplicita di tipo può essere forzata con uno speciale operatore unario detto di conversione (o di type cast) Formati ( tipo ) ( espressione ) provoca la conversione del risultato di espressione al tipo specificato (che è tipo) (come se il risultato di espressione dovesse essere assegnato a una variabile del tipo specificato) (vedi avanti) ( tipo ) espressione ha un effetto che dipende da espressione (vedi avanti) Conversione di tipo in C (VI) Precedenza e associatività -- di utilizzazione Se r float e h e k int, allora r = ( float ) h / k ; provoca, ai fini della valutazione, la conversione di h da int a float e l assegnazione a r del valore float della divisione non intera tra h e k (ai fini della valutazione, k sarà promosso a float perchè coinvolto in un operazione con un tipo float) Per la precedenza dell operatore di conversione, se h e k int, ( float ) h / k ; equivale a ( float ) ( h ) / k ; Se h e k int, l effetto di ( float ) ( h / k ) ; è quello di convertire a float il risultato int di h / k (se r float, r = ( float ) ( h / k ) ; equivale a r = h / k ;)! (tipo) * / % + - < <= > >= ==!= && = += -= *= /= %= da destra a sinistra da destra a sinistra 3 4

2 -- Puntatori in C (I) -- Un puntatore è una variabile di un tipo speciale, detto (anch esso) puntatore, ed è caratterizzato dal fatto che il suo valore è utilizzabile per accedere a una variabile Se il valore del puntatore p è utilizzabile per accedere alla variabile v, si dice che v è puntata da p (o che p punta a v) In C, il tipo puntatore è un tipo derivato (anche l array lo è, mentre gli altri tipi visti finora sono tipi base) Formato dichiarazione tipo-puntato *nome ; int *iptr ; iptr è così dichiarato per puntare a una variabile di tipo int (attenzione: il valore di iptr è per ora indefinito) 5 -- Puntatori in C (II) -- Quando applicato a puntatori, il simbolo * indica un operatore unario detto di risoluzione del riferimento (indirection/dereferencing) Applicando l operatore * a un puntatore già dichiarato si accede alla variabile puntata da questo (il valore della variabile puntata può essere acquisito o modificato) E possibile far puntare un puntatore p a una variabile v assegnando a p il valore ottenuto applicando a v l operatore indirizzo & (attenzione: & è applicabile solo a variabili (non applicabile a costanti, espressioni, (e altro!)) Se p punta a v è possibile accedere al valore di v (per acquisirlo o per modificarlo) usando sia l espressione v sia l espressione *p 6 -- Puntatori in C (III) -- int *iptr ; /* iptr puntatore a tipo int */ int ia = 4, ib, ic = 8 ; /* ia, ib variabili int */ iptr = &ia ; /* iptr punta a variabile ia */ ib = *iptr ; /* ib assume il valore di ia (4) */ *iptr = ic ; /* ia assume il valore di ic (8) */ -- Puntatori in C (IV) -- Il significato di tipo-puntato *nome ; è: risolvendo il riferimento del puntatore nome (usando l operatore *), si accederà a una variabile di tipo tipopuntato Un puntatore è dichiarato quindi per un tipo specificato Data la dichiarazione tipo-puntato *nome ; è lecito utilizzare *nome ovunque sia accettabile la presenza di una variabile di tipo tipo-puntato 7 8

3 -- Puntatori in C (V) -- Istruzioni con esempi di espressioni con puntatori e variabili puntate (ipotesi: i, j puntatori a tipo int e x, y, z di tipo int) i = &x ; j = &y ; *i = *j x ; if ( z == *j * *i ) y = 0 ; *i = *i y ; *i += * j ; -- Puntatori in C (VI) -- A un puntatore (indipendentemente dal suo tipo-puntato) può essere assegnato lo speciale valore NULL per indicare la situazione in cui il puntatore non punta ad alcuna variabile (puntatore inattivo) int *iptr ; /* iptr ha valore indefinito */ iptr = NULL ; /* iptr ha valore definito (iptr inattivo) */ NULL può essere usato come valore di inizializzazione nella dichiarazione di un puntatore int *jptr = NULL ; Precedenza e associatività Puntatori e array in C (I) --! (tipo) * & * / % + - < <= > >= ==!= && = += -= *= /= %= da dx a sin da dx a sin E possibile far puntare un puntatore p a un elemento di un array v monodimensionale assegnando a p il valore ottenuto applicando all elemento di v l operatore indirizzo &; per puntare al primo elemento dell array (quello di indice 0) oltre ad applicare a questo l operatore indirizzo & si può anche usare il nome dell array (p puntatore a int e v array di 3 int) p = &v[ 2 ] ; /* p punta a v[ 2 ] */ *p = 21 ; /* v[ 2 ] = 21 */ p = v ; /* p punta a v[ 0 ] */ *p = 12 ; /* v[ 0 ] = 12 */ 11 12

4 -- Puntatori e array in C (II) -- Se un puntatore punta a un elemento di un array monodimensionale, si può ottenere che esso punti ad altri elementi dell array incrementando o decrementando, tramite gli operatori +, -, ++ e --, il valore del puntatore di un opportuno valore intero (vedi slide Aritmetica dei puntatori ) (p puntatore a int, v array di 7 int, b int) p = &v[ 2 ] ; /* p punta a v[ 2 ] */ p = p+1 ; /* p punta a v[ 3 ] */ p = p-2 ; /* p punta a v[ 1 ] */ b = *p ; /* b = v[ 1 ] */ b = *( p+5 ) ; /* b = v[ 6 ] */ Puntatori e array in C (III) e -- sono operatori validi per puntatori (vedi slide Aritmetica dei puntatori ) Attenzione all uso di pre/post-incremento (++) e pre/post-decremento (--) con puntatori (vedi tabella Precedenza e associatività ) Esempi (puntatore i punta a x di tipo int) ++*i ; equivale a ++( *i ) ; e la variabile puntata (x) sarà pre-incrementata (analogamente per --*i ;) *i++ ; equivale a *( i++ ) ; e il puntatore (i) sarà postincrementato (analogamente per *i-- ;) Puntatori e array in C (IV) Variabili (I) -- Si può usare il nome di un puntatore come se fosse il nome di un array monodimensionale (attenzione!) Se p è un puntatore e k un intero, p[ k ] equivale a *( p+k ) (p puntatore a int, v array di 6 int, b int) p = &v[ 2 ] ; /* p punta a v[ 2 ] */ p = p+1 ; /* p punta a v[ 3 ] */ p = p-2 ; /* p punta a v[ 1 ] */ b = p[ 4 ] ; /* b = v[ 5 ] */ 15 Il nome di una variabile (di un qualunque tipo) è associato univocamente alla locazione di memoria in cui il valore della variabile è registrato int k = 10, h ; /* valore di h indefinito (indicato con?) */ 10? L accesso alla locazione di memoria assegnata a una variabile (cioè l accesso al valore di una variabile) avviene usando il nome della variabile (questo sarà quindi equivalente all indirizzo della locazione assegnata) k h 16

5 -- Variabili (II) Variabili (III) -- indirizzo N-2 N-1 N N+1 N+2 10? k h Quanto detto vale anche per variabili di tipo puntatore int k = 10, *iptr ; iptr = &k ; /* indirizzo associato a k assegnato ora a iptr */ In questa rappresentazione 1. Si assume che una locazione di memoria abbia capacità sufficiente per la memorizzazione di un valore di tipo qualunque 2. Le posizioni di k e h in memoria sono arbitrarie 3. Si mostrano gli indirizzi delle locazioni di memoria indirizzo N-2 N-1 N 10 iptr N N+1 N+2 k int k = 10, *iptr ; iptr = &k ; /* iptr punta a k */ *iptr = 8 ; /* k assume valore 8 */ indirizzo N-2 N-1 iptr -- Variabili (IV) -- N 8 *iptr N N+1 N+2 L accesso al valore di k tramite iptr si ottiene applicando a iptr l operatore * di risoluzione del riferimento (*iptr attualmente associato alla stessa locazione a cui è associato k ) k Dimensioni delle variabili (I) -- Il numero di byte impiegati per memorizzare il valore di una variabile o di una costante dipende dal tipo di queste (già visti vari esempi) In C, ogni byte è univocamente individuabile da un indirizzo (l unità di memoria indirizzabile è il byte) L indirizzo associato a una variabile/costante è l indirizzo del primo dei byte di memoria utilizzati per registrare il valore della variabile/costante Il nome di una variabile è associato all indirizzo del primo dei byte di memoria in cui il suo valore è registrato (il tipo della variabile determina quanti altri byte devono essere considerati oltre al primo e permette quindi di accedere al valore della variabile) 20

6 indirizzo -- Dimensioni delle variabili (II) -- M-1 M M+1 M+2 M A 41 k ch In questa rappresentazione 1. Una locazione di memoria ha capacità di un byte 2. Le posizioni di k e ch in memoria sono arbitrarie 3. k (un tipo intero) occupa 2 byte e ch occupa 1 byte (tipo char) 4. I valori dei singoli byte di k e ch sono rappresentati in esadecimale 5. Non è indicato come i valori dei byte assegnati a una variabile determinano il valore di questa Operatore sizeof (I) -- La dimensione in byte di una specifica variabile o di una generica variabile di uno specificato tipo può essere ottenetuta con l operatore sizeof Un espressione contenente sizeof è valutata durante la compilazione Il valore fornito da sizeof è del tipo speciale size_t (definito in stddef.h) (size_t è assimilabile a un intero senza segno (può essere necessario l uso dell operatore type-cast per forzare la conversione al tipo (intero) desiderato) Formati sizeof variabile sizeof( tipo ) Operatore sizeof (II) -- Quando applicato a un array, sizeof fornisce il numero di byte impiegati per la memorizzazione di tutti gli elementi dell array (a condizione che la dimensione dell array risulti definita al momento della compilazione) Il numero di elementi di un array di dimensione definita può essere ottenuto dividendo il valore di sizeof nome-array (dimensione totale in byte) per il valore di sizeof( tipo-elementi-array ) (dimensione di un valore del tipo specificato in byte) o per il valore di sizeof nome-array[ indice-lecito ] (dimensione di un singolo elemento di nome-array in byte) -- Operatore sizeof (III) -- Esempi printf( ''%d'', ( int ) sizeof( double )) ; stampa il numero di byte impiegati per un double printf( ''%d'', ( int ) sizeof k ) ; stampa il numero di byte impiegati per la variabile k printf( ''%d'', ( int ) sizeof( int * )) ; stampa il numero di byte impiegati per un puntatore a int 23 24

7 -- Operatore sizeof (IV) -- Esempi /* double v[ 10 ] ; */ printf( ''sizeof v = %d'', ( int ) sizeof v ) ; stampa il numero di byte per 10 double /* int A[ 15 ], b ; */ b = (( int ) sizeof A ) / (( int ) sizeof( int )) ; assegna a b il valore 15 /* float w[ 9 ], x ; */ x = (( int ) sizeof w ) / (( int ) sizeof w[ 0 ] ) ; assegna a x il valore 9 -- Precedenza e associatività --! (tipo) * & sizeof da dx a sin * / % + - < <= > >= ==!= && = += -= *= /= %= da dx a sin Aritmetica dei puntatori (I) -- Su un puntatore possono essere eseguite le operazioni di Incremento e decremento (++/--) Somma di un intero Sottrazione di un intero Se si somma/sottrae un intero a/da un puntatore, questo viene incrementato/decrementato dell intero moltiplicato per la dimensione in byte del tipo a cui il puntatore punta (ricordare che, in C, la memoria è vista come una successione di celle, ognuna di capacità pari a un byte) -- Aritmetica dei puntatori (II) -- La regola precedente può essere compresa osservando quanto segue Gli elementi di un array sono memorizzati in successione ordinata, a partire dall elemento di indice 0 Ogni elemento di un array occupa in memoria lo stesso numero k di byte consecutivi, con k determinato dal tipo degli elementi dell array Un array di n elementi di un dato tipo occupa in memoria n*k byte, con k determinato dal tipo degli elementi dell array 27 28

8 -- Aritmetica dei puntatori (III) -- 1: Se iptr è un puntatore al tipo intero int e un intero int occupa 2 byte, iptr += 3 ; incrementa il valore di iptr di 6 /* int v[ 8 ], *p, a ; */ p = v ; /* p punta a v[ 0 ] */ a = *( p+3 ) ; /* a = v[ 3 ] */ 2: Se fptr è un puntatore al tipo reale float e un reale float occupa 4 byte, fptr += 4 ; incrementa il valore di fptr di 16 /* float w[ 5 ], *q, x ; */ q = &w[ 1 ] ; /* q punta a w[ 1 ] */ x = *( q+1 ) ; /* x = w[ 2 ] */ -- Puntatori e funzioni (I) -- E possibile dichiarare/definire funzioni con puntatori tra i propri argomenti Formato del singolo argomento puntatore (vedi avanti) tipo-puntato *nome (nome opzionale nel prototipo) Nella chiamata di una funzione, gli argomenti attuali sono sempre passati per valore Quando si passa un puntatore a una funzione, si fornisce alla funzione uno strumento per accedere alla variabile puntata dal puntatore Passare un array a una funzione equivale a passare (per valore) un puntatore al primo elemento dell array Puntatori e funzioni (II) -- Per la chiamata di una funzione con argomenti puntatori è necessario (per evitare sorprese) utilizzare argomenti attuali compatibili con il prototipo della funzione Se nella dichiarazione/definizione di una funzione si è specificato l argomento tipo-puntato *nome (nome opzionale nel prototipo) allora, per questo argomento, nella chiamata della funzione si può usare un puntatore per il tipo tipo-puntato l indirizzo di una variabile v di tipo tipo-puntato (ottenuto con espressione &v) un array monodimensionale a con elementi di tipo tipo-puntato (equivale all uso di &a[ 0 ]) Funzione con argomenti puntatori (I) -- void scambia( int *, int * ) ; void scambia( int *iptr, int *jptr ) { int temp ; temp = *iptr ; *iptr = *jptr ; *jptr = temp ; } int h, k ; scambia( &h, &k ) ; /* chiamata con espressioni &h e &k: la funzione riceve gli indirizzi di h e k e accede in memoria a questi indirizzi producendo lo scambio dei valori di h e k */ 32

9 -- Funzione con argomenti puntatori (II) -- void scambia( int *, int * ) ; void scambia( int *iptr, int *jptr ) { /* vedi slide precedente */ } int h, k ; int *p, *q ; p = &h ; q = &k ; scambia( p, q ) ; /* chiamata con puntatori p, puntante ad h, e q, puntante a k: la funzione riceve gli indirizzi di h e k e accede in memoria a questi indirizzi producendo lo scambio dei valori di h e k */ Funzione senza argomenti puntatori -- void scambia( int, int ) ; void scambia( int i, int j ) { int temp ; temp = i ; i = j ; j = temp ; } int h, k ; scambia( h, k ) ; /* chiamata con i valori di h e k: la funzione non riceve gli indirizzi di h e k e non accede in memoria a questi indirizzi (i valori di h e k resteranno invariati) */ min e max di array monodimensionale (I) -- void mm( float v[ ], int dim, float *pm, float *pm ) ; void mm( float v[ ], int dim, float *pm, float *pm ) { int i ; *pm = *pm = v[ 0 ] ; for ( i = 1 ; i < dim ; i++ ) { if ( v[ i ] < *pm ) *pm = v[ i ] ; if ( v[ i ] > *pm ) *pm = v[ i ] ; } } /* a fine esecuzione della funzione mm le variabili puntate da pm e pm avranno valori determinati da questa */ min e max di array monodimensionale (II) -- void mm( float v[ ], int dim, float *pm, float *pm ) ; float f[ 10 ], min, max ; int d ; mm( f, d, &min, &max ) ; /* si assume 0 <= d < 10 */ /* a fine esecuzione della funzione mm le variabili min e max avranno valori determinati da questa */ 36

10 -- Stringhe (I) -- Tipo char usato per la dichiarazione di variabili carattere ( : char c1 = 'A' ; ) Tecnicamente si tratta di un tipo intero i cui valori sono rappresentati su singolo byte Ordinariamente, una stringa è una sequenza di caratteri In C, il termine stringa (string) indica un array monodimensionale di elementi di tipo char contenente lo speciale carattere '\0' char deg[ 4 ] ; deg è un array di 4 caratteri: se usato come stringa, deg avrà al massimo 3 caratteri utili (il quarto sarà il carattere '\0') -- Stringhe (II) -- E possibile usare dichiarazione con inizializzazione, specificando ogni carattere, compreso quello di terminazione char deg[ 4 ] = { 'c', 'a', 'p', '\0' } ; E possibile usare dichiarazione con inizializzazione con stringa costante (sequenza di caratteri limitata da " e "): in questo caso, l inserimento del carattere '\0' di terminazione è automatico char deg[ 4 ] = "cap" ; a deg[ 3 ] sarà assegnato automaticamente il valore '\0' Stringhe (III) -- Nella dichiarazione con inizializzazione, la dimensione della stringa può essere omessa poiché risulta stabilita dalla inizializzazione stessa char deg[ ] = "cap" ; deg ha dimensione 4 (3 caratteri utili più carattere '\0') -- Stringhe (IV) -- Una stringa è un array di caratteri terminato con un carattere speciale si può accedere in lettura/scrittura a uno specifico elemento della stringa utilizzando uno specifico indice char s[ 3 ] = { 'y', 'n', '\0' }, c ; c = s[ 0 ] ; /* c vale 'y' */ s[ 0 ] = s[ 1 ] ; /* s[ 0 ] vale 'n' */ s[ 1 ] = c ; /* s[ 1 ] vale 'y' */ c = s[ 2 ] ; /* c vale '\0' */ 39 40

11 -- Stringhe (V) -- Attenzione a non confondere un singolo carattere 'c' con una stringa costante di un solo carattere "c" (che contiene 'c' e '\0') Una stringa (array di caratteri terminato con carattere '\0') può essere stampata (carattere di terminazione escluso) con funzione printf usando la specifica di conversione %s e passando a printf una stringa costante o un riferimento all array di caratteri sorgente (un riferimento è il nome dell array (indirizzo del primo carattere), o l indirizzo di uno dei caratteri dell array, o un puntatore a un elemento dell array) 41