1
Le classi Le classi
Definizione di classe Attributi e metodi di una classe
Costruttori e distruttori Private e public Funzioni friendIl puntatore this
2
Cos’è un oggetto?Cos’è un oggetto?
• Né più né meno di quello che potreste trovare scritto in un vocabolario…– Un oggetto è un’entità che si possa immaginare dotata
di determinate caratteristiche e funzionalità.
• Lo stato di un oggetto è rappresentato da dati che ne descrivono le caratteristiche in un certo istante
• Le funzionalità di un oggetto sono le operazioni che può svolgere quando glielo si richiede (cioè quando riceve un messaggio)
• Nella nostra vita quotidiana siamo molto più abituati a ragionare per oggetti che non in modo strutturato!
3
Un esempio...Un esempio...
4
FunzioneFunzione
Funzione
Codice
funzione
CodicefunzioneCodice
funzione
… cos’è un oggetto:… cos’è un oggetto:Un insieme di dati e funzioni:
Dato
Dato
Dato
5
IncapsulazioneIncapsulazione• Netta divisione fra interfaccia e implementazione• Da fuori si vede solo l’interfaccia che definisce i
messaggi accettati dall’oggetto• I dettagli dell’implementazione (dati e codice delle
funzioni) sono invisibili dall’esterno• Ogni oggetto ha in se tutto ciò che gli serve per
rispondere alle chiamate (o deve sapere a chi chiedere…)
• Il confinamento di informazioni e funzionalità in oggetti permette livelli maggiori di astrazione e semplifica la gestione di sistemi complessi.
6
Approccio OOApproccio OO
• Sono le strutture di dati che svolgono le azioni, non le subroutines
• Il lavoro è svolto dal server, non dal client• “Cos’ è?” “Com’ è fatto?”
Data Oriented• “Cosa può fare per me?”
Object Oriented
7
Perché programmare per oggetti?Perché programmare per oggetti?
• Programmare per oggetti non velocizza l’esecuzione dei programmi...
• Programmare per oggetti non ottimizza l’uso della memoria...
E allora perchè programmare per oggetti?• Programmare per oggetti facilita la progettazione
e il mantenimento di sistemi software molto complessi!
8
Caratteristiche del software non mantenibile
Caratteristiche del software non mantenibile
• Rigidità– non può essere cambiato con faciltà– non può essere stimato l’impatto di una modifica
• Fragilità– una modifica singola causa una cascata di modifiche
successive– i bachi sorgono in aree concettualmente separate
dalle aree dove sono avvenute le modifiche
• Non riusabilità– esistono molte interdipendenze, quindi non è possibile
estrarre parti che potrebbero essere comuni
9
Programmazione ad oggettiProgrammazione ad oggetti
• La programmazione ad oggetti, attraverso l’incapsulazione, consente di:– ridurre la dipendenza del codice di alto livello dalla
rappresentazione dei dati – riutilizzare del codice di alto livello– sviluppare moduli indipendenti l’uno dall’altro– avere codice utente che dipende dalle interfacce ma
non dall’implementazione
10
Organizzazione dei filesOrganizzazione dei files• Normalmente, le dichiarazioni delle interfacce e le
specifiche sono separate dall’implementazione– header files (.h o .hh)
• inclusi nei file sorgente utilizzando direttive del precompilatore
• non contengono codice eseguibile (con l’eccezione delle definizioni delle funzioni inline)
• non devono essere inclusi piu` di una volta, per evitare problemi con il linker
#include <iostream>
#ifndef MyHeader_H#define MyHeader_H// dichiarazioni…..#endif
11
Organizzazione dei files (2)Organizzazione dei files (2)
– Files sorgente (.C,.cxx,.cpp,.cc)• contengono l’implementazione di funzioni e metodi • codice eseguibile• includono gli header files utilizzando le direttive del
preprocessore• vengono compilati
12
C++ e Object OrientationC++ e Object Orientation• Definizione di nuovi tipi (oltre a int, float, double) come:
• numeri complessi,• vettori,• matrici, . . .
• ma anche:• curve,• superfici,• Modelli 3D,...
• Gli oggetti permettono di modellare una problema che rappresenti la realtà
13
…C++ e Object Orientation…C++ e Object Orientation
• Object Orientation implementata in C++ attraverso il concetto di classe:
• I dati privati (o attributi) di una classe definiscono lo stato dell’oggetto
• Le funzioni (o metodi) di una classe implementano la risposta ai messaggi
14
Una classe C++Una classe C++
MessaggioMessaggio
Messaggio
Metodo
Metodo
MetodoAttributo
Attributo
Attributo
15
Classe Vector2DClasse Vector2D• Un esempio: un vettore bidimensionale
class Vector2D{public:
Vector2D(double x, double y);double x();double y();double r();double phi();
private:double x_;double y_
};
class Vector2D{public:
Vector2D(double x, double y);double x();double y();double r();double phi();
private:double x_;double y_
};
Vector2D.hVector2D.hcostruttore
funzioni o metodi
dati o attributi
Punto e virgola!
#include “Vector2D.h”#include <math.h>Vector2D::Vector2D(double x, double y): x_(x),
y_(y) { }double Vector2D::x() { return x_; }
double Vector2D::r() { return sqrt( x_*x_ + y_*y_); }
...
#include “Vector2D.h”#include <math.h>Vector2D::Vector2D(double x, double y): x_(x),
y_(y) { }double Vector2D::x() { return x_; }
double Vector2D::r() { return sqrt( x_*x_ + y_*y_); }
...
Vector2D.ccVector2D.cc
16
Interfaccia e implementazioneInterfaccia e implementazione
#include “Vector.h”
Vector2D::Vector2D(double x, double y) : x_(x), y_(y){}
double Vector2D::x(){ return x_; }
double Vector2D::r(){ return sqrt(x_*x_ + y_*y_); }
Vector2D.ccVector2D.cc
class Vector2D{public: Vector2D(double x, double y); double x(); double y(); double r(); double phi();private: double x_; double y_;};
Vector2D.hVector2D.h
• Gli attributi privati non sono accessibili al di fuori della classe
• I metodi pubblici sono gli unici visibili
17
Costruttori e distruttoriCostruttori e distruttori• Un costruttore è un metodo il cui nome è quello
della classe a cui appartiene• Lo scopo di un costruttore è quello di costruire
oggetti del tipo della classe. Questo implica l’inizializzazione degli attributi e, frequentemente, l’allocazione della memoria necessaria
• Un costruttore la cui lista di argomenti è vuota o composta di argomenti di default viene normalmente chiamato costruttore di default Vector2D::Vector2D() {. . . .} // costruttore di default
#include “Vector2D.h”. . .
Vector2D v; // oggetto costruito con il // costruttore di default
18
Costruttori e distruttori (2)Costruttori e distruttori (2)• Un costruttore del tipo che ha come argomento un
riferimento ad un oggetto della stessa classe viene chiamato copy constructor (costruttore per copia)
• Il copy constructor viene normalmente utilizzato:
– quando un oggetto è inizializzato per assegnazione– quando un oggetto è passato come argomento ad una
funzione– quando un oggetto è ritornato da una funzione
• Se non viene fornito esplicitamente dall’utente, il compilatore ne genererà uno automaticamente
Vector2D::Vector2D(const Vector2D& v) {. . . .}
Vector2D v(v1); // dove v1 e` di tipo Vector2D
19
Costruttori e distruttori (3)Costruttori e distruttori (3)• Gli attributi di una classe possono essere
inizializzati nel costruttore per mezzo di una lista di inizializzatori, che precede il corpo della funzione
• Quando uno degli attributi è esso stesso una classe, il costruttore appropriato viene scelto sulla base dei parametri forniti nell’inizializzazione
• E` obbligatorio inizializzare gli attributi (non statici) che siano o riferimenti o const
Vector2D::Vector2D(double x, double y) : x_(x), y_(y){. . . }
20
Costruttori e distruttori (4)Costruttori e distruttori (4)• Il distruttore è un metodo il cui nome è quello della
classe a cui appartiene preceduto da una tilde (~)• Il distruttore viene chiamato automaticamente
quando un oggetto sta per essere distrutto (sia perchè delete è stato invocato sia perchè l’oggetto è finito fuori scope
• Il compito del distruttore è di assicurarsi che l’oggetto per cui è invocato verrà distrutto senza conseguenze. In particolare, se memoria è stata allocata nel costruttore, il distruttore dovrà assicurarsi di restituirla allo heap
Vector2D::~Vector2D() {} // vuoto, in questo caso
21
Costruttori e distruttori (5)Costruttori e distruttori (5)• I costruttori con un solo parametro sono
automaticamente trattati come operatori di conversione
• Per evitare la conversione si puo` usare explicit
Vector2D::Vector2D(int i) {. . .}// costruisce un vettore a partire da un intero, ma puo` // essere usato per convertire un intero in vettore
v=Vector2D(i);
explicit Vector2D(int); // solo costruttore
22
Classe Vector2DClasse Vector2D
#include <iostream>using namespace std;#include “Vector2D.h”
int main(){ Vector2D v(1, 1); cout << “ v = (“ << v.x() << “,” << v.y() << “)” << endl; cout << “ r = “ << v.r(); cout << “ phi = “ << v.phi() << endl; return 0;}
#include <iostream>using namespace std;#include “Vector2D.h”
int main(){ Vector2D v(1, 1); cout << “ v = (“ << v.x() << “,” << v.y() << “)” << endl; cout << “ r = “ << v.r(); cout << “ phi = “ << v.phi() << endl; return 0;}
main.ccmain.cc
• Come usare Vector2D:
v = (1, 1)r = 1.4141 phi = 0.7854v = (1, 1)r = 1.4141 phi = 0.7854
Output:Output:
invoca il constructor
23
Classe Vector2DClasse Vector2D
#include <iostream>using namespace std#include “Vector2D.h”
int main(){ Vector2D *v = new Vector2D(1, 1); cout << “ v = (“ << v->x() << “,” << v->y() << “)” << endl; cout << “ r = “ << v->r(); cout << “ phi = “ << v->phi() << endl; delete v; return 0;}
#include <iostream>using namespace std#include “Vector2D.h”
int main(){ Vector2D *v = new Vector2D(1, 1); cout << “ v = (“ << v->x() << “,” << v->y() << “)” << endl; cout << “ r = “ << v->r(); cout << “ phi = “ << v->phi() << endl; delete v; return 0;}
main.ccmain.cc
• … oppure attraverso un puntatore...
v = (1, 1)r = 1.4141 phi = 0.7854v = (1, 1)r = 1.4141 phi = 0.7854
Output:Output:
Allocazione sullo heap
Attenzione!
24
Interfaccia e implementazioneInterfaccia e implementazione
• La struttura interna dei dati (x_, y_) che rappresentano l’oggetto della classe Vector2D sono nascosti (private) agli utilizzatori della classe.
• Gli utilizzatori non dipendono dalla struttura interna dei dati
• Se la struttura interna cambia (es.: r_, phi_), il codice che usa Vector2D non deve essere modificato.
25
• Protezione dell’accesso ai dati:
• I metodi di una classe hanno libero accesso ai dati privati e protetti di quella classe
Classe Vector2DClasse Vector2D
#include <iostream>using namespace std#include “Vector2D.h”
int main(){ Vector2D v(1, 1); cout << “ V = (“ << v.x_ << “,” // << v.y_ << “,” << endl; // non compila ! cout << “ r = “ << v.r(); cout << “ phi = “ << v.phi() << endl;}
#include <iostream>using namespace std#include “Vector2D.h”
int main(){ Vector2D v(1, 1); cout << “ V = (“ << v.x_ << “,” // << v.y_ << “,” << endl; // non compila ! cout << “ r = “ << v.r(); cout << “ phi = “ << v.phi() << endl;}
main.ccmain.cc
26
• Selettore: metodo che non modifica lo stato (attributi) della classe. E’ dichiarato const
• Modificatore: metodo che può modificare lo stato della classe
Selettori e modificatoriSelettori e modificatori
#include “Vector2D.h”
void Vector2D::scale(double s){ x_ *= s; y_ *= s;}
Vector2D.ccVector2D.cc
class Vector2D{public: Vector2D(double x, double y); double x() const; double y() const; double r() const; double phi() const; void scale(double s);private: double x_, y_;};
Vector2D.hVector2D.h
modificatore#include “Vector2D.h”int main(){ const Vector2D v(1, 0); double r = v.r() // OK v.scale( 1.1 ); // errore!}
#include “Vector2D.h”int main(){ const Vector2D v(1, 0); double r = v.r() // OK v.scale( 1.1 ); // errore!}
main.ccmain.ccSelettori (const)
27
friend friend
• La keyword friend puo` essere usata perche` una funzione (o una classe) abbia libero accesso ai dati privati di un’altra classeclass A {. . .
friend int aFunc();friend void C::f(int);
}; class B {…
friend class C;};class C {. . .};
28
friend (2)friend (2)• friend (nonostante il nome) e` nemico
dell’incapsulamento e quindi dell’Object Orientation
• Un uso eccessivo di friend è quasi sempre sintomo di un cattivo disegno
• Esistono anche situazioni in cui un friend può essere accettabile– Overloading di operatori binari– Considerazioni di efficienza– Relazione speciale fra due classi
“A programmer must confer with an architect before making friend declarations”
29
thisthis• In una classe è automaticamente definito un
attributo particolare: this– this è un puntatore all’oggetto di cui fa parte– E’ particolarmente utile quando una funzione deve
restituire l’oggetto tramite il quale è stata invocata
class Vector2D {public: Vector2D& copia(const Vector2D& ); // ...private: double x_, y_;};
class Vector2D {public: Vector2D& copia(const Vector2D& ); // ...private: double x_, y_;};
Vector2D.hVector2D.hVector2D& copia(const Vector2D& v){ x_=v.x(); y_=v.y(); return *this;}
Vector2D& copia(const Vector2D& v){ x_=v.x(); y_=v.y(); return *this;}
Vector2D.ccVector2D.cc
#include “Vector2D.h”int main() { Vector2D null(0, 0); Vector2D a, b; a.copia(b.copia(null));}
#include “Vector2D.h”int main() { Vector2D null(0, 0); Vector2D a, b; a.copia(b.copia(null));}
main.ccmain.cc
L’operatore copia ritorna una referenza a se stesso. Permette copiemultiple
30
staticstatic
• Attributi dichiarati static in una classe sono condivisi da tutti gli oggetti di quella classe
• Metodi dichiarati static non possono accedere ad attributo non statici della classe
• Attiributi statici possono essere usati e modificati soltanto da metodi statici
• Nonostante l’utilizzo di static sembri imporre condizioni troppo restrittive, esso risulta utile nell’implementazione di:– contatori– singleton (vedi oltre)
31
Un contatoreUn contatoreClass MyClass {private:
static int counter;static void increment_counter() { counter++; }static void decrement_counter() { counter--; }
public:MyClass() { increment_counter(); }~MyClass() { decrement_counter(); }static int HowMany() { return counter; }
};#include <iostream>using namespace std#include “MyClass.h”
int MyClass::counter=0;
int main() {MyClass a,b,c;MyClass *p=new MyClass;cout<<“ How many? “<< MyClass::HowMany() <<endl;delete p;cout<<“ and now? “<< a.HowMany() <<endl;return 0;
}
Un membro statico deve essereinizializzato una e una sola volta
nel codice eseguibile
Un metodo statico puo` essere invocato cosi`...
… o cosi`...
32
Un singletonUn singleton• Un singleton è una classe di cui, in ogni
momento nel corso del programma, non può esistere più di una copia (istanza)
class aSingleton {private:
static aSingleton *ptr;aSingleton () {}
public:static aSingleton *GetPointer(){
if (ptr==0) ptr=new aSingleton;
return ptr; }
};
#include “aSingleton.h”
aSingleton *aSingleton::ptr=0;
int main() {aSingleton *mySing=
aSingleton::GetPointer();. . . Return 0;
}
Pattern utile per l’implementazione di classi “manager” di cui deve esistere una sola istanza
Attenzione a non farlodiventare l’equivalente di un common block!