Salvatore Cuomo » 18.Il linguaggio C++ - parte seconda

Oggetti

Una volta definita la classe è possibile dichiarare un oggetto di tale classe. Un oggetto è un’istanza di una classe.

Si può pensare che oggetti e classi sono nello stesso rapporto di tipi e variabili. Ad esempio con la direttiva:

point A;

si dichiara dichiaro un oggetto della classe point, mentre con:

point B[3];

si dichiara un array di oggetti della classe point di dimensione 3.

Metodi

Invocazione dei metodi e dei dati membro

Per invocare un metodo si utilizza la sintassi:

nome_oggeto.nome_metodo(argomenti)

Esempio.

Per invocare setx sull’oggetto A ed assegnare alla coordinata x di A il valore 3 scriveremo

point A;
A.setx(3); // Assegno al dato membro _x di A il valore 3
...

Analogamente per accedere ad un dato membro si utilizza la sintassi:

nome_oggeto.nome_dato_membro

Public e Private

Invocazione dei metodi e dei dati membro
Non tutti i dati membro ed i metodi sono accessibili all’esterno della classe ma soltanto quelli dichiarati public.
Le keyword public e private che delimitano le dichiarazioni servono a stabilire il tipo di accesso.
I membri o le funzioni private sono accessibili solo all’interno della classe.

class point {
private:

int _x, _y;

public:

void setx(const int val);
void sety(const int val);
void getx( ) { return _x}
void gety( ) { return _y}


};

Public e Private

Invocazione dei metodi e dei dati membro

Nella classe point i dati membro (_x e _y) non sono accessibili all’esterno, mentre tutti i metodi possono essere invocati.
Pertanto per assegnare un valore al dato membro _x dell’oggetto dobbiamo usare la sintassi:

point A;
A.setx(3); // Assegno al dato membro _x di A il valore 3
...

e non possiamo usare la sintassi:

point A;
A._x=3; // NON CONSENTITO
...

Accesso ai membri

Invocazione dei metodi e dei dati membro

È buona norma non consentire l’accesso diretto ai dati membro di una classe, ma creare metodi ad hoc per conoscerne od assegnarne il valore.

Nella classe point si utilizzano getx, gety, per conoscere _x e _y e setx e sety per assegnarli

class point {
private:


int _x, _y;


public:


void setx(const int val);
void sety(const int val);
void getx( ) { return _x}
void gety( ) { return _y}


};
...

Protected

Esiste un terza categoria di visibilità definibile tramite la keyword protected che verrà analizzata nel momento in cui parleremo dell’ereditarietà.

La sintassi per la dichiarazione di una classe è quindi:

class <NomeClasse> {
public:


<membri pubblici>


protected:


<membri protetti>


private:


<membri privati>


};

Qualora non specificato i dati membro di una classe sono privati.

Metodi di tipo inline

Si noti che i metodi setx e sety sono soltanto dichiarati mentre getx e gety sono definiti all’interno della classe
Questo equivale a definire i due metodi inline.

class point {
private:


int _x, _y;


public:


void setx(const int val);
void sety(const int val);
void getx( ) { return _x}
void gety( ) { return _y}


};

Metodi definiti esternamente

Quando i metodi vengono definiti all’esterno di una classe è possibile associarli ad essa mediante l’operatore ::
Tale operatore è necessario in quanto altre classi potrebbero definire un metodo con lo stesso nome
Per definire i metodi setx e sety all’esterno della classe utilizzeremo la sintassi:

void point::setx(const int val) {


_x=val


};
void point::sety(const int val) {


_y=val


};

Costruttori

I costruttori sono metodi invocati ogni volta che un oggetto viene dichiarato ed hanno lo scopo di inizializzare l’oggetto.

I costruttori si distinguono dagli altri metodi perché hanno lo stesso nome della classe e non restituiscono alcun valore.

È buona prassi fornire un costruttore per ogni classe definita.

Esempio

Definiamo un costruttore per la classe point

class point {
...


point( ) {


_x = _y = 0;


}


...
};
Il costruttore point() viene invocato ogni volta che viene definito un oggetto di tipo point e inizializza le coordinate _x e _y dell oggetto a 0

point: A // chiama point() per cui _x e _y di A sono nulle ...

Costruttori

Costruttori con argomenti

È possibile definire più costruttori che accettino diversi argomenti in input.
Definiamo un costruttore di point che inizializzi l’oggetto mediante valori passati come argomento


class point {
...


point(const int x, const int y ) {


_x = x ; _y = y;

}

Per utilizzare il costrutture point(const int x, const int y ) invece di point() nella dichiarazione dell’oggetto A useremo la sintassi

point A(3,2) // Inizializza _x e _y di A rispettivamente a 3 e a 2

Costruttore copia

È possibile definire un particolare costruttore detto costruttore copia che viene invocato quando si crea un oggetto e lo si vuole inizializzare mediante un oggetto preesistente della stessa classe.
Il costruttore copia si distingue dagli altri in quanto accetta come input un riferimento ad un oggetto della propria classe.
Tale costruttore è utile nel caso in cui all’atto dell’inizializzazione sia necessario eseguire delle operazioni particolari.

Esempio
Definiamo un costruttore copia per la classe point
class point {
...
point(const point &orig) {


_x = orig._x ; _y = orig._y;


}


...
};

Costruttore copia e distruttori

Per utilizzare il costruttore point(const point &) mediante la seguente sintassi:
...
point B;
...
point: A(B) // inizializza A con i valori di B
point C=B // inizializza C con i valori di B
...

Costruttore copia e distruttori

Distruttore
L’operatore complementare del costruttore è il distruttore che viene richiamato all’uscita del blocco in cui è stato dichiarato l’oggetto.

Un distruttore non accetta parametri di input ne restituisce valori in uscita

class point
{ private:


int _x, _y;


public:


...


~point( ) {


// non c'è molto da fare in questa classe }

Distruttori

L’operatore complementare del costruttore è il distruttore che viene richiamato all’uscita del blocco in cui è stato dichiarato l’oggetto.
Esempio
Definiamo il distruttore della nostra classe point in modo che ci stampi le coordinate del punto ogni volta che l’oggetto viene distrutto

class point {
private:


int _x, _y;


public:


...


~point( ) {


cout << "(" << _x; << _y << ")" << endl


}
...
};