Prove sull'overriding delle proprietà pubbliche di una classe.

Overridiamo una proprietà pubblica...

#include "iostream"
using namespace std;


class Genitrice{
 
public:
 char * proprieta;
 Genitrice(){
  proprieta="sono la proprieta' della genitrice";
 }
 void metodo(){
  cout << proprieta << endl;
  getchar();
 }
};

class Derivata:public Genitrice{
 
public:
 char * proprieta;
 Derivata():Genitrice(){
  proprieta="sono la proprieta' della derivata";
 }

 void metodo(){
  cout << proprieta << endl;
  getchar();
 }

};

void main(){
 Genitrice gen;
 Derivata der;
 gen.metodo();
 der.metodo();

}

sono la proprieta' della genitrice

sono la proprieta' della derivata

Ho messo pubblica una proprietà e l'ho ridefinita nella classe derivata.
Se istanzio la classe genitrice viene letta la proprietà della classe genitrice, mentre se istanzio la classe derivata, che overridda il metodo, questo legge la proprietà della classe derivata e non più quella della genitrice.
Anziché overriddare il metodo, creo due metodi con nome diverso che mettano a video la proprietà, un nome nella classe genitrice e uno nella classe derivata.

#include "iostream"
using namespace std;


class Genitrice{
 
public:
 char * proprieta;
 Genitrice(){
  proprieta="sono la proprieta' della genitrice";
 }
 void metodoGen(){
  cout << proprieta << endl;
  getchar();
 }
};

class Derivata:public Genitrice{
 
public:
 char * proprieta;
 Derivata():Genitrice(){
  proprieta="sono la proprieta' della derivata";
 }

 void metodoDer(){
  cout << proprieta << endl;
  getchar();
 }

};

void main(){
 Genitrice gen;
 Derivata der;
 gen.metodoGen();
 der.metodoDer();

}

sono la proprieta' della genitrice

sono la proprieta' della derivata

Anche così il comportamento è lo stesso.
Dunque un metodo della classe genitrice vede la proprietà della classe genitrice, mentre un metodo della classe derivata vede la proprietà overriddata della classe derivata.

Essendo la proprietà pubblica, possiamo anche chiamarla direttamente:

#include "iostream"
using namespace std;


class Genitrice{
 
public:
 char * proprieta;
 Genitrice(){
  proprieta="sono la proprieta' della genitrice";
 }
 void metodoGen(){
  cout << proprieta << endl;
  getchar();
 }
};

class Derivata:public Genitrice{
 
public:
 char * proprieta;
 Derivata():Genitrice(){
  proprieta="sono la proprieta' della derivata";
 }

 void metodoDer(){
  cout << proprieta << endl;
  getchar();
 }

};

void main(){
 Genitrice gen;
 Derivata der;
 cout << gen.proprieta << endl;
 getchar();
 cout << der.proprieta << endl;
 getchar();

} 

sono la proprieta' della genitrice

sono la proprieta' della derivata

---

---

Adesso proviamo a eseguire il metodo della classe genitrice dalla genitrice e dalla derivata e vediamo quale proprietà vede:

#include "iostream"
using namespace std;


class Genitrice{
 
public:
 char * proprieta;
 Genitrice(){
  proprieta="sono la proprieta' della genitrice";
 }
 void metodoGen(){
  cout << proprieta << endl;
  getchar();
 }
};

class Derivata:public Genitrice{
 
public:
 char * proprieta;
 Derivata():Genitrice(){
  proprieta="sono la proprieta' della derivata";
 }

 void metodoDer(){
  cout << proprieta << endl;
  getchar();
 }

};

void main(){
 Genitrice gen;
 Derivata der;
 gen.metodoGen();
 der.metodoGen();
}

sono la proprieta' della genitrice

sono la proprieta' della genitrice

Vede sempre la proprietà della classe genitrice anche quando viene eseguito dalla classe derivata.

---

---

Se togliamo la proprietà dalla classe derivata, anche da questa si dovrebbe avere accesso a quella della classe genitrice.
Proviamo:

#include "iostream"
using namespace std;


class Genitrice{
 
public:
 char * proprieta;
 Genitrice(){
  proprieta="sono la proprieta' della genitrice";
 }
 void metodoGen(){
  cout << proprieta << endl;
  getchar();
 }
};

class Derivata:public Genitrice{
 
public:

 Derivata():Genitrice(){
  
 }

 void metodoDer(){
  cout << proprieta << endl;
  getchar();
 }

};

void main(){
 Genitrice gen;
 Derivata der;
 gen.metodoGen();
 der.metodoDer();

}

sono la proprieta' della genitrice

sono la proprieta' della genitrice

Da qui possiamo comprendere meglio:
Dunque, una proprietà pubblica può essere ereditata dalla classe derivata, ma overridata. Nel caso sia overridata, però, la classe genitrice vede sempre la proprietà "sua", anche quando il metodo della classe genitrice venga chiamato dalla classe derivata.
Proviamo a evocarlo direttamente.

void main(){
 Genitrice gen;
 Derivata der;
 cout << gen.proprieta << endl;
 getchar();
 cout << der.proprieta << endl;
 getchar();
}

sono la proprieta' della genitrice

sono la proprieta' della genitrice

In pratica non ci sono molte novità...
L'unica cosa notevole, che non mi risultava molto immediata, è che un metodo della classe genitrice vede la proprietà della classe genitrice, non overridata.
Cominciamo a entrare in confidenza con il meccanismo... lo sto spremendo come un limone (quando ho tempo di concentrarmi con calma!)