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!