FONDAMENTI di INFORMATICA - Intranet...

Fondamenti di Informatica – Corso di Laurea Prof. L. Mezzalira

FONDAMENTI di INFORMATICA Prof. Lorenzo Mezzalira

Appunti del corso

5 Linguaggio C Costrutti di controllo e strutture dati Indice 1. Istruzioni di selezione 2. I cicli 3. Array 4. Record 5. Puntatori 6. Funzioni di I/O

Linguaggio C – Costrutti di controllo e strutture dati ... 1


COSTRUTTI DI CONTROLLO DELL’ESECUZIONE ISTRUZIONI DEL LINGUAGGIO C

Per tipologia

• istruzioni di assegnamento • istruzioni composte • costrutti di (modifica del flusso di) controllo (istruzioni di

selezione, istruzioni cicliche) • “istruzioni” di ingresso e uscita • chiamate di sottoprogrammi (funzioni) ISTRUZIONI COMPOSTE (BLOCCO DI ISTRUZIONI) Una successione di istruzioni assume l’”identità” di blocco quando è racchiusa tra parentesi graffe.

{ istr1; istr2; istr3; …… }

Blocco di istruzioni

I blocchi di istruzioni possono essere a loro volta annidati, cioè inseriti all’interno di altri blocchi, consentendo così di impostare una struttura che rispecchia i livelli di astrazione.

Nel processo di sviluppo di un programma per raffinamenti successivi si “espandono” man mano i blocchi più interni (annidati) che corrispondono ai dettagli dei livelli di astrazione inferiori. Sintatticamente un blocco può essere collocato dovunque sia lecito scrivere un’istruzione.



ISTRUZIONI CONDIZIONALI DI SELEZIONE Consentono di prescrivere l’esecuzione, o meno, di diverse parti di programma, sulla base del verificarsi delle condizioni indicate da espressioni logiche. SELEZIONE SEMPLICE Sintassi

condizionesi no

blocco

istruzione

if (<condizione>) { <blocco> } <istruzione>

SELEZIONE DOPPIA Sintassi

if (<condizione>) {

condizionesi no

blocco_1 blocco_2

istruzione

<blocco_1> } else { <blocco_2> } <istruzione>



ISTRUZIONI IF ANNIDATE Es.1

if (<condizione1>) if (<condizione2>)

istr1; else

istr2; istr3;

Nota: in Es.1 • istr1 viene eseguita se condizione1 è vera e condizione2 è

vera. • Istr2 viene eseguita se condizione1 è vera e condizione 2 è

falsa • Istr3 viene eseguita sempre else viene automaticamente associato all’ultimo if “aperto” quindi se else va associato ad un altro if occorre indicarlo esplicitamente con parentesi graffe. Es. 2

if (<condizione1>) { if (<condizione2>)

istr1; } else /* condizione1 falsa */ istr2; istr3;

Nota: in Es.2 • istr1 viene eseguita se condizione1 è vera e condizione2 è

vera. • Istr2 viene eseguita se condizione1 è falsa • Istr3 viene eseguita sempre



COSTRUTTI CICLICI Costituiscono un modo per indicare che un blocco di istruzioni va rieseguito ciclicamente. I cicli costituiscono costrutti estremamente potenti generali e compatti. • Possono essere usati per eseguire determinate operazioni

anche su un elevato numero di dati omogenei, aggregati in array (o in liste).

• Possono essere utilizzati per il calcolo di un risultato per approssimazioni successive.

• Possono essere usati per realizzare algoritmi di ricerca di una soluzione ottima nello spazio delle soluzioni di un problema.

Elementi essenziali per un costrutto di iterazione (ciclico): • inizializzazione

le variabili interessate, ed in particolare quelle usate nell’espressione della condizione, devono essere inizializzate prima della valutazione della condizione.

• test deve essere prevista una fase di valutazione della condizione (di permanenza nel ciclo) che determini la ripetizione o la terminazione del ciclo

• modifica almeno una delle variabili della condizione deve essere modificata all’interno del ciclo, in modo che prima o poi la condizione di ripetizione diventi falsa (terminazione).



CICLO A CONDIZIONE INIZIALE

condizione

si

no

blocco

istruzione

Sintassi

while (<condizione>) { <blocco> } <istruzione>

Non viene eseguito neppure una volta se all’inizio la condizione vale FALSE. Le inizializzazioni devono essere effettuate nelle istruzioni precedenti il ciclo. CICLO A CONDIZIONE FINALE

condizionesi

no

blocco

istruzione

Sintassi

do { blocco } while (<condizione>); <istruzione>

Viene sempre eseguito almeno una volta. Le inizializzazioni possono essere eventualmente effettuate all’interno del blocco del ciclo.



ESEMPIO 5 - CALCOLO DELLA MEDIA DI UNA SUCCESSIONE DI VALORI POSITIVI TERMINATI DAL VALORE 0 (“TAPPO”) (con ciclo a condizione finale)

#include <stdio.h> void main () { int num, numel, somma; float media; numel=0; /* inizializzazioni */ somma=0; do { printf("introdurre un numero "); scanf("%d",&num); numel++; /* conto anche il “tappo” */ somma=somma+num; }while(num!=0); numel--; /* avevo contato anche il “tappo” */ if(numel>0) /* verifica importante */ { media=(float)somma/numel; printf("la media di %d elementi vale %f\n", numel, media); } else { printf("la media di 0 elementi non esiste\n"); } }



ESEMPIO6 - CALCOLO DELLA MEDIA DI UNA SUCCESSIONE DI VALORI POSITIVI TERMINATI DAL VALORE 0 (con ciclo a condizione iniziale)

#include <stdio.h> void main () {int num, numel, somma; float media; numel=0; somma=0; printf("introdurre un numero "); scanf("%d",&num); /* completa inizializz. */ while(num!=0) { numel++; /* conto solo elem. Validi */ somma=somma+num; printf("introdurre un numero "); scanf("%d",&num); } if(numel>0) { media=(float)somma/numel; printf("la media di %d elementi vale %f\n", numel,media); } else { printf("la media di 0 elementi non esiste\n"); } }



CICLO A CONTEGGIO: CICLO FOR Se si ha un ciclo come il seguente: var_cont = val_iniz; /* inizializzazione */ while (var_cont <= val_fin) /* test */ { <istruzioni del corpo del ciclo> var_cont = var_cont +1; /* modifica */ } Il linguaggio C prevede anche un costrutto di ciclo che racchiude inizializzazione, test e modifica di una variabile. for (espr1; espr2; espr3)

espr2

si

no

blocco

istruzione

espr1

espr3

{ <istr del ciclo> } <istruzione> espressione1: deve definire il valore iniziale della variabile di

conteggio espressione2: deve definire la condizione sul valore finale della

variabile di conteggio espressione3: deve definire la modifica della variabile di

conteggio for (var_cont=val_iniz; var_cont<=val_fin;var_cont++) { <istruzioni del corpo del ciclo> } <istruzione>



TIPI STRUTTURATI DEL C - COSTRUTTORE ARRAY - 1 Consente di dichiarare variabili che tramite un unico identificatore rappresentano un aggregato ordinato di informazioni omogenee. Costruttore array [ ] • un array è definito come una sequenza di lunghezza fissata di

elementi omogenei (cioè dello stesso tipo) • ogni elemento è individuato tramite un indice che rappresenta

la sua posizione nell’array • un array rappresenta in modo implicito un ordinamento tra gli

elementi, legato alla loro posizione (indice) • se DIM è la dimensione dell’array (DIM costante intera),

l’indice degli elementi assume valori da 0 a DIM -1 Dichiarazione di una variabile array: sintassi C tipo_elem nome_array [DIM] DIM

è un’espressione costante di tipo intero che definisce la dimensione dell’array, cioè quanti elementi può contenere.

tipo_elem è il tipo degli elementi (predefinito o definito dall’utente, semplice o strutturato)

nome_array è l’identificatore (nome) di una variabile “collettiva” (di tipo) array costituita da DIM elementi ognuno di tipo tipo_elem



COSTRUTTORE ARRAY - 2 Accesso ai singoli elementi: tramite indice (operazione legata al costruttore di tipo) nome_array[i]: con questa notazione si individua il valore dell’elemento in posizione i i designa un valore (che rappresenta l’indice, cioè la posizione, dell’elemento nell’array) di tipo integral i cui valori significativi per accedere agli elementi dell’array sono da 0 a DIM –1. L’indice può essere espresso con una variabile o un’espressione Operatori utilizzabili per i singoli elementi di un array:

tutti gli operatori “leciti” per il tipo degli elementi Spazio di memoria allocato per una variabile di tipo array (numero di byte)

DIM * sizeof(tipo_elem) lo spazio di memoria viene allocato ad indirizzi fisici contigui Rappresentazione in memoria di un array: int vett[4] vett[0] valore di vett[0] vett[1] valore di vett[1] vett[2] valore di vett[2] vett[3] valore di vett[3]



COSTRUTTORE ARRAY - 3 La dichiarazione di una variabile di tipo array

• alloca lo spazio di memoria sufficiente a contenere la variabile • associa al nome della variabile (nome_array) l’indirizzo del

primo byte che contiene il primo elemento dell’array (quello di indice pari a 0)

• il valore associato a nome_array è quindi un indirizzo ed è costante

• a nome_array, oltre all’indirizzo è associata anche l’informazione sul tipo degli elementi che lo compongono e, in particolare, sulla quantità di memoria allocata per quel tipo. Questa “associazione” viene fatta dal compilatore in fase di traduzione del programma.

int vett[30]; Aritmetica degli indirizzi per gli array: Le coppie di notazioni seguenti sono equivalenti

vett e &vett[0] vett + 1 e &vett[1] vett + k e &vett[k]

cioè definiscono lo stesso indirizzo di memoria, e

• l’espressione (vett + i) - (vett + j) se i > j fornisce un valore intero pari al numero di elementi tra j (escluso) e i (compreso)



COSTRUTTORE ARRAY USO DEGLI ARRAY Gli array sono usati per contenere elenchi ordinati di informazioni omogenee. La dimensione di un array viene stabilita al momento della compilazione: durante l’esecuzione del programma non può essere modificata. La dimensione va quindi fissata in base al massimo numero di elementi che potranno essere contenuti. E’ molto importante adottare tecniche per indicare quanti elementi significativi sono contenuti nell’array in ogni momento dell’esecuzione del programma. Uso di una variabile di servizio; ad es. int numelem

Si mantiene il valore della variabile in modo che rispecchi sempre il numero di elementi significativi, che dovranno sempre essere i primi nell’ordine.

Uso di valori indicatori di “non significativo” (se possibile)

Se esiste un valore che nel particolare problema non è significativo (ad es. –1 in un elenco di voti) esso può essere assegnato agli elementi “vuoti”, rendendoli così intrinsecamente riconoscibili.



ARRAY DI ARRAY - 1 L’elemento di un array può essere a sua volta un array. La dichiarazione int matrice[Dim2][Dim1]; • definisce la variabile matrice come un array di Dim2

elementi, dove ciascun elemento è un array di Dim1 elementi interi.

• alloca spazio in memoria (in locazioni fisiche contigue) adatto a contenere Dim1 x Dim2 interi.

• il nome dell’array (matrice) equivale a &matrice[0][0] (e a matrice[0]) e rappresenta l’indirizzo del primo byte di un array di Dim1 interi, che è anche l’indirizzo del primo byte allocato per la variabile matrice



ARRAY DI ARRAY - 2 Rappresentazione in memoria di un array a 2 dimensioni: mappa di memorizzazione int matrice [2][3]; matrice[0] valore di matrice[0][0] valore di matrice[0][1] valore di matrice[0][2] matrice[1] valore di matrice[1][0] valore di matrice[1][1] valore di matrice[1][2] Accesso ai singoli elementi matrice[i][j] denota il valore del (j-1)-mo elemento

dell’(i-1)-mo array di interi Simili a righe (i) e colonne (j) e quindi nella mappa di memorizzazione varia più velocemente l’indice più a destra Le notazioni &matrice[i][j] e &matrice[0][0] + Dim1*i + j definiscono entrambe l’indirizzo del primo byte dell’elemento (i,j)



TIPI STRUTTURATI DEL C - COSTRUTTORE STRUCT - 1 Consente di dichiarare variabili che tramite un unico identificatore rappresentano un aggregato di informazioni non omogenee (detto anche record). Costruttore struct {} • una struttura (record) è definita come un insieme prefissato di

campi (elementi) non omogenei • ogni campo è dotato di nome e di tipo Dichiarazione di una variabile di tipo record SINTASSI struct { tipo_campo1 nome_campo1; tipo_campo2 nome_campo2; tipo_campo3 nome_campo3; } nome_var; SEMANTICA • nome_var rappresenta il valore della variabile (valore visto

come aggregato di valori di tutti i suoi campi) • &nome_var rappresenta l’indirizzo del primo byte allocato per

la variabile



COSTRUTTORE STRUCT - 2 Accesso ai campi della struttura: sintassi C (operazione legata al costruttore di tipo): notazione puntata nome_var. nome_campo1 struct { char cognome[30]; char nome[30]; int matricola; int votiesa[29]; } studente; studente.matricola studente.votiesa[3] studente.cognome[0] Operatori utilizzabili per i singoli campi:

tutti gli operatori “leciti” per il tipo del campo Operazioni “globali”: l’assegnamento globale è lecito typedef struct { char cognome[30]; char nome[30]; int matricola; int votiesa[29]; } STUDENTE; STUDENTE studente1,studente2; studente2=studente1; // assegnamento lecito



Spazio di memoria allocato per una variabile di tipo struct

• adeguato a contenere i valori dei suoi campi • lo spazio di memoria viene allocato ad indirizzi fisici non sempre

contigui (dipende dal particolare compilatore)

Rappresentazione in memoria di una struttura studente.cognome Valore di studente.cognome[0] ------------ ------------ Valore di studente.cognome[29] studente.nome Valore di studente.nome[0] ------------ ------------ Valore di studente.nome[29] studente.matricola Valore di studente.matricola studente.votiesa Valore di studente.votiesa[0] ------------ ------------ Valore di studente.votiesa[28]

Uso di variabili aggregate STRUCT Nei problemi applicativi si presenta frequentemente il caso di dover trattare entità corredate da diversi attributi: • Persone dotate di nome, data di nascita, codice fiscale,

residenza …. • Automobili dotate di targa, modello, proprietario, Km

percorsi ….. • Caldaie dotate di temperatura, pressione, portata d’acqua • Ecc., ecc. ….. E’ molto importante che l’appartenenza di informazioni ad una stessa entità sia evidenziata adottando per tale entità una variabile aggregata struct, i cui campi costituiscono gli attributi rilevanti per il problema da trattare.



ARRAY DI STRUTTURE Gli elementi di un array possono essere delle strutture, tipicamente per rappresentare elenchi di informazioni articolate. #define N 1000 typedef struct { char cognome[30]; char nome[30]; int matricola; int votiesa[29]; } STUDENTE; Dichiarazioni di array della struttura STUDENTE: STUDENTE iscrittiinf[N], iscrittieln[N], iscrittimec[N]; Esempi di accesso a singole informazioni iscrittiinf[20].matricola

è la matricola del ventunesimo allievo informatico

iscrittimec[299].votiesa[20] è il voto del ventunesimo esimo esame del trecentesimo allievo meccanico



COSTRUTTORE PUNTATORE - 1 (costruttore * ). Consente di dichiarare delle variabili i cui valori sono gli indirizzi di memoria di variabili di un certo tipo. Dichiarazione di una variabile puntatore: sintassi C

<tipo_dato> *P; Semantica: P è una variabile che può assumere come valori gli indirizzi di un dato (una variabile) di tipo tipo_dato. Si dice che P punta ad una variabile di tipo tipo_dato.

La dichiarazione di una variabile puntatore: • alloca lo spazio di memoria necessario a contenere i valori di P

(spazio necessario a contenere l’indirizzo di una variabile di tipo tipo_dato)

• a P è associata l’informazione su tipo_dato. Questa associazione (così come negli array) viene fatta dal compilatore in fase di traduzione del programma.

Rappresentazione in memoria P &P valore di P = indirizzo area di

memoria adatta a contenere un valore di tipo tipo_dato



COSTRUTTORE PUNTATORE - 2 typedef int *Punt; Punt P; /* puntatore a intero */ int x; ASSEGNAMENTO (e inizializzazione) P=&x; /* adesso p punta alla variabile x */

Significato: il valore di P è l’indirizzo di memoria associato alla variabile x (P punta a x)

Attenzione: un puntatore, anche prima dell’inizializzazione, ha un valore e cioè punta (in modo non significativo) ad una qualche parola di memoria. ASSEGNAMENTO DEL VALORE SPECIALE NULL (NULL è un identificatore riservato del C)

P=NULL;

Significato: il valore di P è un particolare indirizzo che corrisponde ad una parola di memoria “riservata”. Si intende che P non punta ad alcuna informazione significativa: si dice che “P non punta ad alcunchè”. Rappresentazione tipica delle variabili puntatore P

Indirizzo valori di tipo <tipo_dato>

P

P=NULL; NULL



COSTRUTTORE PUNTATORE - 3 ACCESSO ALLA VARIABILE PUNTATA (operazione di dereferenziazione) typedef int *Punt; Punt P; /* puntatore a intero */ int x, y;

P=&y; x=3; *P=x; /* qui y vale 3 */

P=&y; y=5; x=*P; /* qui x vale 5 */

PUNTATORI E TIPI PUNTATI (COMPATIBILITÀ TRA TIPI) Ad ogni puntatore è associata l’informazione del tipo puntato. int *P; /*puntatore a intero*/ float *Q; /*puntatore a float*/ int x; float v; P=&x; Q=P; WARNING Q=&v; v=13.5; *P=*Q; WARNING



COSTRUTTORE PUNTATORE - 4 Operatore -> Dereferenziazione per accesso a elementi di strutture typedef struct { char cognome[30]; char nome[30]; data data_di_nascita; char codice_fiscale; } dati_anagrafici; dati_anagrafici *P; dichiara il puntatore dati_anagrafici persona; dichiara una variabile P = &persona

Accesso ai campi della struttura (*P).data_di_nascita.giorno (*P).cognome[0]

le notazioni seguenti (con l’operatore -> ) sono equivalenti, e più eleganti ed usate: P->data_di_nascita.giorno P->cognome[0]



COSTRUTTORE PUNTATORE - 5 OPERAZIONI LECITE per le variabili puntatore • assegnamento (operatore &, tra puntatori, NULL) • dereferenziazione: contenuto della parola di memoria puntata • confronto tra puntatori • operazioni aritmetiche (aritmetica dei puntatori) USO DELLE VARIABILI PUNTATORE • nelle funzioni • per creare strutture dati dinamiche EFFETTI COLLATERALI CON L’USO DI VARIABILI PUNTATORE: modifica non voluta di valori di variabili puntate

int *P; int x, y; P=&y; x=3; *P=x; /* y vale 3*/

int *P, *Q; int x, y; P=&x; Q=&y; *P=3; /*x vale 3*/ *Q=5; /*y vale 5 */ P=Q; /*P punta a y*/ *Q =7; /* adesso anche *P

vale 7 */



DOPPIO PUNTATORE float **DPunt; float *Punt; float v; Significato: DPunt è una variabile puntatore che contiene l’indirizzo di un’area di memoria che, a sua volta, contiene l’indirizzo di un tipo float. (DPunt punta a un puntatore a float) Rappresentazione DPunt Punt valore di

tipo float Dopo la dichiarazione: (ma con variabili non ancora inizializzate) DPunt Punt v &DPunt valore ? &Punt valore ? &v valore?

DPunt = &Punt; /* adesso DPunt punta a Punt */ Punt=&v; /* adesso Punt punta a v */ **DPunt = 13.5; /* adesso v vale 13.5 */ Dopo gli assegnamenti precedenti DPunt Punt v &DPunt &Punt &v 13.5



VARIABILI PUNTATORE E ARRAY: ARITMETICA DEGLI INDIRIZZI int i; int vett[10]; int *P; vett: • è l’indirizzo del primo byte dell’array di interi (indirizzo primo

byte di un intero) • ha associato il tipo degli elementi (cioè interi) • ha un valore costante (cioè non modificabile) vett si comporta come un puntatore “fisso”, cioè costante vett[i] equivale a *(vett+i) *(P+i) equivale a P[i] P=vett equivale a P=&vett[0] P=vett+i equivale a P=&vett[i] (P+i) - (P+j) valore intero pari al numero di elementi (interi) tra i e j



UTILITA’ DEI PUNTATORI Accesso ad indirizzi di memoria prefissati

Assegnando ad un puntatore un valore costante (spesso hex) si può accedere proprio a quell’indirizzo. Ad es. EPROM.

Accesso tramite lo stesso puntatore a diverse variabili Utile quando un pezzo di programma deve usare di volta in volta diverse variabili, ovviamente dello stesso tipo, che non sia opportuno inserire in un array.

Accesso a variabili fuori dal campo di visibilità Tramite puntatori un pezzo di programma (in genere un sottoprogramma) può accedere in lettura e in scrittura anche a variabili cui non potrebbe accedere direttamente (fuori scope). Naturalmente occorre far attenzione ad evitare accessi scorretti.

Accesso ad aree di memoria allocate dinamicamente Questo punto verrà discusso più avanti.

ATTENZIONE! – Rischi nell’uso dei puntatori In generale l’uso dei puntatori consente anche accessi (run-time) non controllabili dal compilatore (compile-time). Si tratta quindi di uno strumento potente ma potenzialmente pericoloso, il cui uso corretto è responsabilità del programmatore, che deve assicurarsi di usare solo puntatori cui ha assegnato indirizzi corretti di aree di memoria lecitamente accessibili. Nei sistemi più evoluti esistono meccanismi che impediscono l’accesso, sia pure con puntatori, a determinate aree di memoria, come ad esempio quelle allocate al sistema operativo.



STRUTTURA DATI DI UN PROGRAMMA Si dice struttura dati di un programma l’insieme delle variabili semplici ed aggregate su cui operano gli algoritmi del programma. E’ importante notare che una struttura dati ben progettata deve rispecchiare in modo chiaro le relazioni esistenti tra i dati dell’applicazione Poiché le modalità di accesso agli elementi di variabili aggregate dipendono dai costruttori usati, è importante che le strutture dati vengano progettate accuratamente prima di scrivere la forma definitiva dei programmi.



ESEMPIO1 - CALCOLO DEL FATTORIALE #include <stdio.h> main () { int n,i,fattoriale; fattoriale=1; printf("Inserisci il numero \n"); scanf("%d",&n); if(n!=0) { for(i=1;i<=n;i=i+1) fattoriale=fattoriale*i; } printf("il fattoriale di %d e' %d\n", n, fattoriale); }



ESEMPIO2 - CALCOLO DEI DIVISORI DI UN INTERO #include <stdio.h> main () { int k,j; printf("Inserisci il numero \n"); scanf("%d",&k); if(k!=0) { for(j=1;j<=k;j=j+1) if (k%j==0) printf("%d e' divisore di %d \n", j,k); } else printf("Non c'e' alcun divisore di %d\n",k); }



ESEMPIO3 - CALCOLO PRODOTTO MATRICE PER VETTORE (vris = mat*vett) ................... int vett[M], mat[N][M], vris[N]; int i,j; .......................... for(i=0;i<=N-1;i++) { vris[i]=0; for (j=0; j<=M-1;j++) vris[i]=vris[i]+mat[i][j]*vet[j]; } ESEMPIO4 - CALCOLO PRODOTTO MATRICE PER MATRICE (ris = mat1*mat2) ................... int mat1[N][M], mat2[M][K], ris[N][K]; int i,j,k; .......................... for(i=0;i<=N-1;i++) { for (k=0;k<=K,k++) { ris[i][k]=0; for (j=0; j<=M-1;j++) ris[i][k]=ris[i][k]+mat1[i][j]*mat2[j][k]; } }



FUNZIONI DI INGRESSO E USCITA In C non esistono istruzioni proprie del linguaggio per l’ingresso e uscita di dati.

L’ingresso e uscita avvengono tramite chiamate (attivazioni) di funzioni (sottoprogrammi) disponibili nella Standard Library del C.

STANDARD LIBRARY: è una collezione di funzioni (organizzate per tipologia) disponibili nell’ambiente C e utilizzabili dai programmi applicativi.

Funzioni: • di ingresso e uscita da terminale e da file • gestione di stringhe • funzioni matematiche • funzioni grafiche ....

Le due componenti della STANDARD LIBRARY:

1. collezione di header file (stdio.h, string.h, math.h) ⇒ un header file contiene le dichiarazioni di tipi, costanti

simboliche predefinite, e prototipi di funzione (nomi) esportati dalla libreria.

⇒ la direttiva di inclusione (# include) consente ad un programma qualsiasi di importare, cioè utilizzare questi identificatori, che non sono stati dichiarati all’interno del programma stesso.

2. insieme di file in codice oggetto, dove ciascun file è costituito dal codice oggetto delle funzioni (nomefile.lib)

Compiti del pre-processore C: includere nel programma sorgente applicativo i file header per risolvere, a livello di sorgente, i riferimenti esterni Compiti del linker: includere nel programma oggetto il codice oggetto delle funzioni di libreria per risolvere, a livello di eseguibile, i riferimenti esterni



AMBIENTE C Ambiente di programmazione C Programma applicativo

pre-processoreC

compilatore

linker

compilatore codice oggetto delle funzioni definite nella Standard Library

stdio.h

math.h

file1.h

file1.c

file1.obj

programma.c

programma.obj

programma.exe

f1.lib

f2.lib

f3.lib

header file Standard Library: in linguaggio C: dichiarazione di tipi, funzioni…… esportate

header file definiti dall’utente in linguaggio C: dichiarazione di tipi, funzioni……esportate

codice oggetto delle funzioni esportate dalla libreria definita dall’utente

codice sorgente C delle funzioni esportate dalla libreria definita dall’utente

Librerie (moduli) definiti dall’utente



FUNZIONI DI I/O PER VIDEO E TASTIERA Stampa su video printf(stringa di controllo, elementi da stampare) dove: • printf ( ) è l’identificatore riservato della funzione • stringa di controllo è racchiusa tra “ e “ e contiene

⇒caratteri alfanumerici da stampare direttamente su video ⇒caratteri di conversione e/o di formato preceduti dal

simbolo % che vengono utilizzati al momento di interpretare per la stampa i valori degli elementi da stampare. Esempi di caratteri di conversione d, f, c ....

⇒caratteri di controllo della stampa (che sono caratteri ASCII cui non corrisponde alcun simbolo stampabile e che hanno come effetto quello di linea nuova (\n), tabulazione, salto pagina…

• elementi da stampare è una lista di identificatori di variabili, identificatori di costanti, espressioni, il cui valore deve essere stampato. La lista è ordinata rispetto ai caratteri di conversione.

Significato e funzionamento: • l’istruzione printf (stringa dicontrollo, elementi da stampare);

è la chiamata alla funzione e quindi attiva l’esecuzione del sottoprogramma associato.

• vengono stampati gli eventuali caratteri alfanumerici tra doppi apici e nella posizione del carattere di conversione viene stampato il valore dell’identificatore corrispondente nella lista di elementi da stampare. I caratteri di controllo stampa spostano il cursore (posizione di stampa) in posizione opportuna.



Ingresso da tastiera

scanf(stringa di controllo, variabili cui associare il valore letto)

dove: • scanf( ) è l’identificatore riservato della funzione • stringa di controllo è racchiusa tra “ e “ e contiene

⇒caratteri di conversione e/o di formato preceduti dal simbolo % che vengono utilizzati al momento di interpretare il codice associato alla pressione dei tasti della tastiera per la memorizzazione dei valori nelle variabili (con la codifica adeguata). Esempi di caratteri di conversione d, f, c ....

• variabili cui associare il valore letto è una lista di identificatori di variabili. Le variabili devono essere indicate tramite il loro indirizzo: &nome_var. La lista è ordinata con corrispondenza uno a uno rispetto ai caratteri di conversione.

Significato e funzionamento: • l’istruzione scanf (stringa dicontrollo, lista di variabili);

è la chiamata alla funzione e quindi si attiva l’esecuzione del sottoprogramma associato.

• ad ogni pressione di tasto la funzione fa eco su video, visualizzando il carattere alfanumerico premuto

• la sequenza di tasti premuti deve terminare con la pressione del tasto ENTER.

• la funzione assegna, con l’opportuna codifica binaria, il valore alle variabili, fin quando possibile.

E’ da usare con attenzione. • Carattere di conversione %d: la sequenza di cifre è interpretata

come un valore intero da assegnare. • Carattere di conversione %f: la sequenza di cifre con il punto è

interpretata come un valore float da assegnare. • Carattere di conversione %c: il singolo carattere alfanumerico

è interpretato come un carattere ASCII da assegnare.



ESEMPIO Programma che riceve in ingressso nome e cognome separati da uno spazio e visualizza cognome e nome separati da uno spazio #include <stdio.h> #define N 30 main () { char Cognome[N], Nome[N]; int indiceC, indiceN,i; char carattere, proseguire,tappo; do { printf("\nInserire Nome e Cognome separati da uno spazio\n"); indiceN=0; /*legge un carattere del nome fa eco e lo inserisce in Nome */ scanf("%c", &carattere); while (carattere != ' ') { Nome[indiceN]=carattere; indiceN=indiceN+1; scanf("%c", &carattere); }



indiceC=0; /*legge un carattere del cognome fa eco e lo inserisce in Cognome */ scanf("%c", &carattere); while (carattere != '\n') { Cognome[indiceC]=carattere; indiceC=indiceC+1; scanf("%c", &carattere); } /*ciclo per la scrittura del Cognome*/ for (i=0; i<indiceC; i++) /*scrive un carattere del Cognome*/ printf("%c", Cognome[i]); printf(" "); /* scrive uno spazio */ /*ciclo per la scrittura del Nome*/ for (i=0; i<indiceN; i++) /*scrive un carattere del Nome*/ printf("%c", Nome[i]); printf("\nVuoi inserire un altro nome (S\N)? "); scanf("%c", &proseguire); scanf("%c", &tappo); } while(proseguire == 'S'); } /* fine main */


FONDAMENTI di INFORMATICA - Intranet...

Documents

Transcript of FONDAMENTI di INFORMATICA - Intranet...