Ereditarietà

L ereditarietà è un concetto importante per tutti i linguaggi di programmazione orientati agli oggetti, serve per aggiornare un vecchio codice aggiungendo nuove funzionalità conservando quelle vecchie. Per effettuare l aggiornamento si usano delle regole di passaggio (o modificatori) e sono 3:
PUBLIC: con questo modificatore solo la parte pubblica e protetta verrà ereditata dalla nuova classe, gli attributi e i metodi che erano pubblici rimarrano pubblici e quelli protetti resteranno protetti.
PROTECTED: usando questo moificatore la parte pubblica e protetta verrà ereditata dalla nuova classe, ma gli attributi e i metodi diventeranno tutti protetti.
PRIVATE:usando questo modificatore la parte pubblica e privata verrà ereditata dalla nuova classe, ma i metodi e gli attributi saranno tutti privati.
Di seguito un semplice esempio di uso dell' ereditarietà:

#include <iostream.h>

class Nonna 
{
private: int n1;
protected: int n2;
public: int n3;
  Nonna() : n1(0),n2(0), n3(0) {}
  void scrivi_Nonna() const;
} ;

class Mamma : protected  Nonna
{
private: int m1;
protected: int m2;
public: int m3;
  Mamma() : m1(0),m2(0), m3(0) {}
  void scrivi_Mamma() const;
} ;

class Figlia : Mamma    // accesso private di default
{
private: int f1;
protected: int f2;
public: int f3;
  Figlia() : f1(0),f2(0), f3(0) {}
  void scrivi_Figlia() const;
};

void Nonna::scrivi_Nonna() const
{
 cout << "\nFunzione-membro scrivi_Nonna:\n";
 cout << "n1 = " << n1 << '\n';
 cout << "n2 = " << n2 << '\n';
 cout << "n3 = " << n3 << '\n';
}

void Mamma::scrivi_Mamma() const
{
 cout << "\nFunzione-membro scrivi_Mamma:\n";
// cout << "n1 = " << n1 << '\n';  // errore
 cout << "n1 e' privato: non si eredita\n";
 cout << "n2 = " << n2 << '\n';
 cout << "n3 = " << n3 << '\n';
 cout << "m1 = " << m1 << '\n';
 cout << "m2 = " << m2 << '\n';
 cout << "m3 = " << m3 << '\n';
}

void Figlia::scrivi_Figlia() const
{
 cout << "\nFunzione-membro scrivi_Figlia:\n";
// cout << "n1 = " << n1 << '\n';  // errore
 cout << "n1 e' privato: non si eredita\n";
 cout << "n2 = " << n2 << '\n';
 cout << "n3 = " << n3 << '\n';
// cout << "m1 = " << m1 << '\n';  // errore
 cout << "m1 e' privato: non si eredita\n";
 cout << "m2 = " << m2 << '\n';
 cout << "m3 = " << m3 << '\n';
 cout << "f1 = " << f1 << '\n';
 cout << "f2 = " << f2 << '\n';
 cout << "f3 = " << f3 << '\n';
}

void scrivi_Figlia(const Figlia& f)
{
 cout << "\nFunzione globale scrivi_Figlia:\n";
// cout << "n1 = " << f.n1 << '\n';  // errore
 cout << "n1 e' privato: inaccessibile\n";
// cout << "n2 = " << f.n2 << '\n';  // errore
 cout << "n2 e' protetto: inaccessibile\n";
// cout << "n3 = " << f.n3 << '\n';  // errore
 cout << "n3 e' protetto (in Mamma): inaccessibile\n";
// cout << "m1 = " << f.m1 << '\n';  // errore
 cout << "m1 e' privato: inaccessibile\n";
// cout << "m2 = " << f.m2 << '\n';  // errore
 cout << "m2 e' protetto: inaccessibile\n";
// cout << "m3 = " << f.m3 << '\n';  // errore
 cout << "m3 e' privato (in Figlia): inaccessibile\n";
// cout << "f1 = " << f.f1 << '\n';  // errore
 cout << "f1 e' privato: inaccessibile\n";
// cout << "f2 = " << f.f2 << '\n';  // errore
 cout << "f2 e' protetto: inaccessibile\n";
 cout << "f3 = " << f.f3 << '\n';
}

int main()
{
 {
  Nonna n;
  n.scrivi_Nonna();
 }
 {
  Mamma m;
  m.scrivi_Mamma();
 }
 cout << "\nPremi return per visualizzare il secondo blocco ";
 char c;
 cin.get(c);
 Figlia f;
 f.scrivi_Figlia();
 scrivi_Figlia(f);
 return 0; 

}

Primo programma con uso di oggetti

#include<iostream>
using namespace std;
class persona
{
    public:
        persona();
        persona(int a);
        ~persona();
        void aggiorna();
        void visualizza();
    private:
        char nome[15];
        char cognome[15];
        int eta;
};

persona::persona()
{
    cout<<endl<<"inserire nome: ";
    cin>>nome;
    cout<<endl<<"inserire cognome: ";
    cin>>cognome;
    cout<<endl<<"inserire età: ";
    cin>>eta;
}
persona::persona(int a)
{
    cout<<"inserire nome: ";
    cin>>nome;
    cout<<endl<<"inserire cognome: ";
    cin>>cognome;
    eta=a;
}
void persona::visualizza()
{
    cout<<"dati inseriti:"<<endl<<"nome:"<<nome<<endl<<"cognome:"<<cognome<<endl<<"età:"<<eta;
}
persona::~persona()
{
    cout<<endl<<"destruction derby";
}
void persona::aggiorna()
{
    char ins;
    cout<<"quali dati si desiderano aggiornare?"<<endl<<"n--> nome c-->cognome e-->età ";
    cin>>ins;
    switch(ins)
    {
        case 'n': cout<<"inserire nuovo nome: ";
                  cin>>nome;
                  break;
        case 'c': cout<<"inserire nuovo cognome: ";
                  cin>>cognome;
                  break;
        case 'e': cout<<"inserire nuova età: ";
                  cin>>eta;
                  break;
    }
}
main()
{
    char scelta;
    int i;
    persona dipendente;
    do
    {
        dipendente.visualizza();
        cout<<endl<<"si desidera modificare i dati?s-n ";
        cin>>scelta;
        if(scelta=='s')
        dipendente.aggiorna();
    }while(scelta!='n');
    persona dipv(18);
    dipv.visualizza();
    persona dip[3];
    for(i=0;i<3;i++)
    {
        cout<<endl<<"dipendente "<<i;
        dip [i].visualizza();
    }
}
Come si può notare nella classe sono stati dichiarati due costruttori con parametri diversi e un solo distruttore. nel main invece sono state effettuate delle prove con diversi tipi di oggetti:
persona dipendente: dichiarato un oggetto senza parametri, quindi viene invocato il costruttore di default.
persona dipv(18): dichiarato un oggetto con un parametro int, quindi verrà chiamato il costruttore con il parametro int.
persona dip[3]: dichiarato un array di oggetti (3 in questo caso), quindi, non avendo ulteriori parametri, verrà invocato il cotruttore di default. Provando ad eseguire il programma si potrà notare come appena, il programma, eseguirà la linea con la dichiarazione degli oggetti il costruttore venga chiamato 3 volte di seguito.
Si può notare inoltre che  prima della fine del programma il distruttore venga invocato 5 volte per liberare la memoria di tutti gli oggetti.

Costruttore-distruttore

Il costruttore è un metodo quando viene dichiarato un oggetto e serve per allocare la memoria del medesimo. Il nome del costruttore deve essere lo stesso della classe, ci possono essere più costruttori a patto che i loro parametri siano differenti. Esiste inoltre un costruttore di default senza parametri.
Il distruttore è sempre un metodo e viene chiamato quando un oggetto viene rilasciato dalla memoria, infatti serve per liberare lo spazio sulla memoria, deve avere lo stesso nome della classe preceduto dal carettere speciale ~, il distruttore è uno solo non necessitando di parametri. Come per il costruttore esiste un  distruttore di default.
Di seguito un semplice esempio di uso di costrotturi e distruttori:

#include<iostream>
using namespace std;
class A{        //dichiaro una classe
                //di defaukt gli attributi sono privati, cioè nn accessibile dall'esterno
        int c;
       public:     // con public rendo i metodi accessibili dall'esterno
        A();    // costruttore
        A(int a);
        A(float a);
        ~A();   // distruttore
        void stampa(); //dichiaro un metodo
        };
void A::stampa() //definizione sterna del metodo stampa
{
        cout << c;
}
A::A(int a)//inizializzo c con il costruttore
{
   cout << "sono int"<<a;
}
A::A(float a)//inizializzo c con il costruttore
{
   cout << "\nsono float"<<a;
}
A::A()//inizializzo c con il costruttore
{
cout << "eseguo costruttore \n";
}
A::~A()// liberiamo la memoria occupata dall'oggetto
{
cout << "eseguo distruttore\n";
}
 main() //corpo
 {
   //dichiarazione di un oggetto
  //B.c; error 'int A::C is private'
  A stampa(5);//notazione puntata per raggiungere il metodo nell'oggetto
  A stampa1((float)1.5);
  A stampa2;
  return 0;
}


Provando ad eseguire il programma si noterà quando il costruttore e il distruttore vengono chiamati.

Classi ed oggetti

Un oggetto è un elemento dotato di attributi e metodi, i quali posso essere pubblici, ovvero accessibili dal main, oppure privati, non accessibili dal main. Le classi invece ci servono per creare l' interfaccia cioè gli attributi e i metodi dell' oggetto e per definire se debbano essere pubblici o privati. Lo scopo delle classi è quello di permettere all' oggetto di essere utilizzato da terzi senza il bisogno di sapere come ne agiscano i metodi.  un esempio di creazione ed suo di una classe: