Ereditarietà in C++: classi derivate

17 marzo 2006

Come abbiamo detto, una classe derivata può essere considerata un’estensione di una classe oppure una classe che eredita le proprietà e i metodi da un’altra classe. La classe originaria viene denominata classe base mentre la classe derivata viene anche chiamata sottoclasse (o classe figlia).

Fondamentalmente, una classe derivata consente di espandere o personalizzare le funzionalità di una classe base, senza costringere a modificare la classe base stessa.

È possibile derivare più classi da una singola classe base e la classe base può essere una qualsiasi classe C++ e tutte le classi derivate ne rifletteranno la descrizione.

In genere, la classe derivata aggiunge nuove funzionalità alla classe base. Ad esempio, la classe derivata può modificare i privilegi d’accesso, aggiungere nuove funzioni membro o modificare tramite overloading le funzioni membro esistenti.

La sintassi di una classe derivata

Per descrivere una classe derivata si fa uso della seguente sintassi:

class classe-derivata : <specificatore d'accesso> classe-base
{
	...
};

Ad esempio:

class pesce_rosso : public pesce
{
	...
};

In tal caso, la classe derivata si chiama pesce_rosso. La classe base ha visibilità pubblica e si chiama pesce.

Il meccanismo di ereditarietà, pur essendo abbastanza semplice, richiede una certa attenzione per non cadere in errori perchè dipende dallo standard della classe base.

Gli attibuti ed i membri che vengono ereditati dalla classe base possono cambiare la loro visibilità nella classe figlia, in base allo specificatore d’accesso con il quale si esegue l’ereditarietà stessa. Precisamente:

Se lo specificatore d’accesso è public:

  • i public restano public
  • i protected restano protected
  • I private non possono essere trasferiti

Se lo specificatore d’accesso è private:

  • i public diventano private
  • i protected diventano private
  • i private non possono essere trasferiti

Si ricordi, comunque, che durante l’ereditarietà un accesso può restringersi o restare uguale ma mai ampliarsi.

Esempio di ereditarietà

Vediamo ora un esempio che fa uso di una classe derivata: definiamo la classe animale e da essa facciamo discendere la classe cane.

Iniziamo con la definizione della classe base animale:

/*
 * animale.h
 */
class animale
{
	public:
		animale( );
		~animale( );

	protected:
		char specie[20];
		int eta;
		char sesso;

		void mangia ( );
		void beve ( );

	public:
		void ottieni_dati ( );
};
/*
 * animale.cpp
 */
#include <iostream.h>
#include "animale.h"

animale()
{
	strcpy(specie," ");
	cout << "Costruttore della classe animale\n";
}

~animale()
{
	cout << "Distruttore della classe animale\n";
}

void animale::mangia()
{
	cout << "Invocato il metodo mangia\n";
}

void animale::beve()
{
	cout << "Invocato il metodo beve\n";
}

void animale::ottieni_dati()
{
	cout << "Inserire l'età dell'animale: ";
	cin >> eta;
	cout << endl;

	cout << "Inserire il sesso dell'animale (M o F): ";
	cin >> sesso;
	cout << endl;
}

Definiamo ora la classe derivata cane:

/*
 * cane.h
 */
#include "animale.h"

class cane : public animale
{
	public:
		cane();
		~cane();
		void esegui_azioni();
		void stampa_dati();
	
	private:
		void abbaia();
};
/*
 * cane.cpp
 */
#include <iostream.h>
#include <string.h>
#include "cane.h"

cane()
{
	cout << "Costruito un oggetto di tipo cane\n";
	strcpy(specie,"cane");}

~cane()
{
	cout << "Distrutto un oggetto di tipo cane\n";
}

void cane::abbaia()
{
	cout << "Invocato il metodo abbaia\n";
}

void cane::stampa_dati()
{
	cout << "La specie dell'animale e': " << specie << endl;
	cout << "L' età dell'animale e': " << eta << endl;
	cout << "Il sesso dell'animale e' :" << sesso << endl;
}

void cane::esegui_azioni()
{
	mangia();
	beve();
	abbaia();
}

main()
{
	cane c;
	c.ottieni_dati();
	c.stampa_dati();
	c.esegui_azioni();
	return (0);
}

È utile esaminare questo semplice programma per capire il funzionamento delle classi derivate. Come si può osservare, abbiamo creato una classe base, animale, che contiene alcune informazioni di base (metodi e attributi) comuni a tutti gli animali. Poi, abbiamo costruito una classe figlia, cane, che eredita tutte le informazioni della classe animale (che sono state dichiarate protected) ed in più implementa un nuovo metodo, abbaia(), comune soltanto alla specie cane.

Infine è utile notare anche l’utilizzo della funzione strcpy, implementata nella libreria standard string.h, che serve per copiare il valore di una stringa sorgente ad una destinazione.

Tutte le lezioni

1 ... 52 53 54 55

Se vuoi aggiornamenti su Ereditarietà in C++: classi derivate inserisci la tua e-mail nel box qui sotto:
Tags:
 
X
Se vuoi aggiornamenti su Ereditarietà in C++: classi derivate

inserisci la tua e-mail nel box qui sotto:

Ho letto e acconsento l'informativa sulla privacy

Acconsento al trattamento di cui al punto 3 dell'informativa sulla privacy