L'ambiente DevC++ e la struttura di un programma C++ Il C++ è stato sviluppato da Bjarne Stroustrup negli anni '80 (Bell Laboratories) ed è senza dubbio il linguaggio di programmazione ad alto livello più utilizzato e potente. In quest'articolo cominciamo a vedere come è strutturato un semplice programma C++ e a realizzare una prima applicazione. Per creare un programma abbiamo bisogno di varie componenti: un ambiente di sviluppo (il compilatore), un linguaggio di programmazione (nel nostro caso il C++) e le sue librerie, cioè un insieme di funzioni che il linguaggio stesso ci mette a disposizione. L ambiente di sviluppo che useremo è il DevC++. Una volta installato, facciamolo partire e nel menu file selezioniamo new->project e poi ancora empty project dandogli un nome, ad esempio cplusplus. A questo punto aggiungiamo un foglio bianco al nostro progetto facendo di nuovo file e new->source file. Rinominiamo il source file con FirstProg e passiamo subito a scrivere il nostro codice: #include <iostream.h> Questa è la struttura di ogni programma C++. Le righe uno e due, gli include, servono ad importare le librerie nel nostro programma, in particolar modo iostream.h include le funzioni riguardanti l input e l output grazie alle quali possiamo leggere da tastiera e stampare a video mentre stdlib.h sta per standard library e include alcune funzioni standard, come vedremo in seguito. In alcuni programmi si usa la nuova libreria iostream invece della iostream.h. In questo caso lo si dice al programma con la riga using namespace std; cioè #include <iostream.h> using namespace std; Il programma comincia con la riga int main() e tutto quello che viene dopo, tra le parentesi graffe aperte e chiuse, è il nostro punto di ingresso. La scritta int main() vuole dire che main è una funzione che restituisce come valore un int, cioè un numero intero; infatti nel corpo del main troviamo return 0 che vuol dire che restituiamo il valore intero 0. Lo zero in C++ vuol dire che tutto è andato bene e che quindi il programma che in ultima analisi è il corpo della funzione main è terminato con successo. Questo programma funziona ma non fa nulla. Aggiungiamoci un'ulteriore riga: #include <iostream.h>
cout << "Primo programma C++ \n CIAO! \n"; Il comando cout<< serve a mandare la stringa che viene dopo nel flusso di output (il nostro monitor). Una stringa si definisce tra i doppi apici ; praticamente tra i doppi apici possiamo scrivere tutto quello che vogliamo e questo verrà stampato a video grazie al comando cout <<. Lo \n serve ad andare a capo. Da notare che ogni riga di codice deve terminare con il punto e virgola. Infine aggiungiamo una funzione di servizio delle stdlib.h che serve a bloccare il programma fin quando non si preme un tasto, questo per riuscire a vedere quello che abbiamo realizzato. Ecco il codice finale: #include <iostream.h> cout << "Primo programma C++ \n CIAO! \n"; system( PAUSE ); La compilazione Ora passiamo alla compilazione del nostro primo programma, cioè la traduzione in linguaggio macchina del codice scritto in un linguaggio di programmazione. Andiamo nel menu execute e premiamo su Compile&Run: dovrebbe così avviarsi il nostro primo programma in C++. In ogni parte del codice le linee che iniziano con i caratteri // rappresentano dei commenti che ci aiutano a ricordare cosa abbiamo fatto. #include <iostream.h> //libreria input/output // libreria standard //punto di ingresso //STAMPA A VIDEO cout << "Primo programma C++ \n CIAO! \n"; system( PAUSE ); //punto di uscita
Se andiamo nella cartella del nostro progetto troviamo i seguenti file: - cplusplus.dev è il file del progetto - firstprog.cpp è il listato del codice - firstprog.o è il file oggetto - firstprog.exe è il file eseguibile Una reale applicazione Il programma firstprog ci ha permesso di capire qual è la struttura di un programma C++, ora pronti per fare qualcosa di concreto: un convertitore in euro. Prendiamo il codice di firstprog è apportiamo le seguenti modifiche: #include <iostream.h> cout << "----------------------EuroConvertitore-----------------------\n"; cout << " Immetti il valore in lire da convertire: "; //DICHIARAZIONI DELLE VARIABILI float cambio=1936.27; float valoredaconvertire; float valoreconvertito; system( PAUSE ); Il cout già lo abbiamo visto e serve a mandare le scritte a video; la novità sono le dichiarazioni delle variabili che sono delle locazioni statiche di memoria in cui un valore viene memorizzato. Le variabili che abbiamo utilizzato sono di tipo reale (float), mentre in generale per dichiarare una variabile occorre mettere prima il tipo e poi il nome che noi gli vogliamo dare. Ad esempio se ci serve un intero scriveremo int mionumerointero, se ci serve un carattere scriveremo invece char miocarattere. E' una buona abitudine di programmazione dare un nome alle variabili che ci ricordino il suo significato nel corso del programma. Se scrivessimo float a=1936.27; float b; float c; il programma funzionerebbe lo stesso ma sarebbe difficile da gestire e ricordare. Tornado al codice notiamo che la variabile cambio è stata inizializzata perché sarà una costante nel nostro programma e non verrà modificata. Sarebbe un buon uso anche inizializzare le altre variabili al valore zero per non avere effetti indesiderati:
#include <iostream.h> cout << "----------------------EuroConvertitore-----------------------\n"; cout << " Immetti il valore in lire da convertire: "; //DICHIARAZIONI DELLE VARIABILI float cambio=1936.27; float valoredaconvertire=0; float valoreconvertito=0; system( PAUSE ); Ora dobbiamo chiedere all'utente della nostra applicazione di immettere un valore per la variabile valoredaconvertire e questo è possibile con il comando cin duale di cout. Ecco il codice: #include <iostream.h> cout << "----------------------EuroConvertitore-----------------------\n"; cout << " Immetti il valore in lire da convertire: "; //DICHIARAZIONI DELLE VARIABILI float cambio=1936.27; float valoredaconvertire=0; float valoreconvertito=0; cin >> valoredaconvertire; system( PAUSE ); Il programma verrà eseguito fino al cin (si legge ci-in) dopo di che si interrompe e attende che venga immesso un valore dal dispositivo di input che per default è la tastiera. Questo valore viene poi immesso nella variabile di tipo reale valoredaconvertire. Ora aggiungiamo il codice che ci permette la conversione e la visualizzazione del risultato col solito cout.
#include <iostream.h> cout << "----------------------EuroConvertitore-----------------------\n"; cout << " Immetti il valore in lire da convertire: "; //DICHIARAZIONI DELLE VARIABILI float cambio=1936.27; float valoredaconvertire=0; float valoreconvertito=0; cin >> valoredaconvertire; //CODICE DELL'OPERAZIONE DI CONVERSIONE valoreconvertito = valoredaconvertire/cambio; //STAMPA DEL RISULTATO cout << "\nil valore convertito e' " << valoreconvertito << " euro.\n"; system( PAUSE ); Il codice dell'operazione di conversione è una semplice espressione matematica, cioè dividiamo la variabile valoredaconvertire (il cui valore è quello immesso dall'utente) per il cambio. L'uguale è l'operatore di assegnazione a sinistra, non possiamo scrivere l'inverso! Per quanto riguarda cout c'è una novità: inviamo al dispositivo di output oltre a delle stringe anche una variabile, il tutto separato dai doppi simboli <<. ESEMPIO 1: Specifica del problema: Scrivere un programma che forniti in ingresso da tastiera due numeri interi diversi tra loro determini quale è il maggiore dei due. Si suppone che l ingresso effettuato da chi utilizza il programma sia corretto (che i due dati in ingresso sono numeri interi e sono diversi). L algoritmo per la risoluzione di questo problema è molto semplice. I due numeri (chiamiamoli A e B) vengono confrontati. Se A è maggiore di B viene stampata a video la frase A è maggiore di B, altrimenti viene stampata a video la frase B è maggiore di A.
Esecuzione e test Una volta realizzato, il programma deve essere testato per individuare eventuali malfunzionamenti ed assicurarsi che sia corretto rispetto alle sue specifiche Pertanto devono essere definiti tutti i possibili casi di test e il programma deve essere eseguito su ognuno di essi. In concreto si tratta di identificare gli insiemi di ingressi che determinano tutte le possibili sequenze dinamiche. In questo caso le possibile sequenze dinamiche sono due. E sono determinate dai due rami dell if I due esempi di esecuzione mostrano che il programma si comporta correttamente sia nel caso che A sia minore di B, sia nel caso che A sia maggiore di B.
Esempio 2 Specifica del problema: Scrivere un programma che forniti in ingresso da tastiera tre numeri interi diversi tra loro, determini quale è il minore dei tre. Si suppone che l ingresso effettuato da chi utilizza il programma sia corretto (in ingresso sono forniti tre interi e sono tre numeri diversi tra loro). L algoritmo per la risoluzione di questo problema può essere descritto mediante il diagramma di flusso già presentato nella lezione sulle istruzioni strutturate e riportato nel prossimo lucido La determinazione dei casi di test ed il test della soluzione proposta è lasciata per esercizio. L algoritmo quindi può essere implementato utilizzando due costrutti if-then-else innestati L elaborazione è Y=F(X) Dati iniziali X= A, B, C interi da confrontare Dati finali Y= minimo tra i tre valori Abbiamo bisogno quindi di tre variabili per memorizzare i valori da confrontare di tipo intero. In questo semplice esempio ci limitiamo a stampare il risultato del confronto.
Osservazioni Il secondo costrutto if-then-else è innestato nel primo ed è precisamente l istruzione che deve essere eseguita nel caso in cui la condizione (A<B && A<C) risulti falsa. La condizione logica (A<B && A<C) è composta: cioè è costituita da due relazioni in AND (l operatore &&). Ciò significa che entrambe devono risultare vere affinchè globalmente la condizione risulti vera. Se anche una sola delle due relazioni risulta falsa, allora la valutazione della condizione produce come risultato falso. Le istruzioni che devono essere eseguite nel ramo then (notate che in C/C++ la parola then non è espressa esplicitamente) e nel ramo else di un costrutto if-then-else devono essere chiuse in un blocco se sono più di una, mentre è possibile omettere le parentesi graffe se c è una unica istruzione da eseguire. Un costrutto globalmente preso è considerato come un unica istruzione (infatti non c è bisogno delle parentesi prima e dopo l if innestato). Esempio 3 Specifica del problema: Scrivere un programma che realizzi un semplice menù: l utente fornisce in ingresso due numeri interi A e B ed ha la possibilità di scegliere tra tre opzioni. In corrispondenza della prima viene effettuata la somma A+B, in corrispondenza della seconda viene effettuato il prodotto A*B, in corrispondenza della terza viene effettuata la differenza A-B Si suppone che l ingresso effettuato da chi utilizza il programma sia corretto (in ingresso sono forniti due interi e l opzione è del tipo richiesto dal programma). L algoritmo per la risoluzione di questo problema è molto semplice e può essere realizzato mediante l uso del costrutto di selezione a più vie (case) Tale costrutto in C/C++ è reso dall istruzione switch e mediante l opportuno utilizzo dell istruzione di salto break.
Osservazioni Il costrutto di selezione a più vie in C/C++ utilizza le parole chiave switch e case. Inoltre il suo corpo costituisce un blocco, cioè deve essere racchiuso tra parentesi graffe Dopo lo switch viene valutata l espressione tra parentesi (in questo caso il valore della variabile scelta) che deve assumere valore in un insieme discreto e finito. Tutti i possibili valori che l espressione può assumere devono essere noti a priori A ciascun case corrisponde uno dei possibili valori (espressi come costanti del loro tipo e seguiti dai e le istruzioni da eseguire in corrispondenza del presentarsi di tale valore Non sono necessarie le parentesi graffe per racchiudere le istruzioni di un singolo case Il costrutto switch prevede la possibilità di esprimere un default: cioè le istruzioni che devono essere eseguite nel caso che la valutazione dell espressione produca un valore diverso da quelli previsti Per ottenere un comportamento equivalente al costrutto di selezione descritto in maniera generale nella lezione precedente, è necessario utilizzare al termine di ogni case l istruzione di salto break che non appartiene al costrutto switch e anzi provoca l uscita dallo switch: il controllo passa all istruzione successiva allo switch ESERCIZIO: ELIMINARE i break ed eseguire gli stessi casi di test. Qual è il comportamento del costrutto switch? ESERCIZIO: Realizzare lo stesso programma utilizzando degli if innestati e/o degli if in cascata (uno dopo l altro, senza innestarli). Esempi di Programmi con cicli ESEMPIO 4: Specifica del problema: scrivere un programma che fornito in ingresso da tastiera un numero intero N non negativo calcola il fattoriale di N. Si suppone che l ingresso effettuato da chi utilizza il programma sia corretto (viene introdotto un numero intero)
L algoritmo per la risoluzione di questo problema ricalca il procedimento per il calcolo del fattoriale, che può essere iterativo o ricorsivo. La ricorsione non è affrontata in questo corso, pertanto esamineremo solo la soluzione iterativa. La procedura iterativa per il calcolo del fattoriale è la seguente: Se N è uguale a 0 il fattoriale di N per convenzione è 1 Altrimenti se N è maggiore di 0 il fattoriale di N si calcola così: N!= 1 x 2 x (N-1) x N Ad esempio, supponiamo che N sia uguale al valore 4: 4!= 1 x 2 x 3 x 4 L algoritmo per la risoluzione di questo problema richiede quindi che venga generata una sequenza di interi 1,2,3,4 da 1 a N. Ogni elemento della sequenza deve essere moltiplicato per i precedenti. Abbiamo bisogno quindi di memorizzare i prodotti man mano che vengono effettuati. In effetti è lo stesso procedimento mentale che adottiamo se vogliamo calcolare a mente 4!: 1x2=2 (e ricordiamo 2) 2 x 3= 6 (e ricordiamo 6) 6 x 4 = 24 il fattoriale di 4 è 24 L elaborazione è Y=F(X) Dati iniziali X= valore intero di cui calcolare il fattoriale Dati finali Y= il fattoriale del valore X Abbiamo bisogno quindi di una variabile per memorizzare il valore di cui calcolare il fattoriale e di una variabile per contenere il risultato: chiamiamole rispettivamente N e fattoriale. Saranno di tipo intero perchè N deve essere intera e il prodotto di numeri interi è un intero. Abbiamo bisogno poi di variabile di algoritmo (non sono dati di iniziali o finali ma servono per portare avanti l elaborazione): una variabile per contare il numero di iterazioni e una variabile per memorizzare i risultati parziali, chiamiamole rispettivamente i e parziale. Saranno ovviamente di tipo intero. parziale deve contenere di volta in volta i risultati dei prodotti effettuati, QUINDI DEVE ESSERE INIZIALIZZATA all elemento NEUTRO per il prodotto (altrimenti il suo valore iniziale sarà indefinito, e verrà moltiplicato per il valore calcolato ottenendo così un risultato SBAGLIATO): parziale=1 parziale=1 i=1 // primo elemento della sequenza di numeri 1,2,3, N ripeti finchè i<=n : parziale=parziale x i i=i+1 // genera il numero successivo nella sequenza fattoriale = parziale // L ultimo dei risultati parziali è evidentemente il risultato finale. Questo è l algoritmo per il calcolo del fattoriale. Bisogna però considerare i casi particolari: se N inizialmente vale 0 oppure 1 fattoriale = 1 altrimenti esegui l'algoritmo per il calcolo del fattoriale Bisogna inoltre considerare che N deve rispettare delle condizioni, per definizione di fattoriale infatti deve essere un numero non negativo. Questo controllo può essere aggiunto prima di effettuare il calcolo del fattoriale, ad esempio: se N<0 stampa un messaggio di errore altrimenti calcola il fattoriale di N In definitiva: se N<0 stampa un messaggio di errore
altrimenti se N inizialmente vale 0 oppure 1 fattoriale = 1 altrimenti parziale=1 i=1 // primo elemento della sequenza di numeri 1,2,3, N ripeti finchè i<=n : parziale=parziale x i i=i+1 // genera il numero successivo nella sequenza fattoriale = parziale // L ultimo dei risultati parziali è evidentemente il risultato finale. Ora possiamo tradurre l algoritmo in linguaggio C/C++ aggiungendo la definizione delle varialbili e le istruzioni di ingresso (lettura di N) e di uscita (stampa del risultato) Il ciclo viene espresso mediante un for (ciclo a conteggio) ESERCIZIO: implementare il programma utilizzando in vece del ciclo for il ciclo while ESERCIZIO: realizzare il diagramma di flusso del presente algoritmo Osservazioni Il secondo costrutto if-then-else è innestato nel primo ed è precisamente l istruzione che deve essere eseguita nel caso in cui il controllo sull input abbia esito positivo. Pertanto il calcolo del fattoriale costituisce il ramo else dell if più esterno. La condizione logica (N==0 N==1) è composta: cioè è costituita da due relazioni in OR (l operatore ). Ciò significa che almeno una di esse deve risultare vera affinchè globalmente la condizione risulti vera. Se entrambe le relazioni risultano false, allora la valutazione della condizione produce come risultato falso. Attenzione. La relazione di uguaglianza è espressa dall operatore ==. Un errore comune è utilizzare per distrazione l operatore di assegnazione = al posto dell operatore ==. La sostituzione
non provoca errori in compilazione, perché il left value viene modificato e la condizione così espressa è la seguente: se il valore assunto dal left value è vero Le istruzioni che devono essere eseguite nel ramo else del primo if costituiscono un blocco. Nel blocco vi sono le seguenti 3 istruzioni: 1. un if-then-else (che a sua volta contiene un for nel ramo else), 2. una assegnazione e 3. una istruzione di uscita (la stampa del risultato). ESEMPIO 5: Specifica del problema: modificare l esempio 4 in modo che dopo la prima esecuzione sia possibile effettuare eventualmente ulteriori esecuzioni consecutive, a scelta dell utente Vuole essere un semplice esempio di utilizzo del ciclo a condizione finale. Per realizzare il comportamento descritto dalla specifica infatti è necessario che il calcolo del fattoriale venga effettuato almeno una volta, dopo la prima esecuzione all utente viene chiesto se desidera calcolare un altro fattoriale o meno. Il programma sviluppato per l esempio 4 deve essere quindi il corpo di un ciclo a condizione finale. Il valore di verità della condizione è determinato dalla scelta dell utente. Si noti, eseguendo il programma riportato nella prossima slide, che l istruzione system ( PAUSE ) non è più necessaria