Il linguaggio C Un primo programma

C : un primo programma (2) /* Programma che calcola il massimo fra tre numeri inseriti da tastiera */ #include #define N 4 int main (void){ int i, tmp, max=0; printf(“Inserisci %d interi positivi\n”,N); for (i = 0; i < N; i++) { scanf(“ %d”, &tmp); max = (max < tmp)? max : tmp ; } printf(“Il massimo è %d \n”,max); return 0; }

C : un primo programma (4) #include #define N 3 int main (void){ int i, tmp, max=0; printf(“Inserisci %d interi positivi\n”,N); for (i = 0; i < N; i++) { scanf(“ %d”, &tmp); max = (max > tmp)? max : tmp ; } printf(“Il massimo è %d \n”,max); return 0; } Inclusione delle informazioni necessarie per utilizzare le funzioni nelle librerie standard di I/O del C

C : un primo programma (5) #include #define N 3 int main (void){ int i, tmp, max=0; printf(“Inserisci %d interi positivi\n”,N); for (i = 0; i < N; i++) { scanf(“ %d”, &tmp); max = (max > tmp)? max : tmp ; } printf(“Il massimo è %d \n”,max); return 0; } Inclusione delle informazioni necessarie per utilizzare le funzioni nelle librerie standard di I/O del C Funzioni per leggere da tastiera, visualizzare dati

C : un primo programma (6) #include #define N 3 int main (void){ int i, tmp, max=0; printf(“Inserisci %d interi positivi\n”,N); for (i = 0; i < N; i++) { scanf(“%d”, &tmp); max = (max > tmp)? max : tmp ; } printf(“Il massimo è %d \n”,max); return 0; } Definizione di MACRO (costante simbolica) - N è il nome simbolico per la sequenza di caratteri “3” - Ogni occorrenza di N viene sostituita da “3” prima di iniziare la compilazione

C : un primo programma (7) #include #define N 3 int main (void){ int i, tmp, max=0; printf(“Inserisci %d interi positivi\n”,N); for (i = 0; i < N; i++) { scanf(“%d”, &tmp); max = (max > tmp)? max : tmp ; } printf(“Il massimo è %d \n”,max); return 0; } Intestazione della funzione, fornisce : - il tipo del valore prodotto dalla funzione ( int ) - descrizione degli argomenti (in questo caso nessuno ( void ))

C : un primo programma (8) #include #define N 3 int main (void){ int i, tmp, max=0; printf(“Inserisci %d interi positivi\n”,N); for (i = 0; i < N; i++) { scanf(“%d”, &tmp); max = (max > tmp)? max : tmp ; } printf(“Il massimo è %d \n”,max); return 0; } Dichiarazione di variabili locali alla funzione (il loro spazio di memoria viene allocato all’inizio della esecuzione della funzione e deallocato alla fine)

C : un primo programma (9) #include #define N 3 int main (void){ int i, tmp, max=0; printf(“Inserisci %d interi positivi\n”,N); for (i = 0; i < N; i++) { scanf(“%d”, &tmp); max = (max > tmp)? max : tmp ; } printf(“Il massimo è %d \n”,max); return 0; } Invocazione della funzione di libreria che scrive su video

C : un primo programma (10) #include #define N 3 int main (void){ int i, tmp, max=0; printf(“Inserisci %d interi positivi\n”,N); for (i = 0; i < N; i++) { scanf(“%d”, &tmp); max = (max > tmp)? max : tmp ; } printf(“Il massimo è %d \n”,max); return 0; } Stringa di formattazione Placeholder (segnaposto) per un valore intero (%d)

C : un primo programma (11) #include #define N 3 int main (void){ int i, tmp, max=0; printf(“Inserisci %d interi positivi\n”,N); for (i = 0; i < N; i++) { scanf(“%d”, &tmp); max = (max > tmp)? max : tmp ; } printf(“Il massimo è %d \n”,max); return 0; } Il segnaposto viene rimpiazzato con il valore dei parametri (in ordine)

C : un primo programma (12) #include #define N 3 int main (void){ int i, tmp, max=0; printf(“Inserisci %d interi positivi\n”,N); for (i = 0; i < N; i++) { scanf(“%d”, &tmp); max = (max > tmp)? max : tmp ; } printf(“Il massimo è %d \n”,max); return 0; } Invocazione della funzione di libreria che legge da tastiera

C : un primo programma (13) #include #define N 3 int main (void){ int i, tmp, max=0; printf(“Inserisci %d interi positivi\n”,N); for (i = 0; i < N; i++) { scanf(“%d”, &tmp); max = (max > tmp)? max : tmp ; } printf(“Il massimo è %d \n”,max); return 0; } Indirizzo ( & ) della variabile ( tmp ) in cui deve essere inserito il valore intero ( %d ) letto da tastiera.

C : un primo programma (14) #include #define N 3 int main (void){ int i, tmp, max=0; printf(“Inserisci %d interi positivi\n”,N); for (i = 0; i < N; i++) { scanf(“%d”, &tmp); max = (max > tmp)? max : tmp ; } printf(“Il massimo è %d \n”,max); return 0; } Espressione condizionale

C : un primo programma (15) #include #define N 3 int main (void){ int i, tmp, max=0; printf(“Inserisci %d interi positivi\n”,N); for (i = 0; i < N; i++) { scanf(“%d”, &tmp); max = (max > tmp)? max : tmp ; } printf(“Il massimo è %d \n”,max); return 0; } Comando return : termina l’esecuzione della funzione e restituisce il valore delle espressione specificata Per convenzione se tutto è andato bene il main restituisce 0.

Il linguaggio C Preprocessing e Compilazione

Pre-processing e compilazione Il programma deve essere editato e salvato in un file con estensione ‘.c’ –es. posso salvare il programma esempio nel file prova.c Non c’è alcun rapporto fra il nome del file ed il nome delle funzioni in esso contenute (!= Java)

Pre-processing e compilazione (2) Il compilatore può essere invocato con il comando gcc -Wall -pedantic -g prova.c -o nomees –-Wall -pedantic opzioni che aumentano il numero di controlli e di messaggi di ‘avvertimento’ visualizzati –-g opzione che include anche le informazioni necessarie al debugger –prova.c nome del file da compilare/preprocessare –-o nomees opzione che permette di decidere il nome del file eseguibile ( nomees ). Altrimenti il file eseguibile si chiama di default a.out

Pre-processing e compilazione (3) Preprocessing –#include –#include “file” queste linee vengono rimpiazzate dal contenuto dei file specificati ( viene cercato tra gli header standard, su Linux /usr/include; “file” viene cercato a partire dalla directory corrente ) –#define nome testo rimpiazza ogni occorrenza di nome con il testo specificato è possibile specificare del testo parametrico

Pre-processing e compilazione (4) Compilazione –trasforma il file preprocessato (senza più #include o #define ) in un file eseguibile che contiene alcune informazioni di carattere generale rappresentazione binaria di (parte dei) dati del programma (variabili globali) codice assembler eseguibile dal processore target (testo) –per capire come avviene questa traduzione, dobbiamo specificare come un programma vede la memoria durante la sua esecuzione (spazio di indirizzamento) –un programma in esecuzione viene comunemente detto processo

Il C è un linguaggio a blocchi int main (void) { } blocco

Il C è un linguaggio a blocchi (2) Non è possibile mischiare dichiarazioni e comandi ! int main (void) { } Dichiarazione di variabili locali Comandi

Variabili non inizializzate Le variabili non inizializzate non producono nessun errore!!!! int main (void) { /* ed esempio …. */ int min, max, out; int = max * out; … } Controllate sempre di aver inizializzato lo variabili prima del loro uso!

Il linguaggio C Tipi di dato, costanti, operatori

I tipi di dato primitivi Interi : short, int, long, –2,4,8,16 byte (dipende dalla implementazione) –segnaposto %d rappresentazione decimale %x,%o rappresentazione esadecimale o ottale –costanti intere : 1, -2, 4565 –La funzione predefinita sizeof() fornisce la lunghezza in byte di un qualsiasi tipo o variabile C es. sizeof(int)

I tipi di dato primitivi (2) Caratteri : –char, 1 byte, cod. ASCII, segnaposto %c –costanti carattere : `a`, `b`, `c` –i caratteri sono visti da C come interi un po’ speciali : è possibile operare sui caratteri con le normali operazioni su interi –es: char c = `a`; c++; putchar(c); /* ???? */

I tipi di dato primitivi (3) Reali : –float, double, long double –4,8,16 byte, –rappresentazione in virgola mobile –segnaposto : stampa (es. printf()) %f, %lf lettura (es. scanf()) %f (float), %lf (double), %Lf (long double),

I tipi di dato primitivi (4) Libreria matematica ( libm ) –fornisce tutte le più comuni operazioni matematiche per operare sui reali es. sqrt() –per utilizzarla includere il file #include –compilare con gcc … … … -lm effettua il link esplicito della libreria

I tipi di dato primitivi (5) Non esistono i tipi byte e bool !!! Le stringhe sono rappresentate come array di caratteri. signed/unsigned –modificatore per i tipi interi e caratteri –permette di scegliere fra la rappresentazione di soli interi positivi (es su un byte) o quella in complemento a due (es -128,+127) es. unsigned int, signed char

I tipi di dato primitivi (6) limits.h –contiene macro che definiscono i massimi ed i minimi numeri rappresentabili per tutti i tipi –es. INT_MIN, INT_MAX –per utilizzarli includere il file limits.h

I tipi di dato primitivi (7) Conversioni fra tipi diversi : –sono automatiche in C –posso scrivere espressioni con operandi di tipo diverso int a=0; float b, r=3.1; b = a + r; –di solito viene convertito tutto nel tipo più accurato, le regole p.115 nel testo KP –conversioni esplicite r =(float) a / b

I valori booleani Rappresentazione dei valori booleani in C : –non esiste il tipo bool ! –sono rappresentati con int –0 rappresenta FALSO, qualsiasi valore != 0 rappresenta VERO es. 456 viene interpretato come VERO es. if (1) printf(“VERO”); è un condizionale con condizione sempre vera, che quindi stampa sempre VERO sullo schermo.

Gli array Aggregati di variabili dello stesso tipo : –dichiarazione (array statici): int a[4]; –gli indici partono da 0 –non viene effettuato nessun controllo sugli indici nell’accesso : se cerco di accedere a a[15] il compilatore non dà errore ed in fase di esecuzione il risultato dipende dal contenuto della memoria adiacente ad a 1378 a[1] posizione valore

Le stringhe Sono array di caratteri terminati da ´\0´ –dichiarazione : char parola[8]=“mango”; –permette di memorizzare una qualsiasi parola di al più 7 caratteri (l’ottavo serve per il terminatore) –è inizializzata con la parola “ mango ” –string.h fornisce tutte le più comuni funzioni per manipolare stringhe

Le strutture (record) Aggregati di variabili di tipo diverso –dichiarazione di una nuova struttura: struct studente { char nome[40]; char cognome[40]; double voto; } ; –dichiarazione di variabili di tipo struttura : struct studente x; struct studente classe[140];

Le strutture (record) (2) Ridenominazione tipi : typedef tipo nome; –es : typedef int Intero; Intero nome[40]; –es : typedef char stringa40[41]; stringa40 nome;

Le strutture (record) (3) Ridenominazione tipi : typedef struct { char nome[40]; char cognome[40]; double voto; } studente ; – così si può eliminare struct dalle dichiarazioni studente x; studente classe[140];

Le strutture (record) (4) Ridenominazione tipi : typedef struct studente { char nome[40]; char cognome[40]; double voto; } studente ; – così si può eliminare struct dalle dichiarazioni studente x; studente classe[140]; Opzionale (serve per i tipi ricorsivi)

Le strutture (record) (5) Accesso ai campi : –tramite l’operatore punto (.) –es : studente x; studente classe[140]; classe[i].nome = x.nome;

I tipi enumerati Rappresentano insiemi finiti: –giorni: lunedi, martedi, … –mesi: gennaio, febbraio, … –bool: true, false. Associano un identificatore (costante) ad ogni elemento dell’insieme Sono rappresentati con degli interi –.. Ma il compilatore controlla che le funzioni siano chiamate con il tipo giusto (type checking)

I tipi enumerati (2) Esempio: enum giorni {lun,mar,mer,gio,ven,sab,dom}; enum giorni x; /* dichiarazione */ x = lun; … –Si può evitare di ripetere enum con un typedef –I valori interi assegnati partono da 0 : lun == 0,mar == 1,mer == 2,…

I tipi enumerati (3) Esempio: typedef enum {true = 1, false = 0} bool; bool trovato; /* dichiarazione */ trovato = false; … –Si possono scegliere i valori interi assegnati ad ogni elemento

Il linguaggio C Funzioni

Funzioni C Le funzioni C sono l’unico modo per strutturare i programmi e non si possono annidare Non esistono le procedure Non esistono i metodi Dichiarazione di funzioni : –descrive il prototipo della funzione ovvero: nome della funzione, il tipo del valore restituito ed il tipo di tutti gli argomenti utilizzati

Funzioni C (2) Dichiarazione di funzioni : –es: prototipo della funzione di somma di due interi int somma (int, int); oppure int somma (int x, int y); x, y sono inutili, ma vengono convenzionalmente specificati per documentazione

Funzioni C (3) Definizione di funzioni : –la definizione di una funzione è divisa fra : una intestazione (head) che fornisce il prototipo della funzione a i nomi per i parametri formali, ed un corpo (body) che specifica le azioni da compiere –es: int somma (int x, int y) { return (x + y); } intestazione

Funzioni C (4) Definizione di funzioni : –la definizione di una funzione è divisa fra una intestazione (head) che fornisce il prototipo della funzione a i nomi per i parametri formali, ed un corpo (body) che specifica le azioni da compiere –es: int somma (int x, int y) { return (x + y); } corpo

Funzioni C (5) La dichiarazione o la definizione di una funzione deve sempre precedere il suo uso! –Tipica struttura di un programma C (unico file): #direttive al preprocessore dichiarazioni di varibili globali (es. int k;) dichiarazione di funzioni (prototipi) (es. int somma (int x, int y);) int main (…) {….} definizione di funzioni (es. int somma (int x, int y) {….})

Funzioni C (6) Scope delle variabili: –Il corpo di una funzione contiene le variabili locali sono allocate sulla pila, sono accessibili solo a quella funzione perdono il valore fra un’invocazione e l’altra

Funzioni C (7) Scope delle variabili (cont.) : –Le variabili globali sono variabili dichiarate al di fuori delle funzioni sono accessibili all’interno di tutte le funzioni sono allocate nell’area dati e vengono deallocate solo alla terminazione del programma –Le globali sono sconsigliate a meno di casi motivati! Devono essere sempre adeguatamente documentate

Funzioni C (8) Scope delle variabili (cont.) : –Le variabili statiche locali ( static ) sono accessibili all’interno della funzione che le dichiara mantengono il valore fra una invocazione e l’altra Tutti i parametri sono passati per valore –una copia viene messa sullo stack all’atto della chiamata

Esempio di funzione #include int max (int a, int b); /* dichiarazione */ int main (void){ printf(“Il massimo è %d \n”, max(10,2)); return 0; } int max (int a, int b) { return (a < b)? b : a ; /* definizione */ }

Esempio di funzione (2) /* un esempio di var globale */ #include int max (int a, int b); /* dichiarazione */ int k = 0; /* var globale */ int main (void){ printf(“Il massimo è %d \n”, max(10,2)); printf(“Il valore di k è %d \n”, k); return 0; } int max (int a, int b) { k = k + 1; /* side effect */ return (a < b)? b : a ; /* definizione */ }

Esempio di funzione (3) /* un esempio di var statica */ #include int max (int a, int b); /* dichiarazione */ int main (void){ printf(“Il massimo è %d \n”, max(10,2)); /* k non è più accessibile fuori da max */ return 0; } int max (int a, int b) { static int k = 0; k++; return (a < b)? b : a ; /* definizione */ }

Compilazione separata

Finora abbiamo trattato solo programmi C contenuti in un unico file define/include variabili globali typedef main def F1 … def FN prototipi F1..FN Struttura tipica di un sorgente C

Compilazione separata (2) Scopi di suddividere il codice sorgente C su più file –per raggruppare un insieme di funzioni congruenti –per incapsulare un insieme di funzioni esportando solo quelle che vogliamo fare utilizzare agli altri (pubbliche) –per compilare una volta per tutte un insieme di funzioni e metterlo a disposizione di altri in una libreria es. le librerie standard viste finora ….

Compilazione separata (2.1) Problemi da risolvere : –(1) come si possono utilizzare funzioni definite in altri file ? Vogliamo che il compilatore continui a fare i controlli di tipo etc … –(2) come posso compilare una volta per tutte le funzioni definite in un file separato ? non voglio doverle ricompilare ogni volta che le uso in un altro file (come avviene per printf(), scanf() ) voglio che il codice assembler risultante possa essere facilmente ‘specializzato’ per generare l’eseguibile finale

Compilazione separata (3) Tipicamente : define/include variabili globali typedef main def F1 … def Fk prototipi F1..Fk glob.h prototipi Fk+1..FN main.c fun_toK.c def Fk+1 … def FN fun_toK.h fun_toN.c fun_1toN.h

define/include variabili globali typedef #include “glob.h ” #include “fun_toK.h” #include “fun_toN.h” …... ass F1 … ass Fk prototipi F1..Fk glob.h prototipi Fk+1..FN main.c fun_toK.o ass Fk+1 … ass FN fun_toK.h fun_toN.o fun_1toN.h

Compilazione separata (4) Per utilizzare delle funzioni definite in file diversi basta –(1) specificare il prototipo (dichiarazione) prima dell’uso tipicamente includendo un file che lo contiene –(2) avere a disposizione una versione precompilata delle funzioni stesse (il modulo oggetto relativo al file che le contiene) Perché questo basta ?

Compilazione separata (5) Perché basta ? –Il prototipo della funzione permette al compilatore di fare i controlli di tipo ogni funzione di cui non è noto il prototipo viene considerata void -> int questo genera errori strani ma non fa fallire la compilazione (provate a non includere stdio.h….) –Dal modulo oggetto si può generare correttamente l’eseguibile finale del programma che utilizza le funzioni definite separatamente senza ricompilarle da capo (cioè dal sorgente complessivo)

define/include variabili globali typedef prototipi F1..Fk glob.h prototipi Fk+1..FN main.c fun_toK.o fun_toK.h fun_toN.o fun_1toN.h Modulo oggetto 1,k Modulo oggetto k+1,N #include “glob.h ” #include “fun_toK.h” #include “fun_toN.h” …...

Compilazione separata (6) Come si crea il modulo oggetto? –gcc -c file.c produce un file file.o che contiene il modulo oggetto di file.c –Il formato dell’oggetto dipende dal sistema operativo –Che informazioni contiene l’oggetto ? L’assemblato del sorgente o testo (si assume di partire dall’indirizzo 0) La tabella di rilocazione La tabella dei simboli (esportati ed esterni)