Prefissi (modificatori). signed, unsigned, short, long. Dichiarazione delle variabili. <tipo> <nome>; Es:

Transcript

1 LINGUAGGIO C 1 Creato nel 1972 da Dennis Ritchie (Kernighan & Ritchie, Linguaggio C, 2nd ed.) Caratteristiche: Potenza Flessibilità Successo Portabilità Modularità Da C bisogna partire per imparare C++ e Java Il C è standard (ANSI) Caratteristiche di un programma. INTEGRITÀ: il programma deve fare quello che ci si aspetta che faccia CHIAREZZA: il programma deve essere leggibile e adeguatamente commentato SEMPLICITÀ: nei limiti del possibile, il programma deve essere semplice EFFICIENZA: il programma deve essere veloce ed utilizzare nel modo migliore le risorse MODULARITÀ: il programma deve essere "decomposto" in moduli di programma distinti. Così si agevola anche la manutenzione e l aggiornamento GENERALITÀ: il programma deve essere il più generale possibile (nei limiti della ragionevolezza) Ciclo di produzione del software. Determinare PRIMA obiettivi e metodi Creazione del codice: editor ASCII generici o dedicati Compilazione: dal codice al file.obj controllo sintattico controllo lessicale controllo semantico ottimizzazione (dipendente o indip. dalla macchina) Link: collegamento con le funzioni di libreria generazione del file eseguibile Ambienti IDE (Integrated Development Environment) Nome delle variabili. Può contenere lettere, cifre e _ (underscore) il 1 carattere deve essere una lettera (può essere _ ma è fortemente sconsigliato) il C è case sensistive, cioè distingue maiuscole e minuscole. Di norma le variabili si scrivono in lettere minuscole non si possono usare alcune parole (reserved keywords) eventualmente, seguire una convenzione sui nomi int numerostudenti, punteggio; int intnumstudenti, intpunteggio; int numero_studenti, voto_esame; Tipi fondamentali. char (1 byte) (da -128 a 127) int (2 byte) (da a 32767) float (4 byte) (da 1.2E-38 a 3.4E38) double (8 byte) (da 2.2E-308 a 1.8E308) Prefissi (modificatori). signed, unsigned, short, long Dichiarazione delle variabili. <tipo> <nome>; Es: int prodotto; int persone, paiadiguanti; La posizione della dichiarazione conta. Si può anche fare un inizializzazione nella dichiarazione. Es: int prodotto = 0; float costanteg = 6.67e-11; char testo = B ;

2 2 È sempre consigliabile inizializzare le variabili Costanti. si mette il prefisso const, ad es.: const float pigreco = le costanti non possono essere modificate durante il programma. Si tratta, in sostanza, di variabili read-only il debugger vede le variabili e le costanti Costanti simboliche. Specificate attraverso la direttiva #define #define PI sostituzioni letterali (come in un word processor) - di solito indicate con lettere maiuscole non sostituisce all interno delle virgolette printf("il val. di PI è: %f",pi); la sostituzione avviene al momento della compilazione. Nel file.obj non rimane alcuna traccia del nome della costante. preprocessore Istruzioni. Un istruzione è un comando. Le istruzioni terminano con un ";". x = 2+3; printf("\nfond. di\ninform. A"); Più istruzioni sono racchiuse tra graffe: x = 2+3; printf("ciao!"); Operatore di assegnazione. L operatore di assegnazione è =. x = 2+3; x = x + 3; Attenzione: l operatore = non è un operatore di confronto! (:= in Pascal). Non è come l uguale in matematica Operatori matematici e -- (incremento e decremento) x = 2; /* x vale 2 */ x++; /* x vale 3 */ x--; /* x vale 2 */ corrispondono a x=x+1; e x=x-1; Attenzione: preporre o posporre l operatore produce effetti diversi. Infatti: ++x; incrementa x e poi lo valuta, mentre x++; valuta x e poi lo incrementa int a=5,b=5; printf("\na:%d,b:%d", a--, --b); printf("\na:%d,b:%d", a--, --b); printf("\na:%d,b:%d", a--, --b); printf("\na:%d,b:%d", a--, --b); printf("\na:%d,b:%d", a--, --b); A:5,B:4 A:4,B:3 A:3,B:2 A:2,B:1 A:1,B:0

3 #include <stdio.h> #include <math.h> main() double a,b,c,x1,x2; printf("\ninserire il coeff. a: "); scanf(" %lf", &a); printf("\ninserire il coeff. b: "); scanf(" %lf", &b); printf("\ninserire il coeff. c: "); scanf(" %lf", &c); x1 = (- b + sqrt(b*b-4*a*c) )/(2*a); x2 = (- b - sqrt(b*b-4*a*c) )/(2*a); printf("soluzioni: %lf, %lf", x1, x2); return 0; 3 Operatori matematici 2. +, -, *, /, % 32%5 = 2 100%2 = 0 Osservazione 1: il tipo del risultato può variare al variare del tipo degli operandi: prima di svolgere l operazione l operando con la precisione più bassa viene convertito alla precisione dell altro Osservazione 2: alcune operazioni possono risultare prive di significato int i=7; float f=5.5; i+f vale 12.5 (è di tipo float) (i+f) % 4 non è valida (e viene segnalato errore) ( (int) (i+f) ) % 4 è valida (perché (i+f) è convertito al tipo intero (cast)) Operatori matematici 3. la scrittura x = x+a ha una forma abbreviata: x += a in generale: exp1 op= exp2 significa exp1 = exp1 op exp2 y -= z+1 vuol dire y = y-(z+1) Funzioni matematiche. int abs(x) double ceil(x) double exp(x) double floor(x) double fabs(x) double sin(x)... int abs(x) double ceil(x) double exp(x) double floor(x) double fabs(x) double sin(x)... Strutture. La struttura è una collezione di variabili (non necessariamente dello stesso tipo) raggruppate sotto lo stesso nome. struct tempo int ore; int minuti; int secondi; orologio1, orologio2;

4 4 oppure: struct tempo int ore; int minuti; int secondi; ; struct tempo orologio1, orologio2; orologio1.ore = 18; orologio1.minuti = 21; orologio1.secondi = 22; Le strutture si possono nidificare (cioè si può inserire una struttura dentro un altra struttura). struct nascita struct tempo ora; struct data data; ; L istruzione typedef. L istruzione typedef definisce un sinonimo per un tipo di variabile. Ad es.: tipedef int intero; intero x = 3; Con le strutture typedef definire un breve sinonimo per strutture complesse tipedef struct tempo... orologio; orologio swatch, sector; typedef è un sinonimo per la dichiarazione di istanze di strutture /*dichiarazione*/ typedef struct int x; int y; coord;... /*istanza*/ coord punto1, punto2; /*dichiarazione*/struct coord int x; int y;;... /*istanza*/ struct coord punto1, punto2; Controllo di flusso. Alcuni comandi permettono di controllare l esecuzione del programma, nel senso che, in dipendenza da certi valori, il programma può eseguire certe operazioni piuttosto che altre. il comando if.. else #include <stdio.h> #include <math.h> main() double a,b,c,x1,x2,r; printf("\ninserire il coefficiente a: "); scanf(" %lf", &a); printf("\ninserire il coefficiente b: "); scanf(" %lf", &b); printf("\ninserire il coefficiente c: "); scanf(" %lf", &c); r = b*b-4*a*c; if ( r >= 0 ) x1 = (- b + sqrt(r) )/(2*a); x2 = (- b - sqrt(r) )/(2*a);

5 printf("soluzioni: %lf e %lf", x1, x2); else printf("nessuna soluzione reale."); return 0; 5 if... else. if ( espressione ) istruzione1; istruzionesuccessiva; if ( espressione ) istruzione1; else istruzione2; istruzionesuccessiva; if ( espressione1 ) istruzione1; else if ( espressione2 ) istruzione2; else istruzione3; istruzionesuccessiva; if ( eta < 18 ) printf("minore"); else if ( eta < 65 ) printf("adulto"); else printf("pensionato"); /* prosegue */ istruzionesuccessiva; Operatori di confronto. >, >=, <, <=,!=, == i valori che possono assumere sono: VERO ( = uno ) FALSO ( = zero ) Attenzione: l operatore == non va confuso con l operatore = (assegnazione) usare sempre uno stile semplice da leggere, invece di scrivere if(x!= 5) A; else B; scrivere if(x == 5) B; else A; Operatori logici. AND && (vero solo se entrambi veri) OR (vero se almeno uno è vero) NOT! Attenzione alle precedenze (in caso di dubbio usare le parentesi) Controllo di flusso (2): l istruzione for. for(inizio;condizione;incremento) istruzione; seguito;

6 6 1. L espressione inizio viene valutata(di solito è un assegnazione di valore ad una variabile) 2. L espressione condizione viene valutata. 3. Se essa è falsa il controllo del programma passa all istruzione seguito 4. Se condizione è vera viene eseguita istruzione 5. Viene valutata incremento e si ritorna al passo 2 int i; for(i=1; i<11; i++) printf("\nil quadrato di %d è %d",i,i*i); int i; for(i=1; i<11; i++) printf("\nil quadrato di %d è %d",i,i*i); printf("\nil cubo di %d è %d",i,i*i*i); Controllo di flusso (2): l istruzione for. int i,k,pot; for(k=1; k<=10; k++) pot = 1; for(i=1; i<=3; i++) pot *= k; printf("\n%d elev. alla %d è %d",k,i,pot); 1 elev. alla 4 è 1 2 elev. alla 4 è 8 3 elev. alla 4 è 27 4 elev. alla 4 è int i,k,pot; for(k=1; k<=10; k++) pot = 1; for(i=1; i<=3; i++) pot *= k; printf("\n%d elev. alla %d è %d",k,i-1,pot); Controllo di flusso (3): l istruzione while. while(condizione) istruzione; seguito; 1. L espressione condizione viene valutata. 2. Se essa è falsa il controllo del programma passa all istruzione seguito 3. Se condizione è vera viene eseguita istruzione 4. Viene valutata incremento e si ritorna al passo 1 int i=1; while(i<=10) printf("\nil quadr. di %d è %d",i,i*i); i++; int i=1;

7 while(i<=10) printf("\nil quadrato di %d è %d",i,i*i); printf("\nil cubo di %d è %d",i,i*i*i); i++; 7 Confronto tra while e for. while(condizione) e for( ; condizione ;) sono la stessa cosa. Quindi, ogni cosa che si può fare con for si può fare con while. Con il for, inizializzazione, incremento e controllo di uscita vengono scritti nello stesso posto. Con il while in posti diversi. Istruzione do... while. do istruzione; while(condizione); La differenza con il while è che in questo caso la valutazione della condizione viene fatta alla fine. istruzione, quindi, viene eseguita almeno una volta. Si usa do... while, quando il ciclo viene eseguito sicuramente la prima volta (ad es. nei menu). Array. un array è un insieme di locazioni di memoria con lo stesso nome e distinte da un numero detto indice (posizione, posto, in inglese subscript). Gli array si indicano come le variabili ma sono seguiti da [n], dove n è la dimensione dell array int x[10]; char testo[20]; Corrispondono ai vettori matematici o alle matrici n X 1. Le singole locazioni di memoria si indicano con i simboli x[0],x[1],x[2],..., x[9] Attenzione: gli indici cominciano da ZERO #include <stdio.h> main() int lista[5]; int ctr = 0, nbr = 0; printf("inserire 5 numeri tra 1 e 10\n"); while ( ctr < 5 ) nbr = 0; while (nbr < 1 nbr > 10) printf("\nins. il num. %d: ", ctr + 1 ); scanf("%d", &nbr ); lista[ctr] = nbr; ctr++; for (ctr = 0; ctr < 5; ctr++) printf("\nval. %d=%d", ctr + 1, lista[ctr] ); return 0; Trova l errore! int num = 0; while ( num < 100 ) printf("\nnum. %d:", num );

8 8 printf("\ninserire il seguente..."); Trova l errore 2! for( num = 1; num < MASSIMO; num++) printf("\nnum. = %d:", num ); Funzioni in C. double area_triangolo(int b, int h); main() int base = 4; int alt = 6; double area; area = area_triangolo(base, alt); double area_triangolo(int b, int h) double a = (b * h) / 2; return a; base = 4 alt = 6 b h 5 6 a = (b * h) / 2 12 a area base 4 alt 6 area b h a 12 void swap(int &a, int &b); main() int n1 = 3; int n2 = 5; swap(n1, n2);

9 void swap(int &a, int &b) int temp; 9 temp = a; a = b; b = temp; n1 = 3 n2 = 5 a &n1 b &n2 temp = a a = b b = temp n1 3 n1 5 a b temp 3 Puntatori. un puntatore è una variabile numerica che contiene un indirizzo di memoria Per dichiarare un puntatore, così come per le altre variabili, bisogna indicare un nome univoco e far precedere il nome da un * int *p_x; char *testo; La prima dichiarazione assegna ad una certa cella di memoria il nome p_x e dice che il contenuto di quella cella sarà un intero. La seconda assegna ad un altra cella di memoria il nome testo e dice che il contenuto di quella cella sarà un carattere. Come si inizializza un puntatore? Assegnandogli l indirizzo di memoria di una variabile esistente int pippo; p_x = &pippo; L operatore & restituisce l indirizzo di memoria della variabile (pippo) indirizzi contenuto La variabile a vale 31 ed è nella cella 3. Allora: int a = 31; printf( %d,a); /* scrive 31 */ printf( %d,&a); /* scrive 3 */ Se usiamo un puntatore si ha: int a = 31; int *punt_a; punt_a = &a; a

10 10 printf( %d,a); /* scrive 3 */ printf( %d,*punt_a); /* scrive 31 */ Gli operatori * e & agiscono rispettivamente su puntatori e su variabili ordinarie (in realtà, però, anche i puntatori sono tipi di variabili)il C sa che differenti tipi di variabile occupano un numero diverso di byte. Diversi puntatori possono riferirsi alla stessa variabile: int a = 31; int *punt_b, *punt_c; punt_b = &a; punt_c = &a; printf( %d,a); /* scrive 31 */ printf( %d,*punt_b); /* scrive 31 */ printf( %d,*punt_c); /* scrive 31 */ Ma si può anche assegnare ad un puntatore il valore di un altro puntatore int a = 31; int *punt_b, *punt_c; punt_b = &a; punt_c = punt_b; printf( %d,a); /* scrive 31 */ printf( %d,*punt_b); /* scrive 31 */ printf( %d,*punt_c); /* scrive 31 */ Attenzione: int a; int *punt_b; *a /* illegale */ &punt_b /* corretto ma molto anomalo */ Puntatori e array indirizzi contenuto Il nome di un array senza le parentesi è il puntatore al suo primo elemento: int a[4]; printf( %d,a[0]); /* scrive 31 */ printf( %d,a); /* scrive 3 */ printf( %d,&a[0]); /* scrive 3 */ Incrementando il puntatore, quindi, si incrementa un indirizzo di memoria: int a[4]; printf( %d,*(a + 2)); /* scrive 55 */ printf( %d,a[2]); /* scrive 55 */ Quando un array è un parametro di una funzione, si sta in realtà passando un puntatore (e quindi la chiamata è per indirizzo) La seguente funzione copia una stringa da una variabile ad un altra. main() #include <stdio.h> void copias( char *x, char *y ); int main() char *testo1 = "W Milan!"; char *testo2 = "W Inter!"; printf("\n\n1: %s", testo1 ); printf("\n2: %s", testo2 ); copias( testo1, testo2 ); printf("\n\n1: %s", testo1 ); printf("\n2: %s", testo2 ); a[0] a[1] a[2] a[3]

11 return 0; 11 void copias( char *x, char *y ) while (1) *x = *y; if ( *x == \0 ) return; x++; y++; Puntatori 1. main() char lettera = c ; int anno = 1998; float radice = 2.563; printf( %c %d %f, lettera, anno, radice); lettera anno c FF FF FF73 radice Puntatori 2. main() char lettera = c ; int anno = 1998; float radice = 2.563; printf( %p %p %p, &lettera, &anno, &radice); lettera anno c 1998 & lettera & anno & radice radice Puntatori 3. main() int anno = 1998;

12 12 int* p_anno; p_anno = &anno; c anno 1998 & anno 0012FF74 p anno Puntatori 4. main() int anno = 1998; int* p1_anno = &anno; int* p2_anno = &anno; c anno 1998 & anno 0012FF FF74 p1 anno p2 anno Puntatori 5. main() int n1 = 3; int n2 = 5; swap(&n1, &n2); void swap(int* a, int* b) int temp = *a; *a = *b; *b = temp; n1 3 n2 5 temp FF FF76 a = &n1 b = &n2

13 Gestione dei file. La gestione dei file avviene mediante l inizializzazione di una variabile con una particolare struttura, FILE. La prima operazione è l apertura del file che si esegue con la funzione fopen(). Il suo prototipo è: FILE *fopen(const char *nomefile, const char *modo); nomefile è il nome del file che si vuole aprire (eventualmente l intero percorso); modo è un parametro che indica quali operazioni si vogliono eseguire con il file. (r=lettura, w=scrittura, a=append, r+=lettura e scrittura, ecc.) La funzione fopen, quindi, restituisce un puntatore ad una variabile di tipo FILE. Con questo puntatore si può poi operare con diverse funzioni. FILE *fp; fp = fopen( ricette.txt, r+ ); La funzione fopen() FILE *fopen(const char *nomefile, const char *modo); fopen NON restituisce un puntatore quando c è un errore: restituisce NULL. Pertanto è necessario controllare che il puntatore restituito non sia NULL per evitare disastri! FILE *fp; fp = fopen( ricette.txt, r+ ); if ( fp == NULL ) printf( \nerrore! ); fprintf() e fscanf() Sono le funzioni che corrispondono a printf() e scanf(). Operano con i file in modo analogo. fclose() Questa funzione chiude il file aperto con fopen (chiude, cioè, il canale di comunicazione con il file). Quando la chiusura avviene senza problemi la funzione restituisce 0. Esempio: #include <stdlib.h> #include <stdio.h> 13 main() float f1, f2, f3, f4, f5; FILE *fp; if ((fp=fopen("input.txt","r"))==null) fprintf(stderr,"errore di apertura."); fscanf(fp,"%f %f %f %f %f", &f1, &f2, &f3, &f4, &f5); printf("valori:%f,%f,%f,%f, e %f.", f1, f2, f3, f4, f5); fclose(fp); return(0); exit(1); INPUT.TXT getc() e fgetc() int getc(file *fp); getc legge un carattere (un intero) dal FILE; può funzionare anche se FILE non è specificato: allora legge da tastiera (il file stdin). Il C definisce tre file sempre aperti: stdin, stdout e stderr. fgetc e getc sono identiche! Corrispondente in output: putc int putc(int ch, FILE *fp);

14 14 fgets() char *fgets(char *str, int n, FILE *fp); fgets legge una linea o al massimo n-1 caratteri e li mette in *str. Corrispondente in output: fputs char *fputs(char *str, FILE *fp); fwrite() int fwrite(void *buf, int size, int count, FILE *fp); *buf è il puntatore in memoria ai dati da scrivere; size è la lunghezza del singolo dato; count è il numero dei dati e *fp è il file su cui scrivere. Di solito, size viene calcolato con l operatore sizeof(). La funzione restituisce il numero di dati effettivamente scritti. fread() int fread(void *buf, int size, int count, FILE *fp); *buf è il puntatore in memoria ai dati da leggere; size è la lunghezza del singolo dato; count è il numero dei dati e *fp è il file su cui scrivere.di solito, size viene calcolato con l operatore sizeof().la funzione restituisce il numero di dati effettivamente letti. #include <stdlib.h> #include <stdio.h> #define SIZE 20 main() int c, array1[size], array2[size]; FILE *fp; for (c = 0; c < SIZE; c++) array1[c] = 2 * c; if ( (fp = fopen("direct.txt", "wb")) == NULL) fprintf(stderr, "Error opening file."); exit(1); if (fwrite(array1, sizeof(int), SIZE, fp)!= SIZE) fprintf(stderr, "Error writing to file."); exit(1); fclose(fp); if ( (fp = fopen("direct.txt", "rb")) == NULL) fprintf(stderr, "Error opening file."); exit(1); if (fread(array2, sizeof(int), SIZE, fp)!= SIZE) fprintf(stderr, "Error reading file."); exit(1); fclose(fp); for (c = 0; c < SIZE; c++) printf("%d\t%d\n", array1[c], array2[c]); return(0); ftell() long ftell(file *fp); la funzione restituisce la posizione corrente del cursore sul file (0=all inizio; -1=errore) fseek() int fseek(file *fp, long offset, int origine); la funzione sposta il cursore sul file di offset a partire da origine. Il valore di origine può essere SEEK_SET, SEEK_CUR, SEEK_END; le tre costanti sono definite in <io.h>.

15 15 ATTENZIONE: le funzioni di scrittura e lettura non spostano necessariamente il cursore (il motivo è il buffering della scrittura su file); per sapere dove si trova il cursore occorre sempre chiamare la ftell(). feof() int feof(file *fp); La funzione restituisce ZERO (falso) quando non si è alla fine del file, non ZERO altrimenti.