NB L uso delle istruzioni condizionali annidate causa rischio di ambiguità quando qualcuna di loro manca del ramo else:

Transcript

1 Si vuole costruire un programma che legga tre numeri dall ingresso, quindi verifichi che questi possano essere la lunghezza dei tre lati di un triangolo (la lunghezza di ogni lato deve essere minore della somma degli altri due) e infine determini se il triangolo avente lati con le lunghezze indicate è scaleno, isoscele oppure equilatero. /*Programma per la valutazione di un triangolo */ main() { /*Lettura dei dati di ingresso */ scanf(x); scanf(y); scanf(z); /* Verifica che i dati possano essere le lunghezze dei lati di un triangolo */ if ((X < Y + Z) && (Y < X + Z) && (Z < X + Y)) /*Distinzione tra i vari tipi di triangolo */ if (X == Y && Y == Z) printf("i dati letti corrispondono a un triangolo equilatero"); else if (X == Y Y == Z X == Z) printf("i dati letti corrispondono a un triangolo isoscele"); else printf("i dati letti corrispondono a un triangolo scaleno"); else printf("i dati letti non corrispondono ad alcun triangolo"); }

2 NB L uso delle istruzioni condizionali annidate causa rischio di ambiguità quando qualcuna di loro manca del ramo else: if (C1) if (C2) S1; else S2; if (C1) else S2; if (C2) S1; oppure if (C1) if (C2) S1; else S2;? Convenzione: il primo ramo else viene attribuito all ultimo if. Nell esempio precedente, questo significa scegliere la seconda alternativa. Altrimenti, scriviamo esplicitamente: if (C1) {if (C2) S1;} elses2; Analogamente con a + b * c intendiamo a + (b * c); altrimenti (a + b) * c.

3 Torniamo al problema di leggere una sequenza di dati e riscriverli in ordine inverso Il problema richiede la memorizzazione di tutti i dati - in celle diverse- prima di cominciare a scriverli Nel linguaggio assembler (di von Neumann) avevamo risolto il problema mediante l indirizzamento indiretto (si poteva fare anche in maniera più basilare, ma più complessa) I linguaggi di alto livello invece introducono il concetto di dato strutturato, ossia informazione che a sua volta è composta di informazioni più elementari. Il primo tipo di dato strutturato che affrontiamo è l array: sequenza lineare di celle omogenee e consecutive che di per sé costituiscono una variabile.

4 Rivediamo la struttura della macchina astratta C, includendo il nuovo tipo di variabili

5 Un array viene identificato come qualsiasi altra variabile Però anche i suoi elementi sono variabili Ad essi si accede mediante un indice: Ad esempio: scanf(s[2]); per leggere un dato e memorizzarlo nella terza cella dell array s: in C il primo elemento di ogni array è sempre lo 0-esimo ---> se un array ha 10 elementi il suo indice può assumere i valori interi tra 0 e 9 (per il momento però non ci preoccupiamo del numero di elementi di un array); a[3] = s[1] + x; if (a[4] > s[1] + 3) s[2] = a[2] + a[1]; ma anche x = a[i]; a[i] = a[i+1]; a[i*x] = s[a[j+1] 3]*(y a[y]);

6 Torniamo al problema di partenza: leggere una sequenza -di caratteri, terminata da un % - e riscriverla in ordine inverso /* Programma InvertiSequenza */ main() { indice = 0; scanf(x); while (x!= '%') { sequenza[indice] = x; indice = indice + 1; scanf(x); } while (indice > 0) { indice = indice - 1; printf(sequenza[indice]); } }

7 A poco a poco cominciamo ad affrontare problemi, e a scrivere programmi, un po meno banali Supponiamo di avere sullo Standard Input una serie di dati relativi a delle fatture: per ogni fattura una cella dello Standard Input ne contiene l importo e le tre successive la data di emissione, nella forma giorno (un numero compreso tra 1 e 31), mese, anno. Il solito % di terminazione è posto dopo l anno dell ultima fattura. Si vogliono stampare, nell ordine, sullo Standard Output: la dicitura: IMPORTI FATTURE EMESSE; la sequenza di tutti gli importi, nello stesso ordine di ingresso, preceduti dal carattere $; la dicitura: TOTALE FATTURE EMESSE; il totale delle fatture stesse, precedute dal carattere $; la dicitura: DATE DI EMISSIONE; la sequenza delle date di emissione, nello stesso ordine di ingresso. I tre elementi di ogni data devono essere separati da una /; alla fine di ogni data va scritto il carattere #.

8 Quando i problemi si complicano -poco per ora- è difficile scrivere d acchito un programma che li risolva: conviene andare per gradi. Cominciamo con lo scrivere l algoritmo, poi lo codificheremo Un primo ciclo esegue la lettura dei vari dati, quattro per volta (infatti ogni fattura è descritta da quattro elementi). Ognuno dei quattro dati letti viene memorizzato, rispettivamente, in una cella di quattro diversi array, denominati fatture, giorno, mese e anno. L indice di ognuno di questi array viene incrementato di 1 a ogni iterazione del ciclo. Durante questo ciclo viene anche calcolato l importo totale delle varie fatture. Viene stampata la dicitura IMPORTI FATTURE EMESSE mediante un unica istruzione printf. Un primo ciclo di scrittura stampa nell ordine tutti gli elementi dell array fatture intercalandoli con il simbolo $. Viene stampata la dicitura TOTALE FATTURE EMESSE seguita da $ e dal valore del totale precedentemente calcolato. Viene stampata la dicitura DATE DI EMISSIONE. Un secondo ciclo di scrittura stampa le varie terne di valori giorno, mese, anno, prelevandole nell ordine dai corrispondenti array e introducendo il carattere / tra giorno e mese e tra mese e anno, e il carattere # tra l anno della data corrente e il giorno della terna successiva.

9 Dall algoritmo al programma: /* Programma Fatture */ main() { contatore = 0; totale = 0; scanf(dato); while (dato!= '%') { fatture[contatore] = dato; totale = totale + dato; scanf(dato); giorno[contatore] = dato; scanf(dato); mese[contatore] = dato; scanf(dato); anno[contatore] = dato; scanf(dato); contatore = contatore + 1; } printf("importi FATTURE EMESSE"); NumFatture = contatore; contatore = 0; while (contatore < NumFatture) { printf('$'); printf(fatture[contatore]); contatore = contatore + 1; } printf("totale FATTURE EMESSE"); printf('$'); printf(totale); printf("date DI EMISSIONE"); contatore = 0; while (contatore < NumFatture) { printf(giorno[contatore]); printf('/'); printf(mese[contatore]); printf('/'); printf(anno[contatore]); printf('#'); contatore = contatore + 1; } }

10 La costruzione incrementale dei programmi mediante pseudocodice Si vuole costruire un analizzatore di testo che sostituisca sistematicamente una parola con un altra. Precisamente, si supponga che lo Standard Input della macchina abbia il contenuto seguente. In primo luogo è scritta (carattere per carattere) una parola (per parola intendiamo qui una sequenza di caratteri alfabetici); segue il carattere $; poi un altra parola seguita dal carattere #; successivamente vi è una sequenza di parole separate tra di loro da uno spazio e chiusa da un % (cioè, dopo l ultima parola c è uno spazio seguito dal terminatore finale %). Il programma deve riscrivere su Standard Output il testo costituito dalla sequenza di parole dopo il #, sostituendo a ogni occorrenza della prima parola dello Standard Input la seconda. Se per caso la prima parola mancasse, il programma deve stampare un messaggio che avverte l utente dell errore e sospendere l esecuzione. Al contrario, può essere mancante la seconda parola: in tal caso si ottiene l effetto di cancellare ogni occorrenza della prima parola; è ammesso il caso particolare che l intero testo da riscrivere sia assente. Osservazione Per la prima volta ci preoccupiamo della possibilità di dati errati o, più in generale ancora, di condizioni eccezionali.

11 Per costruire il programma -non banalissimoprocediamo per gradi Prima specifichiamo a grandi linee e informalmente -in italiano- l algoritmo: 1 Verifica se prima del carattere $ esiste una parola. In caso negativo stampa il messaggio MANCA LA PAROLA DA SOSTITUIRE. In caso positivo procedi come segue. 2 Memorizza la prima parola del testo in un array di caratteri. 3 Memorizza la seconda parola in un altro array. 4 A questo punto fai la scansione dell intero testo parola per parola (fino all individuazione del carattere %). 4.1 Memorizza ogni parola in un array. 4.2 Confronta la parola letta con la prima parola. Se le due parole coincidono, scrivi nello Standard Output la seconda parola, altrimenti scrivi la parola appena letta. Non tutti i termini utilizzati, pur chiari, (ad esempio: memorizza parola) corrispondono a operazion i elementari del C: occorre analizzarli separatamente come sottoproblemi. Per non fare tutta la fatica in un colpo solo, codifichiamo in parte l algoritmo:

12 main() { /* Programma SostituzioneParole */ scanf(carattere); if (carattere == '$') printf("manca LA PAROLA DA SOSTITUIRE"); else { [memorizza nell'array PrimaParola la sequenza di caratteri fino a '$']; [memorizza nell'array SecondaParola la sequenza di caratteri seguenti '$' fino a '#']; scanf(carattere); while (carattere!= '%') { [memorizza nell'array ParolaCorrente la sequenza di caratteri fino al prossimo spazio]; [confronta PrimaParola con ParolaCorrente]; if ([PrimaParola == ParolaCorrente]) [printf(secondaparola)]; else [printf(parolacorrente)]; printf(' '); /* Sia nel caso che si sia scritta la parola appena letta (ParolaCorrente), sia nel caso che si sia scritta la seconda parola al posto della prima, si scrive uno spazio per separarla dalla parola successiva */ scanf(carattere); /* Inizia la lettura della prossima ParolaCorrente, a meno che il carattere letto non sia % */ } } }

13 Esaminiamo ora i sottoproblemi: memorizzazione di una parola in un array, scrittura di una parola confronto tra due parole. Ognuna di queste operazioni richiede a sua volta un sottoalgoritmo per la sua realizzazione. Concentriamo l attenzione sulla meno banale: il confronto. decidere se due parole memorizzate rispettivamente nei due array PrimaParola e ParolaCorrente coincidono : se le lunghezze delle due parole sono diverse, allora le parole sono senz altro diverse. In caso contrario: fai la scansione dei due array carattere per carattere fino a quando o non trovi due caratteri diversi o l indice dell array ha superato la lunghezza della parola; nel primo dei due casi precedenti concludi che le due parole sono diverse; nel secondo caso concludi che le due parole coincidono.

14 Ora codifichiamo l algoritmo precedente separatamente... if (LunghPrimaPar == LunghParCorr) { contatore = 0; while ((contatore < LunghPrimaPar) && PrimaParola[contatore] == ParolaCorrente[contatore])) contatore = contatore + 1; if (contatore >= LunghPrimaPar) printf("le due parole coincidono"); else printf("le due parole sono diverse"); } else printf("le due parole sono diverse");

15 e alla fine mettiamo tutto assieme /* Programma SostituzioneParole */ main() { scanf(carattere); if (carattere == '$') printf ("MANCA LA PAROLA DA SOSTITUIRE"); else { contatore = 0; while (carattere!= '$') /* Memorizzazione della prima parola */ { PrimaParola[contatore] = carattere; contatore = contatore + 1; scanf(carattere); } LunghPrimaPar = contatore; scanf(carattere); contatore = 0; while (carattere!= '#') /* Memorizzazione della seconda parola */ { SecondaParola[contatore] = carattere; contatore = contatore + 1; scanf(carattere); } LungSecPar = contatore;

16 /* Si entra ora nella fase di scansione del testo */ scanf(carattere); while (carattere!= '%') { contatore = 0; while (carattere!= ' ' ) /* Memorizzazione della parola corrente */ { ParolaCorrente[contatore] = carattere; contatore = contatore + 1; scanf(carattere); } LungParCorr = contatore; /* Si confronta la prima parola con la parola corrente */ if (LunghPrimaPar == LunghParCorr) { contatore = 0; while (contatore < LunghPrimaPar && PrimaParola[contatore] == ParolaCorrente[contatore]) contatore = contatore + 1; if (contatore >= LunghPrimaPar /* Si ricopia la seconda parola */ { contatore = 0; while (contatore < LungSecPar) { printf(secondaparola[contatore]); contatore = contatore + 1; } } else

17 /* Si ricopia la parola corrente */ { contatore = 0; while (contatore < LungParCorr) { printf(parolacorrente[contatore]); contatore = contatore + 1; } } } else /* Si copia la Parola corrente: in questo caso le due parole sono differenti perché le lunghezze sono differenti */ { contatore = 0; while (contatore < LungParCorr) { printf(parolacorrente[contatore]); contatore = contatore + 1; } } printf(' '); /*Sia nel caso che si sia scritta la parola appena letta (ParolaCorrente), sia nel caso che si sia scritta la seconda parola al posto della prima, si scrive uno spazio per separarla dalla parola successiva*/ scanf(carattere); /* Inizia la lettura della prossima ParolaCorrente, a meno che il carattere letto non sia % */ } } }

18 I programmi visti finora non sono ancora puro codice C compilabile Anche se un compilatore per quello pseudo-c sarebbe possibile Che cosa manca per arrivare al puro codice C compilabile? Ricominciamo da capo (quasi): /* Programma SommaSequenza */ #include <stdio.h> void main() { int numero, somma; somma = 0; scanf("%d", &numero); while (numero!= 0) { somma = somma + numero; scanf("%d", &numero); } printf("la somma dei numeri digitati è: %d\n", somma); } ed esaminiamo le novità (non proprio in ordine di apparizione):

19 La struttura dei programmi C Un programma C deve contenere, nell ordine: una parte contenente direttive per il compilatore. Per il momento trascuriamo questa parte. l identificatore predefinito main seguito dalle parentesi () (già visto in precedenza) (e preceduto spesso dalla parola chiave void) due parti, sintatticamente racchiuse dalle parentesi {}: la parte dichiarativa; la parte esecutiva. La parte dichiarativa di un programma costituisce la principale novità. Essa elenca tutti gli elementi che fanno parte del programma, con le loro principali caratteristiche. La parte esecutiva consiste in una successione di istruzioni come già descritto in pseudo-c.

20 La parte dichiarativa Tutto ciò che viene usato va dichiarato In prima istanza -altri elementi seguiranno-: dichiarazione delle costanti; dichiarazione delle variabili. Perché obbligare il programmatore a questa fatica inutile? Aiuta la diagnostica (ovvero segnalazione di errori): x = alfa; alba = alfa + 1; Senza dichiarazione alba è una nuova variabile Principio importante: meglio un po più di fatica nello scrivere un programma che nel leggerlo -e capirlo!

21 Esaminiamo più in dettaglio la dichiarazione delle variabili (posponendo quella delle costanti) Una dichiarazione di variabile consiste in uno specificatore di tipo, seguito da una lista di uno o più identificatori di variabili separati da una virgola. Ogni dichiarazione termina con ; Il concetto di tipo (di dato, o informazione) è un concetto fondamentale della programmazione La stessa stringa di bit può rappresentare un intero, un carattere, Il tipo di dato è il ponte tra la visione astratta dell informazione e la sua rappresentazione concreta: strumento fondamentale di astrazione. Infatti parleremo spesso di tipo di dato astratto. Abbiamo già fatto uso del concetto di tipo (di una variabile): abbiamo infatti parlato di interi, caratteri, tipi strutturati. A poco a poco saremo vieppiù sistematici nell esposizione del sistema di tipi (del C e, in generale, nella programmazione)

22 Cominciamo con tre specificatori di tipi già noti: le parole chiave int, float, char specificano, rispettivamente i tipi intero, reale, carattere: float x,y; int i,j; char simb; equivalenti a: float x; int i,j; char simb; float y; Se un identificatore di variabile x è dichiarato di tipo int, esso potrà essere usato nella parte esecutiva solo come tale. Di conseguenza, x non assumerà mai un valore reale, come per esempio 3.14.

23 La dichiarazione di costanti e il loro uso Una dichiarazione di costante associa permanentemente un valore a un identificatore. Come nel caso della dichiarazione di variabili, la sezione della dichiarazione di costanti consiste in una lista di dichiarazioni. Ogni dichiarazione, a sua volta, consiste in: la parola chiave const; lo specificatore di tipo; l identificatore della costante; il simbolo =; il valore della costante. Esso può essere, fra le altre cose, un numero intero, con o senza segno, un numero reale o un carattere; il solito terminatore ; Esempi di dichiarazioni di costanti: const float PiGreco = 3.14; const float PiGreco = , e = 2.718; const int N = 100, M = 1000; const char CAR1 = 'A', CAR2 = 'B'; Un eventuale assegnamento a una costante sarebbe segnalato come errore dal compilatore.

24 Perché dichiarare le costanti? (potremmo anche farne a meno) L istruzione AreaCerchio = PiGreco*RaggioCerchio*RaggioCerchio; è equivalente a: AreaCerchio = 3.14*RaggioCerchio*RaggioCerchio; (se si fa riferimento alla prima dichiarazione di PiGreco) 1. Maggior astrazione: l area del cerchio è il prodotto del quadrato del raggio per π, e non per 3.14, né , né ecc. 2. Maggior astrazione ===> parametricità ==> generalità ==> modificabilità : Se non mi accontento più di 2 cifre decimali per approssimare π, mi basta modificare la sua dichiarazione, non tutte le istruzioni in cui ne faccio uso. Altri esempi di parametricità ottenuta attraverso la dichiarazione di costanti saranno illustrati in seguito -anche attraverso un nuovo modo di dichiararle.

25 Torniamo ora alla parte esecutiva di un programma L unica differenza tra il codice pseudo-c e il codice C reale dell esempio precedente sta nelle istruzioni di I/O. Il punto è che le istruzioni di I/O non sono vere e proprie istruzioni del linguaggio ma sottoprogrammi di libreria, concetto che verrà illustrato più avanti. Al momento, però facciamo finta che siano istruzioni. printf richiede una stringa di controllo e un insieme di elementi da stampare: printf(stringa di controllo, elementi da stampare); La stringa di controllo è una stringa che viene stampata in uscita e può contenere caratteri detti di conversione o di formato preceduti dal simbolo % e altri simboli particolari. I caratteri di formato %d, %f, %c, %s provocano la stampa sullo Standard Output rispettivamente: di un numero intero decimale, di un numero reale (floating point), di un carattere, di una stringa di caratteri. Il simbolo \n nella stringa di controllo provoca un salto a nuova riga per la successiva scrittura. L insieme degli elementi da stampare è una lista di variabili, di costanti o di espressioni composte con variabili e costanti.

26 printf ("Lo stipendio annuo dei dipendenti di categoria %d è pari a E. %f", cat_dipend, stip_medio); Se cat_dipend è una variabile di tipo int che rappresenta la categoria dei dipendenti considerati, l istruzione printf viene eseguita usando il suo valore corrente, per esempio 6. Se stip_medio è una variabile di tipo float che rappresenta lo stipendio medio calcolato per il gruppo di dipendenti considerato, l istruzione printf viene eseguita usando il suo valore corrente, per esempio L esecuzione dell istruzione printf provocherà la stampa sullo schermo della frase Lo stipendio annuo dei dipendenti di categoria 6 è pari a E

27 printf("%s\n%c%c\n\n%s\n", "Questo programma è stato scritto da", iniz_nome, iniz_cognome, "Buon lavoro!"); Se iniz_nome è una variabile di tipo char che rappresenta l iniziale del nome del programmatore, l istruzione printf viene eseguita usando il suo valore corrente, per esempio G. Se iniz_cognome è una variabile di tipo char che rappresenta l iniziale del cognome del programmatore, l istruzione printf viene eseguita usando il suo valore corrente, per esempio M. L esecuzione dell istruzione printf produce la visualizzazione delle seguenti frasi: Questo programma è stato scritto da GM Buon lavoro! Si noti l effetto dei simboli \n

28 Anche scanf èdel tipo scanf(stringa di controllo, elementi da leggere); ma i nomi delle variabili sono preceduti dall operatore unario &

29 scanf("%c%c%c%d%f", &c1, &c2, &c3, &i, &x); Se al momento dell esecuzione dell istruzione scanf l utente inserisce i seguenti dati: ABC la variabile c1 (di tipo char) assume il valore A. (&c1 va letto come indirizzo della variabile c1); la variabile c2 (di tipo char) assume valore B; la variabile c3 (di tipo char) assume valore C; la variabile i (di tipo int) assume valore 3; la variabile x (di tipo float) assume valore

30 Resta da spiegare la direttiva #include ogni programma che utilizza al suo interno le funzioni printf e scanf deve dichiarare l uso di tali funzioni nella parte direttiva che precede il programma principale. #include <stdio.h> E una direttiva data a una parte del compilatore, chiamata preprocessore, che include una copia del contenuto del file stdio.h. Essa provoca l inclusione (una copia) del contenuto del file stdio.h. Tra le dichiarazioni di funzione contenute in stdio.h sono presenti quelle di printf e scanf. Questo consente una esatta compilazione del programma che utilizza nella sua parte eseguibile printf e scanf e una produzione corretta del codice eseguibile grazie all utilizzo del codice che il sistema C mette a disposizione per printf e scanf. E finalmente...

31 /* PrimoProgrammaC */ #include <stdio.h> main() { printf("questo è il mio primo programma in C\n"); } NB: niente dichiarazioni! /* Programma SommaDueInteri */ #include <stdio.h> main() { int a, b, somma; printf ( inserisci come valore dei due addendi due numeri interi\n ); scanf("%d%d", &a, &b); somma = a + b; printf("la somma di a+b è:\n%d \narrivederci!\n", somma); } Se vengono inseriti i dati 3 e 5 l effetto dell esecuzione del programma sullo Standard Output è il seguente: La somma di a+b è: 8 Arrivederci! Se invece fossero stati omessi i primi due simboli \n nella stringa di controllo? Il programma SommaDueInteri è anche un primo esempio di programma interattivo

32 Intraprendiamo ora lo studio sistematico degli elementi essenziali del linguaggio C Lo scopo non è tanto diventare esperti del linguaggio, quanto impossessarsi di alcuni concetti fondamentali della programmazione che dovranno essere applicati in vari contesti e usando diversi strumenti/linguaggi C sarà perciò soltanto un punto di riferimento ma dovremo presto imparare a giostrare tra vari linguaggi. Alcuni di essi -i più tradizionali (Ada, Pascal, Modula-2, C++, Java,.)- hanno molto in comune con C e ad essi soprattutto faremo riferimento. Altri sono basati su principi meno convenzionali - che verranno illustrati in corsi successivi.

33 Cominciamo con il concetto di tipo di dato Ci siamo già imbattuti in questo concetto: tipo di dato = tipo di informazione alcuni tipi: interi, reali, caratteri, array, ma anche: fatture, conti correnti, pagine web, Quanti tipi? Infiniti! E allora? Occorre un po di sistematicità Definizione generale di tipo di dato: Insieme di valori e di operazioni ad esso applicabili (riscontrare con i tipi già noti) Tipo astratto: conta la visione esterna, non la rappresentazione interna, ovvero il punto di vista di chi usa il tipo, non di chi lo realizza: Gli interi -e tutti gli altri tipi- all interno di un calcolatore sono stringhe -sequenze- di bit. Ma l HW ci permette di astrarre da questa conoscenza: ci permette di scrivere 23, 555,.. e senza conoscere quale algoritmo viene applicato per calcolare la somma. Immaginiamo di dover trattare direttamente come stringhe di bit la divina commedia, una pagina web, Inoltre potremo talvolta usare diverse rappresentazioni concrete per la stessa astrazione

34 Classificazione dei tipi di dato 1 Tipi semplici (interi, caratteri, reali, ) Tipi strutturati (per ora: array) Attenzione: non sempre tipo semplice = valori del tipo contenuti in una cella di memoria tipo strutturato = valori del tipo contenuti in diverse celle di memoria Esistono vari controesempi (e.g. i reali ) Tipo semplice: i valori vengono gestiti dalle varie operazioni in modo unitario Tipo strutturato: i valori possono essere scomposti in elementi più semplici trattabili separatamente. 2 Tipi predefiniti (nel linguaggio) (interi, caratteri, ) Tipi definiti dall utente (per soddisfare le infinite e imprevedibili esigenze) in C: età, data, conto_corrente non sono predefiniti: devono essere costruiti dal programmatore in altri linguaggi special purpose potrebbero esserlo (e.g. data nei fogli elettronici) Il concetto è generale: l attuazione varia a seconda del linguaggio (con molta parte comune a quasi tutti)

35 Cominciamo da: Tipi semplici predefiniti Quattro tipi di base: char (caratteri), int (interi), float (reali), double (reali in precisione doppia). I qualificatori di tipo signed o unsigned possono essere applicati a char e a int, i qualificatori short o long a int il qualificatore long a double.. Tipi semplici predefiniti del C (da non imparare a memoria) Tipo predefinito char signed char unsigned char signed short int signed int signed long int unsigned short int unsigned int unsigned long int float double long double Denominazioni alternative signed short, short signed, int long int, signed long, long unsigned short unsigned unsigned long short e long condiziona(va)no lo spazio allocato dal compilatore per la memorizzazione delle variabili tipizzate signed e unsigned, short e long condizionano l insieme dei valori nonché il valore massimo e minimo Non è necessario dichiarare tipi built-in

36 Il tipo int il tipo interi non è l insieme {..., _1, 0, 1, 2,...}, bensì quello stesso insieme corredato di somma, sottrazione, moltiplicazione ecc. il tipo interi della matematica ha infiniti valori, e anche infinite operazioni. Non così in C: int è un approssimazione finita del corrispondente tipo matematico, legata alla finitezza della memoria reale del calcolatore I valori di int in C spazio allocato (short int) spazio allocato (int) spazio allocato(long int) Un signed int usa un bit per la rappresentazione del segno Un unsigned int utilizza tutti gli n bit (16 ---> > 64) per rappresentare il valore intero supposto positivo. INT_MIN e INT_MAX: identificatori di costante predefiniti, però int è predefinito dalla definizione del linguaggio, INT_MIN e INT_MAX lo sono dall implementazione del linguaggio, non dalla definizione dello stesso. Su qualunque macchina venga eseguito un programma vale comunque la proprietà seguente: spazio allocato (signed int) = spazio allocato (unsigned int)

37 Operazioni built-in per dati di tipo int = Assegnamento di un valore int a una variabile int + Somma (tra int ha come risultato un int) - Sottrazione (tra int ha come risultato un int) * Moltiplicazione (tra int ha come risultato un int) / Divisione con troncamento della parte non intera (risultato int) % Resto della divisione intera == Relazione di uguaglianza!= Relazione di diversità < Relazione minore di > Relazione maggiore di <= Relazione minore o uguale a >= Relazione maggiore o uguale a Se alcune operazioni fornissero un risultato non appartenente all insieme dei valori consentito (per esempio se il risultato di una moltiplicazione fosse maggiore di INT_MAX) il risultato effettivamente prodotto sarebbe una segnalazione di errore (Integer Overflow) : in questo caso il risultato concreto non corrisponde al valore astratto.

38 Operazioni built-in per dati di tipo int = Assegnamento di un valore int a una variabile int + Somma (tra int ha come risultato un int) - Sottrazione (tra int ha come risultato un int) * Moltiplicazione (tra int ha come risultato un int) / Divisione con troncamento della parte non intera (risultato int) % Resto della divisione intera == Relazione di uguaglianza!= Relazione di diversità < Relazione minore di > Relazione maggiore di <= Relazione minore o uguale a >= Relazione maggiore o uguale a Se alcune operazioni fornissero un risultato non appartenente all insieme dei valori consentito (per esempio se il risultato di una moltiplicazione fosse maggiore di INT_MAX) il risultato effettivamente prodotto sarebbe una segnalazione di errore (Integer Overflow) : in questo caso il risultato concreto non corrisponde al valore astratto.

39 I tipi float e double float e double: approssimazione dei numeri reali, non solo dal punto di vista del loro limite, ma anche della precisione di rappresentazione Due diverse rappresentazioni: 1. la normale rappresentazione decimale, o in virgola fissa: rappresentare o in questa maniera richiederebbe un enorme spreco di cifre, e quindi di celle di memoria. 2. la rappresentazione in virgola mobile (floating point) mantissa ed esponente (della base 10), separate dal carattere E. Se un numero n ha mantissa m ed esponente e, il suo valore è n = m 10 e può essere rappresentato in virgola mobile nei modi seguenti: E E E+6,. Le notazioni sono interscambiabili e la macchina provvede automaticamente alle necessarie conversioni spazio allocato (float) spazio allocato (double) spazio allocato (long double) (di solito useremo double)

40 Operazioni built-in per dati di tipo float e double = Assegnamento + Somma - Sottrazione * Moltiplicazione / Divisione (a risultato reale; il simbolo è identico a quello usato per la divisione intera) == Relazione di uguaglianza!= Relazione di diversità < Relazione minore di > Relazione maggiore di <= Relazione minore o uguale a >= Relazione maggiore o uguale a

41 NB: Sia internamente (in base 2) che esternamente (in base 10) le due rappresentazioni in virgola fissa e virgola mobile sono interscambiabili algoritmi interni di conversione. Un operazione di relazione su due valori di tipo float (double o long) produce come risultato un valore intero pari a zero se la relazione non è verificata, e un valore intero diverso da zero se la relazione è verificata. La standard library fornisce anche diverse funzioni matematiche predefinite (sqrt, pow, exp, sin, cos, tan...) (per double ). Per ora trattiamole come operazioni normali built-in (però occorre includere l opportuno file) Attenzione agli arrotondamenti: (x/y) * y == x potrebbe risultare falsa! Invece di scrivere if (x == y)... è meglio scrivere if (x <= y && y <= x )...

42 Il tipo char L insieme dei dati di tipo char, è l insieme dei caratteri ASCII, e contiene tutte le lettere, le cifre e i simboli disponibili sulle normali tastiere. La codifica ASCII consente la rappresentazione di ciascun carattere attraverso un opportuno valore intero. definisce inoltre l ordinamento dei valori: per qualsiasi coppia di caratteri x e y, x < y se e solo se x precede y nell elenco dei caratteri. Alcuni caratteri sono caratteri di controllo: la loro scrittura non consiste in una vera e propria stampa di un simbolo sulla carta o sul video, ma nell esecuzione di un operazione correlata alla visualizzazione dei dati: \n che provoca un a capo, \b = backspace, \t = horizontal tab, \r = carriage return, ETX, EOF,... Il compilatore ANSI C alloca per una variabile di tipo char 1 byte e lo stesso avviene per una variabile di tipo signed char o unsigned char. Un byte può contenere la codifica binaria di 256 valori differenti. Per un signed char l insieme dei valori va da 128 a +127, per un unsigned char l insieme dei valori va da 0 a 255 (ASCII esteso e problemi di standardizzazione ). Sono definite le operazioni di assegnamento (=), le operazioni aritmetiche (+,, *, /, %) e quelle relazionali (==,!=, < ecc.) La comunanza di operazioni tra char e int è una naturale conseguenza della rappresentazione dei caratteri tramite numero intero. Non proprio identico al normale concetto di carattere...

43 Un tipico esempio di sfruttamento - e aberrazioni- delle caratteristiche del C Leggere una sequenza di caratteri (terminata da #); per ciascun carattere letto viene stampato il relativo codice ASCII e, nel caso sia una lettera dell alfabeto minuscola, viene operata la trasformazione in lettera maiuscola. /* Programma ManipolazioneCaratteri*/ #include <stdio.h> main() { char C, CM; printf("inserire un carattere # per terminare il programma\n"); scanf( %c", &C); /*NB lo spazio prima di %*/ while (C!= '#') { printf("il codice ASCII del carattere %c è %d\n", C, C); /* Se il carattere è una lettera minuscola */ if (C >= 'a' && C <= 'z') { /* La differenza 'a' 'A' è lo scarto fra la rappresentazione ASCII delle lettere maiuscole e minuscole dell'alfabeto */ CM = C ('a' 'A'); printf("la lettera maiuscola per %c è %c e il suo codice ASCII è %d\n", C, CM, CM); } printf("inserire un carattere # per terminare il programma\n"); scanf( %c", &C); } }

44 Riassumendo Tipi integral: char signed char unsigned char short int long unsigned short unsigned unsigned long Tipi floating: float double long double Tipi arithmetic: tipi integral + tipi floating Tutti i tipi arithmetic del C condividono alcune importanti caratteristiche: sono totalmente ordinati sono limitati I tipi integral sono insiemi discreti. I tipi floating sono insieme densi (in astratto)

45 Regole sintattiche La costruzione di nuovi tipi in C Una dichiarazione di tipo (type declaration) consiste nella parola chiave typedef seguita dalla rappresentazione o costruzione del nuovo tipo dall identificatore del nuovo tipo, e dal simbolo ; che chiude la dichiarazione. typedef int anno; Una volta definito e identificato un nuovo tipo ogni variabile può essere dichiarata di quel tipo come di ogni altro tipo già esistente. char x; anno y; NB: typedef non consente di costruire veri e propri nuovi tipi astratti (mancano le operazioni colmeremo poi questa lacuna) Presentiamo ora in maniera sistematica le varie modalità per costruire la rappresentazione di un nuovo tipo, cominciando dai tipi semplici.

46 Ridefinizione typedef TipoEsistente NuovoTipo; TipoEsistente può essere sia un tipo built-in (predefinito), per esempio int, sia un tipo user-defined precedentemente definito: typedef int tipo1; typedef char tipo2; typedef tipo1 tipo3; typedef tipo2 tipo4; Constateremo tra breve l estrema utilità e generalità di questa caratteristica.

47 Enumerazione esplicita dei valori Un nuovo tipo può essere costruito anche elencando, all interno di una coppia di parentesi graffe e separati tra loro da una virgola, tutti i suoi valori: typedef enum {lun, mar, mer, gio, ven, sab, dom} GiornoDellaSettimana; typedef enum {rosso, verde, giallo, arancio, violetto, marrone, nero, ocra} colore; typedef enum {Giovanni, Claudia, Carla, Simone, Serafino} persone; typedef enum {gen, feb, mar, apr, mag, giu, lug, ago, set, ott, nov, dic} mese; Data la seguente dichiarazione di variabili: persone individuo, individuo1, individuo2; è possibile scrivere istruzioni del tipo individuo = Giovanni; if (individuo1 == individuo2) individuo = Claudia; senza includere i valori Giovanni e Claudia tra virgolette (non sono dei valori di tipo stringa!).

48 Alcune osservazioni Spesso i valori del nuovo tipo sono rappresentati da nomi; però il compilatore associa a tali nomi un progressivo valore intero Per esempio, una variabile x dichiarata di tipo mese che assume durante l esecuzione del programma valore gen assume in realtà valore 0, 3 per apr, ecc. Nuova mancanza di astrazione del C: consente l uso della rappresentazione interna del valore di gen. non abusare di questa possibilità! Operazioni applicabili: le stesse degli interi: operazioni aritmetiche (+,, *, /, %), assegnamento (=), confronto per uguaglianza (==), diversità (!=), precedenza stretta e debole (<, <=, >, >=). In particolare, la relazione di precedenza è definita dall ordine in cui vengono elencati i valori del tipo. apr < giu rosso < arancio producono un risultato un intero diverso da 0 (valore logico true ): dom < lun Simone < Giovanni producono 0 (corrispondente al valore false ): ===> un tipo costruito mediante enumerazione è, analogamente ai tipi integral, un tipo totalmente ordinato, limitato ed enumerabile.

49 Un importante caso particolare In linguaggi come il Pascal il tipo boolean è predefinito e contiene i due soli valori logici false e true. Su essi sono definite le classiche operazioni logiche AND, OR, NOT. In C la definizione di variabili che possano assumere valore false o true richiede la dichiarazione di un tipo tramite il costruttore di tipo enum: typedef enum {false, true} boolean; boolean flag, ok; flag e ok possono così essere definite come variabili in grado di assumere valore vero (true) o falso (false) durante l esecuzione di un programma che le usi. Raccomandiamo di usare il tipo boolean a la Pascal, anche se in C è diverso.

50 I tipi strutturati Anche se in passato abbiamo introdotto le variabili di tipo strutturato array, Ad essere rigorosi, in C -come in molti linguaggi classici-, tipi predefiniti strutturati non esistono. Questa affermazione può sembrare in contrasto con la seguente tipica dichiarazione di array in C: int lista[20]; che dichiara un array di nome lista costituito da 20 interi (quindi il suo indice assume i valori da 0 a 19) Esaminiamo allora dalla radice il concetto di tipo strutturato. In primis, i tipi strutturati sono solo ottenuti mediante costruttori di tipo, ossia sono tutti costruiti dal programmatore attraverso alcuni meccanismi fondamentali. Cominciamo con il costruttore...

51 array Costruzione del tipo: typedef int anarray[20]; dichiazione di variabili di tipo anarray: anarray lista1, lista2; la dichiarazione int lista[20]; va perciò interpretata come un abbreviazione per typedef int arrayanonimo[20]; arrayanonimo lista Alcuni commenti e precisazioni La variabile che verrà usata come indice per indicare l elemento dell array deve essere un tipo integral l array è un costruttore di tipo, non un tipo: typedef int anarray [20]; e typedef double NuovaLista[30]; danno luogo a due tipi diversi

52 Quando esplicitare il nome del tipo e quando no? typedef double VettoreDiReali[20]; VettoreDiReali v1, v2, v3; invece della più semplice e altrettanto chiara: double v1[20], v2[20], v3[20]; Al contrario: typedef double PioggeMensili[12]; typedef double IndiciBorsa[12]; PioggeMensili Piogge01, Piogge02, Piogge03; IndiciBorsa Indici01, Indici02, Indici03; preferibile a: double Piogge01[12], Piogge02[12], Piogge03[12], Indici01[12], Indici02[12], Indici03[12];

53 Gli elementi degli array possono essere di tipo arbitrario (built-in, user-defined, semplice o strutturato). È quindi possibile avere anche array di array : typedef int Vettore[20]; typedef Vettore MatriceIntera20Per20[20]; MatriceIntera20Per20 matrice1; Oppure: typedef int Matrice20Per20[20][20]; int int matrice1[20][20]; matricetrid1[10][20][30]; Per accedere agli elementi di matricetrid1 potremmo poi scrivere: matricetrid1[2][8][15] colore ListaColori[10];

54 Dall array multidimensionale del C All array monodimensionale della macchina di von Neumann: i j Cella Indirizzo *j +i 18.

55 Un brutto inconveniente un array ha dimensioni fisse ===> gli estremi di variabilità degli indici di un array non possono cambiare durante l esecuzione del programma. Ciò certamente riduce la flessibilità del linguaggio: ad esempio, consideriamo le stringhe di caratteri (parole): siamo costretti a meccanismi del tipo: typedef char string[30]; String Nome, Cognome; Parole corte memorizzate in tali variabili lascerebbero una notevole quantità di memoria (fisica) inutilizzata; d altro canto, prima della lettura di un nuovo carattere, dovremmo anche prevedere istruzioni del tipo: if (LunghezzaParola == 30) printf("parola troppo lunga"); Perché? Perché il C e altri linguaggi sono basati sul principio dell allocazione statica della memoria: (per motivi di efficienza) è il compilatore che decide quanta memoria è necessaria e dove va allocata -tranne alcune eccezioni...

56 Un parziale rimedio #include <stdio.h> /* Programma InvertiSequenza */ main() { int Contatore; int Memorizzazione[100]; Contatore = 0; while (Contatore < 100) { /* si ricordi che il valore dell'indice di un array di 100 elementi varia da 0 a 99 */ scanf("%d", &Memorizzazione[Contatore]); Contatore = Contatore + 1; } Contatore = Contatore 1; while (Contatore >= 0) { printf("%d\n", Memorizzazione[Contatore]); Contatore = Contatore 1; } } E se invece di 100 la sequenza fosse lunga 1000?

57 NB: la stessa cosa non si poteva fare con la dichiarazione const La direttiva #define #include <stdio.h> #define LunghezzaSequenza 100 /* Program InvertiSequenza */ main() { int Contatore; int Memorizzazione[LunghezzaSequenza]; Contatore = 0; while (Contatore < LunghezzaSequenza) { scanf("%d", &Memorizzazione[Contatore]); Contatore = Contatore + 1; } Contatore = Contatore 1; while (Contatore >= 0) { printf("%d\n", Memorizzazione[Contatore]); Contatore = Contatore 1; } }

58 Attenzione! Se Array1 e Array2 sono variabili definite nel modo seguente: typedef int anarray[10]; anarray Array1, Array2; è scorretta l istruzione: Array2 = Array1; Sarà necessaria un istruzione ciclica che scorra i singoli elementi dell array Capiremo a fondo il perché in seguito

59 Il seguente programma legge due stringhe composte da esattamente 50 caratteri ciascuna e costruisce una terza stringa che concatena le prime due in ordine alfabetico. Il programma stampa poi la stringa così creata. /* Programma ConcatenazioneStringhe */ #include <stdio.h> #define LunghezzaArray 50 main() { int i, j, k; char TempCar; char Array1[LunghezzaArray], Array2[LunghezzaArray]; /* Nella seguente dichiarazione il valore LunghezzaArray]*2 è un valore costante calcolato a tempo di compilazione */ char ArrayConc[LunghezzaArray*2]; /* Legge la prima stringa assicurandosi che essa non superi la dimensione dell'array, 50 caratteri /* i = 0; while (i < LunghezzaArray) /* Si ricordi che il valore dell'indice di un array di LunghezzaArray elementi è compreso fra 0 e LunghezzaArray 1 */ { scanf( %c", &TempCar); Array1[i] = TempCar; i = i + 1; }

60 /* Legge la seconda stringa assicurandosi che essa non superi la dimensione dell'array, 50 caratteri /* i = 0; while (i < LunghezzaArray) { scanf( %c%, &TempCar); Array2[i] = TempCar; i = i + 1; } /* Confronta le due stringhe per capire quale precede l'altra in ordine alfabetico */ i = 0; while (i < LunghezzaArray && Array1[i] == Array2[i]) i = i+1; if (i == LunghezzaArray Array1[i] < Array2[i]) /* Le due stringhe sono uguali o la prima precede la seconda in ordine alfabetico */ { k = 0; j = 0; while (j < LunghezzaArray) { ArrayConc[k] = Array1[j]; k = k + 1; j = j + 1; } j = 0; while (j < LunghezzaArray) { ArrayConc[k] = Array2[j]; k = k + 1; j = j + 1; } } else

61 /* Se la seconda stringa precede la prima in ordine alfabetico, ossia se (Array2[i] < Array1[i]) */ { k = 0; j = 0; while (j < LunghezzaArray) { ArrayConc[k] = Array2[j]; k = k + 1; j = j + 1; } j = 0; while (j < LunghezzaArray) { ArrayConc[k] = Array1[j]; k = k + 1; j = j + 1; } } /* Stampa la stringa ottenuta dalla concatenazione */ k = 0; while (k < (LunghezzaArray*2)) {printf("%c", ArrayConc[k]); } k = k + 1;} Un po noiosetto? Si potrà far di meglio -in seguito- ma ricorrendo alle funzioni di libreria.

62 Dati strutturati eterogenei typedef int data [3];??? impiegato: il nome, il cognome, il codice fiscale, l indirizzo, il numero di telefono, eventuali stipendio e data di assunzione e via di seguito. famiglia è costituita da un certo insieme di persone, da un patrimonio, costituito a sua volta da un insieme di beni, ognuno con un suo valore, da un reddito annuo, da spese varie, Queste strutture informative sono eterogenee: l array non si presta a questo tipo di aggregazione. Il costruttore record (parola chiave struct in C) è la risposta a questo tipo di esigenze

63 typedef struct { int Giorno; int Mese; int Anno; } Data; typedef struct { String Destinatario; double Importo; Data DataEmissione; } DescrizioneFatture; Ovviamente si assume che i tipi String e Data siano già stati precedentemente definiti. typedef struct { int Canale; AccType Accensione; double CursoreLuminosita, CursoreColore, CursoreVolume; } CanaliTV; dove : typedef enum {On, Off} AccType;

64 Dal punto di vista del compilatore Pinco Pallino 20, Luglio 2008 Cella Indirizzo P 1000 i 1001 n 1002 o , Luglio

65 typedef struct { String Nome; String Cognome; int Stipendio; char CodiceFiscale[16]; Data DataAssunzione; CatType Categoria; } Dipendenti; dove CatType : typedef enum {Dirigente, Impiegato, Operaio} CatType; La dichiarazione di variabili procede poi come al solito: Dipendenti Dip1, Dip2; oppure struct { String Nome; String Cognome; int Stipendio; char CodiceFiscale[16]; Data DataAssunzione; CatType Categoria; } Dip1, Dip2;.

66 L accesso alle singole componenti del record Così come l accesso a un elemento di un array avviene mediante una notazione funzionale L accesso al campo di un record avviene mediante la dot notation. Dip1.Stipendio = Dip1.Stipendio + (Dip1.Stipendio*10) / 100; I meccanismi di accesso a elementi di variabili strutturate si possono combinare tra loro esattamente come si possono combinare i costruttori di tipi: Dip1.DataAssunzione.Giorno = 3; Dip1.DataAssunzione.Mese = 1; Dip1.DataAssunzione.Anno = 1993; Se si vuole sapere se la prima lettera del cognome di Dip1 è A: if (Dip1.Cognome[0] == 'A') DichiarazioneFatture ArchivioFatture[1000]; Si vuole sapere se la fattura numero 500 è stata emessa entro il 1991 o no, e in caso affermativo, qual è il suo importo: if (ArchivioFatture[500].DataEmissione.Anno <= 1991) printf("%d", ArchivioFatture[500].Importo); else printf("la fattura in questione è stata emessa dopo il 1991\n");

67 Una stranezza del C: Mentre non è permesso scrivere un assegnamento globale tra array (a = b) [meglio, non è ciò che ci si aspetterebbe] l istruzione Dip2 = Dip1; è lecita e fa esattamente ciò che ci si aspetta: copia l intera struttura Dip1 in Dip2, comprese le sue componenti che sono costituite da array! Il perché di questa stranezza risiede nel modo in cui in C sono realizzati gli array e potrà essere capito tra breve

68 Il costruttore puntatore Ritorniamo sul problema dell accesso alle variabili Nel linguaggio di von Neumann attraverso il loro indirizzo (numero d ordine di cella di memoria) Nei linguaggi di alto livello attraverso il loro nome: più astratto -e più mnemonico- Però in taluni casi si vuol fare riferimento a celle diverse mediante lo stesso simbolo: a[i] denota una cella diversa a seconda del valore di i Introduciamo ora un nuovo meccanismo di accesso simbolico legato all indirizzo delle variabili (potente e indispensabile in C -non così in altri linguaggi- ma pericoloso e spesso difficile!)

69 typedef TipoDato *TipoPuntatore; P Valore di tipo TipoDato Dereferenziazione: *P indica la cella di memoria il cui indirizzo è contenuto in P. Essa può essere utilizzata esattamente come una qualsiasi altra variabile di tipo TipoDato. typedef TipoDato *TipoPuntatore; TipoPuntatore P; TipoDato x;

70 le seguenti istruzioni sono ammissibili: *P = x; x = *P; P x (a) P x (b) P 14 x 14 (c)

71 Il compito del compilatore è facilissimo: infatti: accedere a una variabile mediante puntatore, altro non è che accedere al contenuto di una cella in modo indiretto attraverso il suo indirizzo: Identificatore indirizzo contenuto P x 2132??? x = *P *P = x LOAD@ 1034; STORE 2132 LOAD 2132; STORE@ 1034

72 L operatore unario & significa indirizzo di ed è il duale dell operatore *. (Coincidenza non casuale con l utilizzo della scanf) Date le seguenti dichiarazioni di tipo e di variabili: typedef TipoDato *TipoPuntatore; TipoPuntatore P, Q; TipoDato y, z; è possibile [NB: non in Pascal, Modula-2, Ada,!] assegnare al puntatore P e al puntatore Q l indirizzo delle variabili y e z, rispettivamente, tramite le seguenti istruzioni: P = &y; Q = &z; (y e z sono di tipo TipoDato mentre P e Q sono puntatori a variabili di tipo TipoDato.) E possibile eseguire anche il seguente assegnamento: P = Q;

73 P y 14 Q P (a) z 23 y 14 Q (b) z 23 (a) Stato della memoria della macchina dopo l esecuzione delle istruzioni P = &y; Q = &z. (b) Effetto dell esecuzione dell istruzione P = Q (iniziando dallo stato di parte (a)) Si noti la differenza tra le istruzioni P = Q e *P = *Q

74 Il costrutto denotato dal simbolo * è a tutti gli effetti un costruttore di tipo: Alcune dichiarazioni lecite: typedef TipoDato *TipoPuntatore; typedef AltroTipoDato *AltroTipoPuntatore; TipoDato *Puntatore; /* forma abbreviata: unifica una dichiarazione di tipo e una dichiarazione di variabile.*/ TipoDato **DoppioPuntatore; TipoPuntatore P, Q; AltroTipoPuntatore P1, Q1; TipoDato x, y; AltroTipoDato z, w; istruzioni corrette: Puntatore = &y; DoppioPuntatore = &P; Q1 = &z; P = &x; P = Q; *P = *Q; *Puntatore = x; P = *DoppioPuntatore; z = *P1; Puntatore = P; istruzioni scorrette: P1 = P; (warning) w = *P; (error) *DoppioPuntatore = y; (warning) Puntatore = DoppioPuntatore; (warning) *P1 = *Q; (error)

75 Una tipica abbreviazione del C... Sia: typedef struct { int PrimoCampo; char SecondoCampo; } TipoDato; Accesso normale alla componente PrimoCampo della variabile cui P punta: (*P).PrimoCampo accesso abbreviato: P >PrimoCampo = 12;

76 Riassumendo e completando Le operazioni applicabili a variabili puntatori sono le seguenti: l assegnamento dell indirizzo di una variabile tramite l operatore unario & seguito dal nome della variabile; l assegnamento del valore di un altro puntatore; l assegnamento del valore speciale NULL. Se una variabile puntatore ha valore NULL, *P è indefinito: P non punta ad alcuna informazione significativa. l operazione di dereferenziazione, indicata dall operatore *; il confronto basato sulle relazioni ==,!=, >, <, <=, >=; operazioni aritmetiche ( da altri linguaggi!) l assegnamento di indirizzi di memoria a seguito di operazioni di allocazione esplicita di memoria (gli ultimi due casi verranno trattati in seguito); E sempre meglio fare esplicitamente l assegnamento per ogni puntatore (possibilmente inizializzandolo con lo speciale valore NULL), benché alcune implementazioni del linguaggio C possano implicitamente assegnare il valore NULL a ciascun nuovo puntatore. Ciò garantisce che il programma venga eseguito correttamente sotto qualsiasi implementazione del linguaggio.

77 Anche se l importanza -e la criticità- dell uso dei puntatori in C si chiarirà strada facendo vediamone una prima applicazione Il programma che segue tratta informazioni riguardanti i lavoratori di una fabbrica usando dati contenuti in due variabili: la prima, denominata DatiLavoratori, contiene informazioni su diversi lavoratori (dirigenti, impiegati, operai); la seconda, chiamata Management, permette di accedere rapidamente ai dati relativi ai dirigenti contenuti nella prima struttura dati. Si supponga di voler stampare i cognomi e gli stipendi di tutti i dirigenti che guadagnano più di 5 milioni: anziché selezionare tutti gli elementi dell intero array DatiLavoratori sulla base della categoria del lavoratore, immagazziniamo nell array Management (verosimilmente molto più corto) i puntatori a tutti gli elementi di DatiLavoratori che sono dirigenti (ciò, naturalmente, renderà l aggiornamento dei due array più complicato, per esempio quando viene assunta una nuova persona). Il frammento di codice di questo esempio presuppone che i dati contenuti nelle variabili DatiLavoratori e Management siano già disponibili, e restituisce il cognome e lo stipendio dei dirigenti che guadagnano più di 5 milioni.