Scenetta al Ristorante del C++: l'apprendista overridda il maestro con la pentola a pressione.

Adesso l'Apprendista decide di apportare un'innovazione nel suo modo di cucinare la pasta, sia con uno che con due condimenti: usare la pentola a pressione (non mi intendo di cucina e forse, trattandosi di cuochi, sto dicendo un'eresia, ma quello che conta è il senso del discorso).

Quindi egli modifica ambedue le sue abilità introducendo la pentola a pressione:

#include "iostream"
using namespace std;

class Cuoco{
public:
	void Pasta(char * condimento){
		cout << "Io cucino la pasta con " << condimento << endl;
		getchar();
	}
};

class Apprendista: public Cuoco{
public:
	void Pasta(char * condimento){
		cout << "Io cucino la pasta nella pentola a pressione con " << condimento << endl;
		getchar();
	}

	void Pasta(char * condimento, char * condimento2){
		cout << "Io cucino la pasta nella pentola a pressione con " << condimento << " e con " << condimento2 << endl;
		getchar();
	}
};

void main(){
	Cuoco Mario;
	Apprendista Antonio;
	Mario.Pasta("ragu'");
        Antonio.Pasta("sugo");
	Antonio.Pasta("aglio","olio");
	
}; 

Io cucino la pasta con ragu'

Io cucino la pasta nella pentola a pressione con sugo

Io cucino la pasta nella pentola a pressione con aglio e con olio

Abbiamo visto dunque al lavoro il maestro Cuoco, che mette in pratica la tradizionale tecnica con il tradizionale sistema, e l'Apprendista che mette in pratica la tecnica tradizionale (e anche quella sua a due ingredienti) con la pentola a pressione.

Rivediamoli ambedue intenti a cucinare soltanto la Pasta a un unico condimento, ognuno a modo suo:

...
void main(){
	Cuoco Mario;
	Apprendista Antonio;
	Mario.Pasta("fagioli");
        Antonio.Pasta("ragu'");
	
}

Io cucino la pasta con fagioli

Io cucino la pasta nella pentola a pressione con ragu'

---

---

Bene.
Creiamo una funzione che, fornendo il nome del cuoco presente al ristorante e il condimento desiderato, gli faccia cucinare la pasta (a un solo condimento, perché il maestro Cuoco sa fare solo quello).
Ovviamente, essendo l'Apprendista comunque un Cuoco, la funzione userà il tipo Cuoco per ambedue.

#include "iostream"
using namespace std;

class Cuoco{
public:
	void Pasta(char * condimento){
		cout << "Io cucino la pasta con " << condimento << endl;
		getchar();
	}
};

class Apprendista: public Cuoco{
public:
	void Pasta(char * condimento){
		cout << "Io cucino la pasta nella pentola a pressione con " << condimento << endl;
		getchar();
	}

	void Pasta(char * condimento, char * condimento2){
		cout << "Io cucino la pasta nella pentola a pressione con " << condimento << " e con " << condimento2 << endl;
		getchar();
	}
};


void CucinaPasta(Cuoco n, char * condimento){
	n.Pasta(condimento);
}

void main(){
	Cuoco Mario;
	Apprendista Antonio;

	CucinaPasta(Mario, "piselli");
	CucinaPasta(Antonio, "fagioli");
} 

Io cucino la pasta con piselli

Io cucino la pasta con fagioli

Ma...C'E' QUALCOSA CHE NON VA!
Non avevamo detto che l'Apprendista cucinava ormai soltanto con la pentola a pressione?
Perché invece qui risulta che cucina la pasta e fagioli con la tecnica tradizionale?

Semplicemente perché abbiamo usato il tipo Cuoco. Quindi qui l'Apprendista viene chiamato in veste di Cuoco, non di Apprendista!

Come fare?

E se provassimo a usare i puntatori?

...
void CucinaPasta(Cuoco * n, char * condimento){
	n->Pasta(condimento);
}

void main(){
	Cuoco * Mario=new Cuoco();
	Apprendista * Antonio = new Apprendista();

	CucinaPasta(Mario, "piselli");
	CucinaPasta(Antonio, "fagioli");
}

Io cucino la pasta con piselli

Io cucino la pasta con fagioli

ANCORA NIENTE!!!
Il povero Apprendista, chiamato in veste di Cuoco, deve ancora adattarsi a cucinare nel modo che lui giudica obsoleto del suo vecchio maestro... Egli se ne rattrista! Come se non fosse degno di essere chiamato Cuoco a tutti gli effetti anche lui!

Ma ecco che vengono fuori le funzioni VIRTUALI.
...ossia il buon maestro Cuoco, sebbene "contrario alla pentola a pressione" (come da buon vecchio Massimo Boldi! :-) ), ritiene comunque che quello scriteriato ragazzo che però in fondo stima molto abbia anch'egli il diritto a essere chiamato Cuoco a tutti gli effetti, e ammette che, sebbene lui resti della sua idea, l'idea della pentola a pressione è comunque da rispettare anche se non da condividere, e dà per virtuale il suo metodo di cottura, ossia ammette che è comunque un'opinione personale e quindi relativa, e non è giusto che chi la esegua a modo suo, sia pur con la tanto odiata pentola a pressione, non sia degno di essere chiamato Cuoco.

#include "iostream"
using namespace std;

class Cuoco{
public:
	virtual void Pasta(char * condimento){
		cout << "Io cucino la pasta con " << condimento << endl;
		getchar();
	}
};

class Apprendista: public Cuoco{
public:
	void Pasta(char * condimento){
		cout << "Io cucino la pasta nella pentola a pressione con " << condimento << endl;
		getchar();
	}

	void Pasta(char * condimento, char * condimento2){
		cout << "Io cucino la pasta nella pentola a pressione con " << condimento << " e con " << condimento2 << endl;
		getchar();
	}
};


void CucinaPasta(Cuoco * n, char * condimento){
	n->Pasta(condimento);
}

void main(){
	Cuoco * Mario=new Cuoco();
	Apprendista * Antonio = new Apprendista();

	CucinaPasta(Mario, "piselli");
	CucinaPasta(Antonio, "fagioli");
} 

Io cucino la pasta con piselli

Io cucino la pasta nella pentola a pressione con fagioli

...e così il buon Apprendista finalmente è soddisfatto e può esprimersi liberamente con la sua arte e venir chiamato Cuoco con pieno merito!!!