Elementi di programmazione ad oggetti a. a. 2009/2010 Corso di Laurea Magistrale in Ingegneria Elettronica Docente: Mauro Mazzieri, Dipartimento di Ingegneria Informatica, Gestionale e dellAutomazione

Lezione 4 Introduzione alla progettazione e programmazione ad oggetti: classi ed oggetti, notazione UML.

Natura del software Il software è una soluzione temporanea ad un problema Dinamico Complesso Per affrontare la complessità, si suddivide il software in componenti maneggevoli e interagenti Composizione: processo di costruzione a partire da parti semplici Astrazione: trattare le componenti senza interessarsi dei dettagli di come siano costruite Visione limitata alle poche proprietà essenziali, ignorando i dettagli irrilevanti

Dati e funzionalità I dati che un programma tratta si distinguono Le descrizioni dei dati sono fissate I valori individuali dei dati cambiano ogni volta Le funzionalità di un programma determinano cosa si può fare con i dati

Progettazione orientata agli oggetti Gli oggetti sono astrazioni usate per creare un modello del mondo reale Le funzionalità sono distribuite sugli oggetti Ogni oggetto ha la responsabilità di eseguire certe specifiche funzionalità Lallocazione delle responsabilità sugli oggetti è una parte critica di una buona progettazione Il sistema software è costituito da un insieme di oggetti interagenti

Oggetti La collaborazione tra gli oggetti avviene tramite uno scambio di messaggi Ogni oggetto ha Un nome Delle proprietà Dati, costanti e variabili, conosciuti dalloggetto, di cui rappresentano lo stato Dei metodi Funzioni e procedure eseguibili dalloggetto

Messaggi Ogni oggetto conosce delle informazioni ed è in grado di svolgere alcuni compiti Gli oggetti si scambiano messaggi, corrispondenti a richieste di servizi In risposta alle richieste, gli oggetti eseguono le operazioni e forniscono i risultati

Tipologie di messaggi Esistono due tipologie di messaggi Richieste di esecuzione di metodi Richieste di accesso alle proprietà delloggetto Limitatamente a ciò che loggetto espone

Dati e stato I dati hanno una definizione ed un valore associato Le definizioni sono fisse, i valori associati cambiano nel tempo Variabili di istanza Lo spazio di memoria usato per memorizzare tutte le variabili viene allocato al momento della creazione delloggetto Lo stato di un oggetto è contenuto nei suoi dati Insieme dei valori associati alle variabili di istanza

Notazione UML LUML è il linguaggio di modellazione standard per il progetto di sistemi software Comprende diversi tipi di diagrammi usati per modellare diversi aspetti Casi duso Attività Classi Sequenze Comunicazione Sincronizzazione Interazione Struttura composita Componenti Pacchetti Stati Installazione

Classi in UML

Notazione UML Attributi: visibilità nome : tipo Visibilità + public # protected ~ package - private Operazioni: visibilità nome (parametri) : tipo di ritorno

Definizione di una classe C++ La definizione di classe è composta da Testa: class Corpo (racchiuso tra parentesi graffe) Punto e virgola o dichiarazioni, es.: class Class1 { /* … */ }; class Class2 { /* … /* } var1, var2; Il corpo della classe contiene i membri Dati Funzioni membro

Definizione di metodi e operatore di scope Dichiarazione e definizione nella classe ( ) { }; Dichiarazione nella classe ( ); Definizione del metodo :: ( ) { }

Membri I dati sono dichiarati nello stesso modo in cui vengono dichiarate le variabili I metodi sono funzioni dichiarate dentro il corpo della classe Detti anche funzioni membro

Instanziazione Loperazione di creazione di un oggetto di una certa classe è detta instanziazione Un oggetto è instanza di una classe Occupa uno spazio in memoria Due oggetti della stessa classe differiscono per lo stato ma hanno gli stessi metodi Quando si dichiara una variabile del tipo di una classe, viene istanziata

Inizializzazione di una classe Per inizializzare lo stato di una classe, si utilizzano speciali funzioni membro di inizializzazione: i costruttori Un costruttore è una funzione membro con lo stesso nome della classe e senza tipo di ritorno È frequente sovraccaricare il costruttore La maggior parte delle classi ha un costruttore di default, senza parametri Un costruttore può anche non essere public

Esempio: costruttori class Counter { int count; public: Counter() { count = 0; } Counter(int inizio) { count = inizio; } };

Costruttore di default Un costruttore di default è un costruttore che può essere invocato senza parametri Account::Account() { /* … */ } Stack::Stack(int size = 0) { /* … */ } Complex::Complex(double r = 0.0, double i = 0.0) { /* … */ } Quando si scrive Account a; … viene chiamato il costruttore di default, se esiste ed è pubblico Se esiste un costruttore di default pubblico, OK Se il costruttore di default non è pubblico, errore di compilazione Se non esiste alcun costruttore, OK I membri non sono inizializzati, hanno il loro vaore di dafault Se esistono solo costruttori non di default (necessitano di parametri), errore di compilazione

Distruttore di una classe Il distruttore è una speciale funzione membro che viene invocata automaticamente quando loggetto non è più visibile o viene invocato delete sulloggetto Il costruttore ha il nome della classe preceduto da ~ Il distruttore non restituisce alcun valore e non può avere parametri Non cè sovraccaricamento Anche se ci sono più costruttori, cè un solo distruttore

Metodi e visibilità Una classe definisce uno scope Una funzione membro sovraccarica solo le funzioni membro della classe Il nome del metodo non è visibile allesterno della classe Un metodo si invoca come oggetto.metodo( /* … */ ); puntatoreOggetto->metodo( /* … */ ); I metodi di una classe hanno accesso completo ai membri di una classe Ma non a quelli delle altre classi

Accesso ai membri Il principio dellinformation hiding o incapsulamento dei dati consiste nellimpedire laccesso diretto allimplementazione interna di una classe Per default tutti gli elementi definiti in una classe sono privati, ovverro visibili solo allinterno della classe La parola chiave public delimita le variabili e metodi pubblici class nomeClasse { int d[300]; top = 0; public: void push(int); int pop(); }

Controllo dellaccesso Le parti della dichiarazione della classe contenenti i membri con diversa visibilità sono delimitate dalle etichette Public Un membro pubblico è accessibile da qualunque parte del programma Private Un membro privato è accessibile solo allinterno della classe Protected

Esempio: contatore class Counter { int count; public: Counter(void) { count = 0; } int getCount() { return count; } void incrementCounter() { count++; } void reset() { count = 0; } }; int main() { Counter *c = new Counter(); std::cout getCount() << std::endl; c->incrementCounter(); std::cout getCount() << std::endl; c->incrementCounter(); std::cout getCount() << std::endl; c->reset(); std::cout getCount() << std::endl; system("pause"); return 0; }

Interfaccia e implementazione I membri pubblici di una classe ne costituiscono linterfaccia Definiscono dati e funzionalità visibili dagli utilizzatori della classe Le definizioni dei membri ed i membri privati ne costituiscono limplementazione

Puntatore this Le funzioni membro di una classe hanno un parametro implicito Puntatore this, punta allistanza delloggetto Il compilatore trasforma le funzioni membro in sottoprogrammi a cui viene passato un parametro in più

Membri statici Un membro statico appartiene alla classe, non ad una specifica istanza È accessibile da tutti gli oggetti della classe Ne esiste una sola istanza per tutta la classe È comunque nel namespace della classe Rimane linformation hiding Un membro static può essere anche private Un metodo static non ha come parametro implicito in puntatore this

Esempio: contatore static class StaticCounter { static int count; public: static int getCount() { return count; } static void incrementCounter() { count++; } static void reset() { count = 0; } void f() { count++; } };

Funzioni friend La parola chiave friend identifica una funzione che ha accesso ai membri privati di una classe Nella sezione public, si mette il prototipo preceduto dalla parola chiave friend Una funzione friend non è una funzione membro Non ha il parametro implicito this Ha visibilità anche fuori dalla classe Una funzione può essere friend di più di una classe

Esempio: friend class Matrix { int m; int n; double *data; public: friend Vector *prod(Matrix*, Vector*); } class Vector { int n; double *data; public: Vector(int n) : n(n) { data = new double[n]; } friend Vector *prod(Matrix*, Vector*); }; Vector *prod(Matrix *m, Vector *v) { Vector *result = new Vector(v->n); for (int i = 0; i m; i++) { result->data[i] = 0; for (int j = 0; j n; j++) result->data[i] += m->data[i, j] * v->data[j]; } return result; }

Metodi const Un metodo dichiarato const non può modificare lo stato delloggetto int getCount() const { return count; } Costruttori e distruttori non possono essere const! Se un metodo non dovrebbe aver bisogno di modificare lo stato, è buona norma dichiararlo const salvo rimuovere il const se consapevolmente e a ragion veduta vogliamo che possa modificare lo stato

Classi annidate Si può inserire la dichiarazione di una classe dentro la dichiarazione di unaltra classe Una classe annidata è membro della classe La sua visibilità può essere public, private, protected Il nome della classe è nel campo dazione della classe che la racchiude

Esempio: classi annidate class Node {/*...*/}; class Tree { public: // Node è incapsulata nello scope di Tree // nel campo di azione della classe, Tree::Node // nasconde ::Node class Node {/*...*/}; Node *tree; }; //Tree::Node non è visibile nello scope globale //Node si risolve nella dichiarazione globale di Node Node *pNode; class List { public: // Node è incapsulato nello scope di List // nel campo di azione della classe, List::Node // maschera ::Node class Node {/*...*/}; Node *List; };

Risoluzione dei nomi in classi annidate Per risolvere un nome usato in una classe annidata, si considerano Prima, i nomi dichiarati nella classe annidata Poi, i nomi definiti nella classe che la racchiude Infine, i nomi nel namespace che racchiude la classe che la racchiude Una classe può essere definita dentro unaltra classe, in un namespace…

Classi locali Una classe può essere definita anche nel corpo di una funzione Classe locale Visibile solamente nel campo dazione globale dove è definita Le funzioni membro vanno definite direttamente dentro la classe Una classe locale non può dichiarare membri statici

Oggetti passati come parametro Un oggetto può essere usato come tipo di un parametro Gli oggetti vengono passati per valore Le modifiche alloggetto non sono visibili fuori dalla funzione Possibili problemi a causa di effetti collaterali Es. un oggetto che alloca memoria dinamica per poi rilasciarla; la sua copia rilascia la medesima memoria, danneggiando loggetto principale

Esempio: oggetto come parametro #include using namespace std; class myclass { int *p; public: myclass (int i); ~myclass(); int getval() {return *p;} }; myclass::myclass(int i) { cout << Allocazione di p\n; p = new int; if (!p) { cout << Impossibile allocare; exit(1); } *p=i; } myclass::~myclass() { cout << Rilascio di p\n; delete p; } // questo provocherà un problema void display(myclass ob) { cout << ob.getval() << \n; } main() { myclass a(10); display(a); return 0; }

Oggetti passati come parametro Gli oggetti passati come parametro sono normalmente passati tramite puntatori o riferimenti // questo non provocherà problemi void display(myclass& ob) { cout << ob.getval() << \n; }

Oggetti come tipi di ritorno Quando il tipo di ritorno di una funzione è un oggetto, viene creato automaticamente un oggetto temporaneo Dopo che loggetto viene restituito, viene distrutto Altro caso in cui la distruzione può provocare effetti collaterali indesiderati: se rilascia le risorse, loggetto restituito non è più utilizzabile

Esempio: funzione che restituisce oggetto class CharBuffer { char *s; public: CharBuffer(void) { s = '\0'; } ~CharBuffer(void) { if (s) delete(s); std::cout << "rilascio di s" << std::endl; } void show() { std::cout << s << std::endl; } void set(char *str) { s = new char[strlen(str)+1]; if (!s) { std::cout << "Impossibile allocare" << std::endl; exit(1); } strcpy(s, str); } }; CharBuffer input() { char instr[80]; CharBuffer result; std::cout << "Inserire una stringa: "; std::cin >> instr; result.set(instr); return result; } int main() { CharBuffer ob; ob=input(); // questo causa un errore ob.show(); return 0; }

Funzione che restituisce oggetto: soluzioni Restituire un puntatore o un riferimento Usare un costruttore di copia Usare un operatore di assegnamento soggetto a overloading

Costruttore di copia È sempre possibile copiare un oggetto CharBuffer c = d; La copia di un oggetto viene realizzata copiando ogni membro Non sempre la copia bit per bit è adeguata Si può definire un tipo particolare di costruttore (soggetto a overloading) CharBuffer::CharBuffer(const CharBuffer& c)

Esempio: costruttore di copia class CharBuffer { char *s; bool copy; public: CharBuffer(void) { s = 0; copy = false; } CharBuffer(const CharBuffer& c) { if (c.s) { s = new char[strlen(c.s)+1]; if (!s) { std::cout << "Impossibile allocare" << std::endl; exit(1); } strcpy(s, c.s); } else s = 0; copy = true; } ~CharBuffer(void) { if (!copy) { if (s) delete(s); std::cout << "rilascio di s" << std::endl; } else copy = false; } void show() { std::cout << s << std::endl; } void set(char *str) { s = new char[strlen(str)+1]; if (!s) { std::cout << "Impossibile allocare" << std::endl; exit(1); } strcpy(s, str); } };

Union Una union è un particolare tipo di classe in cui i dati vengono memorizzati sovrapposti Loccupazione di memoria è pari a quella del membro più grande È possibile assegnare un valore a solo un membro alla volta

Esempio: union union PackedNumber { int i; double d; public: PackedNumber(int i) : i(i) { } PackedNumber(double d) : d(d) { } int getInt() { return i; } double getDouble() { return d; } };