Lezione 4. Costruttori

Transcript

1 Lezione 4 Costruttori e distruttori Costruttori Quando si crea un oggetto di una classe è possibile inizializzarne i membri tramite il costruttore di classe Il costruttore è una funzione membro che ha lo stesso nome della classe deve essere scritto esplicitamente dal programmatore se non lo si fa il compilatore crea un costruttore di default i costruttori non possono restituire nessun valore (nemmeno void) 1

2 Costruttori I dati membro non possono essere inizializzati esplicitamente all interno della definizione di una classe assicurarsi sempre di inizializzare i dati membro con valori significativi in particolare i puntatori dovrebbero essere inizializzati a NULL o meglio a 0 si possono avere più di un costruttore (per casi differenti di inizializzazione) utilizzando l overloading Costruttori si possono (dovrebbero) utilizzare costruttori con argomenti di default se tutti gli argomenti del costruttore hanno un default questo diventerà il costruttore di default ovvero il costruttore che viene invocato quando non sono specificati inizializzatori (ne può esistere solo uno) i valori di default dovrebbero essere dichiarati solo nei prototipi 2

3 Costruttori Se esiste una funzione set per attribuire un insieme di valori ai dati membri, allora conviene utilizzare una chiamata a questa funzione all interno del costruttore in questo modo non si duplica codice per rendere il tutto più efficiente si può dichiarare la funzione set inline (ad esempio definendola all interno della classe) Esempio #ifndef TIME2_H #define TIME2_H // Time abstract data type definition class Time { public: Time( int = 0, int = 0, int = 0 ); // default constructor void settime( int, int, int ); // set hour, minute, second void printmilitary(); // print military time format void printstandard(); // print standard time format private: int hour; // 0-23 int minute; // 0-59 int second; // 0-59 ; #endif 3

4 // Member function definitions for Time class. #include <iostream> #include "time2.h // Time constructor initializes each data member to zero. // Ensures all Time objects start in a consistent state. Time::Time( int hr, int min, int sec ) { settime( hr, min, sec ); // Set a new Time value using military time. Perform validity // checks on the data values. Set invalid values to zero. void Time::setTime( int h, int m, int s ) { hour = ( h >= 0 && h < 24 )? h : 0; minute = ( m >= 0 && m < 60 )? m : 0; second = ( s >= 0 && s < 60 )? s : 0; // Print Time in military format void Time::printMilitary() { cout << ( hour < 10? "0" : "" ) << hour << ":" << ( minute < 10? "0" : "" ) << minute; // Print Time in standard format void Time::printStandard() { cout << ( ( hour == 0 hour == 12 )? 12 : hour % 12 ) << ":" << ( minute < 10? "0" : "" ) << minute << ":" << ( second < 10? "0" : "" ) << second << ( hour < 12? " AM" : " PM" ); 4

5 #include <iostream> #include "time2.h int main() { Time t1, // all arguments defaulted t2(2), // minute and second defaulted t3(21, 34), // second defaulted t4(12, 25, 42), // all values specified t5(27, 74, 99); // all bad values specified cout << "Constructed with:\n" << "all arguments defaulted:\n "; t1.printmilitary(); cout << "\n "; t1.printstandard(); cout << "\nhour specified; minute and second defaulted:" << "\n "; t2.printmilitary(); cout << "\n "; t2.printstandard(); cout << "\nhour and minute specified; second defaulted:" << "\n "; t3.printmilitary(); cout << "\n "; t3.printstandard(); cout << "\nhour, minute, and second specified:" << "\n "; t4.printmilitary(); cout << "\n "; t4.printstandard(); cout << "\nall invalid values specified:"<< "\n "; t5.printmilitary(); cout << "\n "; t5.printstandard(); cout << endl; return 0; 5

6 Distruttore Un distruttore è una funzione membro speciale di una classe il nome del distruttore è composto da una tilde ~ seguito dal nome della classe (è una specie di complemento del costruttore) un distruttore non riceve parametri e non restituisce alcun valore (nemmeno void) una classe può avere un solo distruttore (non è ammesso overloading) Distruttore il distruttore viene invocato quando l esecuzione del programma olterpassa lo scope in cui l oggetto è istanziato il distruttore effettua delle operazioni sulla memoria occupata dall oggetto prima di restituire tale memoria al sistema in modo che possa essere riutilizzata per memorizzare nuovi oggetti 6

7 Esempio: #include <iostream> class Stack{ public: Stack(int); ~Stack(); void push(int); private: int *array; int dim; int tos; ; Stack::Stack(int num){ tos=0; dim=num; array=new int[dim]; Stack::~Stack(){delete [] array; void Stack::push(int n){ if(tos<dim) { array[tos]=n; tos++; int main(){ Stack v(10); for(int i=0;i<10;i++) v.push(i); return 0; 7

8 Quando sono chiamati i costruttori e i distruttori? Le chiamate a costruttori e distruttori sono automatiche il loro ordine dipende dall ordine in cui il flusso di esecuzione entra ed esce dallo scope in cui sono istanziati gli oggetti in generale i distruttori sono chiamati in ordine inverso rispetto ai costruttori ma il tipo di memorizzazione (es. static) può alterare tale ordine Quando sono chiamati i costruttori e i distruttori? Oggetti globali: I costruttori degli oggetti che hanno scope globale sono chiamati prima di ogni altra funzione (main inclusa) i distruttori corrispondenti sono chiamati quando main termina o viene invocata la funzione exit() 8

9 Quando sono chiamati i costruttori e i distruttori? Oggetti locali: i costruttori sono chiamati per gli oggetti locali nel momento in cui l esecuzione raggiunge il punto in cui sono definiti i distruttori sono chiamati quando l esecuzione oltrepassa lo scope degli oggetti in questione, ovvero al termine del blocco in cui sono definiti Quando sono chiamati i costruttori e i distruttori? Oggetti static: i costruttori sono chiamati solo una volta: la prima volta in cui l esecuzione raggiunge il punto in cui sono definiti il distruttore viene chiamato quando main termina o quando viene invocata la exit() 9

10 Esempio // Definition of class CreateAndDestroy. // Member functions defined in create.cpp. #ifndef CREATE_H #define CREATE_H class CreateAndDestroy { public: CreateAndDestroy( int ); // constructor ~CreateAndDestroy(); // destructor private: int data; ; #endif // Member function definitions for class CreateAndDestroy #include <iostream> #include "create.h" CreateAndDestroy::CreateAndDestroy( int value ) { data = value; cout << "Object " << data << " constructor"; CreateAndDestroy::~CreateAndDestroy(){ cout << "Object " << data << " destructor " << endl; 10

11 // Demonstrating the order in which constructors and // destructors are called. #include <iostream> #include "create.h" void create( void ); // prototype CreateAndDestroy first( 1 ); // global object int main() { cout << " (global created before main)" << endl; CreateAndDestroy second( 2 ); // local object cout << " (local automatic in main)" << endl; static CreateAndDestroy third( 3 ); // local object cout << " (local static in main)" << endl; create(); // call function to create objects CreateAndDestroy fourth( 4 ); // local object cout << " (local automatic in main)" << endl; return 0; // Function to create objects void create( void ) { CreateAndDestroy fifth( 5 ); cout << " (local automatic in create)" << endl; static CreateAndDestroy sixth( 6 ); cout << " (local static in create)" << endl; CreateAndDestroy seventh( 7 ); cout << " (local automatic in create)" << endl; 11

12 Esempio Output: Object 1 constructor (global created before main) Object 2 constructor (local automatic in main) Object 3 constructor (local static in main) Object 5 constructor (local automatic in create) Object 6 constructor (local static in create) Object 7 constructor (local automatic in create) Object 7 destructor Object 5 destructor Object 4 constructor (local automatic in main) Object 4 destructor Object 2 destructor Object 6 destructor Object 3 destructor Object 1 destructor Costruttore di copia Esiste un tipo speciale di costruttore detto costruttore di copia serve per inizializzare un oggetto tramite un altro oggetto Il costruttore di copia è una funzione membro che ha lo stesso nome della classe e ha come argomento un riferimento costante ad un oggetto della stessa classe NomeClasse(const NomeClasse &) Il compilatore crea un costruttore di copia bit a bit di default 12

13 Quando viene invocato il costruttore di copia Ci sono tre casi in cui viene invocato il costruttore di copia: inizializzazione esplicita passaggio per valore ad una funzione restituzione di un oggetto temporaneo Inizializzazione Esplicita Time t1(12,00); Time t2(t1); Time t3=t1; Le due forme t2(t1) e t3=t1 sono equivalenti Nota: t3=t1 non è una assegnazione ma una inizializzazione Ogni dato membro di t2 viene inizializzato con i valori dei dati membro corrispondenti di t1 13

14 Passaggio per valore ad una funzione void func(time); void main(){ Time t(12,00); func(t); void func(time myt){ cout<<myt; Ogni dato membro di myt viene inizializzato con i valori dei dati membro corrispondenti di t Nota: utilizzando il costruttore standard, myt sarebbe inizializzato con valori (di default) diversi da quelli di t e questo sarebbe un errore logico Restituzione di un oggetto temporaneo Time func(time); void main(){ Time t(12,00), t2; t2=func(t); Time func(time myt){ myt.ora+=1; return myt; 14

15 Spiegazione L oggetto myt è locale alla funzione func. Non è pertanto possibile riferirsi a tale oggetto al di fuori della funzione. Quando viene eseguita l istruzione t2=func(t) accade in realtà la seguente cosa: viene creato un oggetto temporaneo [result] qusto oggetto viene inizializzato per copia con l oggetto restituito da func: [result]=myt di func(t) viene distrutto myt viene eseguita l assegnazione t2=[result] Nota sul Costruttore di copia Si deve necessariamente passare un riferimento per alias al costrutture di copia Non sarebbe logicamente possibile effettuare un passaggio di parametri per valore Dare la possibilità di creare un costruttore di copia con passaggio di parametro per valore comporta una dipendenza logica circolare infatti si dovrebbe copiare l oggetto nella variabile locale in ingresso al costruttore ma questo richiamerebbe proprio il costruttore di copia il ciclo continuerebbe senza fine 15

16 Costruttore di Copia con dati dinamici E necessario creare esplicitamente un costruttore di copia quando un oggetto ha dati membro allocati dinamicamente Per oggetti con dati allocati dinamicamente la copia bita-bit copia solo il dato puntatore, cioè l indirizzo di memoria quando un oggetto B è inizializzato come copia di un oggetto A si ha che entrambi gli oggetti hanno un puntatore che indirizza la stessa area di memoria quando si dealloca il dato per un oggetto questo non esiste più nemmeno per la copia si corre il rischio di deallocare due volte la stessa area di memoria! Costruttore di copia class Array{ public: Array(int usr_size=10){ size=usr_size; ptr=new int[size]; Array(const Array& copia){ size=copia.size; ptr=new int[size]; for(int i=0;i<size;i++) ptr[i]=copia.ptr[i]; ~Array(){delete [] ptr; private: int *ptr; int size; ; 16