Programarea orientata pe obiecte in C++:clase, obiecte, functii membru, structuri si uniuni in analogie cu clasele, functii speciale

1. Notiuni introductive

Programarea orientata pe obiecte este o tehnologie moderna in domeniul programarii calculatoarelor, care a rezultat din necesitatea realizarii de aplicatii din ce in ce mai complexe. Programarea clasica si structurata avea urmatoarele dezavantaje: control greoi al programelor de dimensiuni mari, dificultati cu privire la reutilizarea codurilor de programe si inflexibiliatea adaptarii si extinderii unor module de program deja realizate. Programarea clasica structurata are la baza celebra ecuatie a lui Nikolaus Wirth:

Program = Structuri de date + Algoritmi

Programarea Orientata pe Obiecte, POO, se fundamenteaza pe conceptul de obiect, care este definit printr-o multime de date, numite proprietati, si o multime de proceduri sau functii de prelucrare ale acestor date, numite metode. In consecinta, ecuatia POO este:

Obiect = Date + Functii

sau

Obiect = Date + Functii

Obiect = Proprietati + Metode   

Diferenta dintre cele doua cai de abordare ale programarii calculatoarelor consta in maniera de abordare a programarii. In timp ce programarea clasica structurata se concentreaza pe prelucrarea datelor, adica pe programe, proceduri si functii, POO se bazeaza pe definirea obiectelor, adica, pe proprietatile acestora, numite date, si pe functiile acestor obiecte, numite metode.

2. Clase si obiecte

La baza POO stau conceptele de clasa si de obiect.

Definitia 1

Clasa, intr-un anumit limbaj de programare, reprezinta definirea unui tip de obiecte abstracte sau concrete, adica descrierea proprietatilor, a datelor si a metodelor, a prelucrarilor, posibile asupra datelor. Clasa este, de fapt, o notiune abstracta, care defineste un anumit tip de obiecte, sau, altfel spus, o clasa reprezinta multimea posibila a mai multor obiecte de acelasi tip.

Definitia 2

Obiect, reprezinta o multime de date care descrie un anumit obiect concret sau abstract, numite si proprietati, impreuna cu procedurile, functiile, de prelucrare a cestora, numite metode.

Crearea unui obiect presupune specificarea clasei din care face parte, astfel identificandu-se proprietatile obiectului si modul in care acestea pot fi folosite si prelucrate

Observatie:

Crearea sau declararea unui obiect este similara cu crearea sau declararea unor variabile. Declararea unei variabile se face, dupa cum se stie, prin specificarea identificatorului acesteia, precedat de tipul variabilei iar declararea unui obiect presupune precizarea identificatorului acestuia, precedat de clasa din care face parte, clasa care in mod implicit determina proprietatile si metodele obiectului definit.

O clasa in limbajul C++ poate fi reprezentata ca o extindere a conceptului de structura, care, ca si o structura, descrie un sablon pentru viitoarele declarari de variabile obiect.

Definirea generala unei clase in C++

class [nume_clasa]

[obiect1] [,obiect2] . [,obiectm];

unde:

- nume_clasa - optional, este un identificator ales de programator care denumeste clasa definita si prin intermediul caruia se apeleaza aceasta;

- specificator_accesi (i=1,n) - este o eticheta care poate fi unul dintre cuvinele cheie: public, private sau protected.

a)      Spre deosebire de o structura, ai carei membri sunt toti accesibili programului, o clasa poate avea membri pe care programul ii poate accesa direct (public), utilizand operatorul punct (.) si alti membri, denumiti privati (private), pe care programul nu-i poate accesa direct. Unica accesare a datelor si metodelor private (private) se face numai prin intermediul metodelor publice. Dupa cum se va vedea, o clasa poate deriva dintr-o clasa de baza, anterior definita, concept cunoscut sub numele de mostenire. Un membru protejat (protected) are un statut intermediar intre membri publici si privati. Pentru clasa de baza, obiectele acesteia pot accesa membri protejati, ca si cum ar fi publici, iar obiectele claselor derivate nu pot accesa un membru declarat protected in clasa de baza, decat prin intermediul unor functii de interfata declarate publice.

- date_si_functiii; (i=1,n) - descrie datele, adica proprietatile, si functiile, adica metodele specifice clasei definite care, in functie de specificator_accesi (i=1,n), pot fi public, private sau protected.

- [obiect1] [,obiect2] . [,obiectm] - reprezinta identificatorii obiectelor de tipul clasei la care sunt atasati, adica numele variabilelor obiect respective care vor fi utilizate in programul in care apar.

Observatii:

- la declararea obiectelor, o data cu definirea clasei asociate, se poate omite identificatorul de clasa, nume_clasa.

- declararea obiectelor, ulterior definirii clasei asociate, impune obligativitatea identificatorului de clasa, nume_clasa.

Declararea obiectelor, ulterior definirii clase se face astfel:

class nume_clasa [obiect1] [,obiect2] . [,obiectm];

unde, nume_clasa,obiect1,obiect2, . ,obiectm au semnificatiilie mai sus prezentate.

Problema 1

Sa se citeasca de la tastatura informatiile specifice cartilor dintr-o librarie: denumire carte, autorul principal, al doilea autor, numarul de pagini si pretul. Prin intermediul unei clase, carte, care descrie datele despre o carte, proprietatile (denumire carte, autorul principal, al doilea autor, numarul de pagini si pretul) si metodele de prelucrare (initializarea si afisarea unei carti) sa se afiseze pe ecran informatiile despre orice carte tratata.

// definirea clasei carte

#include<iostream.h>

#include<string.h>

#include<stdio.h>

class carte

// descrirea functiei de citire carte

void carte::citeste_carte(char *numecarte,char *numeautor1,

char *numeautor2,int *np,double *p)

void carte::afiseaza_carte()

int i=0;

void main()

}

In urma executarii programului anterior s-au obtinut urmatoarele rezultate, care arata cum se declara o clasa, un obiect al acestei clase si modul in care se apeleaza membrii acestei clase, prin intermediul unei instante a acestei clase.

denumirea cartii:Trecea o moara pe Siret

primul autor:Mihail Sadoveanu

al doilea autor: --

nr. pagini:200

pret:30

cartea nr.0:Trecea o moara pe Siret

primul autor:Mihail Sadoveanu

al doilea autor: --

nr pagini:200

pretul:30

continuati?(d/n):d

denumirea cartii:O noapte furtunoasa

primul autor:Ion Luca Caragiale

al doilea autor: --

nr. pagini:50

pret:25

continuati?(d/n):n

Problema 2

Daca, in programul de mai sus, textul definirii clasei carte impreuna cu textele functiilor precizate in clasa, citeste_carte si afiseaza_carte se salveaza ca un fisier header in directorul include, fie el carti.h, atunci programul de mai sus va arata astfel:

int i;

#include<iostream.h>

#include<string.h>

#include<carti.h>

void main()

In urma executarii acestui program, se obtin aceleasi rezultate ca in problema precedenta, cu deosebirea ca referirea clasei carte se face acum din fisierul header, carti.h.

Problema 3

Pentru orice sir de caractere, introdus de la tastatura, printr-un meniu adecvat, sa se realizeze, utilizandu-se o clasa clasasir, urmatoarele operatii: conversia sirului la caractere mici, conversia la caractere mari si adaugarea unui subsir la sirul dat.

#include<stdio.h>

#include<conio.h>

#include<string.h>

class clasasir

// initializarea cu spatii a sirului s

clasasir(char *s=' ')

// declararea functiei de scriere

void scrie(FILE *fileptr);

// declararea functiei de citire

void citeste(FILE *fileptr);

// declararea functiei de concatenare siruri

void operator +=(clasasir &s)

// declararea functiei friend conversie caractere

friend void conversie(clasasir &s,char optiune);

}; // sfarsitul declararii clasei

// descrierea functiei de scriere

void clasasir::scrie(FILE *fileptr)

// descrierea functiei de citire

void clasasir::citeste(FILE *fileptr)

// descrierea functiei de conversie sir

void conversie(clasasir &s,char optiune)

void main()

while((alegere!='1')&&(alegere!='2')&&

(alegere!='3')&&(alegere!='t'));

while(alegere!='t')

while((alegere!='1')&&(alegere!='2')&&

(alegere!='3')&&(alegere!='t'));

printf('n continuati?(d/n):');

r=getche();

}

printf('n terminat n');

In urma executarii programului de mai sus, s-au obtinut rezultatele din lista de mai jos, care pun in evidenta declararea si folosirea membrilor publici si privati, prin intermediul unei instante a clasei declarate.

dati un sir (max=80 caractere):ana are mere

1. conversie sir in majuscule

2. conversie sir in minuscule

3. adaugare subsir la sirul dat

t. terminare program

==============================

alegeti o optiune:1

sirul modificat este:ANA ARE MERE

1. conversie sir in majuscule

2. conversie sir in minuscule

3. adaugare subsir la sirul dat

t. terminare program

==============================

alegeti o optiune:2

sirul modificat este:ana are mere

1. conversie sir in majuscule

2. conversie sir in minuscule

3. adaugare subsir la sirul dat

t. terminare program

==============================

alegeti o optiune:3

introduceti un sir (max 80): frumoase

sirul modificat este:ana are mere frumoase

==============================

1. conversie sir in majuscule

2. conversie sir in minuscule

3. adaugare subsir la sirul dat

t. terminare program

==============================

alegeti o optiune:1

sirul modificat este:ANA ARE MERE FRUMOASE

1. conversie sir in majuscule

2. conversie sir in minuscule

3. adaugare subsir la sirul dat

t. terminare program

==============================

alegeti o optiune:2

sirul modificat este:ana are mere frumoase

1. conversie sir in majuscule

2. conversie sir in minuscule

3. adaugare subsir la sirul dat

t. terminare program

==============================

alegeti o optiune:3

introduceti un sir (max 80): si mari

sirul modificat este:ana are mere frumoase si mari

====================================

1. conversie sir in majuscule

2. conversie sir in minuscule

3. adaugare subsir la sirul dat

t. terminare program

==============================

alegeti o optiune:1

sirul modificat este:ANA ARE MERE FRUMOASE SI MARI

=============================================

1. conversie sir in majuscule

2. conversie sir in minuscule

3. adaugare subsir la sirul dat

t. terminare program

==============================

alegeti o optiune:2

sirul modificat este:ana are mere frumoase si mari

===================================

1. conversie sir in majuscule

2. conversie sir in minuscule

3. adaugare subsir la sirul dat

t. terminare program

==============================

alegeti o optiune:t

terminat

continuati?(d/n):n

In programul de mai sus s-a declarat o clasa numita clasasir, utilizata pentru declararea obiectelor specifice acesteia (exemplu clasasir tempsir) si are ca membri date si functii. Se constata ca unii membri sunt publici, marcati cu eticheta public: functiile copy, scrie, citeste, operator si conversie iar altii sunt privati, nemarcati cu nici o eticheta sau marcati cu eticheta private: variabila (data) sir de exemplu. Se observa, de asemenea, ca unele functii sunt descrise in corpul clasei clasasir: copy si operator iar altele sunt descrise in afara clasei: citeste, scrie si conversie. Membri publici ai unei clase, date sau functii publice, pot fi accesati din interiorul si exteriorul clasei. De exemplu, functiile citeste si scrie au fost accesate direct din functia main prin intermediul obiectului clsir al clasei clasasir : clsir.citeste si respectiv clsir.scrie. Membri privati ai unei clase nu pot fi accesati decat din interiorul clasei. Membrul privat sir a fost accesat numai din interiorul clasei de catre functiile membre: copy, citeste si scrie indiferent daca sunt descrise in interiorul sau in exteriorul clasei.

3. Functii membru ale unei clase

Functiile membru ale unei clase sunt functiile descrise sau declarate in interiorul unei clase. Deci, descrierea efectiva a functiilor membru ale unei clase se poate face, fie in interiorul clasei, fie in afara clasei, daca in interiorul clasei s-au declarat ca prototipuri. Ele pot fi accesate din interiorul clasei si din afara clasei, prin intermediul obiectelor declarate, daca au fost declarate publice, sau numai direct din interiorul clasei de catre alte functii membru ale aceleiasi clase, daca au fost declarate private.

3. 1. Apelarea unei functii membru al unei clase

Apelarea unei functii membru, din interiorul unei clase, se face precizandu-se numele acesteia si parametrii efectivi:

nume_functie_membru(parametri_efectivi_de_apel)

ca in problema de mai sus: clasasir(char *s=' ')

Apelarea unei functii membru, din exteriorul unei clase, se face precizandu-se obiectul declarat, numele acesteia si parametri efectivi:

nume_obiect.nume_functie_membru(parametri_efectivi_de_apel)

asa cum s-a precizat mai sus: clsir.citeste, clsir.scrie.

2. Functii friend

Functiile friend sunt functii obisnuite declarate intr-o clasa, precedate de calificativul friend.

friend nume_functie_membru(parametri_formali)

Acest calificativ le permite sa acceseze membrii privati ai unei clase, din exteriorul acesteia, asa cum este cazul functiei conversie din problema precedenta:

friend void conversie(clasasir &s,char optiune);

Apelarea unei functii friend se face asemanator cu apelarea oricarei functii din C++, ca de exemplu, in functia main() a programului de mai sus: conversie(clsir,alegere);

Variabile de tip referinta

O variabila de tip referinta, in definirea unei functii, este precedata de operatorul adresa &, iar in corpul functiei variabila este referita normal, ca o variabila de tip structura. De fapt, o variabila de tip referinta este un alias, un pseudonim, pentru alta variabila, in esenta, un pointer cu urmatoarele precizari:

odata initializata valoarea sa nu se mai poate modifica

eliberarea, anularea referirii, se face in mod automat

Variabila referinta se utilizeaza, in corpul functiei, ca o structura (exemplu, in programul de mai sus: s.sir) si nu ca un pointer la o structura, asa cum eram obisnuiti la structuri (s->sir)

Variabilele referinta, dupa cum se stie, permit transmiterea parametrilor la functia apelata, prin adrese si nu prin valoare, eliminand, astfel, pierderile de timp cu copierea parametrilor efectivi in memoria stiva Apelarea unei functii membru cu parametri de tip referinta se face fara a preceda parametri respectivi de operatorul adresa & (exemplu, in functia main()de mai sus:conversie(clsir,alegere))

4. Membri statici ai unei calase

Oricare obiect declarat intr-un program, in mod normal, primeste o copie a membrilor clasei la care este asociat. Uneori, este nevoie sa se defineasca unii membrii care sunt folositi in comun de catre toate obiectele clasei. Astfel de membri se numesc membri statici care au proprietati diferite de ceilalti membri nestatici.

Declararea unui membru static presupune precedarea acestuia de cuvantul cheie static:

static tip_membru nume_membru_static;

iar referirea unui membru static se face astfel:

nume_clasa::nume_membru_static;

unde, nume_membru_static poate fi o data sau o functie membru statica

Referirea unui membru static se poate face chiar si inaintea declararii de obiecte ale clasei, in care a fost declarat membru static respectiv, iar initializarea sa se poate face numai in domeniul sau de vizibilitate.

Problema 4

Se considera o clasa de puncte din spatiu in care se descrie un punct de coordonate fixe M0(x0,y0,z0), reprezentand centrul unei sfere, raza fixa a unei sferei ro si un punct oarecare din spatiu M(x,y,z) si functiile:distanta(M0,M) care determina distanta dintre punctele M0 si M, pozitia_fata_de_centru(M), care determina coordonatele punctului M in raport cu centrul sferei si pozitia(M) care precizeaza pozitia punctului M fata de sfera. Sa se scrie un program care sa sa calculeze distanta dintre punctele M0 si M, coordonatele punctului M fata de centrul sferei si sa determine pozitia punctului M fata de sfera utilizandu-se obiecte din clasa declarata.

#include<iostream.h>

#include<conio.h>

#include<math.h>

// definirea clasei clspunct

class clspunct

int poz_x_fata_m0(void)

int poz_y_fata_m0(void)

int poz_z_fata_m0(void)

double poz_m_fata_sfera(void)

};

// initializare datelor statice inainte de

// declararea obiectelor clasei

int clspunct::x0=10;

int clspunct::y0=10;

int clspunct::z0=10;

int clspunct::raza=10;

void main(void)

In urma executarii programului de mai sus, s-au obtinut rezultatele din lista de mai jos, evidentiindu-se declararea si modul de utilizare a membrilor statici precizati in clasa definita.

sfera are la inceput raza 10 si centrul in M0(10,10,10)

coordonatele unui pct (int x,y,z):20 30 40

distanta(M0(10,10,10),M1(20,30,40))=37.4166

coordonatel lui M fata de centru(10,20,30)

punctul M(20,30,40) este exterior sferei

sfera modificata are raza 10 si centrul in M0(1,1,1)

distanta(M0(1,1,1),M1(20,30,40))=52.1824

coordonatel lui M fata de centru(19,29,39)

punctul M(20,30,40) este exterior sferei

continuati?(d/n):d

sfera are la inceput raza 10 si centrul in M0(1,1,1)

coordonatele unui pct (int x,y,z):1 2 3

distanta(M0(1,1,1),M1(1,2,3))=2.23607

coordonatel lui M fata de centru(0,1,2)

punctul M(1,2,3) este interior sferei

sfera modificata are raza 10 si centrul in M0(1,1,1)

distanta(M0(1,1,1),M1(1,2,3))=2.23607

coordonatel lui M fata de centru(0,1,2)

punctul M(1,2,3) este interior sferei

continuati?(d/n):d

sfera are la inceput raza 10 si centrul in M0(1,1,1)

coordonatele unui pct (int x,y,z):-10 -20 20

distanta(M0(1,1,1),M1(-10,-20,20))=30.3809

coordonatel lui M fata de centru(-11,-21,19)

punctul M(-10,-20,20) este exterior sferei

sfera modificata are raza 10 si centrul in M0(1,1,1)

distanta(M0(1,1,1),M1(-10,-20,20))=30.3809

coordonatel lui M fata de centru(-11,-21,19)

punctul M(-10,-20,20) este exterior sferei

continuati?(d/n):n

Spre deosebire de o functie membru nestatica, o functie membru statica poate fi apelata cu sau fara sintaxa specifica unei functii membru:

Exemplu:

..........

class clsx

;

......

void main(void)

Functiile statice nu sunt aplicate unui obiect anume si din acest motiv ele nu accepta ca parametru implicit pointerul this. Si ca atare, din corpul unei functii statice nu se pot accesa membrii obiectelor decat prin calificare explicita, utilizand sageata dreapta (->) sau punctul (.). Pentru declaratia din exemplul de mai sus descrierea functiei statice se face astfel:

Exemplu:

void clsx::functie(int i,clsx *ptr)

Observatie:

Utilizarea principala a membrilor statici este determinata de necesitatea memorarii datelor comune tuturor obiectelor create, de aceeasi clasa, cum ar fi:

- pastrarea unor informatii comune tuturor obiectelor unei clase: semafoare, comutatori.

- inregistrarea numarului obiectelor create asociate aceleiasi clase

- reducerea numarului declaratiilor globale

- validarea accesului la denumirea campurilor de date

5. Pointerul this din C++

Apelarea unei functii membru pozitioneaza un pointer la obiectul de tipul clasei asociate. In momentul apelului, acest pointer apare ca un argument suplimentar nevizibil. El poate fi referit, totusi, cu ajutorul cuvantului cheie this (aici). Utilizarea de baza a cuvantului cheie this este legata de descrierea functiilor membru care manipuleaza pointeri. Deoarece this este un cuvant cheie in C++, el nu poate fi declarat explicit iar, in orice functie membru nestatica a unei clase, pointerul this este declarat implicit ca nume_clasa *this si initializat sa adreseze spre obiectul pentru care este apelata functia membru. Utilizarea pointerului this poate fi pusa in evidenta in functia care insereaza o componenta intr-o lista dublu inlantuita.

Exemplu:

........

class clsinsert

;

void clsinsert::finsert(clsinsert *ptr)

6. Structuri si uniuni, analogii cu clasele din C++

Limajul C++, dupa cum am mai precizat, reprezinta o extensie a limajului C. Toate facilitatile limbajului C se regasesc in limbajul C++. In continuare, se va pune accentul pe deosebirile dintre cele doua limbaje si, cu precadere, pe extensiile aduse de C++ la C.

In C++ clasele nu sunt, altceva, decat extensii ale structurilor din limbajul C. Mai mult, structurile in C++, sunt constructii mult mai puternice decat in C. Structurile, ca si clasele, pe langa date, pot contine descrieri si/sau declarari de functii prototip, inclusiv functii constructor, care sunt de fapt metode publice ce au acelasi nume cu clasa si care se executa automat ori de cate ori se creeaza o instanta, un obiect, al unei clase, si functii destructor, care sunt tot metode publice ce au acelasi nume cu clasa si care se executa, de obicei, la terminarea programului pentru distrugerea instantei unui clase, cu scopul eliberarii memoriei alocate, anterior, instantei.

6. 1. Structuri in limbajul C++

In C++, o structura este, de fapt, o clasa ai carei membri sunt declarati, in mod implicit, public. In consecinta in C++, la declararea unei variabile de tip structura nu mai este obligatorie precizarea cuvantului cheie struct.

Exemplu:

b)      descrierea unei structuri in C b) descrierea unei structuri in C++

typedef struct struct tip_student

tip_student; }

Iar declararea de variabile de tipul structurii de mai sus, in C si in C++ se face astfel:

a) struct tip_student s1,s2,student; b) tip_student s1,s2, student;

Problema 5

Sa se creeze un tablou de structuri de tip student (cod matricol, un numar in intervalul 1..999; nume student, un sir de 20 caractere; numar de note, un numar in intervalul 1..15, notele: nota(1), nota(2) . si media calculata) pentru maximum nmax (20) studenti si apoi sa se afiseze un tabel cu mediile studentilor, utilizandu-se declararea unei structuri specifice limbajului C++ care sa includa descrierea structurii, functia de citire si cea de afisare a informatiilor unui student.

#include<stdio.h>

#include<iostream.h>

#include<iomanip.h>

#include<conio.h>

#include<string.h>

#define nmax 20

struct tip_student

this->media=this->media/this->nrn;

wmedia=this->media;

}

void afisaza_student()

};

void main(void)

while((wcm<1)||(wcm>999));

printf('n nume student:');

cin.getline(wnume,20,'n');

do

while((wnrn<1)||(wnrn>15));

for(k=0;k<wnrn;k++)

while((wnota[k]<1)||(wnota[k]>10));

}

student[i].citeste_student(wcm,wnume,wnrn,wnota,0);

i++;

printf('n continuati?(d/n):');

r=getche();

}

printf('n mediile studentilor ');

printf('n =====================================');

printf('n cod nume si prenume media ');

printf('n =====================================');

for(k=0;k<i;k++) student[k].afisaza_student();

printf('n =====================================n');

Rezultatele executiei programului, de mai sus, sunt prezentate in continuare, putandu-se urmari cum se declara si se utilizeaza o structura care, pe langa campurile componente, contine si doua functii membre, cu care se prelucreaza datele unei structuri date

cod student (1..999):100

nume student:popescu ilie

nr note(1..15):3

nota(0)=2.55

nota(1)=8.45

nota(2)=9.50

continuati?(d/n):d

cod student (1..999):200

nume student:ionescu stefan

nr note(1..15):4

nota(0)=9.25

nota(1)=7.50

nota(2)=4.95

nota(3)=8.30

continuati?(d/n):d

cod student (1..999):150

nume student:tomescu stan

nr note(1..15):2

nota(0)=8.21

nota(1)=6.13

continuati?(d/n):n

mediile studentilor

==========================

cod nume si prenume media

==========================

100 popescu ilie 6.83

200 ionescu stefan 7.50

150 tomescu stan 7.17

==========================

In problema de mai sus, citirea efectiva a campurilor unei componente a tabloui student poate fi inclusa chiar in definirea structurii tip_student, ca in problema de mai jos:

Problema 6

Aceeasi problema ca cea de mai sus, cu deosebirea ca citire efectiva a campurilor unei componente a tabloului student se face in functia citeste_student(), membru al structurii tip_student.

#include<stdio.h>

#include<iostream.h>

#include<iomanip.h>

#include<conio.h>

#include<string.h>

#define nmax 20

struct tip_student

while((wcm<1)||(wcm>999));

printf('n nume student:');

cin.getline(wnume,20,'n');

do

while((wnrn<1)||(wnrn>15));

for(k=0;k<wnrn;k++)

while((wnota[k]<1)||(wnota[k]>10));

}

this->cm=wcm;

strcpy(this->nume,wnume);

this->nrn=wnrn;

this->media=0;

for(k=0;k<wnrn;k++)

this->media=this->media/this->nrn;

wmedia=this->media;

}

void afisaza_student()

}; // sfarsitul definirii structurii tip_student

void main(void)

printf('n mediile studentilor ');

printf('n =====================================');

printf('n cod nume si prenume media ');

printf('n =====================================');

for(k=0;k<i;k++) student[k].afisaza_student();

printf('n =====================================n');

}

6. 2. Uniuni in limbajul C++

In limbajul C++, tipul uniune de date, precizat prin cuvantul cheie union, se defineste in mod similar cu definirea unei structuri, adica, tot ca si o clasa ai carei membri sunt considerati in mod implicit public, pana la prima declaratie private explicita. Ca si la declararea variabilelor de tip structura, in C++, la declararea unei variabile de tip union nu mai este obligatorie precizarea cuvantului cheie union. Dupa cum se stie, fata de o structura, tipul union declara date de acelasi tip sau de tipuri diferite care utilizeaza in comun aceeasi zona de memorie, dar la momente diferite de timp. Partajarea aceleasi zone de memorie de catre doua sau mai multe variabile nu se poate realiza cu o structura sau o clasa obisnuita. Tipul union de date are si cateva restrictii importante cum ar fi:

- nu poate include obiecte care sa contina functii constructor si destructor, fara a se intelege ca tipul union nu poate avea definite functii constructor si destructor proprii.

- nu poate include membri statici: date si functii statice

- nu poate fi mostenirea altei clase si nu poate servi, ca baza, pentru definirea, derivarea, altei clase.

Problema 7

Se introduc, pe rand, de la tastatura oricare n (1<=n<=nmax) numere reale (float) si 2*n numere intregi (int) si care vor folosi in comun aceasi zona de memorie. Sa se afiseze, pe rand, numerele introduse, cele reale si cele integi, impreuna cu mediile lor aritmetice, utilzandu-se un tip union adecvat care sa contina datele care utilizeaza in comun aceeasi zona de memorie precum si functiile membru de citire, calcul medii si de afisare a datelor si rezultatelor.

#include <stdio.h>

#include <conio.h>

#include<malloc.h>

const int nmax=20;

union tipnumere

}

void citeste_reale(long int n)

}

void calcul_medie_intregi(int n)

printf('n media arit. a celor %d nr. intregi=%1.2lf',n,mint/n);

}

void calcul_medie_reale(int n)

printf('n media arit. a celor %d nr.reale=%1.2lf',n/2,2*mfloat/n);

}; // sfarsitul descrierii uniunii

void main(void)

while((n<1)||(n>nmax)||(n%2));

// apelarea functiei membru ptr citirea a n nr intregi

u.citeste_intregi(n);

v1=u; /* atribuire de variabila de tip uniune cu numere intregi*/

// apelarea functiei membru ptr citirea a n/2 nr reale

u.citeste_reale(n);

v2=u; /* atribuire de variabila de tip uniune cu numere reale*/

pv1=&v1; /* adresa variabilei uniune v1 in pointerul pv1 */

pv2=&v2; /* adresa variabilei uniune v2 in pointerul pv2 */

/* afisarea numerelor intregi si calcularea mediei aritmetice a acestora */

// apelarea functiei membru ptr calculul mediei nr intregi

v1.calcul_medie_intregi(n);

printf('n nr intregi si media calculate in main:n');

/* insumarea numerelor intregi */

for(k=0;k<n;k++)

printf('n media celor %d nr. intregi=%1.2lf',n,mint/n);

/* afisarea numerelor reale si calcularea mediei aritmetice a acestora */

// apelarea functiei membru ptr calculul mediei nr reale

v2.calcul_medie_reale(n);

printf('n nr reale si media calculate in main:n');

/* insumarea numerelor reale */

for(k=0;k<(n/2);k++)

printf('n media celor %d nr. reale=%1.2lf',n/2,2*mfloat/n);

printf('n continuati?(d/n):');

r=getche();

Rezultatele executiei programului, de mai sus, sunt prezentate in continuare, putandu-se urmari cum se declara si se utilizeaza o uniune de date care, pe langa campurile componente, contine si functii membre, cu care se prelucreaza datele uniunii ce folosesc aceeasi zona de memorie in comun

nr par de numere intregi (1<=n<=20):4

introduceti cele 4 de nr. intregi in uniunea u:

x(0)=25

x(1)=45

x(2)=65

x(3)=35

introduceti cele 2 de numere reale din uniunea u:

y(0)=67.77

y(1)=99.12

nr intregi si calculul medie in uniune:

media arit. a celor 4 nr. intregi=42.50

nr intregi si media calculate in main:

25 45 65 35

media celor 4 nr. intregi=42.50

nr reale si calculul medie in uniune:

67.77 99.12

media arit. a celor 2 nr.reale=83.44

nr reale si media calculate in main:

67.77 99.12

media celor 2 nr. reale=83.44

continuati?(d/n):d

nr par de numere intregi (1<=n<=20):6

introduceti cele 6 de nr. intregi in uniunea u:

x(0)=10

x(1)=20

x(2)=30

x(3)=40

x(4)=50

x(5)=60

introduceti cele 3 de numere reale din uniunea u:

y(0)=23.45

y(1)=67.97

y(2)=-34.56

nr intregi si calculul medie in uniune:

media arit. a celor 6 nr. intregi=35.00

nr intregi si media calculate in main:

10 20 30 40 50 60

media celor 6 nr. intregi=35.00

nr reale si calculul medie in uniune:

23.45 67.97 -34.56

media arit. a celor 3 nr.reale=18.95

nr reale si media calculate in main:

23.45 67.97 -34.56

media celor 3 nr. reale=18.95

continuati?(d/n):n

Observatie:

Limbajul C++ accepta uniunile anonime, fara specificarea numelui uniunii, ca in programul de mai jos:

Problema 8

Se considera o uniune anonima, fara nume, de trei date: intreaga, reala si caracter. Sa se afiseze pe rand toate datele intregi, reale si caracter tastate.

#include<iostream.h>void main(void)

char r='d';

while(r=='d')

Problema 9

Se considera trei siruri: primul de numere intregi, al doilea de caractere si al treilea de numere reale, care utilizeaza in comun aceeasi zona de memorie. Cu ajutorul unei uniuni a celor trei tipuri de data, sa se citeasca, pe rand, elementele sirurilor, cu ajutorul unei functii membru (citeste_sir), sa se ordoneze crescator fiecare sir cu o alta functie membru (ordoneaza_sir) si apoi sa se afiseze sirurile astfel ordonate cu alta functie membru (afisaza_sir)

#include<iostream.h>

#define nmax1 20

#define nmax2 15

#define nmax3 10

int i;

union tip_siruri

if(tsir=='c')

if(tsir=='r')

}

void afisaza_sir(int n,char tsir) //functia membru de afisare

void ordonare_sir(int n,char tsir) //functia membru de ordonare

if(tsir=='c')

if(tsir=='r')

}

}

};

void main(void)

while((n<1)||(n>nmax1));

cout<<'n se citesc '<<n<<' intregi:n';

cout<<'===============================';

u.citeste_sir(n,'i');

u.ordonare_sir(n,'i');

cout<<'n=============================';

cout<<'n sirul de intregi ordonat:';

u.afisaza_sir(n,'i');

cout<<'n=============================';

do

while((n<1)||(n>nmax2));

cout<<'n se citesc '<<n<<' caractere:';

cout<<'n=============================';

u.citeste_sir(n,'c');

u.ordonare_sir(n,'c');

cout<<'n=============================';

cout<<'n sirul de caractere ordonat:';

u.afisaza_sir(n,'c');

cout<<'n=============================';

do

while((n<1)||(n>nmax3));

cout<<'n se citesc '<<n<<' reali:n';

cout<<'n=============================';

u.citeste_sir(n,'r');

u.ordonare_sir(n,'r');

cout<<'n=============================';

cout<<'n sirul de reali ordonat:';

u.afisaza_sir(n,'r');

cout<<'n=============================';

cout<<'n continuati?(d/n):';

cin>>r;

}

Rezultatele executiei programului, sunt prezentate in continuare, putandu-se urmari cum se declara si se utilizeaza o uniune de siruri de date care, pe langa aceste siruri, contine si functii membre (citeste_sir(), afisaza_sir() si ordonare_sir()), cu care se prelucreaza datele uniunii, de tip siruri de date, ce folosesc aceeasi zona de memorie in comun

dati nr de intregi de citit(n<20)=4

se citesc 4 intregi:

sint(0)=45

sint(1)=-34

sint(2)=78

sint(3)=-90

sirul de intregi ordonat:-90 -34 45 78

dati nr de caractere de citit(n<15)=5

se citesc 5 caractere:

scar(0)=i

scar(1)=y

scar(2)=3

scar(3)=a

scar(4)=f

sirul de caractere ordonat:3 a f i y

dati nr de reali de citit(n<10)=4

se citesc 4 reali:

sreal(0)=32.45

sreal(1)=89.45

sreal(2)=-67.99

sreal(3)=-23.33

sirul de reali ordonat:-67.99 -23.33 32.45 89.45

continuati?(d/n):d

dati nr de intregi de citit(n<20)=3

se citesc 3 intregi:

sint(0)=45

sint(1)=-34

sint(2)=18

sirul de intregi ordonat:-34 18 45

dati nr de caractere de citit(n<15)=4

se citesc 4 caractere:

scar(0)=k

scar(1)=a

scar(2)=w

scar(3)=h

sirul de caractere ordonat:a h k w

dati nr de reali de citit(n<10)=3

se citesc 3 reali:

sreal(0)=-34.78

sreal(1)=67.33

sreal(2)=-97.5

sirul de reali ordonat:-97.5 -34.78 67.33

continuati?(d/n):n

Probleme propuse:

1. Sa se proiecteze si sa se implementeze o clasa C++ pentru obiecte de tip zaruri.

Clasa respectiva trebuie sa memoreze numarul de pe fata superioara dupa ultima aruncare a unui zar. In plus, ea trebuie sa contina o functie membru care simuleaza o aruncare a zarului. Aceasta functie genereaza in mod aleator un numar intre 1 si 6, reprezentand fata superioara rezultata in urma aruncarii (pentru ea se pot utiliza functiile sistem rand si srand, declarate in stdlib.h).
Utilizand aceasta clasa, sa se simuleze aruncarea a doua zaruri de 7000 de ori consecutiv, iar apoi sa se determine:

perechea de numere cu cele mai multe aparitii;

perechea de numere cu cele mai multe aparitii consecutive;

perechea de numere cu cele mai putine aparitii;

frecventa de aparitie a fiecarei fete a unui zar.

2. Sa se modifice problema precedenta, adaungand noi membri, unii dintre ei statici, astfel incat sa permita calculul si afisarea frecventei de aparitie a fiecarei fete a unui zar in interiorul clasei.

3. Sa se proiecteze si sa se implementeze o clasa C++ pentru cartile de joc. O carte de joc este reprezentata de trei elemente: suita, valoare, precum si starea curenta, indicand daca respectiva carte a fost sau nu ridicata de pe masa de joc.
a) Sa se scrie un program care creaza si afiseaza un pachet de carti de joc. Se va utiliza un tablou de 52 de carti de joc.
b) Sa se scrie un program care simuleaza jocul de carti numit 21: doi jucatori iau pe rand carti din pachet si castiga cel care are suma valorilor egala sau cat mai apropiata (dar mai mica) decat 21.

4. Sa se proiecteze si sa se implementeze o clasa C++ pentru bilele utilizate in extragerile Loto. O bila este reprezentata prin numarul asociat si prin starea curenta, indicand daca respectiva bila a fost sau nu extrasa de pe masa de joc.
Sa se scrie un program care simuleaza o masina Loto pentru jocul 6 din 49. Se va utiliza un tablou de 49 de elemente, precum si o functie care genereaza un numar aleator din multimea . Pentru aceasta se pot utiliza functiile sistem rand si srand, declarate in stdlib.h.