Ereditarietà di Classe

• Introduzione
• Dichiarazioni private, protected e public nelle classi
• Ereditarietà privata, protetta o pubblica
• Costruttori e distruttori in presenza di ereditarietà
• Overloading di funzioni membro
• Polimorfismo

Introduzione

Quando vuoi usare tutti i membri di una classe padre senza doverli dichiarare di nuovo uno alla volta, basta mettere una sola dichiarazione nell'header della classe "figlia":

class father
{
public:
  int a;
};

class A : public father
{
public:
  int b;
};

Quando una classe eredita da un'altra, ne eredita tutti i membri. Questo porta a due problemi:

1. proteggere i membri di una classe in modo che i suoi potenziali figli non siano in grado di accederli.
2. far sì che una classe figlia impedisca l'accesso da parte del mondo esterno alla parte ereditata dalla sua classe padre.

Dichiarazioni private, protected e public

class A
{
  int a;
public:
  int GetA() { return a; }
};

Ndt: qui ovviamente si consiglia di non permettere l'accesso diretto ai membri dati, tranne che in casi rari. Infatti nella maggior parte dei casi i membri dati devono essere gestiti esclusivamente tramite i metodi (le funzioni) dell'oggetto e una loro gestione esterna impropria può portare a delle situazioni di incoerenza nell'oggetto e quindi di errori, oltre che rendere i programmi molto meno "mantenibili".
I membri funzione ovviamente devono essere public se si vuole poter mandare i corrispondenti "messaggi" all'oggetto dal mondo esterno.
Se una funzione invece serve solo ad uso interno dell'oggetto ed è pericoloso e/o inutile metterla a disposizione del mondo esterno (non corrisponde ad alcun messaggio) meglio non renderla public, ma private o protected a seconda dei casi.

Un'altra cosa: ho provato questo codice con tutti i miei compilatori e lo hanno accettato senza problemi, senza manco sputar fuori un warning:

class A
{
  int a;
public:
  int & GetA() { return a; }
};


int main()
{
  A unA;

  unA.GetA() = 5;
  
  return 0;
}

In alcuni casi potresti volere che solo i figli di una classe abbiano il permesso di accedere ad alcuni suoi membri. Quindi, non ci sarà modo di accedere a quei membri dall'esterno, ma all'interno sia della classe padre che figlia, ogni modifica sarà permessa. Questo tipo di dichiarazioni sono dette protette e precedute dalla keyword protected.

Ndt: notare la differenza con le dichiarazioni private: esse non sono accessibili nè all'esterno della classe, nè dai suoi discendenti.

class father
{
protected:		// provate ad commentarla
  int a;
};

class A : public father
{
  int GetA() { return a; }    // può accedere ad a
};
...
{
  father f;
  int x = f.a;                    // rifiutato dal compilatore
}

Ereditarietà privata, protetta o pubblica

class father
{
public:
  int a;
};

class A : public father
{
  int GetA() { return a; }    // può accedere ad a
}
...
{
  A a_obj;
  x = a_obj.a;                // si possono accedere membri pubblici ereditati come tali
}

class father
{
public:
  int a;
};

class A : private father
{
  int GetA() { return a; }    // a si può accedere qui (a è diventato un membro privato)
}
...
{
  A a_obj;
  x = a_obj.a;                // rifiutato dal compilatore: non si può accedere al membro privato a
}

La tabella seguente riassume come cambiano i livelli di accesso in una classe figlia a seconda dei 3 tipi di derivazione possibili:

classe Padre	classe Figlia
	derivazione public	derivazione protected	derivazione private
public	public	protected	private
protected	protected	protected	private
private	non accessibili	non accessibili	non accessibili

Costruttori e distruttori

La sintassi è proprio la stessa:

class Father
{
  int a;
public:
  Father (int aa) { a = aa; }
};

class Child : public Father
{
  int b;
public:
  Child (int aa) : Father (aa) {}   // Ecco un costruttore inline
  Child (int, int);                 // ed uno che è una normale funzione
};

Child::Child (int aa, int bb) : Father (aa)
{
  b = bb;
}

/* alternativa:
Child::Child (int aa, int bb) : Father (aa), b(bb)
{
}*/

Overloading di funzioni membro

class Father
{
public:
  void MakeAThing();
};
class Child : public Father
{
public:
  void MakeAThing();
};
...
{
  Father father;
  father.MakeAThing();    // metodo MakeAThing di Father chiamato
  Child child;
  child.MakeAThing();     // metodo MakeAThing di Child chiamato
}

void MakeAThing();
class Father
{
public:
  void MakeAThing();
};
class Child : public Father
{
public:
  void MakeAThing()
  {
    Father::MakeAThing();  // viene chiamato il metodo di Father
    ::MakeAThing();        // viene chiamata la funzione globale
    //MakeAThing();        // questa è una chiamata ricorsiva!
  }
};
...
{
  Father father;
  father.MakeAThing();    // metodo MakeAThing di Father chiamato
  Child child;
  child.MakeAThing();     // metodo MakeAThing di Child chiamato
  MakeAThing();           // chiamata una funzione globale
}

Polimorfismo

class Father
{
...
};
class Child : public Father
{
...
};
...
void ExampleFunction (Father &);
...
{
  Father father;
  ExampleFunction (father);   // Normale chiamata
  Child child;
  ExampleFunction (child);    // un oggetto child è considerato come uno di tipo father
}