Sei sulla pagina 1di 37

FONDAMENTI DI INFORMATICA (L (L-Z) INGEGNERIA MECCANICA POLITECNICO DI BARI a.a.

2012-2013

Fondamenti di programmazione
Linguaggio C
Dr.Ing. Donato IMPEDOVO

INGEGNERIA MECCANICA (L-Z) FONDAMENTI di INFORMATICA

Dr.Ing. Donato Impedovo

Contents
NOZIONI BASE ............................................................................................................................... 4 Es. 1 .............................................................................................................................................. 5 Variabili e tipi .................................................................................................................................... 5 Es. 2 .............................................................................................................................................. 8 Es. 3 .............................................................................................................................................. 9 Printf e scanf .................................................................................................................................... 11 Es. 4 ............................................................................................................................................ 12 Operatori di incremento e decremento ............................................................................................ 12 Es. 5 ............................................................................................................................................ 13 Es. 6 ............................................................................................................................................ 13 Tipi user-defined .............................................................................................................................. 15 Es. 7 ............................................................................................................................................ 16 Es. 8 ............................................................................................................................................ 17 Es. 9 ............................................................................................................................................ 17 Es. 10 .......................................................................................................................................... 17 CONTROLLO DEL FLUSSO DI ESECUZIONE ......................................................................... 18 Istruzioni di Diramazione ................................................................................................................ 18 If-Else .............................................................................................................................................. 18 Es. 1 ............................................................................................................................................ 18 I-Else-If ............................................................................................................................................ 19 Es. 2 ............................................................................................................................................ 20 Es. 3 ............................................................................................................................................ 20 Es. 3-bis ...................................................................................................................................... 21 Es. 4 ............................................................................................................................................ 21 Switch-Case ..................................................................................................................................... 21 Es. 5 ............................................................................................................................................ 22 Es. 6 ............................................................................................................................................ 23 Istruzioni di ciclo ............................................................................................................................. 24 While................................................................................................................................................ 24 Es. 7 ............................................................................................................................................ 24 For .................................................................................................................................................... 25 Es. 8 ............................................................................................................................................ 25 Do - While ....................................................................................................................................... 26 Break e Continue ............................................................................................................................. 26 Es. 9 ............................................................................................................................................ 26 Es. 10 .......................................................................................................................................... 27 2

INGEGNERIA MECCANICA (L-Z) FONDAMENTI di INFORMATICA

Dr.Ing. Donato Impedovo

Es. 11 .......................................................................................................................................... 27 PUNTATORI................................................................................................................................... 28 Es. 1 ............................................................................................................................................ 29 Es. 2 ............................................................................................................................................ 29 Es. 3 ............................................................................................................................................ 30 FUNZIONI E PROCEDURE .......................................................................................................... 31 Passaggio dei parametri per valore .................................................................................................. 32 Es. 4 ............................................................................................................................................ 32 Es. 5 ............................................................................................................................................ 32 Passaggio dei parametri per indirizzo .............................................................................................. 33 Es. 6 ............................................................................................................................................ 33 Es. 7 ............................................................................................................................................ 34 Es. 8 ............................................................................................................................................ 34 Es. 9 ............................................................................................................................................ 34 PUNTATORI E STRUTTURE ....................................................................................................... 35 Es. 10 .......................................................................................................................................... 35 MEMORIA HEAP .......................................................................................................................... 36 Es. 11 .......................................................................................................................................... 36 Es. 12 .......................................................................................................................................... 36

INGEGNERIA MECCANICA (L-Z) FONDAMENTI di INFORMATICA

Dr.Ing. Donato Impedovo

NOZIONI BASE
Il linguaggio di programmazione C e' stato sviluppato da B. Kernighan e D. Ritchie dei Laboratori Bell come sistema di sviluppo di software su macchine PDP-11 in ambiente UNIX. I vantaggi del linguaggio C rispetto ad altri linguaggi di programmazione sono la semplicit, la compattezza del codice e l' estrema versatilit: le possibilit del linguaggio sono praticamente infinite e sono state scritte intere librerie di software in C non solo in ambito scientifico. Il linguaggio C un linguaggio procedurale: possibile definire funzioni e procedure, e richiamarle poi per nome. Il C un linguaggio dichiarativo: prima di usare una variabile o funzione necessario dichiararla. Il linguaggio C un linguaggio compilato. Al fine di scrivere ed eseguire un programma in linguaggio C, sono necessari i seguenti passi: si scrive il codice in un editor, esso tipicamente ha le stesse funzionalit di un word processor, ma ha anche caratteristiche che aiutano lutente nella scrittura del programma come lindentazione delle istruzioni sulle diverse riga per una maggiore leggibilit del codice, levidenziazione di parole chiave mediante colori, etc. il codice sorgente (generato al punto precedente) viene controllato al fine di verificare lassenza di errori, tale funzionalit svolta dal debugger. Gli errori individuabili sono esclusivamente quelli sintattici relativi alle istruzioni, non potranno essere rilevati errori logici (come ad esempio un ciclo infinito), anche se spesso vengono segnalati dei warning che non costituiscono errore, ma segnalano parti di codice soggetti a comportamenti non ortodossi e quindi sulle quali porre attenzione. Il debugger ha anche il compito di aiutare ad individuare e correggere errori logici o algoritmici con strumenti quali breakpoint e watchpoint. il codice, quando privo di errori, viene compilato ad opera del compilatore, ovvero ogni istruzione viene trasformata nel corrispondente codice in linguaggio di pi basso livello. Viene generato il codice oggetto: i nomi delle variabili definite nel modulo di programma (indirizzi simbolici) sono trasformati in indirizzi rilocabili (indipendenti dallallocazione del programma in memoria centrale, calcolati come se il programma fosse caricato a partire dallindirizzo zero). Il linker genera la fusione (collegamento) di pi codici oggetto, infatti ogni modulo oggetto ha il proprio spazio di indirizzamento che parte da 0. Il linker si occupa di generare un unico modulo e di uniformare i riferimenti di memoria relativi a tutti i moduli generando un unico programma eseguibile. L'esecuzione di un programma richiede che esso sia presente in memoria centrale. Il caricamento effettuato da un programma denominato loader. Lesecuzione del programma eseguibile (in linguaggio macchina) effettuata nella CPU.

Il primo programma in C, il pi semplice in assoluto il famoso "Hello World!" (Ciao Mondo). Esso ha lo scopo di stampare a video una stringa, utilizziamo questo esempio per spiegare la sintassi basilare del linguaggio.

INGEGNERIA MECCANICA (L-Z) FONDAMENTI di INFORMATICA

Dr.Ing. Donato Impedovo

Es. 1
#include <stdio.h> int main() { printf(Hello World!); return 0; }

L'include una direttiva del pre-processore: un comando che permette di richiamare le librerie standard del C. Senza librerie un programma non avrebbe a disposizione i comandi per eseguire anche le operazioni pi semplici, come leggere un file o stampare a video una sequenza di caratteri. La funzione principale in un qualsiasi programma in C il main che, in questo caso, non ha parametri, ma pu ricevere anche degli input da riga di comando. Il main unico e deve essere sempre presente in ogni programma in linguaggio C. Le parentesi graffe servono per delimitare le istruzioni, o come vengono abitualmente chiamate statement, che devono essere eseguite in ordine, da quella pi in alto, gi fino all'ultima; Il punto e virgola chiude una istruzione: dopo il simbolo ; inizia una nuova istruzione. Pi istruzioni possono essere poste sullo stesso rigo, ma alla fine di ogni istruzione deve esserci il ;.

All'interno di un programma in C possono essere inseriti dei commenti, lo scopo dei commenti quello di descrivere le istruzioni al fine di agevolare il programmatore, o chi dovesse leggere il codice alla comprensione dello stesso. I commenti non vengono processati dal compilatore. Esistono due modi per poter inserire commenti:

// - Tutto quello che sta a destra della doppia barra obliqua e sulla medesima riga viene considerato commento e viene ignorato dal debugger e dal compilatore; /* ... */ - Tutto quello che compreso tra i due asterischi viene considerato commento; questa forma viene utilizzata per commenti su pi righe.

Variabili e tipi
Le variabili vengono dichiarate mediante lindicazione di un tipo e di un nome. Il nome utilizzato per identificare la variabile univoco. Un identificatore costituito da uno o pi caratteri (cifra o lettera), deve iniziare necessariamente con una lettera o il carattere di sottolineatura (underscore _ ). Il C case-sensitive: fa distinzione tra lettere maiuscole e lettere minuscole. Il tipo della variabile indica linsieme dei valori che essa pu assumere. Le operazioni che permettono di convertire una variabile da un determinato tipo ad un altro (ad esempio da una lettera ad un numero) prendono il nome di casting. 5

INGEGNERIA MECCANICA (L-Z) FONDAMENTI di INFORMATICA

Dr.Ing. Donato Impedovo

Tutte le variabili, prima di essere utilizzate, devono essere dichiarate, affinch il compilatore sia in grado di allocare la memoria necessaria alla variabile stessa. La dichiarazione generalmente viene fatta all'inizio del programma, ma in programmi di grandi dimensioni pu trovarsi anche in altre posizioni (o altri file), in ogni caso essa deve essere fatta una sola volta. Contemporaneamente o successivamente alla dichiarazione, la variabile pu essere inizializzata (le viene assegnato un valore iniziale).
int x; //dichiarazione x=0; //inizializzazione int x=1;//dichiarazione e inizializzazione

In C esistono tipi built-in (ossia gi definiti allinterno dello stesso linguaggio di programmazione) e tipi user-defined (definibili dallutente). I tipi built-in standard sono quattro: Tipi di dichiarazione Char Int Float Double Rappresentazione Carattere Numero intero Numero reale Numero reale in doppia precisione N. di byte occupati 1 (8 bit) 2 (16 bit) 4 (32 bit) 8 (64 bit)

Ad essi sono applicabili qualificatori di tipo secondo il seguente schema: Qualificatore signed, unsigned short, long Tipo char, int int

1. Il tipo CHAR utilizzato per dichiarare una variabile che potr contenere un solo carattere. Nella maggioranza dei calcolatori viene utilizzato un Byte per memorizzare tale informazione, la codifica utilizzata lASCII. Saranno anche possibili operazioni di confronto, in quanto, ad esempio, a risulter essere minore di b in quanto ad a corrisponde la rappresentazione decimale 97 e a b 98. In C non esiste il tipo stringa (sequenza di caratteri), per ovviare a questo problema possiamo definire una stringa come un array di char, ossia di elementi tutti omogenei di tipo char.
char x=b; //dichiarazione ed inizializzazione con il carattere b char a[10];//stringa di 10 caratteri EOF - ^Z (Ctrl z)

INGEGNERIA MECCANICA (L-Z) FONDAMENTI di INFORMATICA

Dr.Ing. Donato Impedovo

Per poter leggere un singolo carattere da tastiera e assegnarlo ad una variabile char si utilizza listruzione getchar( ), essa contenuta nella libreria stdio.h
int c; //equivalente in questo esempio a char c; c=getchar();

Per poter stampare un singolo carattere a video si utilizza listruzione putchar( ), essa contenuta nella libreria stdio.h

#include <ctype.h> //toupper #include <stdio.h> main() { int c; c=getchar(); putchar(toupper(c)); }

2. Il tipo INT permette di dichiarare variabili che potranno assumere valori interi o naturali. Il tipo int per default short: dichiarazione int equivale alla dichiarazione short int o short. Generalmente un intero viene rappresentato su 16 bit in complemento a 2, int 16 bit: -215 (215-1);

unsigned int: 0 (216-1); Il tipo long permette di estendere (utilizzando due byte in pi) il range dei valori utilizzabili. Operatori aritmetici semplici per gli interi Simbolo + * / % Esempio 4+7=11 5-9=-4 3*7=21 10/3=3 10%3=1

Addizione Sottrazione Moltiplicazione Divisione Intera Operatore modulo

Gli operatori *,/,% hanno precedenza rispetto a + e -, cio a+b%c equivale a a+(b%c). Tuttavia sempre conviene utilizzare le parentesi.

INGEGNERIA MECCANICA (L-Z) FONDAMENTI di INFORMATICA

Dr.Ing. Donato Impedovo

Es. 2
#include <stdio.h> int main() { int a,b,c,d; a=5;b=2; c=a/b; printf("divisione intera:%d\n",c); d=a%b; printf("resto della divisione intera:%d\n",d); getchar(); return 0; }

Nota sugli indici dei vettori. Si supponga di dichiarare una variabile vettore (array)di 10 elementi interi:
int A[10];

L'accesso ai 10 elementi del vettore avviene mediante l'utilizzo di indici, in particolare al primo elemento del vettore corrisponde l'indice 0, mentre all'ultimo elemento (decimo) corrisponde l'indice 9.
A[0]=14; //inizializzazione del primo elemento al valore 14

Gli indici possono essere gestiti anche attraverso l'utilizzo di variabili intere:
int i=4; A[i]=11; //inizializzazione del quinto elemento al valore 11

Caratteri ed interi Il seguente programma ha lo scopo di visualizzare a monitor il valore numerico intero corrispondente ad una variabile di tipo char.
/* Stampa del codice numerico di un carattere */ #include<stdio.h> void main() { char ch; printf(Digitare un carattere: ); scanf(%c, &ch); printf(Il codice numerico corrispondente %d\n, ch); }

Dato che in C i caratteri sono trattati come interi, su di essi possibile effettuare operazioni aritmetiche int j; j = A+B; j conterr il valore 131, somma dei codici ASCII 65 e 66

3. I tipi FLOAT e DOUBLE vengono utilizzati per dichiarare variabili in virgola mobile, in matematica essi corrisponderebbero ai numeri reali. La loro rappresentazione nella memoria di un calcolatore utilizza un numero finito di bit, pertanto il numero di cifre dopo la virgola necessariamente finito, cos come l'insieme dei numeri rappresentabili discreto. 8

INGEGNERIA MECCANICA (L-Z) FONDAMENTI di INFORMATICA

Dr.Ing. Donato Impedovo

Il tipo double utilizza un numero maggiore di bit (doppio rispetto al float) per la rappresentazione del numero e pertanto variabili double risultano avere una precisione maggiore rispetto a variabili float.. La rappresentazione adottata segno/esponente/mantissa. Float 4 byte -> 6 cifre decimali dopo la virgola; 1/8/23 (formato standard IEEE) Double 8 byte ->15 cifre decimali; 1/11/52 (formato standard IEEE) Operatori aritmetici semplici per i float Simbolo + * / Esempio 4.1+7.2=11.3 5.7-9.7=-4.0 3.0*7.5=22.5 7/2=3.5

Addizione Sottrazione Moltiplicazione Divisione

Es. 3
#include <stdio.h> void main() { float x=7; float y=3; float z; //verificare se le tre dichiarazioni equivalgono a float x=7,y=3,z; z=x/y; printf("%f",z); }

Operatori di confronto

Operatori Logici

Uguaglianza Diverso Minore Maggiore Minore uguale Maggiore uguale

== != < > <= >=

AND OR NOT

&& || !

INGEGNERIA MECCANICA (L-Z) FONDAMENTI di INFORMATICA Tavole di verit degli operatori logici: A 0 0 1 1 B 0 1 0 1 A&&B 0 0 0 1 A||B 0 1 1 1

Dr.Ing. Donato Impedovo

!A 1 1 0 0

Confronto di uguaglianza tra float: Il confronto di uguaglianza fra operatori floatingpoint molto pericoloso a causa della approssimazione insita nel tipo di rappresentazione Esempio: Lespressione (1.0/3.0+1.0/3.0+1.0/3.0)==1.0 anche se algebricamente vera, viene valutata come falsa sulla maggioranza dei calcolatori; infatti il risultato della divisione 1.0/3.0 non pu essere rappresentato esattamente: la somma a sinistra dellespressione non coincide con 1 Evitare confronti di uguaglianza fra floatingpoint oppure indicare una soglia di incertezza: s=soglia di incertezza pari ad un determinato valore (y-s<=x<=y+s) ( x> y-s && x<y+s)

10

INGEGNERIA MECCANICA (L-Z) FONDAMENTI di INFORMATICA

Dr.Ing. Donato Impedovo

Printf e scanf Istruzioni di lettura da tastiera e stampa a video definiti nella stdio.h: printf e scanf.
printf: istruzione che consente di stampare a video, la sintassi la seguente:
printf(stringa di formato,[lista parametri]);

la stringa di formato ha due tipi di argomenti: caratteri ordinari - vengono copiati direttamente nell'output; specificazioni di conversione o di formato - contraddistinte dal carattere percentuale "%" seguito da un carattere che specifica il formato con il quale stampare le variabili presenti nella lista di argomenti. La tabella seguente mostra i formati che possono essere usati per formattare le variabili; %d,%i %6d %f %6f %.2f %6.2f %g %s %c %% Stampa intero Stampa un intero in un campo di almeno 6 caratteri Stampa float Stampa float in un campo di almeno 6 caratteri Stampa float con due cifre dopo il punto decimale Stampa float in un campo di almeno 6 caratteri con almeno 2 cifre dopo il punto decimale Stampa double Stampa stringa Stampa carattere Stampa carattere %

E' anche possibile introdurre, nella stringa di formato, delle spefiche di formattazione secondo le indicazioni della seguente tabella: Tipo di opzione \n \t \b \a \f Descrizione Ritorno a capo Tabulazione orizzontale Tabulazione verticale Produce una segnalazione visiva o sonora Salto pagina

scanf: consente la lettura dallo standard input (tastiera) di caratteri o cifre che verranno memorizzate all'interno di opportune variabili. Pi variabili possono essere lette in sequenza mediante lutilizzo di una unica istruzione scanf, esse devono per, essere specificate nella lista degli argomenti. La sintassi la seguente:
scanf(stringa di formato,[lista parametri]);

In questo caso la stringa di formato contiene esclusivamente specificazione di conversione secondo la tabella riportata nel caso della funzione printf, Con riferimento alla lista dei 11

INGEGNERIA MECCANICA (L-Z) FONDAMENTI di INFORMATICA

Dr.Ing. Donato Impedovo

parametri, a differenza della printf, la variabile deve essere preceduta dal simbolo &. Ci giustificato dal fatto che necessario indicare l'indirizzo della variabile nella quale intendiamo memorizzare il dato acquisito e non semplicemente il suo nome.
//acquisizione di un dato intero da tastiera int i; scanf("%d",&i);

Nota sullacquisizione di stringhe :


char stringa[10]; scanf("%s",stringa);

Il simbolo & si pu omettere poich il nome di un array corrisponde all'indirizzo di partenza dell'array stesso.

Es. 4

//divisione tra float con acquisizione da tastiera #include <stdio.h> int main() { float x,y,z; printf("\nInserisci il numeratore: "); scanf("%f",&x); printf("\nInserisci il denominatore :\n"); scanf("%f",&y); z=x/y; printf("%f",z); return 0; }

Ulteriori esercizi: - si scriva un programma che acquisisca da tastiera un valore di temperatura, verifichi se esso compreso tra -50C e +50C, e in caso affermativo si calcoli e si stampi a video il corrispondente valore in termini di F e K. - si scriva un programma che acquisisca il raggio di un cerchio da tastiera, ne calcoli l'area e la stampi a video.

Operatori di incremento e decremento


Gli operatori di incremento e decremento vengono utilizzati per incrementare o decrementare di una unit il valore di una variabile. operatore di incremento: ++ operatore di decremento: -Questi operatori possono essere preposti o posposti alla variabile: se sono preposti il valore della variabile incrementato prima che la stessa variabile sia utilizzata nellespressione in cui compare, 12

INGEGNERIA MECCANICA (L-Z) FONDAMENTI di INFORMATICA

Dr.Ing. Donato Impedovo

nel caso in cui loperatore sia posposto alla variabile, allora la variabile verr prima utilizzata nellespressione e solo successivamente incrementata. Si consideri a titolo esemplificativo il seguente esercizio..

Es. 5

//operatori di incremento e decremento #include <stdio.h> int main() { int x=1; int y=4; int z=8; int k=5; printf("%d printf("%d printf("%d printf("%d return 0; } \n",x++); \n",++y); \n",z--); \n",--k); //1 //5 //8 //4

Dagli operatori di incremento e decremento discende la possibilit di una pi sintetica rappresentazione di alcuni tipi di espressioni: variabile = variabile op espressione Esempi: int y = 4; y += 2; // y=y+2, y vale 6 variabile op= espressione

int x = 3; x *= y + 3; // x=x*(y+3), x vale 27

Es. 6
#include <stdio.h> /* stampa di variabili numeriche*/ int main() { int i; float f; double d; char c; i=6; f=6.3; d=5.4; c='A'; printf("Numero intero: %d\n",i); printf("Numero float: %f\n",f); printf("Numero double: %lf\n",d);

13

INGEGNERIA MECCANICA (L-Z) FONDAMENTI di INFORMATICA


printf("Carattere: %c\n",c); printf("\nNumero float formattato: %5.3f\n",f); printf("Carattere: %d\n",c); getchar(); return 0; }

Dr.Ing. Donato Impedovo

14

INGEGNERIA MECCANICA (L-Z) FONDAMENTI di INFORMATICA

Dr.Ing. Donato Impedovo

Tipi user-defined
TYPEDEF Il costrutto typedef e' utilizzato per la definizione di nuovi tipi di dati. La prima possibilit quella di definire un nuovo tipo sulla base di uno gi esistente. Lesempio seguente mostra come sia possibile rinominare il tipo int.
typedef int intero;

Successivamente a tale definizione di tipo, la dichiarazione di una variabile di tipo intero sar del tipo :
intero a; //equivalente a int a;

Ulteriori esempi:
typedef int vettore[10]; vettore v; //definiamo un vettore di 10 elementi vettore t[10]; //definiamo una matrice 10x10

E' consigliabile usare per i typedef (come per le #define) nomi scritti interamente in caratteri maiuscoli, per agevolare la comprensione. In programmi in cui vi sono tipi dipendenti dalla macchina pu essere utile dare un nuovo nome ad un tipo gi esistente. Esempio: si vuole definire un tipo SIZE1 che corrisponde ad un intero di 32 bit. A seconda della macchina sottostante, potrebbe essere sinonimo di int oppure di long int. Quindi si inserisce la definizione typedef long int SIZE1; e si sviluppa tutto il programma usando il tipo SIZE1 invece che long int. Passando su una macchina diversa, si sostituisce la riga precedente con typedef int SIZE1;

Costruttore ENUM E anche possibile definire un nuovo tipo elencando (specificando) i valori che esso ammette:
typedef enum {false,true} boolean; //definizione del tipo boolean Boolean x; //dichiarazione di una variavile di tipo boolean typedef enum {Mario,Giorgio,Andrea} persona;

15

INGEGNERIA MECCANICA (L-Z) FONDAMENTI di INFORMATICA

Dr.Ing. Donato Impedovo

il compilatore assegna ad ogni elemento elencato un numero progressivo intero 0,1,2,.. , attraverso essi faremo riferimento ai diversi valori da noi indicati. Questi valori di default possono essere modificati:
typedef enum{Mario=2,Giorgio=6,Andrea=9};

Costruttore STRUCT Viene utilizzato per definire strutture dati eterogenee. Es:
struct{ int giorno; int mese; int anno;}data;

typedef struct{ int giorno; int mese; int anno;}data; data x; //dichiarazione di variabile

Per accedere ai campi della struttura si utilizza la dot notation:


x.giorno=01; x.mese=02; x.anno=2006;

Es. 7
Scrivere un programma che visualizzi a monitor la dimensione in numero di byte //delle variabili di tipo standard e di alcune di tipo definito dallutente #include <stdio.h>
/* sizeof() restituisce la lunghezza in numero di byte di una variabile */ int main() { char c; int i; short int si; long int li; unsigned int ui; float f; double d; long double ld; printf("carattere: \t%d\n",sizeof(c)); printf("intero: \t%d\n",sizeof(i)); printf("short int: \t%d\n",sizeof(si)); printf("long int: \t%d\n",sizeof(li));

16

INGEGNERIA MECCANICA (L-Z) FONDAMENTI di INFORMATICA


printf("unsigned int: \t%d\n",sizeof(ui)); printf("float: \t%d\n",sizeof(f)); printf("double: \t%d\n",sizeof(d)); printf("long double: \t%d\n",sizeof(ld)); return 0; }

Dr.Ing. Donato Impedovo

Es. 8
#include <stdio.h> /* conversione (cast) di variabili numeriche */ int main() { double d=65.8; float f; long l; int i; short s; char c; printf("d: %lf\n",d); f=(float)d; printf("f: %f\n",f); l=(long)d; printf("l: %ld\n",l); i=(int)d; printf("i: %d\n",i); s=(short)d; printf("s: %d\n",s); c=(char)d; printf("c: %c\n",c); f=(float)l; printf("\nf: %f\n",f); return 0; }

Esercizi di ricapitolazione

Es. 9
Scrivere un programma che legga due numeri da tastiera e ne calcoli la somma, la differenza, il prodotto e il rapporto e stampi i risultati a video

Es. 10
Scrivere un programma che consenta di memorizzare in una apposita struttura tutti i dati anagrafici relativi ad una persona acquisendoli da tastiera, successivamente stampare a video i tutti i dati anagrafici, precedentemente salvati, con una unica printf. 17

INGEGNERIA MECCANICA (L-Z) FONDAMENTI di INFORMATICA

Dr.Ing. Donato Impedovo

CONTROLLO DEL FLUSSO DI ESECUZIONE


Il C un linguaggio di programmazione strutturato: esso si basa sullutilizzo di strutture per il controllo del flusso di esecuzione. Le strutture appartengono a due macro categorie:

Diramazione (permettono di decidere l'attivazione di parti di codice in base al valore assunto da una espressione): if-else, if-else-if, switch-case; Cicli (permettono di svolgere pi volte un insieme di istruzioni fino al raggiungimento di una condizione): while, do-while, for.

Istruzioni di Diramazione If-Else


L'istruzione if-else una istruzione di diramazione, permette di verificare una determinata espressione, se essa risulta vera allora il blocco di istruzioni che verr eseguito quello che si trova sotto il ramo if, in caso contrario verranno eseguite le istruzioni del ramo else. L'istruzione if-else ha la seguente sintassi:
if (espressione) { istruzione; } else { istruzione; }

E necessario utilizzate le parentesi graffe aperta e chiusa al fine di delimitare linizio e la fine del blocco delle istruzioni da eseguire lungo uno specifico ramo. In generale, nel caso in cui il blocco sia costituito da una sola istruzione, lutilizzo delle parentesi pu essere omesso.

Es. 1
#include <stdio.h> void main() { int eta; scanf("%i",&eta); if (eta>=18) { printf("Utente maggiorenne"); } else

18

INGEGNERIA MECCANICA (L-Z) FONDAMENTI di INFORMATICA


{ } } printf("Utente minorenne");

Dr.Ing. Donato Impedovo

L'istruzione if viene generalmente utilizzata per controllare la validit dei dati. Si consideri un programma che ha come scopo quello di acquisire un dato >0 da tastiera e di stamparne il risultato:
#include <stdio.h> #include <math.h> //per la funzione sqrt() void main() { double num; printf(Introdurre un numero non negativo: ); scanf(%lf, &num); /* %lf indica un tipo double */ if (num<0) printf(Errore: il numero introdotto minore di 0.\n); else printf(La radice quadrata : %f \n, sqrt(num)); }

I-Else-If
Listruzione if-else-if permette di verificare una o pi condizioni. La sintassi la seguente:

if (espressione) { istruzione; } else if (espressione) { istruzione; } else if (espressione) { istruzione; } . else { istruzione; }

Sia con il costrutto if-else che con quello if-else-if possibile avere blocchi annidati. Per evitare problemi relativi allindividuazione delle possibili diramazioni sempre opportuno utilizzare le parentesi graffe ed una corretta indentazione del codice.

19

INGEGNERIA MECCANICA (L-Z) FONDAMENTI di INFORMATICA

Dr.Ing. Donato Impedovo

Es. 2
#include <stdio.h> void main() { int eta; scanf("%i",&eta); if (0<eta && eta<18) { printf("Utente minorenne"); } else if (18<=eta && eta<=65) { printf("Utente maggiorenne"); } else if (eta>65) { printf("Utente anziano"); } }

Es. 3
calcolo delle soluzioni di una equazione di secondo grado
#include <stdio.h> #include <math.h> int main() { float a,b,c; double d, x1, x2; printf("Inserire il coefficiente di secondo grado:\t"); scanf("\n%f",&a); printf("Inserire il coefficiente di primo grado:\t"); scanf("\n%f",&b); printf("Inserire il termine noto:\t"); scanf("\n%f",&c); if(a==0) //verifico se l'equazione di secondo grado { printf("Questa non una equazione quadratica: a=0!\n"); return 0; } d=b*b-4*a*c; //calcolo il determinante if(d<0) printf("equazione con radici complesse e coniugate"); else { x1=((-b)+sqrt(d))/(2*a); x2=((-b)-sqrt(d))/(2*a); printf("Le soluzioni sono: %f, %f", x1,x2); }

return 0;
}

20

INGEGNERIA MECCANICA (L-Z) FONDAMENTI di INFORMATICA

Dr.Ing. Donato Impedovo

Es. 3-bis
Si completi il programma precedente fornendo anche le soluzioni dellequazione di primo grado, e le radici complesse in caso di determinante negativo. Suggerimento: con riferimento alle soluzioni complesse si crei un nuovo tipo "complesso" costituito da due campi (parte reale e parte immaginaria). La funzione abs() (es. x=abs(y);) definita nella libreria math.h restituisce il valore assoluto dellargomento.

Es. 4
Programma calcolatrice
#include <stdio.h> int main() { float op1,op2,r; int scelta; printf("Calcolatrice\n"); printf("Inserire il primo operando, op1:\t"); scanf("%f",&op1); printf("Inserire il secondo operando, op2:\t"); scanf("%f",&op2); printf("Scelta dell'operazione:\n 1)op1+op2\n 2)op1-op2\n 3)op1*op2\n 4)op1/op2\n"); scanf("%d",&scelta); if (scelta==1) { r=op1+op2; printf("Il risultato :%f",r); } else if (scelta==2) { r=op1-op2; printf("Il risultato :%f",r); } else if (scelta==3) { r=op1*op2; printf("Il risultato :%f",r); } else if (scelta==4) { r=op1/op2; printf("Il risultato :%f",r); } else printf("Scelta non valida"); return 0; }

Switch-Case
21

INGEGNERIA MECCANICA (L-Z) FONDAMENTI di INFORMATICA

Dr.Ing. Donato Impedovo

L'istruzione switch viene utilizzata quando una scelta comporta uno o pi possibili flussi di esecuzione, essa appare simile all' if-else-if, tuttavia a differenza di questultima pu essere usata solo quando:

Viene valutata una sola variabile: tutte le scelte dipendono da essa. La variabile deve essere un tipo int, short, long o char; Ogni singolo valore della variabile pu controllare una scelta.

Una scelta chiamata default porta allesecuzione di un blocco di istruzioni nel caso in cui il valore assunto dalla variabile non sia contemplato in uno specifico case. L'istruzione switch ha la seguente sintassi:
switch(espressione) { case valore_costante: istruzioni case valore_costante: istruzioni default: istruzioni }

Lo switch ha una esecuzione a cascata: se un case non termina con un break (causa luscita dallo switch), vengono eseguite anche le istruzioni che fanno parte del case successivo, ci utile quando deve essere eseguito lo stesso insieme di istruzioni in pi casi.

Es. 5
#include <stdio.h> int main() { int scelta; printf("introduci un numero tra 1 e 5:\t"); scanf("%d",&scelta); switch(scelta) { case 1: case 2: case 3: printf("Il numero tra zero e tre");break; case 4: printf("Il valore e' quattro.\n"); break; case 5: printf( "Il valore e' cinque.\n"); break; default: printf( "Valore non consentito!\n"); break; } return 0; }

22

INGEGNERIA MECCANICA (L-Z) FONDAMENTI di INFORMATICA

Dr.Ing. Donato Impedovo

Es. 6
riscrivere il programma calcolatrice dellesempio 1 utilizzando lo swith-case
#include <stdio.h> int main() { float op1,op2,r; int scelta; printf("Calcolatrice\nInserire il primo operando, op1:\t"); scanf("%f",&op1); printf("Inserire il secondo operando, op2:\t"); scanf("%f",&op2); printf("Scelta dell'operazione:\n1)op1+op2\n2)op1op2\n3)op1*op2\n4)op1/op2\n"); scanf("%d",&scelta); switch(scelta) { case 1: r=op1+op2; printf("Il risultato :%f",r); break; case 2: r=op1-op2; printf("Il risultato :%f",r); break; case 3: r=op1*op2; printf("Il risultato :%f",r); break; case 4: r=op1/op2; printf("Il risultato :%f",r); break; default:printf("Scelta non valida"); break; } return 0; }

23

INGEGNERIA MECCANICA (L-Z) FONDAMENTI di INFORMATICA

Dr.Ing. Donato Impedovo

Istruzioni di ciclo
Le istruzioni di ciclo permettono di eseguire ripetutamente un insieme di istruzioni fino al soddisfacimento di una condizione specifica, in particolare:

il while, controlla la condizione di terminazione allinizio del ciclo; il for, controlla la condizione di terminazione allinizio del ciclo; il do-while, agisce in maniera simile al while, ma assicura l'esecuzione delle istruzioni associate almeno una volta in quanto controlla la condizione al termine di ogni iterazione

While
La sintassi del ciclo while la seguente: while(condizione) { istruzioni } Il while controlla la condizione di terminazione allinizio, se essa verificata allora il corpo del ciclo verr eseguito, altrimenti il controllo passer alla prima istruzione successiva al corpo del ciclo (prima istruzione dopo la parentesi graffa chiusa). Ovviamente si presuppone che le variabili che intervengono nella determinazione della condizione vengano inizializzate al di fuori (prima) del ciclo e successivamente modificate allinterno del ciclo.

Es. 7
acquisire un vettore di 10 elementi interi
#include <stdio.h> void main() { int i=0, A[10]; while (i < 10) { printf("elemento %d: ", i); scanf("%d", &A[i]); i++; } }

24

INGEGNERIA MECCANICA (L-Z) FONDAMENTI di INFORMATICA

Dr.Ing. Donato Impedovo

For
La struttura generale del ciclo for la seguente: for(c1;c2;inc) { istruzioni } dove:
c1: variabile_di_conteggio = valore_iniziale c2: variabile_di_conteggio = valore_finale //determina la condizione di uscita //dal ciclo inc: incremento della variabile di conteggio

In generale il for potrebbe essere sostituito dal ciclo while, tuttavia esso risulta essere pi sintetico e concettualmente corretto quando noto a priori il numero di iterazioni. L'esercizio 7 un tipico caso in cui noto a priori il numero di elementi da acquisire: il costrutto pi indicato quello che utilizza il ciclo for. Si riscriva il programma per esercizio. A titolo esemplificativo si consideri il seguente programma per il calcolo del fattoriale di un numero:
void main() { int val; int j, fact = 1; scanf(%d, &val); for (j = 2; j <= val; j++) fact = fact j; printf(%d,fact); }

Se non viene indicato alcun parametro for(;;) si ottiene un ciclo infinito. Tale ciclo verr interrotto attraverso luso delle istruzioni break o return.

Es. 8
acquisizione matrice 3x3
#include <stdio.h> int main() { float v[3][3]; int i=0,j=0; //i righe - j colonne for (i=0;i<=2;i++) { for(j=0;j<=2;j++) { printf("\nInserisci l'elemento %d,%d\t",i,j); scanf("%f",&v[i][j]); } } // stampa formattata della matrice acquisita for (i=0;i<=2;i++) { for(j=0;j<=2;j++) { printf("%f\t",v[i][j]); }

25

INGEGNERIA MECCANICA (L-Z) FONDAMENTI di INFORMATICA


printf(\n); } }

Dr.Ing. Donato Impedovo

Do - While
Il ciclo do-while parzialmente simile al while, lunica differenza che in questo caso la condizione viene verificata alla fine dellesecuzione delle istruzioni che costituiscono il corpo del ciclo, ci significa che il corpo del ciclo viene eseguito sicuramente almeno una volta. Esso ha la seguente sintassi: do { istruzioni } while(condizione);

Break e Continue
Abbiamo gi visto il significato dell'istruzione break nel caso della istruzione di diramazione switch-case: essa eviti che il controllo del programma passi da un case al successivo. In maniera analoga break causa luscita da un ciclo do-while, while e for, e la successiva esecuzione della prima istruzione esterna al corpo del ciclo. In generale preferibile evitare l'utilizzo del break poich essi rappresentano salti incondizionati e rendono difficile la lettura e comprensione del programma. Break insostituibile nel caso di swith. Listruzione continue ha lo scopo di passare il controllo alliterazione successiva. Essa pu essere utilizzata nei cicli do-while, while e for, mentre non ne consentito lutilizzo allinterno dello switch.

Esercizi di ricapitolazione Es. 9


scrivere un programma che calcoli il fattoriale di un numero #include "stdio.h" main() { int n,f; do{ printf("Inserire il numero di cui si vuole calcolare in fattoriale:\t"); scanf("%d",&n); f=1;

26

INGEGNERIA MECCANICA (L-Z) FONDAMENTI di INFORMATICA


while(n>1) { f*=(n*(n-1)); n=n-2; un overflow? }

Dr.Ing. Donato Impedovo

//A partire da quale valore di n si genera

printf("Il fattoriale di %d : %d\n",n,f); }while(getchar()!=EOF); }

Es. 10
scrivere un programma che acquisisca un vettore di 10 elementi float e ne calcoli la media aritmetica, lelemento massimo e lelemento minimo. #include <stdio.h> #include <math.h> int main() { float v[10],media,min; int i=0; do { printf("Inserire elemento %d:\t",i); scanf("%f",&v[i]); i++; }while(i<=9); //calcolo della media aritmetica i=0; media=0; for(i=0;i<=9;i++) { media =media+v[i]; } media=media/10; printf("\nLa media aritmetica degli elementi del vettore :%f",media); //ricerca elemento minimo i=0; min=v[0]; while (i<9) { i++; if(v[i]<min) min=v[i]; } printf("\nIl valore minimo %f",min); }

Es. 11
scrivere un programma che acquisisca due matrici quadrate e ne calcoli la somma elemento-elemento, ed il prodotto righe per colonne.

27

INGEGNERIA MECCANICA (L-Z) FONDAMENTI di INFORMATICA

Dr.Ing. Donato Impedovo

PUNTATORI
Un puntatore una variabile che contiene il riferimento (indirizzo) ad unaltra variabile. Il puntatore, come ogni altra variabile, deve essere dichiarato: il suo tipo deve essere lo stesso di quello della variabile a cui punta. La dichiarazione di una variabile puntatore ha la seguente sintassi: tipo *nome_puntatore;

Es.
int i; int *p;//p un puntatore ad una variabile di tipo intero

Se vogliamo che il puntatore dichiarato punti ad una determinata variabile, necessario assegnare ad esso lindirizzo di tale variabile. Per svolgere questa operazione si utilizza loperatore &.
p=&i; //p punta alla variabile i, ossia si assegna lindirizzo di i alla //variabile puntatore p

Per assegnare ad una variabile il valore assunto dalla variabile puntata si utilizza loperatore *.
int i, j; int *p; i=3; p=&i; j=*p;//assegna alla variabile j il valore della variabile puntata da p

L'inizializzazione di una variabile puntatore consiste nel farla puntare a massa: p=NULL; Esempio:
int a, b; int *p, *q; b=1; p=&a; *p=b; //a=1 q=p; //anche q punta ad a

28

INGEGNERIA MECCANICA (L-Z) FONDAMENTI di INFORMATICA

Dr.Ing. Donato Impedovo

Es. 1
operazioni con puntatori #include <stdio.h> #include <stdlib.h> main() { int i,j,k; int *p,*t; i=1; j=2; t=NULL; p=NULL; //p e t puntano a massa printf("indirizzo puntato da t: %d\n",t); //%p fa stampare lindirizzo printf("indirizzo puntato da p: %d\n",p); t=&i; p=&j; //t punta ad i, p punta a j printf("valore della var puntata da t: %d\n",(*t)); printf("val della var punt da p: %d\n",(*p)); ++(*p); //incremento il valore della variabile puntata da p printf("valore della variabile puntata da p dopo l'incremento: %d\n",(*p)); k=(*p)+(*t); printf("valore della variabile k: %d\n",k); system("pause"); }

Puntatori e vettori Quando una variabile vettore viene allocata nella memoria centrale di un calcolatore, i suoi elementi occupano celle di memoria contigue. Il nome della variabile vettore altro non che un puntatore al primo elemento del vettore. int A[10]; int *p; p=A; //p punta al primo elemento del vettore *(p+i) A[i] Allindirizzo p si sta aggiungendo un offset pari ad i celle, la dimensione di queste celle dipende dal tipo di dato a cui il puntatore punta.

Es. 2
puntatori e vettori #include <stdio.h> void main() { int A[10],i,*p; float B[10], *f; for(i=0;i<=9;i++) {A[i]=i;//inizializzazione del vettore A} p=A; //p punta al primo elemento del vettore A for(i=0;i<=9;i++) {printf("A[%d]: %d\t",i,A[i]); printf("*(p+%i): %d\n", i, *(p+i)); } for(i=0;i<=9;i++) {B[i]=(float)i/3;//inizializzazione del vettore B

29

INGEGNERIA MECCANICA (L-Z) FONDAMENTI di INFORMATICA


f=B; //p punta al primo elemento del vettore B for(i=0;i<=9;i++) {printf("B[%d]: %f\t",i,B[i]); printf("*(f+%i): %f\n", i, *(f+i)); } }

Dr.Ing. Donato Impedovo

Se i e j sono due puntatori che puntano a 2 elementi diversi di uno stesso vettore, la differenza p-q restituisce il numero di elementi che intercorrono tra essi.

Es. 3
#include <stdio.h> void main() { int A[10],i,*p,*q; for(i=0;i<=9;i++) {A[i]=i;//inizializzazione del vettore A } p=A; //p punta al primo elemento del vettore A q=&A[4]; //q punta al quinto elemento di A printf("&p: %d\n&q: %d\n",&p,&q); //q-p restituisce il numero di elementi che intercorrono tra essi printf("%d\n",i=q-p); printf("in termini di byte: %d", i*sizeof(q)); }

30

INGEGNERIA MECCANICA (L-Z) FONDAMENTI di INFORMATICA

Dr.Ing. Donato Impedovo

FUNZIONI E PROCEDURE
codominio nome(dominio id, dominio id, )

In un programma in linguaggio C oltre alla funzione main(), che deve sempre essere presente, possono essere definite anche altre funzioni. Come avviene in matematica, anche in C le funzioni hanno un dominio ed un codominio che devono essere specificati. Le funzioni che si intende realizzare vanno dichiarate, tali dichiarazioni vanno poste nellarea delle dichiarazioni globali se si vuole che tali funzioni abbiano una visibilit globale, in oltre tale operazione viene considerata anche appartenente ad un buono stile di programmazione in linguaggio ANSI C. La dichiarazione di una funzione avviene come segue:
tipo nome_funzione(lista parametri formali);

la lista dei parametri formali richiede per ognuno di essi la specificazione del tipo e lidentificatore
parametri formali: tipo id, tipo id,

tuttavia lidentificativo delle diverse variabili pu essere omesso, pertanto sufficiente indicare il tipo. Ci consentir di poter utilizzare i nomi che si desiderano solo al momento della definizione della funzione, senza dover ricordare i nomi assegnati nella fase di dichiarazione. Dopo essere stata dichiarata una funzione deve essere definita:
tipo nome_funzione(lista parametri formali) { dichiarazioni variabili locali istruzioni return nome_variabile } //header della funzione

Lheader di una funzione simile alla dichiarazione della funzione stessa, esso costituito dal tipo del valore ritornato dalla funzione (codominio), dal nome che la identifica, dalla lista dei parametri con i relativi tipi (dominio) sui quali la funzione opera, nellheader della funzione al momento della sua definizione necessario indicare il nome assegnato ai parametri. Tali parametri vengono detti formali perch essi rappresentano un riferimento simbolico. Nel momento (run time) in cui alla funzione verranno passati dati specifici, questi prenderanno il nome di parametri attuali. In termini pi rigorosi possiamo affermare che dal punto di vista del chiamante, gli argomenti sono parametri attuali, mentre dal punto di vista del chiamato gli argomenti sono parametri formali. E' necessario che i tipi dei parametri attuali coincidano con quelli dei corrispondenti parametri formali. Le funzioni possono avere un numero qualsiasi di argomenti. La parte eseguibile di una funzione termina conlistruzione return seguita dal nome della variabile che si vuole restituire al chiamante. E' possibile ritornare una sola variabile. In una funzione possono essere presenti pi istruzioni di return, verr eseguita solo la prima che si incontra durante lesecuzione, la funzione termina ed il controllo torna al chiamante. Linsieme dei tipi dei parametri formali definisce il dominio della funzione, mentre il tipo della variabile ritornata ne definisce il codominio. In alcuni tipi di applicazioni non detto che si necessiti di una funzione che restituisca un valore alla funzione chiamante, ad esempio potremmo considerare una porzione di codice il cui scopo la stampa a video di una particolare interfaccia, in tale caso possiamo definire una procedura. La dichiarazione e la definizione di una procedura simile a quanto gi visto per le funzioni, con 31

INGEGNERIA MECCANICA (L-Z) FONDAMENTI di INFORMATICA

Dr.Ing. Donato Impedovo

lunica nota di indicare come codominio il tipo void: esso indica che non viene restituito nessun valore al chiamante.

Passaggio dei parametri


I parametri ricevuti in ingresso da una funzione o procedura, possono essergli passati dal chiamante per valore o per indirizzo.

Passaggio dei parametri per valore


Il chiamante trasferisce alla funzione chiamata il valore dei dati su cui operare per mezzo di variabili temporanee, ci implica che la funzione chiamata non ha la possibilit di modificare il contenuto delle variabili passatele in quanto lavora su delle copie. E' indispensabile che i tipi dei parametri attuali coincidano con quelli dei corrispondenti paprametri formali.

Es. 4
passaggio parametri per valore #include <stdio.h> float prodotto(float x,float y); //equivalente a float prodotto(float,float) void main() { float i,j,r; scanf("%f",&i); scanf("%f",&j); r=prodotto(i,j); printf("%f",r); } float prodotto(float x,float y) { float z; z = x*y; return z; }

Es. 5
fattoriale passaggio per valore #include <stdio.h> #include <stdlib.h> int fatt(int); main() { int n,f; scanf("%d",&n);

32

INGEGNERIA MECCANICA (L-Z) FONDAMENTI di INFORMATICA


f=fatt(n); printf("Il fattoriale di %d %d", n,f); //la variabile n non' stata modificata system("pause"); } int fatt(int num) { int res=1; while(num>1) { res*=(num*(num-1)); num=num-2; } return res; }

Dr.Ing. Donato Impedovo

E importante osservare che sono state utilizzate solo variabili locali, pertanto il contenuto delle variabili del chiamante non pu essere in alcun caso modificato dal chiamato.

Passaggio dei parametri per indirizzo


Il passaggio dei parametri per indirizzo consiste nel trasferire alla funzione chiamata lindirizzo della cella di memoria che contiene la variabile sulla quale operare. Per poter realizzare tale tipo di passaggio dei parametri necessario utilizzare i puntatori.

Es. 6
passaggio parametri per indirizzo #include <stdio.h> int somma(int *x, int *y); //equivalente a somma(int*, int*); void main() { int ris,i,j; scanf("%d",&i); scanf("%d",&j); ris=somma(&i,&j); printf("%d",ris); } int somma(int *x,int *y) { int risultato; risultato= (*x)+(*y); return risultato; }

Tramite luso del passaggio dei parametri per indirizzo possiamo intercambiare luso di funzioni e procedure. Lesempio seguente mostra come la funzione dellesempio precedente pu essere trasformata in procedura: 33

INGEGNERIA MECCANICA (L-Z) FONDAMENTI di INFORMATICA

Dr.Ing. Donato Impedovo

Es. 7
trasformazione di funzione in procedura #include <stdio.h> void somma(int *op1,int *op2, int *ris); void main() { int r,i,j; scanf("%d",&i); scanf("%d",&j); somma(&i,&j,&r); printf("%d",r); } void somma(int *x,int *y, int *ris) { *ris = (*x)+(*y); }

Es. 8
scrivere un programma che mediante luso di una funzione o procedura inverta (swap) i valori assegnati a due variabili di tipo intero. #include <stdio.h> void swap(int*, int*); int main() { int x = -1,y = 1; printf("x=%d\ty=%d\n",x,y); swap(&x,&y); printf("x=%d\ty=%d\n",x,y); } void swap(int *v1,int *v2) { int tmp; tmp=*v1; *v1=*v2; *v2=tmp; }

Es. 9
scrivere un programma che calcoli in una unica funzione o procedura la somma e il prodotto di due operandi e li restituisca al chiamante.

34

INGEGNERIA MECCANICA (L-Z) FONDAMENTI di INFORMATICA

Dr.Ing. Donato Impedovo

PUNTATORI E STRUTTURE
Per accedere ai diversi campi di una struttura abbiamo utilizzato la dot notation. Nel caso in cui definiamo una struttura e ci troviamo nella situazione di voler passare una variabile di tale tipo ad una funzione o procedura, si rende necessario dichiarare un puntatore a tale stuttura, assegnare a tale puntatore lindirizzo della variabile struttura in oggetto e realizzare un passaggio per indirizzo. Per accedere ai diversi campi della struttura utilizzeremo gli operatori * -> e la dot notation.

Es. 10
puntatori e strutture #include <stdio.h> typedef char string[80]; typedef struct { int giorno; int mese; int anno;}data; typedef struct { string nome; string cognome; data birth; }personale; void inserisci_info(personale *p); void stampa_info(personale *p); void main() {personale x; inserisci_info(&x); stampa_info(&x); } void inserisci_info(personale *p) { printf("\nIntroduci il nome: ");scanf("%s",&(p->nome)); printf("\nIntroduci il cognome: ");scanf("%s",&(p->cognome)); printf("\nIntroduci il giorno: ");scanf("%d",&(p->birth.giorno)); printf("\nIntroduci il mese: ");scanf("%d",&(p->birth.mese)); printf("\nIntroduci l'anno: ");scanf("%d",&(p->birth.anno)); } void stampa_info(personale *p) { printf("\n%s %s\nNato il: %d/%d/%d",p->nome,p->cognome,p->birth.giorno,p>birth.mese,p->birth.anno); }

35

INGEGNERIA MECCANICA (L-Z) FONDAMENTI di INFORMATICA

Dr.Ing. Donato Impedovo

MEMORIA HEAP
Fino ad ora abbiamo sempre dovuto dicharare a priori le variabili di cui avevamo bisogno, ad esempio nel caso di un vettore abbiamo specificato il numero di elementi di cui esso si compone. Non detto che in tutte le applicazioni sia noto a priori il numero di variabili necessarie, pertanto potrebbe occorre, durante lesecuzione del programma stesso, allocare dinamicamente dello spazio di memoria. La memoria heap quello spazio di memoria associata ad un programma riservata alle variabili dichiarate dinamicamente. In C lallocazione e il rilascio dinamico di memoria avviene attraverso luso di due funzioni definite nella libreria stdlib.h, esse sono: malloc: utilizzata per lallocazione es: se p un puntatore ad un determinato tipo p=(tipo *)malloc(sizeof(tipo)); la malloc restituisce un puntatore ad un blocco di memoria di dimensioni tali da poter contenere una variabile del tipo specificato, oppure NULL se lo spazio non pu essere allocato. free: per liberare la memoria precedentemente allocata free(p);

Es. 11
#include <stdio.h> #include <stdlib.h> main() { int num, dim, *v, i; printf("indicare il numero di elementi del vettore: "); scanf("%d",&num); v = (int *)malloc(sizeof(int)*num); //allocazione memoria dim=sizeof(int)*num; printf("Il numero complessivo di bytes allocati %d\n", dim); for(i=0; i<num; i++) {v[i] = i; printf("%d ", v[i]); } free(v); //rilascio memoria system("pause"); }

Es. 12
//calcolo del fattoriale con ricorsione #include <stdio.h> int fatt(int);

36

INGEGNERIA MECCANICA (L-Z) FONDAMENTI di INFORMATICA


void main() { int num=5,ris; ris=fatt(num); printf("%d",ris); } int fatt(int num) { int r; if(num==0) r=1; else r=num*fatt(num-1); return r; }

Dr.Ing. Donato Impedovo

37