Mostenirea permite crearea ierarhiilor de clase, deci a ierarhiilor de concepte (Un concept poate fi implementat printr-o clasa. Clasele grupeaza obiecte de acelasi tip; reprezinta aceeasi idee, acelasi concept).

Aceasta proprietate se manifesta prin faptul ca din orice clasa putem deriva alte clase.

A - clasa de baza;

B, C, D - clase derivate din clasa de baza A

E, F - clase derivate din clasa de baza B

Informatia comuna apare in clasa de baza, iar informatia specifica - in clasa derivata. Clasa derivata reprezinta o specializare a clasei de baza. Orice clasa derivata mosteneste datele membru si metodele clasei de baza. Deci acestea nu trebuie redeclarate in clasa derivata.

Mostenirea poate fi: simpla (orice clasa are o singura superclasa) sau multipla (o clasa are mai multe superclase).

Mostenirea simpla

Declararea unei clase derivate

class <nume_clasa_derivata>: <modificator_de_acces> <nume_clasa_de_baza>

;

In functie de modificatorii de acces care apar in clasa de baza, in declararea clasei derivate si in clasa derivata, lucrurile se pot rezuma astfel:

Constructorii claselor derivate

Constructorii si destructorii sunt functii membre care nu se mostenesc. La instantierea unui obiect din clasa derivata se apeleaza mai intai constructorul clasei de baza, apoi constructorul clasei derivate. La distrugerea obiectelor, se apeleaza intati destructorul clasei derivate, apoi destructorul clasei de baza.

Transmiterea argumentelor unei functii constructor din clasa de baza se face folosind o forma extinsa a declaratiei constructorului clasei derivate, care transmite argumentele unui sau mai multor constructori din clasa de baza.

In general, clasele utilizeaza constructori definiti de programator. In cazul in care acestia lipsesc, compilatorul genereaza automat un constructor implicit pentru clasa respectiva. Acelasi lucru se intampla si in cazul constructorilor de copiere.

La instantierea unui obiect din clasa derivata, o parte din valorile primite ca parametri folosesc la initializarea datelor membru ale claselor de baza, iar restul initializeaza datele membru specifice clasei derivate.

In exemplul urmator, este construita urmatoarea ierarhie de clase:

#include <iostream. h>

class baza

void seteaza_w (int w1)

public:

int c;

baza (int a1, double w1, int c1)

~baza()

void arata()

double calcul()

friend ostream & operator<<(ostream &, const baza &);

};

class deriv1: public baza

~deriv1()

double calcul()

// a nu poate fi folosit, fiind private

// o alternativa:

// double calcul()

friend ostream &operator<<(ostream &, const deriv1 &);

};

class deriv2: protected baza

~deriv2()

double calcul()

friend ostream &operator<<(ostream &, const deriv2 &);

};

class deriv3: private baza

~deriv3()

double calcul()

friend ostream &operator<<(ostream &, const deriv3 &);

};

ostream &operator<<(ostream &ies, const baza &b)

ostream &operator<<(ostream &ies, const deriv1& d1)

ostream &operator<<(ostream &ies, const deriv2& d2)

ostream &operator<<(ostream &ies, const deriv3& d3)

void main()

In clasa de baza membrul a este private, w este protected si c este public.

In clasa de baza, cat si in clasele derivate exista constructori care initializeaza datele membru.

Membrii private dintr-o clasa de baza pot fi folositi doar in cadrul acesteia (de metodele sale), nu si in clasele derivate.

Pentru clasa deriv1:

Membrii privati din clasa baza sunt inaccesibili (a exista, dar este incapsulat)

Pentru a putea fi folositi, se acceseaza metoda din clasa de baza in care apare a

Daca in clasa derivata exista o metoda cu acelasi nume cu al unei metode din clasa de baza (redefinirea unei metode in clasa derivata), aceasta din urma se poate utiliza in clasa derivata folosind un apel de forma:

baza: : calcul( ) sau y. baza: : calcul( )

Pentru clasa deriv2:

Membrii publici din clasa de baza devin protejati in clasa deriv2

Membrii protejati din clasa de baza devin protejati in clasa deriv2

Daca in functia main( ) am incerca folosirea :

cout<<z. baza: : calcul( ) , metoda calcul din z este inaccesibila, ea devenind protejata in clasa deriv3.

Pentru clasa deriv3:

Membrii public sau protected din clasa de baza au devenit privati in clasa deriv3.

Se pot folosi toti membrii clasei de baza, cu exceptia celor privati (a).

In cazul constructorilor, se apeleaza constructorul din clasa de baza

Un obiect y din clasa deriv2 va incorporeaza un obiect deja initializat cu ajutorul constructorului din clasa de baza

OBS:

Daca aveam: deriv1(int a1, double b1, int c1, int b1)

nu era corect, deoarece clasa baza nu are constructori fara parametri, deci nu exista constructor implicit; data a este private in deriv1.

Apelarea constructorului se face apeland explicit constructorul din clasa de baza.

O clasa poate poate contine mai multe obiecte cu aceeasi structura (aceleasi date membru si metode), dar ele difera prin valorile luate.

EX:

#include 'sir. h'

#include <conio. h>

class persoana

persoana(const sir&, const sir&, const char); //constructor

persoana (const persoana&); //constr. copiere

virtual ~persoana(); //destructor

const sir& nume();

const sir&prenume();

char sex();

virtual void afisare();

friend ostream & operator<<(ostream &, const persoana &);

friend istream & operator>>(istream &, persoana &);

};

class student: public persoana

const sir& spec()

int an()

int grup()

virtual void afisare();

friend ostream & operator<<(ostream &, const student &);

// friend istream & operator>>(istream &, student &);

};

class student_bursier: public student

double valoare_bursa();

virtual void afisare();

// friend ostream & operator<<(ostream &, const student_bursier &);

// friend istream & operator>>(istream &, student_bursier &);

};

persoana: : persoana(const sir& nume, const sir& prenume, const char sex)

persoana: : persoana(const persoana& pers)

persoana: : ~persoana()

const sir& persoana: : nume()

const sir& persoana: : prenume()

char persoana: : sex()

void persoana: : afisare()

ostream & operator<<(ostream &monitor, const persoana &p)

istream & operator>>(istream & tastat, persoana &p)

// METODE CLS. STUDENT

student: : student(const sir&nume, const sir&prenume, const char sex, const sir& facult, const sir& spec, const int an, const int gr): persoana(nume, prenume, sex)

student: : student()

student: : student(const persoana &pers, const sir& facult, const sir& spec, const int an, const int gr): persoana(pers)

student: : student(const student& stud): persoana(stud. numele, stud. prenumele, stud. sexul)

student: : ~student()

void student: : afisare()

ostream & operator<<(ostream &monitor, const student &s)

// friend istream & operator>>(istream &, student &);

//METODE CLS. STUDENT_BURSIER

/* student_bursier(student&, char);

student_bursier(const student_bursier&);*/

student_bursier: : student_bursier(const student &stud, char tip_bursa): student(stud)

student_bursier: : student_bursier(const student_bursier &stud): student(stud. numele, stud. prenumele, stud. sexul, stud. facultatea, stud. specializarea, stud. anul, stud. grupa)

double student_bursier: : valoare_bursa()

return val;

}

student_bursier: : ~student_bursier()

void student_bursier: : afisare()

void main()