Laboratorio di Calcolo

1. Laboratorio di Calcolo AA 2006/2007Canale A Prof. G.Ciapetti Struttura del corso: ~ 20 h lezioni ~ 28 h esercitazioni in laboratorio ( 8 esercitazioni x 3.5 h – 14:15 18:00 - Classe Win e classe Linux). Valutazione alla fine dell’esercitazione. Max assenze 2. Ultime 2 (realizzazione programma) valutate anche come prove in itinere. Prova finale (se prove in itinere non OK) con realizzazione di un programma. Sito: www.roma1.infn.it/people/ciapetti/labcalc/index.htm • Testi consigliati: • Programmazione scientifica – Barone, Marinari, Organtini, Ricci-Tersenghi – Pearson education • C-Didattica e programmazione. – Kelley & Pohl - Addison e Wesley • Programmare in C. – M.Liverani – Progetto Leonardo Laboratorio di Calcolo

2. Sistemi Informatici • Hardware: • CPU • Memoria centrale • Periferiche (tastiera, mouse, video, dischi, stamp….) • Struttura generale (dai PC ai grandi Mainframes): • Hardware (componenti fisici del sistema) • Firmware ( microprogrammi permanenti ) • Software ( programmi eseguiti dal sistema) • Software: • Sistemi operativi • Software di comunicazione • Programmi applicativi Laboratorio di Calcolo

3. Architettura hardware: • Basata sul modello della macchina di Von Neumann (Priceton, 1946). • “IAS machine” a valvole. Programma in memoria. Bus di sistema CPU Memoria centrale Interfaccia periferiche Memorie di massa Terminali Stampanti Reti di connessione Central Processing Unit: svolge operazioni logiche e aritmetiche, gestisce il trasferimento dei dati fra memoria centrale, registri di calcolo e memorie periferiche Memoria Centrale: contiene (parte) delle istruzioni che i processori della CPU devono eseguire e i dati locali Intrefaccia periferiche: gestisce tutto il traffico di informazioni in ingresso/uscita ( I/O ) Unita’ logico-aritmetica Laboratorio di Calcolo

4. Home computer 2004 da rivista 1954 Laboratorio di Calcolo

5. Portatile –The next generation Laboratorio di Calcolo

6. CPU Memoria Centrale Funzionamento Memoria Laboratorio di Calcolo

7. CODIFICA DELL’INFORMAZIONE • CODIFICA DEI NUMERI • Sistema “posizionale”: • Numero  sequenza di simboli il cui valore dipende dalla posizione • Noi utilizziamo un sistema di numerazione posizionale “arabico” (10 simboli: 0,1,………9) • Alternativa; Sistema additivo: • Numero  sequenza di simboli il cui valore dipende dalla somma dei simboli • Numeri romani: I, V, X, L, C, D, M 3000  MMM • Sistemi posizionali:caratterizzati dalla base p ( “p” simboli diversi) • Alfabeto: a,b,c,d,e,f........ (p simboli) • Nbase p anan-1….a1a0 ai = generico simbolo (a,b,c,d,e,f........) • m = n+1: numero delle cifre • Np = an pn + an-1 pn-1 +.......+ a1 p1 + a0 p0 = n0 i ai pi • Con m cifre pm numeri diversi da: 0  pm-1 • SISTEMA ARABICO  10 simboli p=10 Laboratorio di Calcolo

8. p=10 (decimale) (0,…….9) 33110 = (3*102 + 3*101 + 1*100) p=2 (binario) (0,1) 1010010112 = (1*28 + 0*27 + 1*26 + 0*25 + 0*24 + 1*23 + 0*22 + 1*21 + 1*20) = 33110 p=8 (ottale) (0,1,………..7) 5138 = (5*82 + 1*81 + 3*80) = 320 + 8 + 3 = 33110 p=16 (esadecimale) (0,1,………..9,A,B,C,D,E,F,) 14B16 = (1*162 + 4*161 + 1*160) = 33110 In un calcolatore la codifica è binaria Facile utilizzare (in elettronica) fenomeno fisico in due stati diversi: Tensione (alta/bassa) Magnetizzazione (n/s) Luce-buio Unità di informazione in codifica binaria: bit (0/1) Byte (8 bit) Max n decimale rappresentabile con n bit (Con n cifre pm numeri diversi da: 0  pm-1 ): 8 bits -> 256-1 16 -> 65532-1 32 -> ~ 4.29 109 64 -> ~ 1.84 1019 Laboratorio di Calcolo

9. DECIMALE 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 .. 32 .. 64 .. 128 BINARIO 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111 10000 .. 100000 .. 1000000 .. 10000000 OTTALE 0 1 2 3 4 5 6 7 10 11 12 13 14 15 16 17 20 .. 40 .. 100 .. 200 ESADECIMALE 0 1 2 3 4 5 6 7 8 9 A B C D E F 10 .. 20 .. 40 .. 80 Laboratorio di Calcolo

10. Codifica caratteri Codice ASCII (American Standard Code for Information Interchange). 7 bit  128 caratteri : caratteri di comando, alfanumerici, segni. Ogni carattere 1 byte Ottavo bit : bit di parita’ 0 o 1 in modo che il n di 1 nel byte sia pari (individuare errori di trasferimento). Laboratorio di Calcolo

11. Codifica immagini Immagine suddivisa in punti (pixel). Per ogni punto n bit che definiscono il colore (o il tono di grigio). Risoluzione misurata in dpi (dot per inch). Standard di codifica che possono permettere di ridurre le dimensioni dell’ immagine in memoria ( 1152*864 ~ 3 Mb usando 3 bytes per def. colore) BMP TIFF JPEG …… Laboratorio di Calcolo

12. Programmazione. Risolvere un problema in modo automatico. Trovare un “ algoritmo” che, dato un certo set di informazioni in input fornisca la soluzione del problema (output). Algoritmo: insieme di istruzioni (basate su un “Linguaggio di programmazione”) che, esguite in un certo ordine, trasformano i dati di input nella soluzione. Linguaggio di programmazione: istruzioni (“statements”) interpretabili dalla CPU della macchina per effettuare operazioni aritmetiche o logiche sui dati. Necessaria traduzione in “linguaggio macchina”. Programma: insieme di algoritmi per risolvere problemi complessi. Esiste una moltitudine di linguaggi con set di istruzioni differenti e con differenti “ livelli” basso livello : vicino all’ hardware alto livello : vicino al linguaggio naturale Linguaggio macchina : istruzioni (sequenze di bit) che possono essere eseguite direttamente dai circuiti ( CPU ) del calcolatore. Tre fasi : fetch (caricamento), interpretazione, esecuzione. Codice operativo: operazione da fare Istruzione Operando/i : locazione/i di memoria contenente i dati su cui operare Assembly : Codici operativi (istruzioni) sono rappresentati tramite stringhe alfanumeriche (LOAD, STOR, ADD, DIFF, MUL, DIV, JUMP,HALT …….). Necessita traduzione (triviale) in linguaggio macchina. Laboratorio di Calcolo

13. Linguaggi di alto livello: Algoritmo e’ realizzato utilizzando 5 tipi base di istruzioni: • dichiarazioni di variabili e costanti e del loro tipo (non in tutti i linguaggi) Es. : int a , float b; • istruzioni di assegnazione (mettere in una locazione di memoria risultato di una espressione aritmetica /logica). Es: c=a+b; • istruzioni di input/output (ingresso/uscita dati) Es. printf (“ risultato = %d \n”, c); • istruzioni condizionali (ramificare il flusso delle istruzioni a seconda del valore di una variabile logica) Es. if (a > b) {istruzioni} • istruzioni di ciclo condizionale (ripetizione un certo gruppo di istruzioni condizionata da variabile) Es. for(i=0; i<100; i++) {istruzioni} • nei linguaggi OO (C++,Java) anche altre istruzioni base • Per eseguire un programma: • preprocessore : esegue istruzioni per preparare la compilazione del programma • compiler : traduzione istruzioni in linguaggio macchina (controllo sintassi e logica istruzioni errori di compilazione) • linker : collegamento con altri programmi di utilita’ gia’ compilati contenuti in “librerie” • debugger : eliminazione di errori al livello di esecuzione Laboratorio di Calcolo

14. Linguaggi • Tanti linguaggi a seconda della funzione: • Basic(Beginner All-purpose Instruction Code) : applicazioni didattico/scientifiche. • Cobol : applicazioni gestionali • Fortran, Pascal: applicazioni scientifiche (numeriche) • C : progetto di sistemi operativi e basi dati • C++, Java : applicazioni orientate ad oggetti • Lisp, Prolog: applicazioni di AI • ............................. • ............................. Laboratorio di Calcolo

15. Istruzione di input/output Istruzione di assegnazione Istruzione condizionale Grafi di flusso. Progettazione simbolica degli algoritmi per via grafica. I simboli rappresentano i 5 tipi base di istruzioni. Istruzione ciclo Laboratorio di Calcolo

16. Somma di 100 numeri Prodotto di 2 numeri interi X x Y = sommare X volte Y Z = Y+Y+Y+Y........ X volte Laboratorio di Calcolo

17. Programmare in C • Programma in C : insieme di funzioni (funzione speciale : main) • Funzione : insieme di istruzioni.Puo’ ricevere o no dati dalla funzione chiamante. Alla fine dell’ esecuzione puo’ ritornare un solo dato. Il main viene chiamato dal sistema operativo. Le istruzioni operano su un inseme di variabili o costanti. • Istruzioni: • -dichiarazioni: variabili usate devono essere definite , incluso il loro tipo. • tipo:int (interi), float/double (numeri razionali, detti anche in virgola mobile) , char (carattere) • qualificatori di tipo: signed, unsigned, short, long, const • -istruzioni di assegnazione, condizionali, di ciclo. • -assegnazione: operano su variabili o su costanti e assegnano risultato a nuova variabile. • nome_variabile = numero ; • nome_variabile = espressione ; • -condizionale: se una certa condizione e’ vera o falsa eseguire differenti istruz. • -ciclo: ripetere blocco di istruzioni fino a che una certa condizione e’ vera/falsa Laboratorio di Calcolo

18. Numeri Floating Interi short int long float double Long double float a ; double b;...... short i; int j; Costanti e variabili. Il programma attribuisce un nome e un valore ad ogni costante o variabile che appare nelle dichiarazioni (attribuisce un indirizzo in memoria e alloca un certo numero di bit a seconda del tipo definito nella dichiarazione). Nome: deve iniziare con carattere alfabetico. Lunghezza arbitraria ma definito dai primi 31 caratteri. Caratteri possono essere maiusc/minusc., numerici, simboli (non usare: -, /, $, %, &. Att. alle parole risevate (vedi libro). Tipo: Laboratorio di Calcolo Nota : il prefisso const indica valore che non puo’ essere modificato

19. Struttura funzione: tipo (di ritorno) nome-funzione (argomenti in ingresso) /* se non ritorna nulla tipo = void. Argomenti forniti dal chiamante; se non ci sono : ( ) */ // commenti contenuti in una sola linea { dichiarazioni(terminano SEMPRE con ; ) istruzioni(terminano SEMPREcon ; ) return (valore) ; (valore puo’ mancare) } /* Programma Base */ #include <stdio.h> #include <math.h> #define PIGRECO 3.14159 /* -------------------------------------------------*/ int main( ) { /* dichiarazione e assegnazione variabili*/ int a, b , c=180 , d; /* ingresso dati */ ……………; /* istruzioni per effettuare l’ algoritmo */ d=(a+b)/c; /* stampa risultato algoritmo */ ……………; return 0; } • Direttive al preprocessore Laboratorio di Calcolo

20. Direttive al preprocessore:iniziano con#; in genere poste all’ inizio del programma. • #define nome valore tutte le volte che nel codice appare nome viene sostituito con valore • #define SUMQ(a,b) ((a*a)+(b*b))tutte le volte che appare nel codice SUMQ(...) viene sostituito • con ((a*a)+(b*b))Macro • es. c = SUMQ(7,4)  c = 49 + 16 • #include<nome.h> • #include“miofile.h”(il file deve essere contenuto nella stessa directory dove risiede il codice) • nome.h : header file. Contiene lista (i prototipi) di funzioni delle librerie del C ed eventuali macro. • stdio.h : funzioni I/O • math.h : funzioni e macro matematiche • string.h : funzioni per manipolare stringe di caratteri • stdlib.h : funzioni di utilita’ • time.h : manipolazione ora/data • #if , #ifdef , #ifndef , #endif , #undef servono ad inserire o meno parti di codice nel programma (vedi dopo) Laboratorio di Calcolo

21. Istruzioni di dichiarazione. int nome1, nome2 ; float nome3 = 12.314 ; int x = y = z = 0 ; Istruzionidiassegnazione. nome_variabile = espressione ; espressione : costante num., altra variabile, risultato operazione fra variabili (con operatori aritmetici) a = pigreco ; a = 1.234 ; a = b + c/d*e ; k = k+1; Nota : se tipo variabile a destra diverso da sinistra viene effettuata conversione Operatori aritmetici (binari). + , - , * , / , % Note : % solo ad interi (resto divisione). Operatori * , / , %precedenza su +, - Se operandi tipo diverso si converte a precisione superiore. Laboratorio di Calcolo

22. Operatori aritmetici (unari). • - , & , * • & : restituisce indirizzo operando ( &a : indirizzo in memoria di a) • * : valore contenuto nell’ indirizzo ( *p : valore contenuto in indirizzo p) • - : cambiamento di segno • Operatori incremento e decremento: ++ , -- Possono essere prefissi o suffissi w = x++ - yw = ++x – y w = x – y x = x + 1 x = x + 1 w = x - y • Operatori di assegnazione abbreviata : += , -= , *= , /= Quando operando e’ anche la variabile risultato: x += 3 y /= 3 x = x + 3 y = y / 3 Operatore aritmetico (ternario) ? ( a > b ) ? ( max = a ) : ( max = b ) max = ( a > b ) ? a : b Laboratorio di Calcolo

23. Altri operatori Operatore di cast (o conversione). Serve a modificare temporaneamente il tipo di una variabile. Istruzione: (new type) nome-variabile int i=3; double a; a = (double) i / 2; Operatore di sizeof(dimensione di ). Serve a sapere le dimensioni (in n di bytes) di una espressione o di un generico oggetto : n = sizeof(…….); n = sizeof(int); n = sizeof(a); int x[99]; n = sizeof(x); (n sara’ uguale a 99 x 4 = 396 bytes) Laboratorio di Calcolo

24. VARIABILI E OPERATORI LOGICI (Algebra di Boole) Variabile logica : verofalso (1) (0) Operazioni logiche: aAND b (2 operandi) = vero se ambedue operandi veri aORb (2 operandi) = vero se almeno 1 operando vero NOT a (1 operando) = cambia valore operando ANDORNOT (b) 0 1 (a) 0 1 0 0 0 0 0 1 0 1 1 0 1 1 1 1 1 0 && AND || OR !NOT Laboratorio di Calcolo

25. Operatori di relazione a < b : se vera ritorna valore 1 (vero) altrimenti 0 (falso) a <= b : se vera ritorna valore 1 (vero) altrimenti 0 (falso) > maggiore >= maggiore o uguale = = uguale != diverso Confronto di due espressioni; ritorna valore 1 se vera altrimenti 0. Creano delle condizioni logiche. Operatori di relazione hanno precedenza su operatori logici . Laboratorio di Calcolo

26. Istruzionidi ciclo Servono a far ripetere un gruppo di istruzioni fino a quando non si verificano certe condizioni. while while (condizione) { istruzioni ; } Fino a che condizione e’ vera il blocco di istruzioni fra graffe viene ripetuto. for Analogo al while ma usato per cicli basati su una variabile che aumenta/diminuisce ad agni iterazione. Stop quando raggiunge un certo valore. for ( espress1; espress2; espress3) { istruzioni ; } espress1 : variabile di ciclo espress2 : se vera continua ciclo espress3 : modo di modifica della variabile di ciclo Es. : for( k=0; k<=10; k++ ) { istruzioni; } Laboratorio di Calcolo

27. do/while Analogo al while solo che il controllo viene effettuato alla fine del ciclo. do { istruzioni; } while (condizione) break Per uscire da un ciclo continue Per saltare la corrente iterazione del ciclo Laboratorio di Calcolo

28. #include <stdio.h> #include <math.h> #include <stdlib.h> float gauss(float,float); //---------------------------------------------------------------------- int main() { int i,j,nevent=20; float x,mu,sigma; /* Inserimento parametri da parte dell'utente */ printf ("mu sigma= "); scanf ("%f %f", &mu, &sigma); for(i=0;i<=nevent;i++){ x=gauss(mu,sigma); printf("mu = %f, sigma = %f x = %f \n",mu,sigma,x); } return (0); } //------------------------------------------------------ float gauss(float mu, float sigma){ int i; float sum; sum=0.; for (i=1;i<=12;i++) sum+=rand()/(RAND_MAX+1.); sum=(sum-6.)*sigma+mu; return(sum); } //------------------------------------------------------ Esempio : GaussGen.c Generare un numero con funzione di distribuzione gaussiana (m , s). Algoritmo: sommare 12 numeri casuali con f(x) uniforme fra 0 e 1, sottrarre 6,moltiplicare pers e aggiungere m. Laboratorio di Calcolo

29. /* while */ float radiant; int degree = 0; while (degree <= 360) { radiant = degree*PIG/180; printf(" %6d %9.6f \n" , degree,radiant) ; degree += 10 ; } /* for */ for (degree = 0 ; degree <= 360 ; degree += 10 ) { radiant = degree*PIG/180; printf(" %6d %9.6f \n" , degree,radiant) ; } /* do/while */ int degree = 0 do { radiant = degree*PIG/180; printf(" %6i %9.6f \n" , degree,radiant) ; degree += 10 ; } while (degree < 370 ) Laboratorio di Calcolo

30. Algoritmo di Erone per calcolo radice quadrata Supponiamo che a0 sia una approssimazione per eccesso di SQRT(x); Laboratorio di Calcolo

31. Array e puntatori Int s[10], double x[100] ; Definiscono in memoria vettori (array). Vanno utilizzati come: x[ i ] ; ATT: il primo elemento del vettore sara’: x[0]. Inizzializzazione: double x[100] = {1.,2.,3.,4.,……} ; int s[10] = {0} ; int s[ ] = {1,0,3,42}; ( dimensioni di s = 4) for(k=0;k<=9;k++) s[k] = 99; E’ possibile dichiarare la lunghezza del vettore: #define LEN 10 int n = 3; float x[LEN * 2]; float x[n]; NON e’ possibile leggere il valore di n a run time (ATT. non da errore di compilazione). ATT. nessun controllo se indice eccede valore max delle dimensioni, risultato non prevedibile. Array bidimensionali: float a [ 2 ] [10] ; sinistra indice riga; destra indice di colonna. In memoria come vettore unidimensionale memorizzato per righe. a(1,1) a(1,2) ……a(1,10) a(2,1)………a(2,10) Laboratorio di Calcolo

32. Per gestire array molto usati (in particolare per passare vettori a funzioni) i puntatori . inta[10]; int*pa; (pa e’ un intero usato come puntatore) pa = &a[ 0] ; (indirizzo in memoria di a [0] ) pa = a ; equivalente alla precedente. Il nome di variabile tipo vettore e’ interpretato come l’indirizzo del suo primo elemento. Quindi &a[ i ] e (a+i) sono equivalenti. x = *pa; (mette in x il valore di a [0] ) x = *(pa+3); (mette in x il valore di a [3] ) x = *(a+3); (equivalente alla precedente) ATT. pa e’ una variabile a non lo e’; quindi pa = a pa++ corretto a = pa a++ non corretto Laboratorio di Calcolo

33. Le funzioni Algoritmo complesso puo’ essere suddiviso in sottoalgoritmi (funzioni) che vengono chiamati in una certa sequenza logica da uno “ steering”, cioe’ da una funzione principale (“ main”). Le funzioni possono a loro volta chiamare altre funzioni. Una funzione ritornera’ un valore al programma chiamante e avra’ in ingresso uno o piu’ valori forniti dal chiamante. Una funzione deve essere dichiarataprima del main (prototipo della funzione) e successivamente deve essere definita. Dichiarazione: tipo_ritorno nome_funz ( tipo_par1, tipo_par2,………) es. float funz (int, double,double, ….); NB. #include <aaaaa.h> inserisce una lista di prototipi delle funz. di libreria (anche macro e costanti) Definizione: tipo_ritorno nome_funz ( tipo_par1 par1, tipo_par2 par2,………) { definizioni; istruzioni; return (valore); } Utilizzo (chiamata della funzione): a = nome_funz( par1, par2, .......); se tipo ritorno e’ voidnome_funz( par1, par2, .......); Laboratorio di Calcolo

34. Es. double area (float, float); int main(){ float aa,h,b,s; s = 2 * (b+h); aa = area (b, h); printf(“ perimetro = %f area = %f\n”, s,aa); return (0); } double area ( float base, float altezza){ double s; s = 0.5*(base*altezza); return ( s ) ; } Le variabili di una funzione hanno visibilita’ “locale”. Si possono (!! ma e’ pericoloso!!) definire variabili “globali”, cioe’ visibili da tutte le funzioni del programma. Vanno dichiarate prima del main. Il passaggio dei parametri avviene per “valore” . Se si vuole che la eventuale modifica degli argomenti sia “visibile” anche dalla funzione chiamante passare gli “indirizzi” delle variabili. Se si vuole passare alla funzione un vettore in genere si trasmette l’ indirizzo dell’ elemento 0 del vettore. Laboratorio di Calcolo

35. Es. Funzione scambia (NO) void scambia (float,float); int main(){ float x,y; x=16.; y=8.; scambia(x,y); return (0); } void scambia(float a, float b){ float temp; temp = a; a = b; b = temp; return; } Es. Funzione scambia (OK) void scambia ( float *, float *) int main(){ float x,y; x=16.; y=8.; scambia(&x,&y); return (0); } void scambia(float *pa,float *pb){ float temp; temp = *pa; *pa = *pb; *pb = temp; return; } Laboratorio di Calcolo

36. Passaggio vettori a funzione /* Vector handling I */ #include <stdio.h> #include <stdlib.h> #include <math.h> #define NMAX 100 int leggiv(float *); void stampav(float *,int); //-------------------------------------------------------------- int main(){ int n,i; float v[NMAX]; n=leggiv(v); printf(" Il vettore di N= %d elementi:\n",n); stampav(v,n); return( 0); } //-------------------------------------------------------------- int leggiv(float x[]){ int i,nn; printf("Inserire il n di componenti del vett:"); scanf("%d",&nn); printf("Inserire le %d componenti del vett:\n",nn); for (i=0;i<nn;i++) scanf("%f",&x[i]); return (nn); } //------------------------------------------------------------------------------ void stampav(float x[],int n){ int i; for (i=0;i<n;i++) printf("%f ",x[i]); printf("\n"); return; } //------------------------------------------------------------------------------ Laboratorio di Calcolo

37. /* Vector handling II*/ #include <stdio.h> #include <stdlib.h> #include <math.h> #define NMAX 100 int leggiv(float *); void stampav(float *,int); //------------------------------------------------------------- int main(){ int n,i; float v[NMAX]; n=leggiv(&v[0]); printf(" Il vettore di N= %d elementi:\n",n); stampav(&v[0],n); return (0); } int leggiv(float *px){ int i,nn; printf("Inserire il n di componenti del vett:"); scanf("%d",&nn); printf("Inserire le %d componenti del vett:\n",nn); for (i=0;i<nn;i++) scanf("%f",px+i); return (nn); //---------------------------------------------------------------------- } void stampav(float *px,int n){ int i; for (i=0;i<n;i++) printf("%f ",*(px+i)); printf("\n"); return; } Laboratorio di Calcolo

38. Funzioni matematiche di libreria ( x tipo float); abs(x) se x int Laboratorio di Calcolo

39. Input/Output dei dati printf Visualizza su schermo valori numerici di variabili e stringhe. printf (“ strnga di controllo”,valore1,valore2,…..); Stringa di controllo contiene testo e marcatori di controllo che definiscono il formato di uscita delle variabili. printf(“var1= %f , var2=%i ,…” , var1, var2, ….); I marcatori di conversione possono essere preceduti da specifiche di formato: %5i %7.4f %.3e La stringa di controllo termina con \ seguito da carattere (sequenza di escape) che controlla il comportamento della stampante ( \n : a capo). Laboratorio di Calcolo Il La stringa di controllo termina sempre con \ seguito da carattere (sequenza di escape) che controlla il comportamento della stampante.

40. scanf Serve per l’ immissione dei dati tramite la tastiera. scanf (“%f %lf %i..”, &a, &b , &n , …….); I valori letti ritornano alla funzione chiamante “ per indirizzo “. La stringa di controllo contiene le specifiche di formato per la variabili da immettere. La scanf termina quando ha esaurito le specifiche di formato della stringa di controllo o quando c’ e’ inconsistenza fra specifica e valore digitato. Laboratorio di Calcolo

41. Stringhe Un array di tipo char permette di gestire un insieme di caratteri (stringa): char stringa[80]; printf(“Inserisci una frase”); scanf(“%s”,stringa); printf(“La frase inserita e’: %s \n”,stringa); La stringa viene memorizzata come sequenza di caratteri terminata dal carattere nul ( \0 ); se si vogliono contare i caratteri contenuti nella stringa: int i = 0; while (stringa[i] != ‘\0’) i++ ; printf( “Lunghezza frase %d caratteri \n”, i); Se voglio aggiungere una seconda frase dentro stringa scanf( “%s”,stringa2 ); for( i=0 ; stringa[i] != ‘\0’; i++) ; for( j=0 ; stringa2[j] != ‘\0’ ; j++) stringa[i] = stringa2[j]; i++ ; stringa[i] = ‘\0’ ; Un altro modo per leggere/scrivere una stringa e’ uso di getchar()/putchar() : for ( i=0 ; (stringa[i]=getchar() ) != ‘\n’; i++); stringa[i] = ‘\0’ ; for ( i=0 ; stringa[i]!= ‘\0’; i++) n = putchar(stringa[i]) ; Laboratorio di Calcolo

42. Per assegnare un valore a variabile di tipo char: caracter = ‘a’ ; Per assegnare il contenuto ad una stringa: char line[] = “Nel mezzo del cammin di nostra vita”; Non e’ possibile invece una assegnazione del tipo: char line[100]; ERRATOline = “Nel mezzo del cammin di nostra vita”; (line e’ un puntatore!!!) ------------------------------------------------------------------------------------------------------------------- Specificatori di formato per scanf e printf : %c (carattere) %s (stringa) RICORDARE:scanf(“%s”,line); (line e’ un puntatore!!) Per scrivere su una stringa : sprintf( line, “scrivereintero %d sustringa”,nn); Per leggere da una stringa : sscanf(line,”%s %d %s”, str1,ii,str2); Per convertire da stringa a numero: nn = atoi(stringa);aa = atof(stringa); intero double Laboratorio di Calcolo

43. Funzioni di libreria( string.h ) per manipolazione stringhe : strcpy ( stringa1 , stringa2) ; strncpy (stringa1, stringa2, n); copia n caratteri di stringa2 su stringa1 strcat (stringa1 , stringa2) ; concatena stringa2 a stringa1 n = strcmp (stringa1 , stringa2) ;n=0 se uguali, +-1 se stringa1 >< stringa2 n = strlen (stringa); lunghezza della stringa (senza \0 ) Es. int strlen (char s[] ) { int i=0 ; while ( i < MAX && s[i] != ‘\0’ ) i++ ; return i ; } void converti (char s[] ){ int i = 0 ; while ( i < MAX && s[i] != ‘\0’ ){ if ( s[i] >= 97 && s[i] <= 122) s[i] = s[i] - 32 ; i++ ; } return; } Laboratorio di Calcolo

44. I / O da file • Per scrivere/leggere dati da file (non da standard input/ output): • definire un puntatore speciale di tipo FILE (che punta ad una “struttura” contenente • informazioni sul file). • associare al puntatore uno specifico file e definirne le modalita’ di apertura. • chiudere il file alla fine del suo utilizzo. • FILE *fp1 ; • FILE *fp2 ; • fp1 = fopen( “file1.dat”, “mode”) ; • fp2 = fopen( “file2.dat”, “mode”) ; • ……………….. • fclose (fp1); • fclose (fp2); • Se ci sono problemi nell’ apertura del file fopen ritorna : NULL • mode: • “r” solo lettura; • “w” solo scrittura; se non esiste viene creato; il contenuto precedente viene perso • “r+” lettura/scrittura; • “w+” lettura/scrittura; se non esiste viene creato • “a” solo scrittura; in append mode; se non esiste viene creato • “a+” lettura/append; se non esiste viene creato Laboratorio di Calcolo

45. I / O formattato da file Leggere/scrivere su file con formato definito da utente: n = fprintf (fp, “specifica formato”,val1, val2, ……); m = fscanf (fp, “specifica formato”, &val1, &val2, …..); n : rappresenta il n di caratteri scritti o n negativo in caso di errore m : numero di elementi letti o EOF in caso di fine del file di input Es. int main() { FILE *fin; FILE * fout; float x1, y1 ; int n; fin = fopen( “filein.dat”, ”r” ); if(fin == NULL){ printf(" error in input file\n"); return (0); } fout = fopen( “/data/fileout.dat”, “w”); while ( ( fscanf(fin, “ %f %f ”,&x1, &y1 ) != EOF) { n = fprintf (fout, “%f, %f \n”, x1, y1) ; } fclose(fin); fclose(fout); return( 0); } Laboratorio di Calcolo

46. hh[nh*lmaxh] 0 100 200 300 400 ................................................................ np nin nunder nover Histog.h np Laboratorio di Calcolo

47. Laboratorio di Calcolo

48. La ricorsione Una funzione e’ ricorsiva se e’ in grado di richiamre se stessa. Non tutti i linguaggi permettono la ricorsione. Puo’ essere usata con formule ricorsive (es. fattoriale …..). Laboratorio di Calcolo

49. inserire il n di elementi della serie; <0 stop)20 i 0 fibonacci 0 i 1 fibonacci 1 i 2 fibonacci 1 i 3 fibonacci 2 i 4 fibonacci 3 i 5 fibonacci 5 i 6 fibonacci 8 i 7 fibonacci 13 i 8 fibonacci 21 i 9 fibonacci 34 i 10 fibonacci 55 i 11 fibonacci 89 i 12 fibonacci 144 i 13 fibonacci 233 i 14 fibonacci 377 i 15 fibonacci 610 i 16 fibonacci 987 i 17 fibonacci 1597 i 18 fibonacci 2584 i 19 fibonacci 4181 i 20 fibonacci 6765 Laboratorio di Calcolo

50. Puntatori a funzioni Se funzione deve poter operare su un’altra funzione (es. df(x)/dx ) e’ necessario poter indirzzare la generica funzione su cui operare puntatore a funzione = variabile di tipo puntatore che contiene l’indirizzo in memoria in cui iniziano le istruzioni della funzione stessa. void funfun(float (*)(int),double); float funz (int); float (*pfun)( ); pfun = funz; (non serve & ; analogo ai vettori) la coppia di parentesi ( ) caretterizza il puntatore come puntante ad una funzione ATT : int *pfun ( ); e’ il prototipo di una funzione pfun che ritorna un puntatore Laboratorio di Calcolo