Ingegneria Elettronica Ingegneria delle Telecomunicazioni (J-Z) Ing. Antonio Monteleone A.A. 2001/02 3 ciclo

Transcript

1 Ingegneria Elettronica Ingegneria delle Telecomunicazioni (J-Z) Ing. Antonio Monteleone A.A. 2001/02 3 ciclo

2 Il C++ permette la definizione di nuovi tipi (oltre a int, float, double ), detti tipi definiti dall utente (UDT) L Object Orientation è implementata in C++ attraverso il concetto di classe: Idati membro (o attributi) di una classe definiscono lo stato dell oggetto Lefunzioni membro (o metodi) di una classe implementano la risposta ai messaggi Corso di Fondamenti di Informatica II 41

3 Point2D.h class Point2D { public: Point2D(double x, double y); double x(); double y(); double norm(); double phi(); private: double m_x; double m_y; ; dati membro Punto e virgola! Point2D.cpp costruttore funzioni membro #include Point2D.h Point2D::Point2D(double x, double y) : m_x(x), m_y(y){ double Point2D::x() { return m_x; double Point2D::norm() { return sqrt( m_x*m_x + m_y*m_y);... Corso di Fondamenti di Informatica II 42

4 L operatore :: di risoluzione dello scope L operatore binario :: di risoluzione dello scope serve ad indicare al compilatore a quale classe appartiene una data funzione membro // altro codice double Point2D::x() {return m_x; double Point2D::norm() { return sqrt( x()*x() + y()*y()); double Point3D::x() {return m_x; // altro codice Tramite l operatore :: il compilatore è in grado di distinguere tra funzioni membro aventi lo stesso nome ma appartenenti a classi diverse Quando una funzione membro chiama un altra funzione membro appartenente alla stessa classe lo può fare senza utilizzare l operatore :: Corso di Fondamenti di Informatica II 43

5 In C++ è possibile controllare l accesso ai membri di una classe mediante l uso delle seguenti parole chiave public le variabili e le funzioni membro elencate dopo lo specificatore public, e prima dello specificatore successivo, sono accessibili in tutti i punti del programma in cui si può accedere a un oggetto della classe private le variabili e le funzioni membro elencate dopo lo specificatore private, e prima dello specificatore successivo, sono accessibili soltanto all interno delle funzioni membro della classe protected le variabili e le funzioni membro elencate dopo lo specificatore protected, e prima dello specificatore successivo, sono accessibili soltanto all interno delle funzioni membro della classe e delle classi da questa derivate Corso di Fondamenti di Informatica II 44

6 Gli specificatori di accesso ai membri (2) Gli specificatori d accesso sono sempre seguiti dai due punti e possono comparire più volte e in qualunque ordine nella definizione di una classe E comunque preferibile far comparire ciascuno specificatore d accesso una sola volta e per primo lo specificatore public class A { public: int i; void func(); private: char j; float f; ; void main() { A a1; A *a2 = new A; a1.j = 10; // non compila a1.i = 12; // OK a2->j = 10; // non compila a2->func(); // OK ; Corso di Fondamenti di Informatica II 45

7 Per accedere ai membri di una classe si utilizzano gli operatori di accesso ai membri L operatore punto. si usa col nome di un oggetto o con un riferimento a un oggetto L operatore freccia -> si usa con un puntatore a un oggetto counter.h class Counter { int val; public: Counter(int v=0): val(v) { void reset(){val = 0; void incr() {++val; void decr() {--val; int value() {return val; ; #include <iostream> #include counter.h void main() { Counter cntr; cntr.val = 1; // non compila! cntr.incr(); Counter pcntr = new Counter; pcntr->incr(); cout << pcntr->value() << endl; cout << cntr.value() << endl; delete pcntr; Corso di Fondamenti di Informatica II 46

8 I dati membro privati non sono accessibili al di fuori della classe I dati e le funzioni membro pubbliche sono gli unici elementi accessibili dall esterno: essi costituiscono l interfaccia di una classe Point2D.h class Point2D { public: Point2D(double x, double y); double x(); double y(); double norm(); double phi(); private: double m_x; double m_y; ; Point2D.cpp #include Point2D.h Point2D :: Point2D(double x, double y) : m_x(x), m_y(y) { double Point2D::x() { return m_x; double Point2D::norm() { return sqrt(m_x* m_x + m_y* m_y); Corso di Fondamenti di Informatica II 47

9 La struttura interna dei dati (m_x, m_y) di un oggetto della classe Point2D sono nascosti (private) agli utilizzatori della classe. Gli utilizzatori non dipendono dalla struttura interna dei dati: se la struttura interna cambia, ad esempio si decide di rappresentare un punto mediante coordinate polari (m_r, m_phi), il codice che usa Point2D non deve essere modificato. Corso di Fondamenti di Informatica II 48

10 In C++ una struct è semplicemente una classe i cui membri sono pubblicamente accessibili struct MyStruct { int val; void f(); ; class MyStruct { public: int val; void f(); ; In una struct i membri senza specificatore di accesso sono pubblici In una classe i membri senza specificatore d accesso sono privati Corso di Fondamenti di Informatica II 49

11 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, allocazione di memoria dallo heap Un costruttore la cui lista di argomenti è vuota o composta di argomenti di default viene normalmente chiamato costruttore di default Point2D::Point2D() {.... // costruttore di default #include Point2D.h... Point2D pt; // oggetto costruito con il // costruttore di default Corso di Fondamenti di Informatica II 50

12 (2) Un costruttore che ha come argomento un riferimento ad un oggetto della stessa classe viene chiamato costruttore di copia Point2D :: Point2D(const Point2D & pt) : m_x(pt.m_x), m_y(pt.m_y) { Il costruttore di copia viene normalmente utilizzato: quando un oggetto è inizializzato per assegnazione Point2D pt1(1,3), pt2(pt1); Point2D pt3 = pt1; // pt3 e pt2 vengono inizializzati con il costruttore di copia quando un oggetto è passato come argomento ad una funzione quando un oggetto è ritornato da una funzione Se il costruttore di copia non viene fornito esplicitamente, il compilatore ne genererà uno automaticamente Corso di Fondamenti di Informatica II 51

13 (3) I dati membro di una classe possono essere inizializzati nel costruttore per mezzo di una lista di inizializzatori, che precede il corpo della funzione Point2D::Point2D(double x, double y) : m_x(x), m_y(y) Lista di inizializzatori { I dati membro (non statici) che siano o riferimenti o const devono essere inizializzati nella lista di inizializzatori I dati membro sono inizializzati nell ordine della loro dichiarazione nella classe, non nell ordine in cui compaiono nella lista di inizializzatori Corso di Fondamenti di Informatica II 52

14 (4) Quando uno dei dati membro è esso stesso un oggetto, il costruttore appropriato viene scelto sulla base dei parametri forniti nell inizializzazione. class A { public: A(int x = 0) : m_x(x) { // altri metodi private: int m_x; class B { public: B(const A &a1, int z); // altri metodi private: A m_a1, m_a2, m_a3; B::B(const A &a1, int z) : m_a1(a1), m_a3(z) { // m_a1 : costruttore di copia // m_a2, m_a3 : costruttore di default Ogni dato membro che non compare nella lista di inizializzatori viene inizializzato chiamando il costruttore di default della classe a cui il dato membro appartiene Corso di Fondamenti di Informatica II 53

15 (5) 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 Point2D::~Point2D() { // vuoto, in questo caso Corso di Fondamenti di Informatica II 54

16 (6) Icostruttori con un solo parametro sono automaticamente trattati come operatori di conversione Point2D:: Point2D(int i) {... // costruisce un punto a partire da un intero, ma puo // essere usato per convertire un intero in un punto p = Point2D(i); Per evitare la conversione si può usare explicit explicit Point2D(int); // solo costruttore Corso di Fondamenti di Informatica II 55

17 Una classe che ha dei membri di tipo puntatore deve sempre definire un costruttore di copia class IVector { public: IVector(int len=100):m_len(len){ m_data = new int[m_len]; for (int i=0; i<m_len; ++i) m_data[i] = 0; ~IVector() { delete [] m_data; int size() { return m_len; int & item(int index) { return m_data[index]; private: int m_len; int *m_data; ; int main() { IVector v1(10), v2 = v1; v1.item(0) = 10; // v2[0]==10! return 0; // crash! Soluzione: costruttore di copia IVector::IVector(const IVector &src) : m_len(src.m_len) { m_data = new int[m_len]; for (int i=0; i<m_len; ++i) m_data[i] = src.m_data[i]; Corso di Fondamenti di Informatica II 56

18 La parola chiave friend può essere usata per permettere che una certa funzione o classe abbia libero accesso ai dati privati della classe class A { private: int m_x; friend int fun(const A &); friend void C::f(int); ; class B { private: int m_y; friend class C; ; class C { void f(int i); void g(); ; int fun(const A & a) { return a.m_x; // OK perché friend void C::f(int i) { A a; a.m_x = i*10; // OK perché friend void C::g() { A a; a.m_x = 12; //errore: g non è friend Corso di Fondamenti di Informatica II 57

19 (2) friend e nemico dell incapsulamento e quindi dell OOP Un uso eccessivo di friend è quasi sempre sintomo di un cattivo disegno Esistono anche situazioni in cui l uso di friend può essere accettabile Overloading di operatori binari Considerazioni di efficienza Relazione speciale fra due classi Corso di Fondamenti di Informatica II 58

20 Variabili membro dichiarate static in una classe sono condivise da tutti gli oggetti di quella classe Funzioni membro dichiarate static non possono accedere a membri non statici della classe Variabili membro statiche possono essere usate e modificate soltanto da funzioni membro statiche I membri static possono essere public, private, o protected Corso di Fondamenti di Informatica II 59

21 Un esempio: un contatore di istanze Class MyClass { private: static int instancecount; static void incrementcount() {instancecount++; static void decrementcount() {instancecount--; public: MyClass() {incrementcount(); ~MyClass() {decrementcount(); static int getinstancecount() { return instancecount; ; #include <iostream.h> #include MyClass.h int MyClass:: instancecount=0; int main() { MyClass a,b,c; MyClass *p=new MyClass; Un membro statico deve essere inizializzato una e una sola volta nel codice eseguibile Un metodo statico puo essere invocato cosi... cout<< How many? << MyClass::getInstanceCount() <<endl; delete p; cout<< and now? << a.getinstancecount() <<endl; return 0; o cosi`... Corso di Fondamenti di Informatica II 60

22 In un progetto C++ il codice è organizzato in Header files (.h o.hh) contengono dichiarazioni di classe e prototipi di funzioni un dato header file non deve essere incluso più volte nello stesso file sorgente File sorgente (.C,.cxx,.cpp,.cc) #ifndef MyClass_H #define MyClass_H // dichiarazioni.. #endif contengono l implementazione di funzioni e metodi includono gli header files mediante la direttiva #include del precompilatore Gli utilizzatori di una classe devono solo includere l header file contenente la dichiarazione della classe (chi utilizza una classe non ha bisogno di sapere come questa è implementata ma solo di conoscere la sua interfaccia) Corso di Fondamenti di Informatica II 61

23 In C++ è possibile effettuare l overloading degli operatori per utilizzarli sugli oggetti delle classi definite dagli utenti complex.h class Complex { double m_re, m_im; public : Complex(double re, double im) : m_re(re), m_im(im) { // ; #include complex.h void main { Complex c1(1, 2), c2(3,4); Complex c3 = c1 + c2; ridefinizione di + Obiettivo: scrivere le espressioni in cui compaiono gli oggetti con la stessa concisione delle espressioni in cui compaiono i tipi predefiniti Corso di Fondamenti di Informatica II 62

24 (2) Permette di utilizzare tipi definiti dall utente come se fossero tipi fondamentali E possibile effettuare l overloading di qualunque operatore ad eccezione di..* ::? sizeof La cardinalità, l associatività e la precedenza di un operatore non possono essere modificati Non è possibile creare nuovi operatori ma solo ridefinire quelli esistenti L overloading di un operatore è effettuato mediante la definizione di una funzione operatore Corso di Fondamenti di Informatica II 63

25 (3) Le funzioni operatore possono essere implementate come Funzioni membro tipo_di_ritorno nome_classe::operator op(argomenti) op è l operatore da ridefinire Funzioni non membro tipo_di_ritorno operator op(argomenti) Non sempre è possibile ridefinire un operatore come funzione membro #include <iostream> #include complex.h void main { Complex c1(1, 2); cout << c1; // operando sx non di tipo Complex ostream & operator << (ostream & os, const Complex & c); Corso di Fondamenti di Informatica II 64

26 Operatori unari sono implementati come (4) metodi senza argomenti (l oggetto è l argomento implicito) class Date { public: Date(int d, int m, int y); Date & operator++(); //preincr. ; void main() { Date d(12,03,2002); ++d; // d.operator++(); funzioni friend a un solo argomento class Date { public: Date(int d, int m, int y); friend Date & operator++(date &); ; void main() { Date d(12,03,2002); ++d; // operator++(d); Date & operator++(date &); Corso di Fondamenti di Informatica II 65

27 Overloading di operatori (5) Operatori binari possono essere implementati come metodi con un argomento (il primo argomento, implicito, è l oggetto il cui operatore agisce) class Complex { double m_re, m_im; public: Complex(double re, double im); const Complex operator+(const Complex & c) { return Complex(m_re + c.m_re, m_im + c.m_im); ; funzioni friend a due argomenti. class Complex { public: Complex(double re, double im); friend const Complex operator+(const Complex &c1, const Complex &c2); ; const Complex operator+(const Complex & c1, const Complex & c2); Corso di Fondamenti di Informatica II 66

28 Ogni oggetto puo accedere al proprio indirizzo tramite un puntatore di nome this Il valore di this non puo essere cambiato per una classe A il tipo di this e A* const o const A* const E particolarmente utile quando si definisce un operatore di assegnazione (=) o, in generale, quando si vuole restituire una copia o un riferimento all oggetto stesso class Time { public: Time(int h, int m, int s); Time & sethour(int h); Time & setmin(int m); private: int hh, mm, ss; ; Time & Time::setHour(int h) { hh = (h>0 && h <24)? h : 0; return *this; void main() { Time t(12,03,58); t.sethour(11).setmin(8); Corso di Fondamenti di Informatica II 67

29 L overload dell operatore di assegnazione L operatore di assegnazione e un operatore binario invocato dal compilatore quando compare un istruzione di assegnazione fra variabili non utilizzata per inizializzare un oggetto class MyClass {/*..*/; void main() { MyClass b; MyClass a = b; // costruttore di copia a = b; // a.operator=(b); In assenza di overload, il compilatore crea una veersione di default di tale operatore che effettua una copia degli oggetti membro a membro Corso di Fondamenti di Informatica II 68

30 L overload dell operatore di assegnazione (2) Una classe che ha dei membri di tipo puntatore deve sempre ridefinire l operatore = In assenza di overload, dopo l assegnazione la memoria puntata prima dell assegnazione dalla variabile puntatore dell operando sinistro non e piu accessibile i due oggetti hanno un puntatore alla stessa area di memoria L overload dell operatore = permette di eseguire la copia dell area puntata e non del puntatore. La memoria precedentemente puntata dall operando sinistro deve comunque essere deallocata e nuova memoria deve essere allocata Corso di Fondamenti di Informatica II 69

31 L overload dell operatore di assegnazione (3) Senza overload di = class IVector { public: IVector(int len=100):m_len(len) void main() { { /* */ IVector v1(10), v2(20); ~IVector() {/* */ v2 = v1; /* */ for (int i=0; i<v1.size(); ++i) int & operator [] (int i) { v1[i] = i; // v2[i]==i! assert(i>0 && i<m_len); // crash! return m_data[i] IVector & operator(const IVector &); Soluzione: overload di = private: int m_len; int *m_data; ; IVector & IVector::operator=(const IVector &src) { if (this == &src) return *this; if (m_data) delete [] m_data; m_len = src.m_len m_data = new int[m_len]; for (int i=0; i<m_len; ++i) m_data[i] = src.m_data[i]; return *this; Corso di Fondamenti di Informatica II 70

32 Overload degli operatori di I/O su stream Gli operatori << e >> possono essere ridefiniti per consentire operazioni del tipo: IVector v(10); for (int i=0; i<v.size(); ++i) v[i] = i; cout << Il vettore v vale << v << endl; Si utilizza una funzione friend: class IVector { friend ostream& operator<<(ostream& os, const IVector & v); /* */ ; ostream& operator <<(ostream& os, const IVector & v){ for (int i=0; i<v.size(); ++i) os << v[i] <<, ; return os ; // consente di scrivere cout << v1 << v2 Corso di Fondamenti di Informatica II 71

33 Un esempio, la classe Complex // complex.h #ifndef COMPLEX_H_INCLUDED #define COMPLEX_H_INCLUDED // definizione della classe Complex class Complex { public: Complex(double re=0, double im=0) : m_re(re), m_im(im) { Complex(const Complex & c) : m_re(c.m_re), m_im(c.m_im) { ~Complex() { double real() { return m_re; double imag() { return m_im; Complex & operator= (const Complex & c); Complex & operator+=(const Complex & c); Complex & operator-=(const Complex & c); Complex & operator*=(const Complex & c); Complex operator+ (); Complex operator- (); Complex operator+ (double x); Complex operator- (double x); Complex operator* (double x); bool operator==(double x); bool operator!=(double x); friend Complex operator+(double x, const Complex & c); friend Complex operator-(double x, const Complex & c); friend Complex operator*(double x, const Complex & c); friend bool operator==(double x, const Complex& c); friend bool operator==(const Complex & c1, const Complex & c2); friend bool operator!=(const Complex & c1, const Complex & c2); friend bool operator!=(double x, const Complex& c); friend const Complex operator+(const Complex& c1, const Complex& c2); friend const Complex operator-(const Complex & c1, const Complex & c2); friend const Complex operator*(const Complex & c1, const Complex & c2); private: double m_re, m_im; ; 72

34 // continua complex.h // dichiarazione delle funzioni operatore non membro Complex operator+(double x, const Complex & c); Complex operator-(double x, const Complex & c); Complex operator*(double x, const Complex & c); bool operator==(double x, const Complex& c); bool operator==(const Complex & c1, const Complex & c2); bool operator!=(const Complex & c1, const Complex & c2); bool operator!=(double x, const Complex& c); const Complex operator+(const Complex& c1, const Complex& c2); const Complex operator-(const Complex & c1, const Complex & c2); const Complex operator*(const Complex & c1, const Complex & c2); #endif // fine di complex.h 73

35 // complex.cpp #include complex.h // implementazione delle funzioni membro della classe Complex Complex & Complex::operator=(const Complex & c) { m_re = c.m_re; m_im = c.m_im; Complex & Complex::operator+=(const Complex & c) { m_re += c.m_re; m_im += c.m_im; return *this; Complex & Complex::operator-= (const Complex & c){ m_re -= c.m_re; m_im -= c.m_im; return *this; Complex & Complex::operator*= (const Complex & c){ m_re *= c.m_re; m_im *= c.m_im; return *this; Complex Complex::operator+() { return *this; Complex Complex::operator-() { return Complex(-m_re, -m_im); Complex Complex::operator+(double x) { return Complex(m_re + x, m_im); Complex Complex::operator-(double x) { return Complex(m_re - x, m_im); Complex Complex::operator*(double x) { return Complex(m_re * x, m_im * x); bool Complex::operator==(double x) { return m_re == x && m_im == 0; bool Complex::operator!=(double x) { return!operator==(x); 74

36 // continua complex.cpp // implementazione delle funzioni operatore non membro Complex operator+(double x, const Complex & c) { return Complex(x + c.m_re, c.m_im); Complex operator-(double x, const Complex & c) { return Complex(x - c.m_re, -c.m_im); Complex operator*(double x, const Complex & c) { return Complex(x * c.m_re, x * c.m_im); const Complex operator+(const Complex & c1, const Complex & c2) { return Complex(c1.m_re + c2.m_re, c1.m_im + c2.m_im); const Complex operator-(const Complex & c1, const Complex& c2) { return Complex(c1.m_re - c2.m_re, c1.m_im - c2.m_im); const Complex operator*(const Complex& c1, const Complex& c2) { return Complex(c1.m_re * c2.m_re - c1.m_im * c2.m_im, c1.m_re * c2.m_im + c1.m_im * c2.m_re); bool operator==(const Complex& c1, const Complex& c2) { return c1.m_re == c2.m_re && c1.m_im == c2.m_im; bool operator==(double x, const Complex& c) { return x == c.m_re && 0 == c.m_im; bool operator!=(const Complex& c1, const Complex& c2) { return c1.m_re!= c2.m_re c1.m_im!= c2.m_im; bool operator!=(double x, const Complex& c) { return x!= c.m_re 0!= c.m_im; 75