La programmazione ad oggetti (Parte 1)

Transcript

1 La programmazione ad oggetti (Parte 1) Algoritmicamente November 21, Introduzione Una proprietà importante del C++ è quella che denisce questo linguaggio come linguaggio orientato agli oggetti. Uno dei tanti strumenti di cui fa uso la programmazione ad oggetti è l'astrazione. Denizione 1.1 L'astrazione, in informatica, è un processo tramite cui si descrivono dei modelli concettuali soermandosi sulle proprietà che questi posseggono. Denizione 1.2 Un oggetto è un ente composto da attributi e comportamenti utili alla rappresentazione di un concetto. Ricordiamo anche che un oggetto non è altro che un'area di memoria allocata. Una volta dichiarato un oggetto(o variabile) il computer non fa altro che destinare un area di memoria dedicata, contraddistinta da un indirizzo. 2 Le classi Altro strumento fondamentale della programmazione ad oggetti sono le classi. Denizione 2.1 Una classe è uno strumento utile alla costruzione di strutture dati che comprendono non solo i dati ma anche i metodi per gestirli. Una classe ci aiuta nella costruzione degli oggetti, accorpando i dati necessari alla rappresentazione dell'oggetto(attributi o dati membro) e il codice necessario a gestirne il comportamento(metodi o funzioni membro). Denizione 2.2 Un membro di una classe è un elemento, sia esso dato o funzione, dichiarato nel corpo della classe. Denizione 2.3 Il corpo della classe è la parte interna della classe stessa, ed è racchiuso tra parentesi grae, di cui l'ultima è seguita da un punto e virgola. 1

2 Per semplicità, possiamo vedere una classe come un tipo di variabile(int, char, bool,... ), e un oggetto come una variabile di quel tipo. Infatti, durante la dichiarazione di una variabile(o oggetto) come per esempio int numero; notiamo che numero è una variabile di tipo int (intero), ma int, difatti, è un tipo di variabile. Quando siamo noi a creare un tipo di oggetto, accade la stessa cosa. Per questo motivo le classi sono anche chiamate tipi deniti dall'utente. La sintassi per la costruzione di una classe è la seguente: class Character ; Dunque, il nuovo tipo di variabile si chiamerà Character, e facendo una dichiarazione otterremo Character personaggio; dove personaggio sarà il nome del nuovo oggetto di tipo Character. Come già detto in precedenza, abbiamo bisogno degli attributi e dei metodi per poter creare un oggetto, di conseguenza dobbiamo inserire questi dati nel corpo della classe. Il corpo della classe può essere suddiviso in 3 sottoparti: public, protected, private. Ogni sottoparte rappresenta un livello di accesso(pubblico, protetto o privato) riferito ai dati inseriti al suo interno. Non è tuttavia vietato dichiarare dei membri fuori dai livelli di accesso, vedremo infatti in seguito come le funzioni friend non vengano inserite in nessuno di questi livelli. La sintassi per la dichiarazione dei livelli di accesso è la seguente: class Character ; public: protected: private: Nota: Non è obbligatorio inserire tutti i livelli di accesso. Questi, inoltre, non hanno un ordine di inserimento prestabilito. Introduciamo qui il concetto di information hiding o di incapsulamento dei dati. Poiché vogliamo proteggere i dati membro della classe dall'accesso diretto da parte di qualsiasi altra funzione del programma, non dichiarata nel corpo della classe, utilizziamo i livelli di accesso: 2

3 I membri pubblici sono accessibili da qualsiasi punto del programma. In questo livello di accesso vengono generalmente inserite le funzioni membro che possono essere utilizzate dal programma per gestire gli oggetti di quella classe. I membri protetti vengono trattati principalmente assieme all'ereditarietà(argomento di cui parleremo in seguito), ma per ora li considereremo come privati. I membri privati sono accessibili solo dalle funzioni membro e dalle funzioni friend (di cui parleremo in seguito) della classe. In questo livello di accesso, applicando sempre l'incapsulamento dei dati, vengono dichiarati gli attributi della classe e le funzioni di utilità, ovvero delle funzioni che vengono chiamate da funzioni pubbliche. Le classi vengono generalmente create in documenti a parte, ovvero in un le.h, detto le header, dove si crea la classe con i suoi dati e le sue funzioni membro, e un le.cpp dove viene incluso il le.h e si implementano i suoi metodi. Quando vorremo utilizzare le classi da noi create, nel main includeremo i le.h necessari. Da notare che per includere i le.h dobbiamo utilizzare il doppio apice e non le parentesi angolari: #include Character.h Inoltre, nei le.h, viene utilizzata una direttiva che ci assicura che il codice all'interno di questa, nel nostro caso l'intero le.h, venga compilato solo una volta anche se viene incluso più volte in diversi punti del nostro codice; una volta compilato quindi, se il compilatore ritroverà incluso il le.h in questione, salterà tutto il codice all'interno della direttiva. La direttiva è la seguente: #ifndef CHARACTER_H #define CHARACTER_H class Character ; #endif Nota: Il nome del le.h deve essere necessariamente inserito tutto a caratteri maiuscoli, e al posto del punto '.' ci va un underscore '_'. 3 Il costruttore Esiste una funzione membro particolarmente importante che viene chiamata costruttore. Denizione 3.1 Il costruttore è una funzione membro, denita come pubblica che deve avere lo stesso nome della classe. 3

4 Il costruttore viene utilizzato per inizializzare le variabili della classe stessa e per allocare aree di memoria; può inoltre prendere in input argomenti, come per qualsiasi funzione. Una volta denita una classe, quando andiamo a dichiarare un oggetto di quel tipo, viene chiamato il costruttore, che può essere quello da noi denito oppure, nel caso in cui non lo avessimo fatto, viene chiamato il costruttore di default generato dal compilatore. Proviamo ora a denire qualche costruttore: Character::Character() name = ; //variabile di tipo string hp = 0; mp = 0; //variabile di tipo int //variabile di tipo int Character::Character(string n, int h, int m) name = n; hp = h; mp = m; Abbiamo denito due costruttori diversi per la stessa classe. Il primo, non prende in input alcun argomento e inizializza le variabili della classe a 0, mentre il secondo, prendendo in input degli argomenti, li assegna ai dati membro. Notiamo inoltre come la sintassi per la denizione di una funzione membro, compreso il costruttore, richieda la denizione della classe di appartenenza, ovvero: Character:: Dichiarando dunque degli oggetti di tipo Character: Character personaggio1; Character personaggio2(p2, 100, 50 ); osserviamo che nel momento in cui dichiariamo l'oggetto personaggio1, non avendo passato alcun argomento, verrà chiamato il primo costruttore che abbiamo denito, inizializzando tutti i dati membro a 0, mentre dichiarando l'oggetto personaggio2 verrà chiamato il secondo costruttore, assegnando rispettivamente P2 alla variabile name, 100 ad hp, e 50 ad mp. Non esistono dunque limiti per il numero di costruttori che possiamo denire, possiamo denirne per esempio due, come in questo caso, oppure nessuno, e in tal caso verrà generato automaticamente un costruttore di default da parte del compilatore. 4 Le funzioni set e get Le funzioni set e get sono delle funzioni che ritroveremo spesso nella programmazione ad oggetti, in quanto verranno utilizzate rispettivamente per assegnare 4

5 un valore ad ogni singola variabile della classe e per prenderne il contenuto. Sono funzioni semplicissime nella loro struttura, ma è comunque utile descriverle anchè se ne apprenda bene l'utilizzo. Qui di seguito deniamo la funzione set e la funzione get per la variabile name della classe Character : void Character::setName(string n) name = n; string Character::getName() return name; Si noti bene il tipo con cui sono state dichiarate queste funzioni. Le funzioni set vengono denite come void in quanto il loro unico scopo è quello di assegnare la variabile passata come argomento alla variabile destinataria prescelta, in questo caso name, e quindi non viene richiesto di ritornare alcun valore. Le funzioni get invece, necessitano di essere denite del tipo della variabile di cui desideriamo estrarne il valore; in questo caso, dato che ci interessa il valore della variabile name, la funzione get sarà denita di tipo string, e non prenderà nessun parametro in input dato che dobbiamo seplicimente fare un return. Per utilizzare qualsiasi funzione implementata per un tipo di oggetto, su un oggetto sempre di quel tipo (Character nel nostro caso) che abbiamo in un main, si utilizza la seguente sintassi: nomeoggetto.nomemetodo( ); che nel nostro caso diventa per esempio: personaggio1.setname(p1); Per concludere questa prima parte, vediamo un esempio completo di denizione di classe con implementazione dei vari metodi e un main dimostrativo. // Character.h #ifndef CHARACTER_H #define CHARACTER_H #include <string> using namespace std; class Character private: string name; 5

6 ; int hp; int mp; public: Character( ); Character(string n, int h, int m); void setname(string n); void sethp(int h); void setmp(int m); string getname(); int gethp(); int getmp(); #endif //Character.cpp #include Character.h #include <iostream> using namespace std; Character::Character() name = ; hp = 0; mp = 0; Character::Character(string n, int h, int m) name = n; hp= h; mp = m; void Character::setName(string n) name = n; void Character::setHp(int h) hp = h; void Character::setMp(int m) 6

7 mp = m; string Character::getName() return name; int Character::getHp() return hp; int Character::getMp() return mp; //main.cpp #include Character.h #include <iostream> using namespace std; int main() Character personaggio1; Character personaggio2(p2, 100, 50); //Caratteristiche del personaggio1 solo con il primo costruttore cout << Caratteristiche personaggio1 (solo con il costruttore) : \n\n; cout << Nome: << personaggio1.getname() << endl; cout << Hp: << personaggio1.gethp() << endl; cout << Mp: << personaggio1.getmp() << endl; cout << endl; personaggio1.setname(p1); personaggio1.sethp(150); personaggio1.setmp(75); //Caratteristiche del personaggio1 dopo le funzioni set e get cout << Caratteristiche personaggio1 (dopo i metodi set e get) : \n\n; cout << Nome: << personaggio1.getname() << endl; cout << Hp: << personaggio1.gethp() << endl; cout << Mp: << personaggio1.getmp() << endl; 7

8 cout<<endl; //Caratteristiche personaggio2 con il secondo costruttore cout << Caratteristiche personaggio2: \n\n; cout << Nome: << personaggio2.getname() << endl; cout << Hp: << personaggio2.gethp() << endl; cout << Mp: << personaggio2.getmp() << endl; return 0; Output: Caratteristiche personaggio1 (solo con il costruttore) : Nome: Hp: 0 Mp: 0 Caratteristiche personaggio1 (dopo i metodi set e get) : Nome: P1 Hp: 150 Mp: 75 Caratteristiche personaggio2: Nome: P2 Hp: 100 Mp: 50 8