Apprendimento C/C++ Passo dopo Passo - Pagina 14

14. Passo dopo Passo C/C++ — Programmazione C++ - Ereditarietà

Ereditarietà

| | Introduzione
Classe derivata e Classe base
Specificare la Classe Derivata
Costruttori della Classe Derivata
Specificatori di Accesso
Pubblico
Privato
Protetto
Specificatori di Accesso senza Ereditarietà
Specificatore di Accesso Protetto
Ambito degli Specificatori di Accesso
Specificatori di Accesso con Ereditarietà
Tipi di Ereditarietà
Ereditarietà Singola
Ereditarietà Multipla
Ereditarietà Multilivello
Ereditarietà Ibrida
Ereditarietà Gerarchica |

Introduzione

L’ereditarietà è la caratteristica più potente della programmazione orientata agli oggetti. L’ereditarietà è il processo di creazione di nuove classi, chiamate classi derivate, da classi esistenti o classi base. La classe derivata eredita tutte le capacità della classe base ma può aggiungere abbellimenti e perfezionamenti propri.
Una classe, chiamata classe derivata, può ereditare le caratteristiche di un’altra classe, chiamata classe base.

Eredire le qualità della classe base alla classe derivata è noto come ereditarietà .
Il suo sostantivo è patrimonio. Sappiamo che nella nostra vita quotidiana utilizziamo il concetto di classi derivate in sottoclassi. Ad esempio, il Veicolo è una classe che è nuovamente suddivisa in Cicli, Moto, Auto, Camion, Autobus e così via.

Qui il Veicolo è conosciuto come Classe base e gli elementi derivati sono conosciuti come classi derivate o sottoclassi. **

Generalmente ogni classe base ha un elenco di qualità e caratteristiche. Il tema principale in questa ereditarietà è condividere tutte le caratteristiche comuni della classe base alle classi derivate.

| | |

L’ereditarietà ha una caratteristica importante che consente la riutilizzabilità. Un risultato della riutilizzabilità è la facilità di distribuzione delle librerie di classi. Un programmatore può utilizzare una classe creata da un’altra persona o azienda e, senza modificarla, derivare altre classi da essa adatte a situazioni particolari.

Classe derivata e Classe base

Una classe, chiamata classe derivata, può ereditare le caratteristiche di un’altra classe, chiamata classe base.
La classe derivata può aggiungere altre caratteristiche proprie, diventando così una versione specializzata della classe base. L’ereditarietà fornisce un modo potente per estendere le capacità delle classi esistenti e per progettare programmi utilizzando relazioni gerarchiche.

L’accessibilità dei membri della classe base dalle classi derivate e dagli oggetti delle classi derivate è un problema importante. Gli oggetti delle classi derivate possono accedere ai dati o alle funzioni nella classe base che sono preceduti dalla parola chiave protetta dalle classi derivate ma non. Le classi possono essere derivate pubblicamente o privatamente dalle classi base. Gli oggetti di una classe derivata pubblicamente possono accedere ai membri pubblici della classe base, mentre gli oggetti di una classe derivata privatamente non possono.

Il diagramma mostra come la Classe derivata eredita.

| | |

Una classe può essere derivata da più di una classe base. Questo è chiamato ereditarietà multipla. Una classe può anche essere contenuta all’interno di un’altra classe.

Specificare la Classe Derivata

La dichiarazione della classe è così facile usando la parola chiave class così come la dichiarazione della classe derivata è anche facile ma la classe deve terminare con l’id della classe base e specificatore di accesso.
Sintassi per dichiarare una classe derivata:

Class lass_name>: ….

Ad esempio, class result : public stud;

| | /  programma per accettare e visualizzare un record studente  /
#include
using namespace std;
class add
{
private :
char str[20];
char city[20];
int pin;
public :
void get_add()
{
cout << “Inserisci Indirizzo  strada,città,pin”;
cin >> street >>city>>pin;
}
void put_data()
{
cout << “L’indirizzo è   “ << str
<}
};
class stud  : public add
{
private :
int sno;
char name[20];
int m1,m2,m3;
public :
void get_data()
{
cout << “Inserisci Numero Studente  “; cin >> sno;
cout << “Inserisci Nome Studente  “; cin >> name;
cout << “Inserisci i voti di 3 materie  “;
cin >> m1 << m2 << m3;
}
void put_data()
{
cout  << “Numero studente  :” << sno;
cout << “Nome studente      :” << name;
cout << “Voti studente     :” << m1 << “  “ <}
};
int main()
{
stud s;
s.get_add();
s.get_data();
s.put_add();
s.put_data();
return 0;
} |

Spiegazione diagrammatica per il programma sopra

| | |

Costruttori della Classe Derivata

Se una classe è dichiarata con i propri costruttori è una classe base di un’altra. La classe derivata ha anche i propri costruttori. Se un oggetto è dichiarato, quale costruttore verrà eseguito?   Non c’è dubbio che verrà eseguito il costruttore della classe derivata.  Se si desidera ancora eseguire il costruttore della classe base o entrambi i costruttori della classe derivata e della classe base, basta chiamare il costruttore della classe base nel costruttore della classe derivata.

| | / Costruttori nella classe derivata /
#include
using namespace std;
class Add
{
protected :                                // NOTA : non privato
unsigned int a;
public :
Add()  {  a = 0; }                  // costruttore, senza argomenti
Add( int c ) { a = c; }             // costruttore, un argomento
int get_val(){     return a; }      // restituisce il valore A
Add operator ++ ()                  // incrementa il conteggio
{
a++;                           // incrementa il conteggio, restituisce
return Add(a);                 // un oggetto temporaneo senza nome
}                                   // inizializzato a questo conteggio
};

class Sub : public Add
{
public:
Sub() : Add() { }                     // Costruttore, senza argomenti
Sub(int c) : Add(c) { }               // Costruttore, un argomento
Sub operator – ()                    // decrementa il valore di A, restituisce
{                                     // un oggetto temporaneo senza nome
a–;                             // inizializzato a questo valore
return Sub(a);
}
};
int main()
{
Sub ob1;                                  // classe Sub
Sub ob2(100);
cout << “\nOb1  =” << ob1.get_val();      // visualizza
cout << “\nOb2  =” << ob2.get_val();      // visualizza
ob1++; ob1++; ob1++;                      // incrementa ob1
cout << “\nOb1  =” << ob1.get_val();      // visualizza
ob2–; ob2–;                             // decrementa ob2
cout << “\nOb2  =” << ob2.get_val();      // visualizza
Sub ob3=ob2–;                            // crea ob3 da ob2
cout << “\nOb3  =” << ob3.get_val();      // visualizza
return 0;
} |

SPECIFICATORI DI ACCESSO

Gli specificatori di accesso vengono utilizzati per controllare, nascondere, proteggere sia i dati che le funzioni membro.  Gli specificatori di accesso sono di 3 tipi

1. Specificatore di Accesso Pubblico
2. Specificatore di Accesso Privato
3. Specificatore di Accesso Protetto.

Pubblico :

| | Se un membro o un dato è pubblico può essere utilizzato da qualsiasi funzione all’interno della classe e anche dalle sue classi derivate.
In C++ i membri di una struct o union sono pubblici per impostazione predefinita.
Il membro pubblico di una classe può essere ereditato dalla classe derivata quando la classe è ereditata pubblicamente ma non le funzioni membro (privatamente). |

Privato :

| | Le funzioni membro e gli amici della classe in cui è dichiarato possono solo utilizzarlo.
I membri di una classe sono privati per impostazione predefinita.
Il membro privato di una classe non viene ereditato a una classe derivata quando la classe base è ereditata pubblicamente o privatamente. Se c’è bisogno, dobbiamo scrivere funzioni membro, che restituiscono quei valori. |

Protetto :

| | È accessibile come lo stesso per privato, inoltre, il membro può essere utilizzato dalle funzioni membro e dagli amici delle classi derivate dalla classe dichiarata ma non solo negli Oggetti del tipo derivato.
Il membro protetto di una classe può essere ereditato solo dalla successiva classe derivata. Ma non dalle classi successive. |

Specificatori di Accesso senza Ereditarietà

| | |

Maggiori informazioni sul Specificatore di Accesso Protetto

Per fornire la funzionalità senza modificare la classe. Protetto può essere accessibile da se stesso e dai membri protetti della classe derivata solo ma negli oggetti o nella sottoclasse derivata o nella classe esterna.

Ambito degli Specificatori di Accesso

| Specificatore di Accesso | Accessibile da
Classe propria | Accessibile da
classe derivata | Accessibile da
Oggetti esterni alla classe | | Pubblico | Sì | Sì | Sì | | Protetto | Sì | Sì | No | | Privato | Sì | No | No |

Specificatori di Accesso con Ereditarietà

| | |

Tipi di Ereditarietà

| | |

| | |

| | / Programma per dimostrare l’Ereditarietà Multipla /
#include
using namespace std;
class M
{
protected :
int m;
public :
void getm()
{
cout << “\nInserisci valore M  :”;
cin >> m;
}
};
class N
{
protected :
int n;
public :
void getn()
{
cout << “\nInserisci valore N  :”;
cin >> n;
}
};
class P : public N, public M
{
public :
void disp()
{
cout << “\n  M   =  “ << m;
cout << “\n  N   =  “ << n;
cout << “\n  MN =  “ << mn;
}
};
int main()
{
P p;
p.getm();
p.getn();
p.disp();
return 0;
} |

Se una classe base è ereditata pubblicamente, allora i membri pubblici, le funzioni membro possono essere accessibili alle funzioni membro della classe derivata e agli Oggetti anche, mentre se una classe base è ereditata privatamente, allora i membri pubblici della classe base sono ereditati solo alle funzioni membro della classe derivata ma non agli oggetti.

| | / Un programma per dimostrare l’Ereditarietà Multilivello /
class student
{
int rno;
public:
void getrno()
{
cout << “Inserisci  Numero :”;
cin >> rno;
}
void showrno()
{
cout << “Numero Studente:” << rno;
}
};
class test : public student
{
int m1,m2;
public :
void getmarks()
{
cout << “Inserisci voti 1  :” ; cin >> m1;
cout << “Inserisci voti 2  :” ; cin >> m2;
}
int  retm1()
{
return m1;
}
int retm2()
{
return m2;
}
};
class result : public test
{
int tot;
public:
void get()
{
getrno();
getmarks();
}
void showresult();
void show()
{
showrno();
showresult();
}
};
void result::showresult()
{
int s1,s2;
s1=retm1();
s2=retm2();
tot=s1+s2;
cout << “\nVoti  “ << s1 << “  “+ s2;
cout << “\nVoti totali  “ << tot;
}
int main()
{
result a;
a.get();
a.show();
return 0;
} |

| | / Programma per dimostrare l’Ereditarietà Ibrida /
#include
using namespace std;
class student
{
int rno;
public:
void getrno()
{
cout << “Inserisci  Numero :”;
cin >> rno;
}
void showrno()
{
cout << “\nNumero Studente   :” << rno;
}
};
class test : public student
{
protected :
int m1,m2;
public :
void getmarks()
{
cout << “Inserisci voti 1  :” ; cin >> m1;
cout << “Inserisci voti 2  :” ; cin >> m2;
}
void showmarks()
{
cout << “\nVoti  di 2 materie ” << m1 << “  “ << m2;
}
};
class sports
{
protected :
int score;
public :
void getscore()
{
cout << “Inserisci   Voto  :”;
cin >> score;
}
};
class result : public test, public sports
{
public :
void getdata()
{
getrno();
getmarks();
getscore();
}
void putdata()
{
showrno();
showmarks();
cout << “\nIl punteggio  è  “ << score;
cout << “\n Voti totali   “ << m1+m2;
}
};
int main()
{
result  r;
r.getdata();
r.putdata();
return 0;
} |

Rappresentazione pittorica del programma sopra:

| | |

Nella figura sopra, la classe studente è ereditata dalla classe risultato in due modi.  Uno è tramite test, l’altro è tramite sport, quindi due set di membri, funzioni membro della classe base comune studente sono ereditati dalla classe derivata risultato. Al momento dell’esecuzione, il sistema si confonderà su quale set di funzioni membro della classe base utilizzare.
Questo può essere evitato rendendo la classe base comune come classe base virtuale.

Es:

| | class student { };
class test : virtual public student { };
class sports : virtual public student { };
class result : public test, sports { }; |

Rif: Programmazione orientata agli oggetti in Turbo C++: Robert Lafore