MINISTERUL EDUCAŢIEI ŞI ŞTIINŢEI AL REPUBLICII

MOLDOVA

Universitatea Liberă Internaţională din Moldova

Facultatea Informatică şi Inginerie

LUCRARE DE LABORATOR Nr.1, 2, 3, 4

La obiectul: Programarea C++

Tema: Clase

A realizat: st. gr. C-1123, Erhan Lucia

Lect. asist: prof., Ichim Ion

Chişinău 2012
Scopul lucrării:
 Utilizarea claselor, constructorilor, destructorilor, moștenirii în programe.

Conținutul lucrării de laborator:

 Condiția
 Codul sursă
 Screenshot cu rezultatul

Condiția 1.
Să se creeze o clasă care va realiza ecuația (a+b-c) 2/z. Ecuația se execută de 10
ori și se afișează doar rezultatele care au valori pare.

#include <iostream.h>
#include <conio.h>
#include <math.h>

class Ec
{ public:
double rez;
Ec(double, double, double, double);
void afiseaza_rez(void);
private:
double a, b, c, z;};
Ec::Ec (double a, double b, double c, double z)
{ Ec::a=a;
Ec::b=b;
Ec::c=c;
Ec::z=z;
rez=(a*a+b*b+c*c)/z;}
void Ec::afiseaza_rez(void)
{cout << "Rezultat: " << rez << endl; }
void main()
{for(int i=0; i<10; i++)
{Ec ecuatie(i+5, i+4, i+3, i+2); ecuatie.afiseaza_rez();}
 getch();}

Fig 1. Rezultatul 1

Condiția 2.
Să se creeze o clasă care va moșteni 2 funcții unei clase de bază.

#include <iostream.h>
#include <conio.h>
#include <math.h>
#include <string.h>

class ULIM
{public:
ULIM(char *, char *);
void afis_ULIM();
private:
char num[64];
char tip[64];
float sum;};
ULIM::ULIM(char *name, char *type)
{strcpy(ULIM::name, name);
strcpy(ULIM::type, type);}

void ULIM::afis_ULIM()
 {cout << "Denumirea universitatii: " << name << endl;
cout << "Tipul universitatii: " << type << endl;}

class UTM: public ULIM

{public:
UTM(char *, char *, char *);
void afis_UTM();
private:
char message[64];};
UTM::UTM(char *name, char *type, char *message) : ULIM(name, type)
{strcpy(UTM::message, message) ;}
void UTM::afis_UTM()
{afis_ULIM();
cout << "Semnificatie:" << message << endl;}
void main()
{ULIM a("ULIM", "Universitatea Libera Internationala din Moldova");
UTM b("UTM", "Universitatea Tehnica a Moldovei", "Institutii de invatamint superior");
a.afis_ULIM();
cout << "============================================" << endl;
b.afis_UTM();
cout << "============================================" << endl;
getch();}

Fig 2. Rezultatul 2
Condiția 3.
Să se creeze o clasă pe tema ”Figuri geometrice”. Clasa va moșteni de la alte 2
clase de bază careva parametri. (triunghi)

#include <iostream.h>
#include <conio.h>
#include <string.h>

class figura
{public:
char fi[64];
void fig ()
{cout<<"Denumirea figurii geometrice: "<<fi<<endl;
cout<<"============================"<<endl;};};

class date: public figura

{public:
int d1, d2, d3;
void dat ()
{cout << "Latura A=" << d1 << endl;
cout << "Latura B=" << d2 << endl;
cout << "Latura C=" << d3 << endl;
cout<<"============================"<<endl;};};

class suprafata: public date

{public:
int x, y, z;
void supr()
{cout << "suprafata X=" << x << endl;
cout << "suprafata Y=" << y << endl;
cout << "suprafata Z=" << z << endl;
cout<<"============================"<<endl;};};

class aria: public suprafata

{ public:
int a;
void ar()
 { cout<<"Aria="<<(d1*d2*d3)/(4*3.14)<<endl;};};
void main()
{aria f1; strcpy (f1.fi, "Triunghi");
f1.d1 = 4; f1.d2 = 6; f1.d3 = 5; f1.x = 12; f1.y = 26; f1.z = -16;
f1.fig(); f1.dat(); f1.supr(); f1.ar();
getch();}

Fig 3. Rezultatul 3

Condiția 4.
Să se creeze o clasă care va prelucra tablouri unidimensionale, tablouri bidimensionale
pentru fiecare clasă trebuie să fie minimum 5 funcții de prelucrare.

#include <iostream.h>
#include <conio.h>
#include <string.h>
#include <math.h>

class Masivul
{public:
int num[128], lungimea;
double rez;

void Suma()
{rez=0;
cout << "1) Suma=";
for(int i=1; i<=lungimea; i++) rez+=num[i];
cout << rez << endl;}

void Diferenta()
 {rez=0;
cout << "2) Diferenta=";

for(int i=1; i<=lungimea; i++) rez=rez-num[i];

cout << rez << endl;}

void Produsul()
{rez=1;
cout << "3) Produsul=";

for(int i=1; i<=lungimea; i++)rez*=num[i];

cout << rez << endl;}

void Sqrt()
{rez=0;
cout << "4) Radacina patrata: " << endl;

for(int i=1; i<=lungimea; i++)

{rez=sqrt(num[i]);
cout << i <<" elementul masivului: "<< rez << endl;}}

void Ridicarea_la_putere()
{int power;
rez=0;
cout << "5) Ridicarea la putere: ^";
cin >> power;

for(int i=1; i<=lungimea; i++)

{ rez=pow(num[i],power);
cout << i <<" elementul masivului: "<<num[i]<< "^" << power << "=" << rez << endl;
}}};

class Masivul_bidimensional
{public:
int num[128][128], lungimea_x, lungimea_y;
double rez;

void Suma()
{rez=0;
cout << "1) Suma=";
for(int y=1; y<=lungimea_y; y++)
{for(int x=1; x<=lungimea_x; x++)
{rez+=num[x][y];}}
cout << rez << endl;}

void Diferenta()
{rez=0;
cout << "2) Diferenta=";

for(int y=1; y<=lungimea_y; y++)

{for(int x=1; x<=lungimea_x; x++)
{ rez=num[x][y];}}
cout << rez << endl;}
void Produsul()
{rez=1;
cout << "3) Produsul=";
for(int y=1; y<=lungimea_y; y++)
{for(int x=1; x<=lungimea_x; x++)
{rez*=num[x][y];}}
cout << rez << endl;}

void Sqrt()
{rez=0;
cout << "4) Radacina patrata: "<< endl;

for(int y=1; y<=lungimea_y; y++)

{for(int x=1; x<=lungimea_x; x++)
{rez=sqrt(num[x][y]);
cout<<"["<<x<<"]["<<y<<"] elementul masivului: "<< rez << endl;}}}

void Ridicarea_la_putere()
{int power;
rez=0;
cout << "5) Ridicarea la putere: ^";
cin >> power;
for(int y=1; y<=lungimea_y; y++)
{for(int x=1; x<=lungimea_x; x++)
{rez=pow(num[x][y],power);
cout<<"["<<x<<"]["<<y<<"] elementul masivului:"<< num[x][y] <<"^"<<power
<<"="<<rez<<endl;}}}};

void main()
{ int elemente[128], lungimea;
cout << "Introduceti lungimea masivului: ";
cin >> lungimea;

for (int i=1; i<=lungimea; i++)

{cout << "Introduceti " << i << " elementul massivului: ";
cin >> elemente[i];}
cout << "===============================" << endl;

Masivul primeste;
primeste.lungimea = lungimea;
memcpy(primeste.num, elemente, sizeof(elemente));
primeste.Suma();
cout << "===============================" << endl;

primeste.Diferenta();
cout << "===============================" << endl;

primeste.Produsul();
cout << "===============================" << endl;

primeste.Sqrt();
cout << "===============================" << endl;

primeste.Ridicarea_la_putere();
 cout << "===============================" << endl;

int double_elemente[128][128], lungimea_x, lungimea_y;

cout << "Introduceti lungimea masivului: ";

cin >> lungimea_x;
cout << "Introduceti lungimea coloanelor masivului: ";
cin >> lungimea_y;lungimea;

for(int y=1; y<=lungimea_y; y++)

{for(int x=1; x<=lungimea_x; x++)
{cout << "Introduceti Masivul["<<x<<"]["<<y<<"]"<< " elementul masivului: ";
cin >> double_elemente[x][y];}}

Masivul_bidimensional Masivul_bi_primeste;
Masivul_bi_primeste.lungimea_x=lungimea_x;
Masivul_bi_primeste.lungimea_y=lungimea_y;
memcpy(Masivul_bi_primeste.num, double_elemente, sizeof(double_elemente));

Masivul_bi_primeste.Suma();
cout << "===============================" << endl;

Masivul_bi_primeste.Diferenta();
cout << "===============================" << endl;

Masivul_bi_primeste.Produsul();
cout << "===============================" << endl;

Masivul_bi_primeste.Sqrt();
cout << "===============================" << endl;

Masivul_bi_primeste.Ridicarea_la_putere();
cout << "===============================" << endl;
getch();}
Fig 4. Rezultatul 4