Elementi di programmazione ad oggetti a. a. 2009/2010

1. Elementi di programmazione ad oggettia. a. 2009/2010 Corso di Laurea Magistrale in Ingegneria Elettronica Docente: Mauro Mazzieri, Dipartimento di Ingegneria Informatica, Gestionale e dell’Automazione

2. Programma del corso • Introduzione al linguaggio C++ e alla libreria standard; richiami di programmazione procedurale. • Regole di visibilità e ciclo di vita. • Funzioni e sovraccaricamento. • Introduzione alla progettazione e programmazione ad oggetti: classi ed oggetti, notazione UML. • Sovraccaricamento degli operatori. • Ereditarietà. Funzioni virtuali e polimorfismo. • Template. • Gestione delle eccezioni. • Input/output e stream. • La libreria standard: i contenitori; cenni su oggetti funzione, algoritmi, iteratori, allocatori, stringhe, calcolo numerico. • Unit testing e test-driven programming.

3. Testi di riferimento • Lippman, Lajoie, "C++ Corso di Programmazione", Addison-Welsey • consigliato • Stroustrup, "C++ Linguaggio, libreria standard, principi di programmazione", Addison-Wesley • La bibbia del C++, consigliato a chi sa già programmare (in altri linguaggi) e desidera la fonte più autorevole sul C++ • … o qualsiasi altro libro di C++ • Aguilar, “Fondamenti di programmazione in C++”, McGraw-Hill • Schildt, "Guida Completa al C++", Mc Graw-Hill • Deitel, Deitel, "C++ Fondamenti di Programmazione", Apogeo

4. Alcune note • Le slides del corso saranno messe al più presto a disposizione sul portale del DIIGA • Le slides non sono dispense, occorre seguire le lezioni e/o leggere uno dei libri di riferimento, ed esercitarsi all’elaboratore • Quale ambiente di sviluppo per C++? • Windows: DevC++, Visual C++ Express • Mac: XCode • Linux: KDevelop

5. Lezione 1 Introduzione al linguaggio C++ ed alla libreria standard Richiami di programmazione procedurale

6. Introduzione al C++ • Bjarne Stroustrup ha inventato il C++ • Eredita dal C le caratteristiche di basso livello • Altre fonti di ispirazione: Simula67, Algol68, Ada, Clu • Il primo “C con le classi” è del 1980, i primi usi fuori dagli ambienti di ricerca sono del 1983 • Standard ISO nel 1998

7. Cos’è il C++? • Il C++ è un linguaggio di programmazione general-purpose orientato alla realizzazione di sistemi • È un C migliorato • Supporta l’astrazione dei dati • Supporta la programmazione orientata agli oggetti • Supporta la programmazione generica

8. Programmazione procedurale • La programmazione procedurale si basa sull’individuazione delle procedure che occorrono e utilizzo dei migliori algoritmi possibili • Decomposizione successiva del sistema da implementare in funzionalità più semplici • Ci si ferma quando le funzionalità sono sufficientemente semplici da essere implementabili come funzioni

9. Esempio di programmazione procedurale #include <iostream> using namespace std; void scambia(int& n1, int& n2) { int temp = n1; n1 = n2; n2 = temp; } int main() { int a, b; cout << "a="; cin >> a; cout << "b="; cin >> b; scambia(a, b); cout << "a=" << a << ", b=" << b << endl; system("pause"); return 0; }

10. Alcune note sul programma #include <iostream> • Direttiva per il preprocessore, indica che il programma ha la necessità di usare le funzioni della libreria predefinita per la gestione dell’I/O using namespace std; • Gli identificatori possono avere un prefisso (“spazio dei nomi”); tramite questa direttiva è possibile usare le funzioni di libreria omettendo il prefisso std cout << "a="; • Output di una stringa sullo standard output cin >> a; • Input di una stringa dallo standard input

11. Programmazione modulare • Un insieme di procedure correlate e di dati da esse manipolati costituisce un modulo • La programmazione modulare si basa sulla suddivisione del programma in moduli, in modo che i dati siano nascosti all’interno dei moduli

12. namespace • Dati, funzioni ed altre entità correlate possono essere correlati in spazi di nomi (namespace) separati // interfaccia namespace stack { void push(int); int pop(); } // implementazione namespace stack { const int MaxSize = 100; int data[MaxSize]; int top = 0; void push(int i) { // controlla che la pila non sia piena ed inserisce i in cima } int pop() { // controlla che la pila non sia vuota e restituisce l’elemento in cima } }

13. Compilazione separata • stack.h namespace stack { void push(int); int pop(); } • stack.cpp #include “stack.h” namespace stack { const int MaxSize = 100; int data[MaxSize]; int top = 0; } void stack::push(int i) { // controlla che la pila non sia piena ed inserisce i in cima } int stack::pop() { // controlla che la pila non sia vuota e restituisce l’elemento in cima }

14. Progettazione orientata agli oggetti • Si individuano le classi di oggetti che caratterizzano il dominio applicativo • Entità reali o astratte • Si individuano le modalità secondo cui gli oggetti devono interagire per realizzare le funzionalità dell’applicazione • Ogni classe è descritta da un’interfaccia che specifica il comportamento degli oggetti della classe

15. Classi e oggetti • Un oggetto è una istanza di una classe di oggetti che condividono lo stesso comportamento • Lo stato di un’istanza è indipendente dallo stato delle altre istanze • Un oggetto rappresenta un’entità del mondo reale o astratta • Un oggetto è caratterizzato da un nome, da dati (variabili locale che ne descrivono lo stato) e metodi (funzioni che ne descrivono i comportamento) • Gli oggetti dialogano tra loro scambiandosi messaggi

16. Programmazione generica • La programmazione generica consente di parametrizzare gli algoritmi che occorrono in modo che funzionino per un’adeguata varietà di tipi e strutture dati • Contenitori • Algoritmi generici

17. Richiami di programmazione procedurale

18. Tipi di dato • Tipi di dato primitivi: • int • char • float, double • bool • enum • Tipi composti a partire dai tipi primitivi: • struct • Puntatori • Vettori

19. Variabili • Per memorizzare ed utilizzare un dato è necessario dichiararne il tipo ed il nome • Le locazioni di memoria dell’elaboratore contengono un dato • La locazione di memoria è indentificata da un indirizzo • Il contenuto della locazione di memoria è il valore int a = 2; • dichiara il tipo ed inizializza il valore char b; • Dichiara il tipo ma non inizializza il valore

20. Operatore di assegnamento • L’operatore di assegnamento: = • All’elemento a sinistra dell’operatore (Lvalue) deve poter essere cambiato il valore • Solitamente, variabili • Dell’elemento a destra (Rvalue) è importante solo il contenuto • Variabili, numeri, output di funzioni • Un Lvalue può fungere da Rvalue ma non viceversa • Operatore di uguaglianza: ==

21. Aritmetici + addizione - sottrazione * moltiplicazione / divisione % resto (modulo) Logici && AND || OR ! NOT Relazionali > maggiore < minore >= maggiore o uguale <= minore o uguale == uguale != diverso Operatori

22. Identificatori • Gli identificatori sono i nomi usati per rappresentare variabili, costanti, tipi, funzioni • Un identificatore viene dichiarato specificandolo della dichiarazione • Sequenza di caratteri (lettere, numeri, _), il primo deve essere una lettera o _

23. Parole chiave • Non possono essere usate come identificatori! asm, auto, bool, break, case, catch, char, class, const, const_cast, continue, default, delete, do, double, dynamic_cast, else, enum, explicit, export, extern, false, float, for, friend, goto, if, inline, int, long, mutable, namespace, new, operator, private, protected, public, register, reinterpret_cast, return, short, signed, sizeof, static, static_cast, struct, switch, template, thwows, true, try, typedef, typeid, typename, union, unsigned, using, virtual, void, volative, wchar_t, while

24. Strutture di controllo: if if (espressione) { // codice che viene eseguito solo se l’espressione è true } else { // codice che viene eseguito solo se l’epsressione è false }

25. Strutture di controllo: while e do while (espressione) { // istruzioni che vengono eseguite fintanto che l’espressione è true } do { // istruzioni che vengono eseguite almeno una volta e fintanto che l’espressione è true } while (espressione)

26. Strutture di controllo: for for (espr1; espr2; espr3) { // istruzioni eseguite fintanto che espr2 è true } • Espr1 viene valutata una volta sola, prima di iniziare • Espr2 si valuta prima delle istruzioni • Espr3 si valuta dopo le istruzioni

27. Puntatore • Il puntatore è un tipo di dato derivato, che contiene l’indirizzo di una locazione di memoria capace di contenere valori di un certo tipo int *a; *a = 3; • * è l’operatore di deferenziazione • int *a si legge “il contenuto della locazione di memoria è un intero” (dunque, a è un puntatore)

28. Riferimenti • Un riferimento fornisce un nome alternativo ad un elemento int a=5; int &b = a; • Un riferimento deve essere inizializzato contestualmente alla sua dichiarazione • L’operatore & fornisce l’indirizzo di una variabile: int *c; c = &a;

29. Array int a[5] = { 5, 10, 15, 20, 25 } int *p; • Il nome di un array è un puntatore al primo elemento: p = a; • oppure p = &a[0]

30. Puntatori const • Il qualificatore const indica che un elemento non può essere cambiato const int a = 5; • È obbligatorio inizializzare una costante nel momento in cui viene definita • Un puntatore const punta sempre alla stessa locazione di memoria int a = 5; const int b =6; const int* c = &a; const int* d = &b; int* d = &b;

31. Allocazione della memoria • L’operatore new alloca a run-time della memoria • La memoria allocata a run-time risiede in un’area apposita chiamata heap int *a = new int; • a contiene un indirizzo corrispondante ad una locazione dell’heap • a viene solo allocata, non inizializzata • int *a = new int(2); // a viene anche inizializzata int *b = new int[2]; // allocazione di un vettore b[0] = 3; b[1] = 4;

32. Rilascio della memoria • L’operatore delete libera della memoria dinamica allocata con new int *a = new int; … delete a; • la memoria all’indirizzo a può essere riallocata • la memoria non viene cancellata • a non cambia valore • Dopo il delete, a è un puntatore dangling (punta ad una locazione di memoria non valida) • Errori comuni • Memory leak: non rilasciare con delete memoria allocata con new • Applicare due volte delete alla stessa locazione di memoria • Usare l’oggetto dopo il delete

33. Allocazione dinamica di array int *p1 = new int(24); // alloca un solo intero, inizializzandolo a 24 int * p2 = new int[24]; // alloca un vettore di 24 interi, non inizializzati int (*p3)[1024] = new int[4][1024]; //alloca una matrice di 4 x 1024 interi • Non si possono inizializzare gli elementi di un array alla loro allocazione, occorre un ciclo for int a = 1024; int *p = new int[a]; for (int i = 0; i < a; i++) p[i] = 1; • Un array si rilascia con delete[] delete[] p;

34. Allocazione dinamica const • Una variabile const una volta inizializzata non può essere modificata, anche se creata sull’heap const int *a = new const int(23); • Una variabile allocata dinamicamente const • Deve essere sempre inizializzata • L’indirizzo di memoria restituito deve essere assegnato a un puntatore const

35. Funzioni • Operazione definita dall’utente • Gli operandi sono i parametri • Il risultato è il valore di ritorno • Il tipo del valore di ritorno è il tipo di ritorno della funzione • void se non restituisce nulla • Le azione svolte sono contenute nel blocco della funzione • Tipo di ritorno, nome della funzione e lista dei parametri costituiscono la definizione della funzione

36. Parametri e variabili locali • Le variabili definite nel corpo di una funzione sono note solo all’interno della funzione • I parametri sono variabili locali istanziate alla chiamate della funzione

37. Prototipo • Il prototipo di una funzione è costituito dalla dichiarazione di tipo di ritorno, nome e parametri (senza il corpo) int middle(int, int, int); • E’ necessario definire il prototipo solo quando la definizione avviene dopo la chiamata della funzione

38. Passaggio di parametri • Il C++ è fortemente tipizzato: il tipo degli argomenti è controllato dal compilatore • La maniera predefinita di passare gli argomenti è per valore • vengono copiati nello spazio di memoria dei parametri • è un problema passare argomenti molto grandi • la funzione manipola solo delle copie locali • non possono essere modificati i valori degli argomenti

39. Introduzione alla libreria standard

40. Uso delle funzioni della libreria standard • Per utilizzare una funzione della libreria standard, bisogna includere l’intestazione in cui sono definite: #include <iostream> using namespace std; […] cout << “hello!”;

41. Flussi di input/output #include <iostream> Using namespace std; […] cout << “a=”; int a; cin >> a; cout << a; cout << endl; cout << “Ripeto: il valore di a è” << a << “!”;

42. Stringhe string s1 = “benvenuto”; string s2 = s1 + “!\n”; bool affermativo(const string &risposta) { return risposta == “sì”; } string s3 = s1.substr(5, 4); // nuto string s4 = s1.replace(0, 5, “mal”); // malvenuto La stringa sostituita può non avere la stessa lunghezza del sostituto!

43. Input di stringhe string s; cin >> s; // inserendo “Mauro”.. cout << “Ciao “ << s; // si ottiene “ciao Mauro” Per leggere una riga intera: getline(cin, s);

44. Contenitori: vector • Un array ha dimensione fissa int numeri1[100]; • Un vettore ha dimensione variabile vector<int> numeri2(100); cout << numeri2.size(); \\ 100 cout << numeri2[40]; \\ si accede ad un elemento come ad un array numeri2.resize(200); cout << numeri2.size(); \\ 200 vector numeri3[300]; \\ 300 vettori vuoti!!

45. Contenitori: list • Una lista è adatta quando inserimenti e cancellazioni sono frequenti list<double> valori; • Di solito non si accede alla lista con un indice, ma si scorrono i suoi elementi for (list<int>::const_iterator i = valori.begin(); i != valori.end(); i++) cout << *i; for (list<int>::iterator i = valori.begin(); i != valori.end(); i++) *i = 1.0; • Un iteratore non è un semplice puntatore, però • Con ++ si punta all’elemento successivo • Con * si accede al contenuto • Aggiungere elementi ad una lista: valori.push_front(2.0); // inserimento in testa valori.push_back(3.0); // inserimento in coda valori.insert(i, 4.0); // inserimento prima dell’elemento a cui i si riferisce

46. Altri contenitori • map: array associativo (dizionario) map<string, int> rubrica […] cout << rubrica[“Mauro”]; • queue: coda • stack: pila • deque: coda bidirezionale • priority_queue: coda ordinata • set: insieme • multiset: insieme con valori ripetuti • multimap: array associativo con valori ripetuti

47. Algoritmi • La libreria standard fornisce gli algoritmi più comuni che operano su elementi dei contenitori standard • Gli algoritmi operano su sequenze, determinate da coppie di iteratori vector<int> v; list<int> l; […] sort(v.begin(), v.end()); // ordinamento copy(v.begin(), v.end(), l.begin()); // copia copy(v.begin(), v.end(), back_inserter(l)); // copia in coda, estendendo la lista quanto serve int::const_iterator i = find(l.begin(), l.end(), 2); // restituisce un iteratore che punta all’elemento trovato int c = count(v.begin(), v.end(), 3); // conta i 3 nel vettore

48. Algoritmi della libreria standard