Cuprins

1. Motenirea ........................................................................................................................................ 1
2. Membrii motenii din clasa de baz ................................................................................................ 4
3. Crearea i tergerea obiectelor instaniate dintr-o clas derivat ................................................... 4
4. Ierarhii de clase ................................................................................................................................. 5
5. Proiectul Persoana ............................................................................................................................ 6
6. Exerciii.............................................................................................................................................. 9

1. Motenirea

Motenirea este posibilitatea de a crea clase noi, definite ca extensii ale altor clase. Clasa iniial
se numete clas de baz, iar clasa nou, care extinde clasa de baz clas derivat. Proprietatea cea
mai important a unei clase derivate este aceea de a moteni toi membrii definii n clasa de baz.
Deasemenea, clasa derivat poate s includ i membri noi, acesta fiind unul din scopurile pentru care
este creat. Motenirea este cel de-al 2-lea principiu al programrii orientate obiect, urmtorul dup
ncapsulare.
De exemplu putem s declarm clasa Persoana, care s reprezinte orice persoan. Din
Persoana putem s derivm clasa Student. Clasa Persoana va avea cmpurile private nume i
prenume, i metodele publice setValoriPersoana() i afisare(). Clasa Student va moteni toi
membrii clasei Persoana, i va avea n plus cmpul privat grupa, i metodele publice
setValoriStudent() i o alt metod afisare(), despre care vom discuta mai jos.
Ca s declarm o clas derivat, folosim urmtoarea sintax:
class nume_clasa_derivata: public nume_clasa_baza {
/*corpul clasei derivate*/
};

Clasa de baz trebuie s fie declarat mai sus, folosind sintaxa obinuit.
Prezentam un exemplu complet de motenire:
//clase derivate
#pragma warning(disable : 4996)
#include<iostream>
#include<conio.h>
#include<string.h>
using namespace std;

class Persoana {
protected:
char nume[20], prenume[20];
public:
void setValoriPersoana(char nume[], char prenume[]);
void afisare();
};

class Student: public Persoana {
private:
int grupa;
public:
void setValoriStudent(char nume[], char prenume[],
int grupa);
void afisare();
};

void Persoana::setValoriPersoana(char nume[], char prenume[]) {
strcpy(this->nume, nume);
strcpy(this->prenume, prenume);
}

void Persoana::afisare() {
cout << nume << " " << prenume << endl;
}

void Student::setValoriStudent(char nume[], char prenume[], int grupa) {
setValoriPersoana(nume, prenume);
this ->grupa = grupa;
}

void Student::afisare() {
cout << nume << " " << prenume << ", grupa: " << grupa << endl;
}

int main() {
Persoana persoana;
Student student;
persoana.setValoriPersoana("Vasile", "Dumitrescu");
student.setValoriStudent("Ion", "Ciubotaru", 1104);
persoana.afisare();
student.afisare();
_getch();
return 0;
}
Ieire:
Vasile Dumitrescu
Ion Ciubotaru, grupa: 1104

Acest exemplu conine mai multe aspecte noi.
1. Modul de acces protected. Observm c membrii nume i prenume din clasa Persoana au
fost definii cu un nou mod de acces protected. Acest mod de acces este strans legat de motenire.
Membrii definiti cu mod protected pot fi accesai de oriunde din interiorul clasei n care au fost
definii, sau din clasele derivate. Avem nevoie de un astfel de mod pentru cmpurile din Persoana,
pentru a le putea accesa din Student::afisare().
Practic, drepturile pentru modul protected se situeaz ntre modurile private i public.
Mai jos prezentm un sumar cu modurile de acces:

Mod de acces public protected private
Membri ai aceleiai clase da da da
Membri ai claselor derivate da da nu
Non-membri Da nu nu

Aici non-membri semnific orice funcie din afara clasei sau a claselor derivate, cum ar fi funcia
main(), orice funcie global sau metodele altei clase.
2. Modul de motenire. Observm declaraia clasei Student:
class Student: public Persoana
Cuvntul cheie public semnific modul de acces maxim pe care l vor avea membrii motenii
din clasa de baz. Specificnd modul de motenire public, toi membrii motenii i vor pstra modul
de acces iniial.
Dac motenim clasa de baz n modul private, toi membrii motenii din Persoana i vor
pstra modul de acces pentru clasa Student, dar vor deveni privai pentru restul programului. De
exemplu, vom putea accesa metoda setValoriPersoana() din setValoriStudent(), i programul
de mai sus se va compila. Dar nu vom putea accesa student.setValoriPersoana() din funcia
main(). Se poate folosi i modul de motenire protected.
n aproape toate cazurile se folosete motenirea public. Celelalte moduri de motenire nu sunt
recomandate.
3. Ascunderea metodei afisare(). Metoda afisare() a fost declarat att n clasa
Persoana, ct i n Student cu acelai nume i aceeai list de parametri. Este permis o astfel de
declaraie. n acest caz, metoda afiare din clasa derivat ascunde metoda cu acelai prototip din clasa
de baz. n apelul
student.afisare();

se va apela metoda afiare din clasa Student. De fapt clasa Student va avea 2 metode cu acelai nume
i aceiai parametri Persoana::afisare() i Student::afisare(). Dar a 2-a metod o ascunde
pe prima. Totui, metoda Persoana::afisare() nu este disprut definitiv, ea poate fi accesat de
exemplu de alte metode ale clasei Persoana.
2. Membrii motenii din clasa de baz

Clasa derivat motenete urmtorii mebri ai clasei de baz:
Cmpurile
Metodele
Operatorii suprancrcai, mai puin operatorul =.
Nu sunt motenii din clasa de baz:
Constructorii
Destructorul
Membrii operator=()
Prietenii
3. Crearea i tergerea obiectelor instaniate dintr-o clas derivat

Dei constructorul i destructorul clasei de baz nu sunt motenii, acetia au un rol i pentru clasa
derivat.
Atunci cnd o nou instan a clasei derivate este creat, compilatorul apeleaz mai nti
constructorul clasei de baz fr parametri, i pe urm constructorul clasei derivate.
Atunci cnd instana unei clase derivate este tears, compilatorul va apela mai nti destructorul
clasei derivate, i mai apoi destructorul clasei de baz.
Alternativ, putem s specificm ce constructor al clasei de baz trebuie apelat pentru fiecare
constructor al clasei derivate. Folosind urmtoarea sintax pentru a declara constructorul:

nume_clasa_derivata(parametri constructor)
: nume_clasa_de_baza (parametri constructor clasa de
baza) {...}

De exemplu:

// constructori si clase derivate
#include<iostream>
using namespace std;
#include<conio.h>

class A {
public:
A() {
cout << "A: fara parametri\n";
}
A(int a) {
cout << "A: parametru int\n";
}
};

class B : public A {
public:
B (int a) {
cout << "B: parametru int\n\n";
}
};

class C : public A {
public:
C(int a) : A(a){
cout << "C: parametru int\n\n";
}
};

int main () {
B b(0);
C c(0);
_getch();
return 0;
}
Ieire:
A: fara parametri
B: parametru int

A: parametru int
C: parametru int

Remarcm c atunci cnd se creaz un obiect de tip B, se apeleaz constructorul fr parametri
al clasei A. Iar atunci cnd se instaniaz C, se apeleaz constructorul cu parametru al lui A. Diferena se
datoreaz declaraiei constructorilor claselor B i C:
B(int a) /*nu s-a specificat constructorul bazei*/
/* se apeleaza constructorul implicit*/
C(int a) : A(a) /* apeleaza constructorul bazei
specificat*/

n exemplele de pn acum clasa derivat motenea o singur clas de baz, ceea ce se numete
motenire simpl. n C++ exist posibilitatea ca o clas s moteneasc mai multe clase de baz. Aceast
proprietate se numete motenire multipl.
4. Ierarhii de clase

Dac considerm o mulime de obiecte diferite dar nrudite, i dac din ele grupm toate
obiectele care au numai proprietile comune pentru toat mulimea, acestea vor fi instanieri ale unei
clase pe care am numit-o clas de baz. Dac grupm n continuare obiecte care au proprietile clasei
de baz la care se adaug proprieti proprii grupului, obinem una sau mai multe clase derivate. n felul
acesta se ajunge la noiunea de ierarhie a claselor.
Clasa de baz a ierarhiei are ntotdeauna nivelul 0. Clasele derivate din ea au nivel 1. Clasele
derivate din clasele de nivel 1 au nivel 2, etc. Clasa de nivel 1 din care se deriveaz o clas de nivel 2 este
clas de baz pentru aceasta. Deci noiunea de clas de baz clas derivat are caracter recursiv.
Exemplu:

class X {
//...
};
class Y :public X{
//...
};
class Z : public Y{
//...
};

n exemplul prezentat avem o ierarhie de 3 clase.
5. Proiectul Persoana

Mai jos este dat codul surs a unui program ce conine 2 clase Persoana i Data. Exerciiile din
acest laborator vor presupune completarea acestui program cu faciliti noi. Pentru nceput, s crem
un proiect pe baza acestor fiiere:

Data.h
#ifndef _Data_h_
#define _Data_h_

class Data {

private:
int an,luna,zi;

public:
Data(){}
Data(int an, int luna, int zi);
int getAn();
int getLuna();
int getZi();

/*returneaza 1 daca this > data2, 0 daca this <= data2*/
int maiMare(Data data2);
};

#endif

Data.cpp
#include<iostream>
#include"Data.h"

Data::Data(int an, int luna, int zi){
this->an = an;
this->luna = luna;
this->zi = zi;
}

int Data::getAn() {
return an;
}

int Data::getLuna() {
return luna;
}

int Data::getZi() {
return zi;
}


/*returneaza 1 daca data1 > (este mai recenta decat) data2, 0 in caz
contrar*/
int Data::maiMare(Data data2) {
if (an > data2.an) {
return 1;
} else if (an < data2.an) {
return 0;
} else {
if (luna > data2.luna) {
return 1;
} else if (luna < data2.luna) {
return 0;
} else {
if (zi > data2.zi) {
return 1;
} else if (zi < data2.zi) {
return 0;
} else {
return 0;
}
}
}
}
Persoana.h
#include"Data.h"

#ifndef _Persoana_h_
#define _Persoana_h_
#pragma warning(disable : 4996)

class Persoana {
private:
char *nume, *prenume;
Data *dataNastere;

protected:
void afisarePersoana();

public:
Persoana(char *nume, char *prenume, Data *dataNastere);
~Persoana();
char *getNume();
char *getPrenume();
Data *getDataNastere();
void afisare();
};

#endif

Persoana.cpp
#include<iostream>
#include<string.h>
#include "Data.h"
#include"Persoana.h"
using namespace std;

Persoana::Persoana(char *nume, char *prenume, Data *dataNastere) {
this->nume = new char[strlen(nume) + 1];
this->prenume = new char[strlen(prenume) + 1];
strcpy(this->nume, nume);
strcpy(this->prenume, prenume);
this->dataNastere =
new Data(*dataNastere);
}

Persoana::~Persoana() {
delete[] nume;
delete[] prenume;
delete dataNastere;
}

char *Persoana::getNume(){
return nume;
}

char *Persoana::getPrenume() {
return prenume;
}

Data *Persoana::getDataNastere() {
return dataNastere;
}

void Persoana::afisarePersoana() {
cout << nume << " " << prenume
<< ", data nastere: "
<< dataNastere->getAn() << "."
<< dataNastere->getLuna() << "."
<< dataNastere->getZi();
}

void Persoana::afisare() {
afisarePersoana();
cout << endl;
}
DemoMain.cpp
#include"Data.h"
#include"Persoana.h"

int main() {

Data data(2000, 3, 20);
Persoana radu("Radu", "Stefan", &data);

radu.afisare();
return 0;
}
6. Exerciii

1. Creai o clas Student, derivat din Persoana. Clasa va avea urmtorii membri noi:
cmpul privat grupa de tip ntreg. Grupa va lua valori ntre 1001 i 1999
afisare() va afia studentul la consol.
Scriei o funcie main care s creeze un vector de 5-10 studeni, din 3 grupe diferite, i s-i afieze
sortai dup grupe.

2. Scriei o clas Angajat, derivat din Persoana. Clasa angajat va avea urmtorii membri:
cmpul privat dataAngajare de tip Data
cmpul privat salariu de tip int salariu lunar.
Constructor care s iniializeze toate cmpurile pe baza parametrilor
Destructor
Metode getDataAngajare(), getSalariu(), care s returneze valoarea cmpurilor.
int getVarstaAnagajare() va returna vrsta la care s-a fcut angajarea, n ani
mplinii.
void afisarePerioadaMuncita(Data &dataCurenta) va afia periada muncit
n firm, pn la data curent. irul va avea formatul "ani.luni.zile". Exemplu: "2.9.20". Vom considera
pentru simplitate c toate lunile au cte 30 de zile.
afisare() va afia informaiile despre angajat la consol. Doar informaiile stocate n
cmpurile clasei, nu i cele calculate. Este indicat s se foloseasc metoda afisarePersoana().
Scriei o funcie main care s creeze o list de 3-4 angajai, i s afieze vrsta angajrii,
perioada muncit i detaliile despre angajat, pentru toi angajaii, folosind metodele definite.