1

Dispense su:

Linguaggio di programmazione C

a cura di Angela Scaringella e Sofia Bochicchio

2

Prefazione Questa dispensa costituisce il testo di riferimento, in aggiunta agli argomenti trattati nel libro di testo, per la preparazione all’esame di base di Informatica, sia per gli studenti di Sociologia Nuovo Ordinamento, sia per gli studenti di Goru, sia per gli studenti di Sociologia Vecchio Ordinamento. Si tratta di una introduzione elementare al linguaggio C che riporta le lezioni e le esercitazioni tenute durante il corso. E’ destinata soprattutto agli studenti che non hanno potuto frequentare il corso e permette di acquisire gli elementi iniziali della programmazione che sono richiesti per sostenere l’esame. Introduzione I linguaggi di programmazione sono alla base dell’Informatica, perché consentono di generare il software, sia quello di base (sistemi operativi), sia quello applicativo utilizzato nei vari aspetti dell’elaborazione di dati, come ad esempio operazioni eseguite da un programma, sequenze di passi eseguiti da una macchina per l’automazione di processi produttivi, controlli e protocolli di telecomunicazione, le interfacce utente, raccolta di dati da Internet, ecc. I linguaggi di programmazione occupano una posizione intermedia tra il linguaggio naturale (tipicamente inglese), comprensibile dalle persone, e quello binario (composto da sequenze delle sole cifre 0 e 1), comprensibili solo dal computer, l'unico linguaggio che pilota direttamente le unità fisiche dell'elaboratore (memoria centrale e cpu). Il linguaggio C, come qualsiasi altro linguaggio di programmazione (confrontare il Cap. 10 del libro di testo), si compone di parole e regole; le prime generate da un dato alfabeto o simboli secondo un metodo prefissato, le seconde costituiscono la portante grammaticale e sintattica del linguaggio che consente di aggregare le parole per formare frasi di senso compiuto, cioè ammissibili. I linguaggi di programmazione sono costituiti da un alfabeto, da una sintassi e da una semantica. La sintassi riguarda l’insieme di regole che devono essere rispettate per scrivere programmi corretti. Il linguaggio dei programmi C è costituito da tutte le stringhe (insiemi di caratteri o simboli) che soddisfano la proprietà di poter essere analizzate da un compilatore C, senza che venga rilevato alcun errore sintattico. La costruzione delle stringhe avviene secondo una metodologia che, in informatica è nota con il nome “Grammatiche formali”. Una grammatica formale (come introdotta da Chomsky) è un sistema che comprende: • variabili terminali, • variabili, • un insieme di regole di produzione e • un insieme di assiomi. La grammatica permette di operare su stringhe di simboli attraverso le regole di produzione che fanno passare da una stringa ad un’altra a partire dagli assiomi. Il linguaggio generato dalla grammatica è l’insieme di stringhe composte solo da variabili terminali che si possono ottenere a partire dagli assiomi operando con le regole di produzione. In seguito, ogni argomento introdotto è supportato da esempi e da esercizi svolti.

3

Relazione tra i linguaggi di programmazione e il concetto di algoritmo Si richiama il concetto di algoritmo e dalla sua rappresentazione mediante i diagrammi di flusso, questo ci permetterà di gettare una buona base sulla logica sottostante ai linguaggi di programmazione (confrontare il Cap. 1 del libro di testo). I computer, conosciuti anche con il nome di elaboratori elettronici o calcolatori o sistemi di elaborazione dati, sono strumenti d’ausilio alla risoluzione di una vasta gamma di problemi (non tutti!!, cfr cap.1, par. 1.4 del libro di testo) ed hanno la caratteristica di svolgere un gran numero di operazioni in maniera rapida e corretta. Questa capacità deriva dal fatto che sono macchine programmabili e cioè che accettano istruzioni e comandi imposti dall’uomo secondo modalità ben precise. I linguaggi di programmazione permettono di tradurre algoritmi interpretabili da un sistema di elaborazione. Un algoritmo scritto in un linguaggio di programmazione viene chiamato programma e il processo di scrittura del programma, a partire dall’algoritmo, viene chiamato codifica. Svolgere un’attività di programmazione (o, brevemente, programmare) significa quindi scrivere programmi che risolvano problemi destinati ad essere eseguiti in maniera automatica su un calcolatore. In generale, è necessario definire il problema nel modo più preciso possibile: tanto più precisa sarà la sua descrizione, tanto più facile risulterà scrivere il programma che lo risolve. E’ necessario quindi specificare in maniera rigorosa i dati noti e i risultati attesi. Esempio: Dato un importo, denominato imponibile, si deve calcolare un secondo importo, denominato lordo, derivante dall’applicazione dell’IVA al 20%. Di seguito è riportata la soluzione:

1. Si esegue la moltiplicazione imponibile*20; 2. La cifra ottenuta al passo 1 si divide per 100; 3. Il risultato cercato è dato dalla somma della cifra ottenuta al passo 2 con il valore

imponibile. Dati iniziali: imponibile e aliquota IVA; risultato atteso: importo lordo. Si osservi che, dato un qualsiasi problema, i dati iniziali vengono sempre trasformati (o meglio,elaborati) al fine di produrre il risultato. Inoltre, con l’elencazione dei 3 passi precedenti, abbiamo dato origine ad un algoritmo. Si richiama la definizione di algoritmo:

a) E’ una successione finita di azioni, o passi, che determinano la risoluzione di un problema. Si intuisce che, dati due algoritmi che risolvono lo stesso problema, viene preferito quello col minor numero di passi.

b) Le azioni specificate devono essere univocamente interpretabili ovvero devono essere comprensibili senza ambiguità da colui che le esegue (solitamente un computer).

c) Se la successione di azioni viene ripetuta in momenti diversi ma con gli stessi dati iniziali, allora deve essere restituito sempre lo stesso risultato; si dice che l’algoritmo deve essere non casuale.

d) In ogni istante, la prossima azione da intraprendere deve essere univocamente determinabile a partire dall’analisi del valore di particolari dati.

Esistono vari modi di rappresentare un algoritmo e precisamente:

- in forma discorsiva per punti (elenco di passi); - mediante uno pseudo-linguaggio di programmazione; - in forma grafica (diagramma a blocchi ) utilizzando simboli standard.

4

Esempio_1 : Consideriamo un gioco con un dado: “una volta lanciato un dado, il giocatore vince solo se è uscito un numero n maggiore di 3, altrimenti perde. In caso di vincita verrà pagato un premio di euro 5*n ”. - In termini di algoritmo si ha la seguente successione di passi elementari:

1. Calcola un numero naturale n tra 1 e 6; 2. Se n appartiene all’insieme {1,2,3} allora vai al passo 4; 3. n appartiene all’insieme {4,5,6} ed è stata vinta la somma di euro 5*n; 4. Il gioco è terminato.

- In pseudo-codice (simile al linguaggio Pascal) : program Gioco Con Dado: begin {inizio dell’algoritmo} n:=CalcolaUnNumeroNaturaleTra1e6: if n>=4 then {è uscito un numero maggiore di 3} begin premio:=n*5{calcola il premio vinto} end end {fine dell’algoritmo} - Per la forma grafica dobbiamo introdurre i simboli fondamentali dell’algoritmo. La struttura logica della soluzione di un problema può essere visualizzata mediante un diagramma a blocchi (diagramma di flusso). Simbolo terminale (Inizio e Fine) Simbolo di ingresso (Input) Simbolo di annotazione (Commento) Simbolo di collegamento

*

5

Simbolo di elaborazione (Processo)

Simbolo di decisione (il computer può decidere solo se vero o falso)

Tornando all’ esempio_1, possiamo così graficamente rappresentare lo sviluppo dell’algoritmo:

Vediamo subito un altro esempio per chiarire alcuni punti.

Hai vinto n*5 euro!

n >= 4 ?

Estrai n

Inizio

si

no

Fine gioco

6

Esempio_2: “Uno studente immette il suo voto: se il voto è uguale o superiore a 18 lo studente viene promosso, se è minore di 18 viene bocciato”.

Da notare che non abbiamo dovuto specificare, con un altro controllo, se il voto fosse minore di 18. Se volessimo inserire più voti ? Mettiamo il caso che: “uno studente inserisca 3 voti e che voglia trovare la media.” Esempio_3:

Bocciato Fine

no

Inizio

voto>=18

Promosso Si

Leggi voto

7

Questa è la logica lineare da seguire se si vuole sviluppare un algoritmo, ora siamo pronti per introdurre la storia del linguaggio C.

LE BASI DELL’AMBIENTE C Il C e' stato progettato da Dennis Ritchie su UNIX, e discende dal B, ideato nel 1970 da Ken Thompson, e il B a sua volta discende dal BCPL, sviluppato da Martin Richards. Nel 1983 l'Istituto Nazionale Americano per gli Standard (ANSI) ha iniziato una standardizzazione del C, terminata nel 1989 con la definizione dell'ANSI C, che differisce di poco dal C di K&R (Kernigan & Ritchie). In seguito e' stato aggiornato secondo la filosofia della programmazione orientata agli oggetti, in questo caso si parla di C++, e il suffisso dei file solitamente e'.CPP. Il C consente la gestione di bit, byte e indirizzi di memoria, a differenza di altri linguaggi di alto livello come basic e pascal, per questo alle volte e' definito un linguaggio di medio livello, ossia piu' vicino al basso livello, ossia all'assembler. Tra l'altro ha solo 32 parole chiave, ben poche al confronto del basic, che ne ha solitamente piu' di 150. Inoltre il C e' un linguaggio portabile, ossia un listato scritto in ANSI C puo' essere compilato su ogni compilatore standard di ogni sistema operativo. I compilatori C richiedono un listato scritto in formato testo, che si puo' scrivere con un editor qualsiasi o con quello integrato nel compilatore. Il file di testo del programma, che di solito ha come suffisso “.c” e viene chiamato “programma sorgente”, viene compilato, cioè tradotto e

Inizio

Leggi voto

somma=0; voto; voti ins=0;

voti_ins = voti_ins + 1

Media = somma / 3

Fine

voti_ins < 3?

somma= somma + voto

no

si

8

trasformato in un nuovo file chiamato “programma oggetto” (o modulo), per distinguerli l’uno dall’altro, il programma trasformato e reso comprensibile solo alla macchina assume un nuovo nome cui bisogna assegnare il suffisso .OBJ. Tutti i sistemi C consistono generalmente di tre parti: l’ambiente, il linguaggio e la libreria standard del C. I programmi scritti in C passano tipicamente attraverso 6 fasi, prima di essere eseguiti. Queste sono: editare, preelaborare, compilare, linkare (collegare), caricare ed eseguire. La prima fase consiste nella scrittura del codice (editing) in un file: questa si esegue con un programma chiamato editor. Il programmatore scrive un programma in C con l’editor e, se necessario, eseguirà delle correzioni. Il programma sarà quindi immagazzinato in un dispositivo di memoria di massa, come un disco. Il nome del file del programma C dovrà terminare con l’estensione .c. Ad esempio il blocco note, il “vi” e l’emacs sono editor largamente utilizzati sui sistemi windows e UNIX. In seguito, il programmatore immetterà il comando di compilazione del programma. Il compilatore tradurrà il programma C nel codice di un linguaggio macchina (detto anche codice oggetto). In un sistema C, prima che incominci la fase di traduzione, sarà eseguito automaticamente il programma preprocessore. Il preprocessore del C obbedisce a comandi speciali, chiamati direttive del preprocessore, con le quali si indica che sul programma dovranno essere eseguite determinate manipolazioni,prima della compilazione vera e propria. Tali manipolazioni consistono generalmente nella inclusione di altri file in quello da compilare,e nella sostituzione di simboli speciali con un testo del programma. La quarta fase è chiamata linking (collegamento). I programmi scritti in C contengono tipicamente dei riferimenti a funzioni definite altrove,per esempi nelle librerie standard o in quelle di un gruppo di programmatori che lavorano su un particolare progetto. Di conseguenza, il codice oggetto prodotto dal compilatore conterrà tipicamente dei “buchi” dovuti a queste parti mancanti. Il linker collega il codice oggetto con quello delle funzioni mancanti per produrre una immagine eseguibile (senza pezzi mancanti). La fase quinta è chiamata caricamento. Prima che possa essere eseguito,un programma dovrà essere caricato nella memoria. Questa operazione sarà eseguita dal loader (caricatore) che prenderà l’immagine eseguibile dal disco e la trasferirà nella memoria. Finalmente, sotto il controllo della sua CPU, il computer eseguirà il programma, una istruzione per volta. Quando si scrive il codice è buona abitudine indentarlo, ovvero, ad ogni istruzione si va a capo e si lascia una tabulazione orizzontale, questo permette al programmatore una più chiara lettura di quello che si sta facendo; per commentare più righe si usano i simboli: /* (Slash asterisco), per aprire il commento, e */ (asterisco slash) per chiudere; // doppio slash per commentare una sola riga. Vediamo subito un programma che visualizzi "Buon giorno!" sullo schermo: #include <stdio.h> /* Include la libreria standard, che non e' altro che un file di testo con delle strutture e macro predefinite. Questi file sono detti Header, infatti terminano con il suffisso .h */ main( ) /* Definiamo la funzione main, che non riceve nessun valore come argomento. Il programma iniziera' l'esecuzione a partire da questa funzione, che deve essere presente in ogni programma */ { /* Le istruzioni della funzione sono racchiuse tra aperta e chiusa parentesi graffa */

9

printf(“Buon giorno!\n”); /* Chiamiamo la funzione di libreria printf che si occupa di ,visualizzare sullo schermo. Da notare che \n indica il newLine, ossia serve per andare a capo. Fondamentale: ogni istruzione termina con ; punto e virgola/ } /* chiudiamo la funzione principale main( ) */ In questo programma si notano già degli accorgimenti fondamentali. Innanzitutto la funzione main(), è la funzione principale, viene eseguita per prima ed è sempre presente in ogni programma. Inoltre si nota che gli argomenti da passare alle funzioni vanno messi tra le parentesi ( ) che si trovano dopo il nome della funzione stessa. Nel caso di main( ), non viene messo alcun argomento, infatti non richiede argomenti. La parentesi graffa aperta { apre il corpo di ogni funzione , la parentesi graffa chiusa } la chiude. La porzione di programma racchiusa in esse è anche detta blocco. Quando si chiama la funzione printf( ) della libreria <stdio.h> immettiamo come argomento il testo da stampare tra “ ” (doppi apici ), come vuole la sua sintassi. All'interno della stringa di caratteri abbiamo la sequenza di escape \n, che equivale al carattere newline, posiziona il cursore all’inizio della riga successiva. Sono disponibili altri caratteri non editabili, ad esempio \t , tabulazione orizzontale, muove il cursore alla tabulazione successiva; \r, ritorno carrello, posiziona il cursore all’inizio della riga corrente; \a, allarme, fa suonare il cicalino del sistema; \\ backslash,visualizza un carattere backslash in una istruzione printf; \’, apice singolo; \” virgolette. Dichiarazione di variabili Gli elementi di base di un programma sono le variabili e le costanti. In C le variabili devono essere dichiarate prima di essere usate e all’inizio del programma. Si possono definire molti tipi di variabili numeriche, ad esempio con int si indicano variabili che possono contenere solo numeri interi, con float variabili che possono contenere numeri con la virgola. Ecco una tabella riassuntiva dei tipi di dati definibili: Tipo Lungh. Range (valori minimi e massimi) unsigned char 8 bits 0 fino 255 char 8 bits -128 "" 127 unsigned int 16 bits 0 "" 65,535 short int 16 bits -32,768 "" 32,767 int 16 bits -32,768 "" 32,767 unsigned long 32 bits 0 "" 4,294,967,295 long 32 bits -2,147,483,648 "" 2,147,483,647 float 32 bits 3.4 * (10**-38) "" 3.4 * (10**+38) double 64 bits 1.7 * (10**-308) "" 1.7 * (10**+308) long double 80 bits 3.4 * (10**-4932) "" 1.1 * (10**+4932)

10

Come si vede i tipi interi (char, int, long) possono essere unsigned, ossia solo positivi, in questo modo contengono il doppio di valori positivi, risparmiandosi di supportare quelli negativi. I tipi a virgola mobile, ossia float, double e long double, sono comunque signed. Se si va fuori del raggio di azione di una variabile, ad esempio se si aggiunge 100 ad una variabile int che vale gia' 32700, il risultato e' -32736! Questo per l'aritmetica in complemento a 2, che per semplificare fa ricominciare dal numero più basso quando si supera quello più alto, dato che non e' segnalato alcun errore e il risultato erroneo può essere usato, attenzione a non far eccedere mai i tipi! Per dichiarare una variabile basta scrivere il tipo seguito dal nome che decidiamo per la variabile stessa, ad esempio: int numero; /*nel caso in cui volessi inserire un numero intero */ float numero; /*nel caso in cui volessi inserire un numero con la virgola */ Nel primo caso abbiamo dichiarato una variabile di tipo intero e di nome numero. Da notare che abbiamo terminato la dichiarazione con un ;. Il nome da dare alla variabile e' a piacere, le uniche limitazioni sono: non può iniziare con un numero, ne con simboli come &,/,!,... , non si possono dare come nomi le parole chiave di comandi del C, come if, else, int, float... Il C è case sensitive, ovvero, le lettere maiuscole e quelle minuscole sono differenti in C, per cui NUMERO e' diverso da Numero o da NumeRO. Le parole chiave come printf() devono essere scritte in minuscolo, e solitamente anche le variabili sono scritte con caratteri minuscoli, nonostante si possano usare anche caratteri maiuscoli. La regola quindi sarebbe di scrivere le variabili a lettere minuscole, e se si vuole si può usare il carattere “_”. Per esempio, si può fare: int numero_1; int prova1_prova; Come assegnare un valore ad una variabile: numero = 1000; abbiamo introdotto l'operatore di assegnamento “ = ”, che assegna il valore ad una variabile. In questo caso abbiamo dato a numero il valore 1000. Da notare che scrivere: numero = 500+500; numero = (250+250)+500; è equivalente, infatti si può mettere anche un’espressione, che sarà risolta in fase di precompilazione, dato che si assegna sempre 1000. A questo punto ci manca di sapere come stampare il valore di una variabile a video con la funzione printf( ). Abbiamo già visto che per stampare un testo normale basta includerlo tra “ ” ,virgolette. Per inserire una variabile nella stringa occorre aggiungere un %d nel punto che ci interessa, e mettere il nome della variabile dopo la chiusura delle “ ”, in questo modo: printf (“Il valore di Numero e' %d.”,numero);

11

Al momento della stampa il %d sarà sostituito dal valore della variabile numero. Da notare la virgola che separa i doppi apici “ ” dalla variabile. La specifica di conversione %d è usata in una stringa di controllo del formato di una funzione printf per indicare che sarà visualizzato un intero, mentre in una stringa di controllo del formato di una funzione scanf per indicare che sarà immesso un intero. La funzione scanf della libreria standard stdio.h è utilizzata per leggere i dati della tastiera. Andiamo ora a semplificare le cose con un esempio: #include<stdio.h> main() { int num1; //dichiarazioni variabili int num2; int somma; num1=5; //inizializzazione num2=0; somma=0; printf(“Inserisci un numero:\n”); //prompt scanf(“%d”, &num2); /* legge un intero, il valore digitato sarà immesso nella posizione di memoria alla quale il nome num2 è stato assegnato */ somma=num1+num2; //assegnamento dell’addizione alla somma printf(“La somma del numero inserito da tastiera e del numero dato dal computer è : %d”,somma); //visualizza la somma return ; /* indica che il programma è terminato con successo */ } L’istruzione scanf (“%d”,&num2); utilizza scanf per ottenere un valore dall’utente. La funzione scanf prende i dati in ingresso dallo standard input che è di solito la tastiera. Questa scanf ha due argomenti: “%d” e &num2. Il primo argomento, la stringa di controllo del formato, indica il tipo di dato che dovrà essere immesso dall’utente. La specifica di conversione %d indica che il dato dovrà essere un intero ( d sta per intero decimale). Il secondo argomento incomincia con una E commerciale &, detta in C operatore di indirizzo, seguita dal nome della variabile. La E commerciale, o ampersand, quando è combinata con il nome della variabile , indica alla scanf la locazione di memoria in cui è immagazzinata la variabile num2. Il computer quindi immagazzinerà il valore della variabile num2 in quella locazione. Ogni qualvolta un valore è sistemato in una posizione di memoria, esso si sostituisce al valore contenuto in precedenza in quella locazione. Dato che questa informazione precedente sarà distrutta, il processo di scrittura in una locazione di memoria è detto scrittura distruttiva. Così come abbiamo visto per la variabile somma, prima inizializzata a 0 e poi sostituita dal valore dato dalla somma di num1 e num2. Quando il valore sarà letto da una locazione di memoria, il valore in quella locazione sarà preservato, questo processo è detto lettura non distruttiva. Per semplicità, immaginate la locazione della memoria come un cassettone, ad ogni cassetto (la dimensione dipende dal tipo della variabile) corrisponde un nome, all’interno troveremo il nostro valore. E’ buona abitudine inizializzare a 0 la variabile (come se volessimo ripulire il cassetto) per evitare risultati poco probabili durante l’esecuzione.

12

L’istruzione return 0; restituisce il valore 0 all’ambiente del sistema operativo in cui il programma è stato eseguito. In questa tabella sono riportate le specifiche di conversione per printf e scanf: Specifiche di conversione Tipi di dato per printf per scanf long double %Lf %Lf double %f %lf float %f %f unsigned long int %lu %lu long int %ld %ld unsigned int %u %u int %d %d short %hd %hd char %c %c L’aritmetica del C Gli operatori aritmetici sono: Operazione Operatore Ordine di valutazione (priorità) Parentesi ( ) Sono valutate per prime Moltiplicazione * Sono valutate per seconde Divisione / Sono valutate per seconde Modulo % Resto di una divisione intera. Sono valutate per seconde Addizione + Sono valutate per ultime Sottrazione - Sono valutate per ultime Gli operatori di uguaglianza e relazionali: Operatori di uguaglianza == uguale != diverso (not uguale) Operatori relazionali > maggiore < minore >= maggiore o uguale <= minore o uguale

13

Tutti questi operatori, a eccezione di quello di assegnamento =, associano da sinistra a destra. L’operatore di assegnamento associa da destra a sinistra. Es.: somma = num1 + num2 ; Gli operatori di assegnamento Il C fornisce diversi operatori di assegnamento per abbreviare le relative espressioni. Per esempio l’istruzione a=a+b; può essere abbreviata con l’operazione di assegnamento addizione += come in: a+=b; L’operatore += aggiunge il valore dell’espressione alla destra dell’operatore alla variabile alla sua sinistra, immagazzinando il risultato in quest’ultima.

+= Addiziona - = Sottrae * = Moltiplica / = Divide %= Da il resto

Gli operatori logici Gli operatori logici dell’algebra booleana (confronta Cap. 3 del libro di testo, par. 3.2) possono essere utilizzati per formare condizioni più complesse, combinando quelle semplici. Questi sono: && ( AND logico), || (OR logico) e ! (NOT logico detto anche negazione logica). (condizione 1) && (condizione 2) , la condizione sarà vera se e solo se entrambe le condizioni semplici saranno vere. (condizione 1) || (condizione 2) , la condizione sarà vera se una o entrambe le condizioni semplici saranno vere. Gli operatori di incremento ++ e di decremento - - Il C fornisce anche l’operatore di incremento ++ unario e l’operatore di decremento – unario. Quindi, qualora volessi incrementare di 1 una variabile, anziché scrivere: a= a+1 o a+=1 Si può scrivere a++ ++a Incrementa la variabile a di 1 e quindi utilizza il nuovo valore di a nell’espressione in cui essa occorre. a++ Utilizza il valore corrente di a nell’espressione in cui essa occorre e quindi incrementa a di 1. --a Decrementa a di 1 e quindi utilizza il nuovo valore di a nell’espressione in cui essa occorre. a-- Utilizza il valore corrente di a nell’espressione in cui essa occorre e quindi decrementa a di 1. Quando gli operatori di incremento o di decremento sono sistemati prima di una variabile, si dicono rispettivamente operatori di preincremento o di predecremento. Quando sono sistemanti dopo una variabile, si dicono rispettivamente operatori di postincremento o di postdecremento.

14

vero

falso

STRUTTURE DI CONTROLLO La maggior parte dei programmi richiede delle iterazioni o cicli. Un ciclo (loop) è un gruppo di istruzioni che il computer eseguirà ripetutamente, finché una certa condizione di continuazione del ciclo rimarrà vera. Tutti i programmi possono essere scritti in termini di tre sole strutture di controllo: la struttura di sequenza, la struttura di selezione, e la struttura di iterazione. Queste strutture di controllo con un ingresso e una uscita singoli semplificano la costruzione dei programmi. Le strutture di controllo possono essere attaccate l’una all’altra, collegando il punto di uscita di una di esse con quello di entrata con una successiva: accatastamento delle strutture di controllo; oppure possono essere innestate: nidificazione delle strutture di controllo. Strutture di sequenza: le istruzioni sono eseguite nell’ordine in cui sono state scritte. Strutture di selezione: sono di tre tipi: - IF , nel caso in cui una condizione sia vera eseguirà una certa azione, mentre la ignorerà nel caso sia falsa. Chiamata struttura di selezione singola. - IF/ELSE , nel caso in cui una condizione sia vera eseguirà una certa azione, nel caso in cui sia falsa eseguirà un’altra differente azione. Detta struttura di selezione doppia. - SWITCH , sceglierà ed eseguirà una tra tante differenti azioni secondo il valore assunto da una data espressione. Consiste di una serie di etichette case (caso) e di un caso opzionale default. Detta struttura di selezione multipla. Strutture di iterazione: sono di tre tipi: - WHILE , consente al programmatore di specificare che una azione dovrà essere ripetuta finchè alcune condizioni rimarranno vere. - DO/WHILE , stesso controllo del WHILE fatto però dopo aver eseguito almeno una volta il corpo del loop (ciclo). - FOR , gestisce automaticamente tutti i dettagli di una iterazione controllata da un contatore. Utilizziamo ora i diagrammi di flusso per visualizzare il funzionamento delle strutture di sequenza, selezione e ripetizione con un ingresso e una uscita singoli . Sequenza Selezione Struttura if (selezione singola)

15

Struttura if/else (selezione doppia)

Struttura switch (selezione multipla)

vero

vero

f

f

vero falso

f

vero

16

Iterazione Struttura do/while

Struttura while

f

vero

vero

f

17

Struttura for

Vediamo due tipi di iterazione: • L’iterazione controllata da un contatore; • L’iterazione controllata da un valore sentinella. L’iterazione controllata da un contatore è detta a volte iterazione definita, perchè conosciamo esattamente in anticipo il numero di volte che il ciclo sarà eseguito. L’iterazione controllata da un valore sentinella è detta a volte iterazione indefinita, perché non è noto in anticipo il numero di volte che il ciclo sarà eseguito. I valori sentinella sono utilizzati per controllare una iterazione quando il numero preciso delle iterazioni non è noto in anticipo e il ciclo include delle istruzioni che otterranno dei dati ogni volta che quest’ultimo sarà eseguito. Il valore sentinella indica la “fine dei dati” e sarà immesso dall’utente dopo che tutti i veri elementi informativi saranno stati forniti dal programma. Nella iterazione controllata da un contatore, è utilizzata una variabile di controllo per contare il numero delle iterazioni. La variabile di controllo sarà incrementata (di solito di 1) ogni volta che sarà eseguito il gruppo di istruzioni. Il ciclo terminerà quando il valore della variabile di controllo indicherà che sarà stato eseguito il numero corretto di iterazioni; a quel punto, il computer potrà continuare con l’istruzione successiva alla struttura di controllo. Una iterazione controllata da un contatore richiede: il nome di una variabile di controllo; il valore iniziale della stessa; l’incremento (o decremento) con cui la variabile di controllo sarà modificata ogni volta nel corso del ciclo; la condizione che verificherà il valore finale della variabile di controllo (ovverosia, quella che determinerà se il ciclo dovrà continuare).

vero

f

18

Esempio_4 Iterazione controllata da un contatore (while): #include<stdio.h> main( ) { int contatore = 1; /* dichiarazione e inizializzazione, posso dargli un qualsiasi nome e valore */ while ( contatore < = 10 ) // condizione di iterazione { printf (“%d Buon giorno!\n”,contatore); contatore++; // incremento } return ; } Questo programma conta quante volte ( 10 nel nostro esempio) ho richiamato la funzione printf e ripete la frase : Buon giorno! ogni volta. La condizione di iterazione la posso prendere dall’esterno del programma e quindi richiederla all’utente e memorizzarla in una variabile d’appoggio. Vedremo come nel prossimo esempio. La struttura di iterazione for gestisce automaticamente tutti i dettagli di una iterazione controllata da un contatore. Riscriviamo il programma dell’esempio_4 con il for aggiungendo anche una variabile d’appoggio: Esempio_5 (for): include<stdio.h> main( ) { int i ; // contatore int appoggio = 0; // variabile d’appoggio printf (“Digita quante volte vuoi ripetere la frase Buon giorno: ”); scanf (“%d”,&appoggio); /* inizializazione, condizione di iterazione e incremento sono tutti inclusi nella intestazione della struttura for */ for (i=1; i <= appoggio; i++) { printf (“%d Buon giorno\n”,i ); } return ; }

19

Proseguiamo con altri esempi sulle strutture di controllo. Esempio_6 (if/else): “Inserire un numero e vedere se è pari o dispari.” #include<stdio.h> void main(void) /* void sta a significare che la funzione main non riceve e non restituisce alcun valore, come abbiamo già visto, si può omettere */ { int numero; // dichiaro variabile printf("Inserisci un numero:\n"); // visualizzo su schermo scanf("%d",&numero); // leggo numero if(numero%2==0) // condizione printf("Il numero inserito è pari"); else printf("Il numero inserito è dispari"); } Esempio_7 (if/else if/else): “Inserire un voto. Se il voto dello studente è >= 90 visualizza "a", altrimenti se il voto è >= 80 visualizza "b", altrimenti se il voto è >= 70 visualizza "c", altrimenti visualizza "d".” #include<stdio.h> void main(void) { int voto; printf("Inserisci voto: "); scanf("%d",&voto); if(voto>=90) /* if appeso */ printf("\n a"); /* costruzione annidata */ else if (voto>=80) /* avendo una sola istruzione printf("\n b"); non ha bisogno delle parentesi graffe*/ else if(voto>=70) printf("\n c"); else printf("\n d"); }

20

Esempio_8 (while/if/else): “ Inserisci un numero e vedere se è un numero primo.” #include<stdio.h> void main (void) { int num, i=2, div=0; // posso dichiarare ed inizializzare più variabili insieme printf("Inserisci un numero:\n"); scanf("%d",&num); while(i<num) // due strutture di controllo l’una dentro l’altra { if(num%i==0) { div=div+1; //div++; i=i+1; } else { i++; // uguale a i=i+1 } } if(div==0) printf("\n%d è un numero primo",num); else printf("\n%d non è un numero primo",num); } Esempio_9 (if/while/while): “Scrivere un programma C che legga il lato di un quadrato e lo disegni sullo schermo utilizzando degli "*".Il programma dovrà funzionare con tutti i quadrati con lati compresi tra 1 e 20”. esempio lato: 3 *** *** *** se lato < 1 o lato > 20 visualizzare "errore" #include<stdio.h> void main(void) { int lato,contatore1,contatore2; printf("Inserisci il lato del quadrato: "); scanf("%d",&lato); if((lato>=1) && (lato<=20)) /* && sta per l’operatore and, se entrambe le condizioni sono vere il programma seguita la lettura nella funzione */ { contatore1=0; while(contatore1<lato) { printf("\n*");

21

contatore1++; contatore2=1; while(contatore2<lato) { printf("*"); contatore2++; } } } else printf("\nErrore!"); } Esempio_10 (switch) “Scrivere un programma che calcoli l'area del quadrato, del rettangolo, del triangolo e del cerchio.” #include<stdio.h> void main (void) { int figura; float base, altezza, area, raggio, p=3.14159; printf("Per calcolare l'area del:\n quadrato digita 1\n rettangolo digita 2\n triangolo digita 3\n cerchio digita 4"); printf("\n\n Digita numero: "); scanf("%d",&figura); switch(figura) { case 1: printf("Inserisci base: "); scanf("%f",&base); area=base*base; break; //esce dallo switch case 2: printf("Inserisci base e altezza separati da spazio: "); scanf("%f %f",&base,&altezza); area=base*altezza; break; case 3: printf("Inserisci base e altezza separati da spazio: "); scanf("%f %f",&base,&altezza); area=(base*altezza)/2; break; case 4: printf("Inserisci il raggio: "); scanf("%f",&raggio); area=raggio*raggio*p; break;

22

default: printf("Che ho detto? o 1 o 2 o 3 o 4...Guarda che hai inserito!"); } printf("L'area della figura geometrica che hai scelto è: %.4f ",area); // %.4f mi visualizza un numero float con solo 4 cifre dopo la virgola } Le istruzioni break e continue sono utilizzate per alterare il flusso di controllo. L’istruzione break, qualora sia eseguita in una struttura while, for, do/while o switch, provocherà l’uscita immediata da quella struttura. L’esecuzione del programma continuerà con la prima istruzione successiva alla struttura. L’utilizzo tipico dell’istruzione break è per anticipare l’uscita da un ciclo, oppure per ignorare la parte rimanente di una struttura switch. In assenza del break sarebbero eseguiti insieme tutti i case di una istruzione switch. Qualora non sia stata riscontrata nessuna occorrenza, sarà eseguito il caso default e sarà visualizzato un messaggio di errore. Ogni case può contenere una o più azioni. La struttura switch è differente da tutte le altre strutture, poiché in un case di switch non sono necessarie le parentesi graffe intorno alle azioni multiple. Qualora sia eseguita in una struttura while, for o do/while, l’istruzione continue farà in modo che quelle rimanenti nel corpo della struttura siano ignorate e che sia eseguita l’iterazione successiva del ciclo. Esempio: for ( x=1; x<=10; x++) { if ( x ==5) continue; /* senza parentesi per la if perché contiene un’unica istruzione */ printf (“%d ”,x); } Il risultato sarà: 1 2 3 4 6 7 8 9 10 Se avessi messo break al posto di continue il risultato sarebbe stato: 1 2 3 4 Il C fornisce l’operatore condizionale ( ? : ) che è strettamente correlato con la struttura if/else. Quello condizionale è l’unico operatore ternario del C, in altre parole, accetta tre operandi. Gli operandi, insieme all’operatore condizionale, formano una espressione condizionale. Il primo operando è una condizione, il secondo operando è il valore che assumerà l’intera espressione condizionale, qualora la condizione sia vera, mentre il terzo operando è il valore che assumerà l’intera espressione condizionale, qualora la condizione sia falsa. Per esempio l’istruzione printf printf ( “%s”, voto >= 18 ? “Promosso” : “Bocciato”); contiene un’espressione condizionale che restituirà la stringa letterale Promosso, qualora la condizione voto >= 18 risulti vera, mentre restituirà la stringa letterale Bocciato, qualora la condizione risulti falsa. La specifica di conversione %s serve per visualizzare una stringa di caratteri. I valori in una espressione condizionale possono anche essere delle azioni da eseguire. Otteniamo lo stesso risultato se scriviamo: voto >= 18 ? printf (“Promosso”) : printf (“Bocciato”);

23

LE FUNZIONI Il modo migliore per sviluppare e amministrare un programma corposo è di costruirlo partendo da pezzi più piccoli o moduli ognuno dei quali sia più maneggevole del programma originale. Questa tecnica è detta dividi e conquista (divide et impera). I moduli in C sono chiamati funzioni. Le funzioni possono essere: predefinite, quelle “preconfezionate” disponibili nella libreria standard del C (es. #include<stdio.h> , file già compilato, #include<math.h>,…); o definite dall’utente. Le funzioni sono invocate da una chiamata di funzione. Questa specifica il nome della funzione e fornisce delle informazioni (gli argomenti ) di cui la funzione chiamata ha bisogno. Un capo (la funzione chiamante) chiede a un operaio (la funzione chiamata) di eseguire un compito e tornare indietro a riferire, quando il lavoro sarà stato eseguito. Il prototipo di funzione indica al compilatore il tipo del dato restituito dalla funzione, il numero dei parametri che quella funzione si aspetta di ricevere, il tipo dei parametri e l’ordine in cui questi sono attesi. Il compilatore utilizzerà i prototipi per convalidare le chiamate di funzione. Il formato di una definizione di funzione è: tipo_del_valore_di_ritorno nome_della_funzione (lista_dei_parametri) { dichiarazioni; istruzioni; return; } Esempio_11: “Trovare la radice quadrata di un numero chiesto all’utente. Utilizzare una funzione predefinita contenuta nella libreria matematica.” #include<stdio.h> #include<math.h> /* includo il file di intestazione matematico, utilizzando la direttiva del preprocessore #include<math.h>, quando utilizzo le funzioni della libreria matematica. */ void main (void) { double x=0; printf("Inserisci il valore: "); scanf("%lf",&x); printf("La radice quadrata di %.2f è %.2f",x , sqrt(x)); /* chiamo la funzione all'interno della printf , in alternativa avrei potuto dichiarare un’altra variabile, assegnarle il risultato della radice quadrata e poi visualizzarla a video. */ }

24

Esempio_12: “Trovare il quadrato di un numero chiesto all’utente. Utilizzare una funzione personalizzata.” #include<stdio.h> int funzione_1 (int valore); /* prototipo di funzione. Nel prototipo posso omettere il nome della variabile che vado a passare, avrei potuto scrivere: int funzione_1 (int);*/ main( ) { int numero=0; /* numero e risultato sono variabili locali. int risultato=0; printf("Inserisci un numero:\n"); scanf("%d",&numero); risultato=funzione_1(numero); /*chiamo la funzione passandogli un argomento, la variabile “numero”, il valore intero di ritorno lo assegno alla variabile d’appoggio “risultato” */ printf(" %d elevato al quadrato è %d", numero, risultato); return; } int funzione_1 (int valore) /* Se chiudessi la funzione con ; il programma non leggerebbe il blocco di istruzioni. */ { /* Nota: non ho bisogno di inizializzare la varibile “valore” int num; Potrei utilizzare lo stesso nome della variabile numero, ma è bene capire che sono due variabili distinte! */ num=valore*valore; /* avrei potuto ottimizzare la scrittura del codice con un’unica istruzione: return valore * valore; senza così utilizzare la variabile d’appoggio “num”. */ return num; } Posso scegliere un qualsiasi nome per la funzione. Il prototipo di funzione: int funzione_1 (int valore); sta ad indicare che la funzione_1 riceverà come argomento una variabile di tipo int e che mi restituirà un’altra variabile di tipo int. Se alla funzione non passassi alcun argomento e se non mi restituisse alcun valore scriverei: void funzione_1 (void); Tutte le variabili dichiarate nelle definizioni di funzione sono variabili locali : esse sono note soltanto in quella in cui sono state definite. Quelle dichiarate all’esterno delle funzioni, anche dal main, sono dette variabili globali : sono note a tutto il programma.

25

Esempio_13: Vedo come varia il valore di una variabile utilizzando due diverse funzioni. #include<stdio.h> void funz1 (int); //prototipo di funzione int funz2 (int, int); //prototipo di funzione void main (void) //funzione principale { int num; num=999; printf("Sono nel main.num vale %d\n",num); funz1(num); //chiamata di funz1, passo un solo argomento num=funz2(10,12); // chiamata di funz2, passo 2 argomenti (valori) da me scelti. printf ("Sono di nuovo nella funzione main! num vale %d",num); } int funz2 (int a, int b) //funz2 { printf("Sono nella funzione 2. a=%d e b=%d\n",a,b); return a+b; } void funz1 (int x) //funz1 { printf("Sono nella funzione 1. num vale %d\n",x); } Invocare le funzioni: chiamata per valore e per riferimento Esistono due modi per invocare le funzioni: la chiamata per valore e la chiamata per riferimento. Quando gli argomenti saranno passati in una chiamata per valore, sarà preparata una copia dei loro valori e questa sarà passata alla funzione chiamata. Le modifiche effettuate alla copia non interessano il valore originale della variabile definita nel chiamante. Quando un argomento sarà passato in una chiamata per riferimento, il chiamante consentirà effettivamente alla funzione chiamata di modificare il valore originale della variabile. Le classi di memoria Per dichiarare una variabile abbiamo sempre utilizzato il nome, il tipo e il valore, questi sono detti attributi. Una variabile è una locazione (posizione) della memoria in cui un valore può essere immagazzinato perché possa essere utilizzato da un programma . Un nome di variabile in C è qualsiasi identificatore valido. Un identificatore è una serie di caratteri,comprendente lettere,numeri e caratteri di sottolineatura (_),che non comincia con un numero. Un identificatore può avere qualsiasi lunghezza, ma soltanto i primi 31 caratteri devono essere riconosciuti dal compilatore C, in accordo con lo standard dell’

26

ANSI C. Il C è case sensitive,ovvero, le lettere maiuscole e quelle minuscole sono differenti in C, perciò a1 e A1 sono identificatori distinti. Ora utilizzeremo gli identificatori anche come nomi per le funzioni definite dall’utente. In realtà, ogni identificatore in un programma ha anche altri attributi che includono: la classe di memoria, la permanenza (o durata) in memoria, la visibilità e il collegamento. Il C fornisce quattro classi di memoria indicate dalle specifiche di classe di memoria: auto, register, extern e static. La permanenza in memoria di un identificatore è il periodo durante il quale quell’identificatore esiste in memoria. Alcuni identificatori esistono per un tempo limitato, altri sono creati e distrutti ripetutamente, mentre altri ancora esistono durante l’intera esecuzione del programma. La visibilità di un identificatore è il punto del programma in cui si può far riferimento all’identificatore. Il collegamento di un identificatore determina se un identificatore sia noto solo in quello corrente o in qualsiasi altro file sorgente che abbia le dichiarazioni appropriate. Le quattro specifiche di classe di memoria possono essere suddivise in due tipi di permanenza: la permanenza automatica in memoria e la permanenza statica in memoria. Le parole chiave auto e register sono utilizzate per dichiarare variabili con permanenza automatica in memoria, queste ultime saranno create ogniqualvolta si entrerà nel blocco in cui sono state dichiarate,esisteranno finchè quello resterà attivo e saranno distrutte quando si uscirà dallo stesso. Le variabili locali hanno per default una permanenza automatica nella memoria. I dati per i calcoli e le altre elaborazioni,nella versione in linguaggio macchina di un programma, sono caricati normalmente nei registri. La specifica di classe di memoria register potrà essere inserita prima della dichiarazione di una variabile automatica,per suggerire al compilatore di conservare la variabile in uno dei registri hardware ad alta velocità del computer. Esistono due tipi di identificatori con permanenza statica nella memoria: gli identificatori esterni (come le variabili e i nomi di funzione globali) e le variabili locali dichiarate con la specifica di classe di memoria static. Le variabili e i nomi di funzioni globali sono definiti per default con la classe di memoria extern. La visibilità di un identificatore è la porzione del programma in cui quello potrà essere oggetto di riferimenti. I quattro tipi di visibilità possibili per un identificatore sono: prototipo di funzione, visibilità nella funzione, visibilità nel file, visibilità nel blocco e visibilità nel prototipo di funzione. Generazione di numeri casuali

L’elemento della casualità può essere introdotto nelle applicazioni per computer utilizzando la funzione rand della libreria standard del C. L’istruzione: i = rand ( ) ; genera un numero compreso tra 0 e RAND_MAX (costante simbolica definita nel file di intestazione <stdlib.h> ). Lo standard dell’ANSI stabilisce che il valore di RAND_MAX debba essere almeno 32767,che è anche il valore massimo per un intero di due byte. Il prototipo per la funzione rand può essere ritrovato in <stdlib.h>. Utilizzeremo l’operatore modulo (%) in congiunzione con rand nel modo seguente: rand ( ) % 6 ; per generare degli interi compresi nell’intervallo da 0 a 5. Questa operazione si chiama riduzione in scala,mentre il numero 6 è detto fattore di scala.

27

La funzione rand genera in realtà dei numeri pseudocasuali. Richiamando ripetutamente rand, si produrrebbe una sequenza di numeri che sembra essere casuale. In realtà, la sequenza si ripeterà ogni volta che il programma sarà eseguito. Una volta che il programma sarà stato completamente messo a punto,potrà essere condizionato in modo da produrre una sequenza diversa di numeri casuali ad ogni sua esecuzione. Questa operazione è detta in gergo randomizzazione, ed è eseguita con la funzione srand della libreria standard. La funzione srand riceve un argomento intero unsigned e insemina la funzione rand, in modo da indurla a generare una diversa sequenza di numeri casuali ad ogni esecuzione del programma. ( Un unsigned int di due byte può contenere soltanto valori positivi compresi nell’intervallo da 0 a 65535.) L’istruzione: srand ( time ( NULL ) ) ; porta il computer a leggere il suo orologio interno per ottenere automaticamente un valore per il seme. La funzione time restituisce l’ora corrente del giorno espressa in secondi. Questo valore sarà convertito in un intero senza segno e utilizzato come seme per il generatore di numeri casuali. La funzione time riceverà un argomento NULL (normalmente time è in grado di fornire al programmatore una stringa che rappresenta l’ora del giorno; il NULL disabilita appunto questa capacità per una chiamata specifica di time). Il prototipo di funzione per time è in <time.h>. (esempio: dado.c) E se volessimo finalmente scrivere il nostro esempio_1 in linguaggio C? #include<stdio.h> // librerie standard del C #include<stdlib.h> #include<time.h> main( ) // funzione principale { // apro blocco istruzioni int numero; // dichiaro la variabile int srand(time(NULL)); numero=1+rand( )%6; /* Con l’aggiunta di +1 estraggo un numero casuale da 1 a 6 */ printf(“E’ uscito il numero %d\n”,numero); if(numero>=4) /* struttura di controllo. Tra parentesi c’è la condizione da rispettare. if, simbolo di decisione: se il numero che io utente ho inserito è > o = 4 la lettura del codice seguìta all’interno del blocco istruzioni e salta la else */ { printf(“Hai vinto %d*5 euro”,numero); /*In questo caso abbiamo una sola istruzione*/ } else /* Altrimenti, implica quindi che il numero è < di 4, salta la if e seguìta la lettura dell’else */ { printf(“Non hai vinto!”); }

28

printf(“Fine gioco!”); /*A fine programma visualizzerà la scritta: Fine gioco! */ return ; } // Fine programma I VETTORI Un vettore è un gruppo di posizioni (o locazioni) di memoria correlate dal fatto che tutte hanno lo stesso nome e tipo di dato.Il primo elemento di ogni vettore è l’elemento zero. I vettori sono entità statiche, giacchè manterranno le proprie dimensioni durante l’esecuzione del programma. Il numero di posizione contenuto all’interno delle parentesi quadre è più formalmente noto come indice. Un indice deve essere un intero o un’espressione intera. DICHIARAZIONE DEI VETTORI int vett[10]; questa riga di istruzioni specifica il tipo elementare di ogni elemento della struttura dati di tipo vettore e il numero richiesto per la grandezza del vettore in modo tale che il computer possa riservare l’appropriata quantità di memoria. Invece la sequente riga di istruzioni: int vett[ ]={2,4,7,4,8}; creerà un vettore di tipo int di nome vett di 5 elementi. int vett[SIZE]; Nella dichiarazione posso utilizzare la costante simbolica SIZE , direttiva del preprocessore #define. Una costante simbolica è un identificatore che sarà sostituito con il testo di sostituzione dal preprocessore C, prima che il programma sia compilato.Utilizzare le costanti simboliche per specificare le dimensioni dei vettori renderà i programmi più scalabili. Una costante simbolica non è una variabile, il compilatore non le riserva nessuno spazio di memoria. int vett[5]={1,2,3,4,5,6}; provocherà un errore di sintassi. INIZIALIZZARE A ZERO GLI ELEMENTI DI UN VETTORE Tre modi: int v[10]={0,0,0,0,0,0,0,0,0,0}; int v[10]={0}; for(i=0;i<10;i++) v[i]=0; Esempio_14: “Chiedere all'utente 10 valori interi, il programma deve visualizzare il max.” #include <stdio.h> void main (void) { int i, vettore[10], max = 0; for(i=0;i<10;i++)

29

{ printf("Inserisci un numero: "); scanf("%d",&vettore[i]); if(vettore[i]>max) max=vettore[i]; } printf("Il maggiore è %d",max); } Esempio_15: “Tabellina del 2.” #include<stdio.h> #define N 10 main() { int v[N]={0},i; for(i=0;i<N;i++) v[i]=2+2*i; printf("%s%13s\n","Elemento","Valore"); for(i=0;i<N;i++) printf("%7d%13d\n",i,v[i]); return; } Come esercizio, si potrebbe chiedere all’utente di introdurre un qualsiasi numero e poi visualizzare la tabellina. Esempio_16: “Scrivere un programma che chieda all’utente di introdurre 10 valori. Visualizzare prima tutti i valori pari e poi tutti i valori dispari.” #include<stdio.h> main() { int v[10]={0},i; printf("Digita 10 numeri:\n"); for(i=0;i<10;i++) scanf("%d",&v[i]); printf("Valori pari:\n"); for(i=0;i<10;i++) if(v[i]%2==0) printf("%d ",v[i]);

30

printf("\nValori dispari:\n"); for(i=0;i<10;i++) if(v[i]%2!=0) printf("%d ",v[i]); return; } Esempio_17: “Scrivere un programma che chieda all’utente di introdurre 10 valori. Visualizzare prima tutti i valori di posizione pari e poi tutti i valori di posizione dispari.” #include<stdio.h> main() { int v[10]={0},i; printf("Digita 10 numeri:\n"); for(i=0;i<10;i++) scanf("%d",&v[i]); printf("Valori di posizione pari:\n"); for(i=0;i<10;i+=2) printf("%d ",v[i]); printf("\nValori di posizione dispari:\n"); for(i=1;i<10;i+=2) printf("%d ",v[i]); return; } PASSARE I VETTORI ALLE FUNZIONI Indicherete il nome del vettore senza parentesi quadre per passare ad una funzione un argomento di quel tipo. Per esempio, se il vettore vett fosse stato dichiarato come int vett[10]; l’istruzione per la chiamata della funzione somma(vett,10); passerebbe il vettore vett, il nome, e la sua dimensione alla funzione somma. Quando si passa a una funzione un vettore, spesso sarà passata anche la sua dimensione, in modo che la funzione possa elaborare il numero specifico degli elementi inclusi nel vettore. Il C passa i vettori alle funzioni utilizzando automaticamente una chiamata per riferimento simulata: la funzione chiamata potrà modificare i valori degli elementi inclusi nel vettore originale del chiamante. Il nome del vettore è in realtà l’indirizzo del suo primo elemento! vett e &vett[0] hanno l’indirizzo equivalente.

31

Di conseguenza, quando all’interno del suo corpo la funzione chiamata modificherà gli elementi del vettore, essa starà modificando effettivamente quelli del chiamante direttamente nelle loro locazioni di memoria originarie. funz( vett[3]); così ho passato un solo elemento del vettore ad una funzione. Il C fornisce lo speciale qualificatore di tipo const per prevenire, all’interno di una funzione, la modifica dei valori contenuti in un vettore. Quando un parametro di tipo vettore sarà preceduto dal qualificatore const, i suoi elementi diventeranno delle costanti nel corpo della funzione e ogni tentativo di modificarli, in quel contesto, provocherà un errore in fase di compilazione. Esempio_18: “Inserisco 10 numeri e trovo il massimo.” Stesso esercizio dell’esempio_14 ma utilizzando una funzione per trovare il max. #include<stdio.h> #define N 10 int maxvet (int v[ ]); main() { int i,vet[N]; printf("Inserisci %d numeri:\n",N); for(i=0;i<N;i++) scanf("%d",&vet[ i ]); printf("Il massimo è : %d",maxvet(vet)); return; } int maxvet (int v[ ]) { int j, max =0; for(j=0;j<N;j++) { if(v[ j ]>max) max=v[ j ]; } return max; // restituisco un intero } Esempio_19: “Cerco un valore all’interno di un vettore di 10 elementi.” #include<stdio.h> #define N 10 void inserimento (int vet[ ]); void cerca (int vettore[ ], int numero); void stampa (int vettoreee[ ]); main() { int v[N],num=0; inserimento(v);

32

printf("\nDigita un numero:"); scanf("%d",&num); cerca(v,num); stampa(v); return; } void inserimento (int vet[ ]) { int i; printf("Inserisci %d numeri\n",N); for(i=0;i<N;i++) scanf("%d",&vet[i]); } void cerca (int vettore[ ], int numero) { int i,f=0; for(i=0;i<N;i++) if(vettore[i]==numero) { f=1; printf("Il numero %d è nella posizione %d\n",numero,i+1); } if(f==0) printf("Il numero %d non è nel vettore\n",numero); } void stampa (int vettoreee [ ]) { int i; for(i=0;i<N;i++) printf("%d\n",vettoreee[i]); } La Struttura Dati MATRICE I vettori in C possono anche avere più di un indice. Un utilizzo tipico dei vettori multidimensionali è la rappresentazione di tabelle di valori formate da informazioni organizzate in righe e colonne. Per identificare un particolare elemento della tabella, dovremo specificare due indici: il primo identificherà per convenzione la riga dell’elemento, mentre il secondo ne identificherà la colonna. Le tabelle o i vettori che per identificare un particolare elemento richiedono due indici sono detti vettori bidimensionali o matrici. Osservate che i vettori multidimensionali possono avere più di due indici. Lo standard ANSI stabilisce che i sistemi ANSI C debbano supportare per i vettori un minimo di 12 indici. Colonna 0 Colonna 1 Colonna 2 Colonna 3Riga 0 M[0][0] M[0][1] M[0][2] M[0][3] Riga 1 M[1][0] M[1][1] M[1][2] M[1][3] Riga 2 M[2][0] M[2][1] M[2][2] M[2][3]

33

Matrice M con 3 righe e 4 colonne, matrice 3 per 4. Esempio_20: /* MATRICE */ #include<stdio.h> #define R 4 /* righe */ #define C 6 /* colonne */ void riempiMx (int Mat[R][C]); /* utilizzo le funzioni */ void stampaMx (int Matrice[R][C]); void main (void) { int Mx[R][C]={0}; /* dichiaro e inizializzo matrice */ riempiMx(Mx); /* chiamata funzione */ stampaMx(Mx); } void riempiMx (int Mat[R][C]) /* inserisco i valori nella matrice */ { int i,j; printf("Inserisci valori:\n"); for(i=0;i<R;i++) /* utilizzo un doppio ciclo for */ for(j=0;j<C;j++) scanf("%d",&Mat[i][j]); } void stampaMx (int Matrice[R][C]) /* stampo i valori */ { int i,j; for(i=0;i<R;i++) { printf("\n"); /* va a capo dopo aver visualizzato una riga */ for(j=0;j<C;j++) printf("%4d",Matrice[i][j]); } } La Struttura Dati PUNTATORE I puntatori sono delle variabili che come valore contengono degli indirizzi di memoria. Una variabile contiene direttamente un valore specifico; un puntatore, invece, contiene l’indirizzo di una variabile nella quale è immagazzinato quel valore specifico.

34

Es.: num 7 num, nome variabile, fa direttamente riferimento ad una variabile il cui valore è 7. numPtr X numPtr fa indirettamente riferimento ad una variabile il cui valore è 7. Per questo motivo il riferimento a un valore per mezzo di un puntatore è detto deriferimento. DICHIARAZIONE int num, *numPtr ; * (asterisco) indica che la variabile dichiarata sarà un puntatore. Possono essere dichiarati in modo da far riferimento a oggetti di qualsiasi tipo di dato. Posso inizializzare il puntatore nella dichiarazione o con una istruzione di assegnamento, come una variabile normale. & operatore di indirizzo, restituisce l’indirizzo del suo operando int y = 5 ; int *yPtr ; yPtr = &y ; assegnerà al puntatore yPtr l’indirizzo della variabile y * operatore di deriferimento o operatore di risoluzione del riferimento, restituisce il valore

dell’oggetto puntato dal suo operando ( cioè dal puntatore ) printf ( “ %d “, *yPtr ) ; visualizzerà il valore della variabile y, 5.

Esempio_21: “Inserisco un numero e lo modifico mediante un passaggio alla funzione del suo puntatore:” #include<stdio.h> void modifico (int *); // riceve come argomento un puntatore main() { int a; printf("Inserisci un valore intero:\n"); scanf("%d",&a); modifico(&a); // chiamo la funzione e le passo un puntatore printf("Il valore di a è = %d\n ",a); /* ho modificato la variabile a senza che la funzione mi restituisse un valore */ return; } void modifico (int *x) { if(*x>10) (*x)-=5; /* se il valore è > di 10 gli sottraggo 5 (numero preso a

35

else caso */ (*x)+=5; // se il valore è < di 10 gli addiziono 5 } La Struttura Dati STRINGA Nel linguaggio C una stringa è in realtà un vettore di caratteri che termina con il carattere nullo (‘\0’). Per accedere a una stringa si utilizzerà un puntatore che farà riferimento al suo primo carattere. Il valore di una stringa corrisponde all’indirizzo del suo primo carattere. Ne consegue che nel linguaggio C è corretto affermare che una stringa è un puntatore: in effetti, è un puntatore al primo carattere della stringa. In questo senso le stringhe sono come i vettori, poiché anche questi sono puntatori al loro primo elemento. Una stringa potrà essere utilizzata in una dichiarazione per inizializzare un vettore di caratteri: char colore [ ] = “rosso”; uguale è scrivere: char colore [ ] = {‘r’,’o’,’s’,’s’,’o’,’\0’}; // i caratteri sono tra apici singoli Assicurarsi che il vettore sia grande a sufficienza per immagazzinare la stringa e il carattere NULL di terminazione. La dichiarazione creerà il vettore colore di 6 elementi. char colore [6]; FUNZIONI PER LA MANIPOLAZIONE DELLE STRINGHE TRATTE DALLA LIBRERIA PER LA GESTIONE DELLE STRINGHE Libreria: <stdlib.h> strcpy ( s1 , s2 ) copia la stringa s2 nella stringa s1 strcat ( s1 , s2 ) accoda s2 a s1 strcmp ( s1 , s2 ) confronta le stringhe s1 e s2 La funzione restituirà 0 se sono uguali < 0 se s1 è minore di s2 > 0 se s1 è maggiore di s2 N.b. Per comprendere < o > si consideri il processo di sistemazione in ordine alfabetico (es. per cognomi ). strlen ( s ) determina la lunghezza della stringa s. Restituisce il numero di caratteri che precedono il NULL di terminazione. strerror ( nomestringa ) traduce in una stringa di testo dipendente dal sistema printf ( “ %s \n “ , strerror ( Sbagliato! ) ; visualizzerà: Error Sbagliato!

36

Nel caso di strncpy, strncat, strncmp posso copiare, accodare, comparare un massimo di ‘ n ‘ caratteri dalla stringa s2 nel vettore s1.

Es.: strncpy ( s1 , s2 , 4 ) ; Per strcpy s1 deve avere uguale o maggiore dimensione di memoria di s2. Dopo aver copiato una stringa bisogna aggiungere il carattere nullo di terminazione

s1 [ strlen ( s1 ) ] = ‘\0’ ; Esempio_22: “Chiedo all’utente di inserire delle parole, il programma termina se si inserisce la parola "fine" e visualizza le stringhe fino ad ora inserite.” #include<stdio.h> #include<string.h> main() { char s[5]="fine"; char s1[20]=" ",s2[20]=" ",s3[200]=" "; //dichiaro ed inizializzo a 0 tre stringhe printf("Digita basta per terminare\n\n"); printf("Inserisci una parola:\n"); gets(s1); //stessa funzione dello scanf, legge in input. while(strcmp(s,s1)<0 || strcmp(s,s1)>0) { strcat(s3,s1); strcat(s3," "); /*inserisco uno spazio tra una parola e l'altra*/ printf("Inserisci una parola:\n"); gets(s2); strcpy(s1,s2); s1[strlen(s1)]='\0'; } printf("%s",s3); return; }