Lucrarea 10

Exercitii Recapitulative

1) Mostenirea.Proprietati ale mecanismului de mostenire.

In programul urmator se va declara o clasa de baza numita Baza din care vom
deriva o clasa numita Derivata1. Din aceasta clasa , Derivata1, se va deriva o alta
clasa numita Derivata2. Acest exemplu isi propune sa scoata in evidenta modul in
care sunt apelati constructorii si destructorii atunci cand se foloseste mostenirea.

#include <stdio.h>
#include <iostream.h>
#include <stdlib.h>
class Baza
{
public : Baza ()
{
cout<<endl<<"Constructorul Clasei De Baza";
}
~Baza()
{
cout<<endl<<"Destructorul Clasei De Baza";
}
};
class Derivata1 :public Baza
{
public : Derivata1 ():Baza ()
{
cout<<endl<<"Constructorul Primei Clase Derivate";
}
~Derivata1()
{
cout<<endl<<"Destructorul Primei Clase Derivate";
}
};
class Derivata2 :public Derivata1
{
public : Derivata2 ():Derivata1 ()
{
cout<<endl<<"Constructorul Celei De-a 2-a Clase Derivate";
}
~Derivata2()
{
cout<<endl<<"Destructorul Celei De-a 2-a Clase Derivate";
}
};
void main ()
{
Derivata2 *obj ;
/* Se declara un pointer la obiect de tip Derivata 2
Derivata2 este o clasa derivata din Derivata1 care la randul ei
este derivata din clasa Baza*/
obj = new Derivata2 ();//se instantiaza obiectul
cout<<endl;
system("pause");
cout<<"Se apeleaza destructorii in ordinea inversa constructorilor: " << endl;
delete obj; //se distruge obiectul
cout<<endl;
system("pause");
}

Urmatorul exemplu isi propune sa evidentieze apelul constructorilor in cazul mostenii

multiple:

#include <stdio.h>
#include <iostream.h>
#include <stdlib.h>
class Baza
{
public : Baza ()
{
cout<<endl<<"Constructorul Clasei De Baza";
}
~Baza()
{
cout<<endl<<"Destructorul Clasei De Baza";
}
};
class Derivata1 :public Baza
{
public : Derivata1 ():Baza ()
{
cout<<endl<<"Constructorul Primei Clase Derivate";
}
~Derivata1()
{
cout<<endl<<"Destructorul Primei Clase Derivate";
}
};
class Derivata2 :public Baza
{
public : Derivata2 ():Baza ()
{
cout<<endl<<"Constructorul Celei De-a 2-a Clase Derivate";
}
~Derivata2()
{
cout<<endl<<"Destructorul Celei De-a 2-a Clase Derivate";
}
};
class Derivata3 :public Derivata1 , public Derivata2
{
public : Derivata3 ():Derivata1 (),Derivata2 ()
{
cout<<endl<<"Constructorul Celei De-a 3-a Clase Derivate";
}
~Derivata3()
{
cout<<endl<<"Destructorul Celei De-a 3-a Clase Derivate";
}
};
void main ()
{
Derivata3 *obj ;
obj = new Derivata3 ();//se instantiaza obiectul
cout<<endl;
system("pause");
cout<<"Se apeleaza destructorii in ordinea inversa constructorilor: " << endl;
delete obj; //se distruge obiectul
cout<<endl;
system("pause");
}

2) Urmatorul program va crea o clasa Cerc din care se va deriva o clasa Sfera.

#include <iostream.h>
#include <stdio.h>
#include <conio.h>
#include <math.h>
const double PI = 3.14159;
class Punct
{
private : float x,y,z;
public :
Punct (void) //Primul Constructor (DEFAULT CONSTRUCTOR);
{
x = y = z = 0;
}
Punct (float X , float Y ,float Z)// Al doilea Constructor
{
x = X;
y = Y;
z = Z;
}
void Afisare_Punct()
{
cout << endl << " Coordonatele sunt : x = " << x << ", y = " << y << ", z = " <<z
;
}
/*in acest mod Clasa Circle va avea acces la membrii privati
ai clasei Punct (x,y,z);*/
friend class Circle ;
};
class Circle
{
/* Membrii Declarati Protected in clasa de baza
sunt vazuti ca publici in clasa derivata.*/
protected : Punct center;
float radius;
public : Circle (void) //Default Constructor
{
radius = 0;
/*nu mai e nevoie sa initializam membrul center, deoarece
acesta a fost initializat in momentul declararii
prin Constructorul Punct(void); */
}
Circle (Punct Center , float Radius)
{
/* fie scriem :
center = * new Punct ( Center.x, Center.y , Center.z)
fie center = Center */
center = Center;
if (Radius < 0 ) radius = 0 ;
else radius = Radius;
}
double Diameter()
{
return 2*radius;
}
double Circumference()
{
return 2*PI*radius;
}
double Area()
{
return radius * radius * PI;
}
Punct Center()
{
return center;
}
float Radius()
{
return radius;
}
void Display()
{
cout << endl << " PROPRIETATILE CERCULUI :";
cout << endl << " Centrul Cercului ";
center.Afisare_Punct();
cout << endl << " Raza Cercului = " << radius;
cout << endl << " Diametrul Cercului = " << Diameter();
cout << endl << " Circumferinta Cercului = " << Circumference();
cout << endl << " Aria Cercului = " << Area();
}
};
class Sphere : public Circle
{
private : Circle createdBy;
public :
Sphere (Circle cerc) : Circle ( cerc.Center() , cerc.Radius())
{
createdBy = cerc;
}
Circle CreatedBy()
{
//Aceasta Functie Returneaza Cercul din care a provenit sfera;
return createdBy;
}
double Volume()
{
return radius * radius * radius * PI * 4 / 3;
}
void Show()
{
cout << endl;
cout << endl << " PROPRIETATILE SFEREI :";
cout << endl << " Centrul Sferei ";
center.Afisare_Punct();
cout << endl << " Raza Sferei = " << radius;
cout << endl << " Diametrul Sferei = " << Diameter();
cout << endl << " Circumferinta Sferei = " << Circumference();
cout << endl << " Aria Sferei = " << 4 * Area();
cout << endl << " Volumul Sferei = " << Volume();
}
};

void main (void)

{
float x,y,z,r;
cout << endl << "Dati Coordonatele Centrului Cercului : ";
cout << endl << " Centru ( x , y , z ) : x = "; cin >> x;
cout << endl << " Centru ( "<<x<<" , y , z ) : y = "; cin >> y;
cout << endl << " Centru ( "<<x<<" , " <<y <<" , z ) : z = "; cin >> z;
Punct centru(x,y,z);
cout << endl << " Raza = " ; cin >> r;
//Acum cream o sfera pe baza cercului format din Centru si Raza

Sphere sfera( Circle (centru , r) );

/* Sphere sfera( Circle (centru , r) ) echivalent cu Circle(centru , r)

reprezinta constructorul clasei Circle ce returneaza un obiect
de tipul Circle. Cu alte cuvinte ce scrie mai sus se traduce prin Sphere
sfera ( un obiect de tipul Circle). In acest moment se executa Constructorul
Clasei Sphere care nu face decat sa tina minte ( intr-o variabila )
cercul din care a provenit sfera */

sfera.CreatedBy().Display();

/* sfera este un obiect de tipul Sphere .

Clasa Sphere are ca membru o functie numita CreatedBy() care returneaza
cercul din care provine sfera. Asta inseamna ca sfera.CreatedBy() este
un obiect de tipul Circle. In acelasi timp Clasa Circle are ca membru
o functie numita Display() care afiseaza informatii despre cerc
Deci sfera.CreatedBy().Display() va afisa informatii despre cercul
din care provine Sfera*/

sfera.Show(); // afiseaza informatii despre un obiect de tipul Sphere

getche();
}

3) Program pentru calculul radacinilor ecuatiei de gradul II folosind clase.

# include <iostream.h>
# include <stdio.h>
# include <stdlib.h>
# include <math.h>
# include <string.h>
class Complex
{
private : double real;
double imaginar;
public : Complex (void) //Default Constructor
{
real = imaginar = 0;
}
Complex ( double Real , double Imaginar) // Al doilea Constructor
{
real = Real;
imaginar = Imaginar;
}
double Modul ()
{
return sqrt ( pow(real,2) + pow (imaginar,2));
}
Complex Conjugat()
{
return Complex(real , imaginar * -1);
}
void Display()
{
if (imaginar >= 0)
cout << endl << real << " + i * "<< imaginar;
else
cout << endl << real << " - i * "<< -1 * imaginar;
}
};
class EC2
{
private : double a0,a1,a2; // a2*X^2 + a1*X + a0 = 0;
public : EC2(void) //Default Constructor
{
a0 = a1 = a2 = 0;
}
EC2(double A2 , double A1 , double A0) //Al doilea constructor
{
a0 = A0;
a1 = A1;
a2 = A2;
}
double Delta()
{
return pow (a1,2) - 4 * a2 * a0 ; // b^2 - 4*a*c
}
friend class Sollutions; // Clasa sollutions are acces la membrii privati a0,a1,a2
// Este nevoie de acces la acestia in momentul in care
//calculam radacinile (functia Calc_Sollutions());
};
class Sollutions
{
private : double x1;
double x2;
Complex rad_complexa;
EC2 ecuatie;
public :
char specificator[50];
//acest specificator indica daca avem radacini reale sau complexe;
Sollutions (EC2 ec2)
{
ecuatie = ec2;
}
void Calc_Sollutions()
{
cout << endl << endl << "SOLUTIILE ECUATIEI SUNT ";
double delta = ecuatie.Delta();
if (delta < 0)
{
cout << "RADACINI COMPLEXE ";
strcpy(specificator , "COMPLEX" );
double real = 0;
double imag = 0;
real = ( -1 * ecuatie.a1 ) / ( 2 * ecuatie.a2);
imag = sqrt( abs (delta) ) / ( 2 * ecuatie.a2);
// abs(delta) este echivalent cu modulul lui delta.
rad_complexa = * new Complex (real,imag);
}
else if (delta >= 0)
{
cout << "RADACINI REALE ";
strcpy(specificator , "REAL");
x1 = ( -1 * ecuatie.a1 - sqrt (delta) ) / ( 2 * ecuatie.a2);
x2 = ( -1 * ecuatie.a1 + sqrt (delta) ) / ( 2 * ecuatie.a2);
}
cout << endl << "DELTA = " << delta;
}
double X1()
{
return x1;
}
double X2()
{
return x2;
}
Complex Rad_Complexa()
{
return rad_complexa;
}
};
void main (void)
{
double a,b,c;
cout << endl << endl << " DATI COEFICIENTII ECUATIEI DE GRADUL 2 aX^2 + bX
+ c = 0" << endl;
cout << endl << " COEFICIENTUL LUI X^2 (a) : " ; cin >> a;
cout << endl << " COEFICIENTUL LUI X^1 (b) : " ; cin >> b;
cout << endl << " COEFICIENTUL LUI X^0 (c) : " ; cin >> c;
Sollutions radacini (EC2(a,b,c));
radacini.Calc_Sollutions();
if ( strcmp ( strupr (radacini.specificator) , "COMPLEX" ) == 0)
{
radacini.Rad_Complexa().Display();
radacini.Rad_Complexa().Conjugat().Display();
//radacini.Rad_Complexa() intoarce un obiect de tipul clasei Complex
//care are o functie Display() ce afiseaza numarul Complex
//radacini.Rad_Complexa().Conjugat() intoarce un obiect de
//tipul clasei Complex care are o functie Display() ce afiseaza numarul Complex
}
else if ( strcmp ( strupr (radacini.specificator) , "REAL" ) == 0)
{
cout << endl << radacini.X1();
cout << endl << radacini.X2();
}
cout<<endl;
system("pause");
}