lab 11

Alexe R. Tudor-Stefan gr.2111, Seria A, sem II, 17.05.2011 22:42

1. În cazul exemplului 4 (care exemplificã moºtenirea simplã, cu clasa de bazã Poziþie ºi derivatã
Punct) se cer urmãtoarele:
a. urmariþi ºi verificaþi ordinea de apel pentru constructori/destructori
b. extindeþi funcþia main() pentru a utiliza toate metodele din clasa de baza ºi din clasa
derivatã
c. introduceþi o nouã clasã Cerc (date ºi metode), derivatã din clasa Poziþie
d. scrieþi un program ce utilizeazã aceste clase.

#include <iostream>
using namespace std;
// clasa de baza
class Pozitie
{
protected :
int x, y;
public :
Pozitie (int=0, int=0);
Pozitie(Pozitie &);
~Pozitie();
void afisare();
void deplasare(int, int);
};
// constructor
Pozitie::Pozitie(int abs, int ord)
{
x = abs; y=ord;
cout << "Constructor \"Pozitie\", ";
afisare();
}
//constructor de copiere
Pozitie::Pozitie(Pozitie &p)
{
x = p.x;
y = p.y;
cout << "Constructor de copiere \"Pozitie\", ";
afisare();
}
// destructor
Pozitie::~Pozitie()
{
cout << "Destructor \"Pozitie \", ";
afisare();
}
void Pozitie::afisare()
{
cout << "coordonate: x = " << x << ", y = " << y << "\n";
}
void Pozitie::deplasare(int dx, int dy)
{
x += dx; y+=dy;
}
// clasa derivata
class Punct: public Pozitie
{
int vizibil;
char culoare;
public:
Punct(int=0, int=0, char='A');
Punct(Punct &);
~Punct();
void arata()
{
vizibil = 1;
}
void ascunde()
{
vizibil = 0;
}
void coloreaza(char c)
{
culoare = c;
}
void deplasare(int, int);
void afisare();
};
// constructor
Punct::Punct(int abs, int ord, char c):Pozitie(abs, ord)
{
vizibil = 0;
culoare = c;
cout << "Constructor \"Punct\", ";
afisare();
}
// constructor de copiere
Punct::Punct(Punct &p):Pozitie(p.x, p.y)
{
vizibil = p.vizibil;
culoare = p.culoare;
cout << "Constructor de copiere \"Punct\", ";
afisare();
}
// destructor
Punct::~Punct()
{
cout << "Destructor \"Punct\", ";
afisare();
}
// redefinire functie de afisare in clasa derivata
void Punct::afisare()
{
cout << "Pozitie: x = " << x << ", y = " << y;
cout << ", culoare: " << culoare;
if(vizibil)
cout << ", vizibil \n";
else
cout << ", invizibil \n";
}
// redefinire functie de deplasare in clasa derivata
void Punct::deplasare(int dx, int dy)
{
if(vizibil)
{
cout << "Deplasare: ";
afisare();
}
x += dx;
y += dy;
if(vizibil)
{
cout << "la coordonatele: ";
Pozitie::afisare();
}
}
class Cerc: public Pozitie
{
private:
int r;
public:
Cerc(int ri, int xi, int yi):Pozitie(xi,yi)
{
r=ri;
}
Cerc(Cerc &a):Pozitie(a.Pozitie::x,a.Pozitie::y)
{
r=a.r;
}
~Cerc()
{
cout << "Sa distrus cercul:(" << endl;
}
void coord()
{
cout << "(" << x << "," << y << ")";
}
void afisare(int a=0)
{
if(a)
Pozitie::afisare();
else
cout << "Cercul de raza r=" << r << " se afla la pozitia x=" << Pozitie::x << ", y=" << Pozitie::y << endl;
}
void deplasare(int xi, int yi)
{
cout << "Cercul sa deplasat de la pozitia "; coord();
Pozitie::deplasare(xi,yi);
cout << " la pozitia "; coord(); cout << endl;
}
void marire(int x)
{
r+=x;
}
};
// program ce utlizeaza clasa derivata
int main(void)
{
Punct p0(1, 1, 'V');
Punct p1(p0);
p1.arata();
p1.deplasare(10,10);
p1.ascunde();
p1.coloreaza('M');
p1.Pozitie::afisare();
p1.afisare();
Cerc c1(1,2,4);
Cerc c2(c1);
c2.marire(4);
c2.deplasare(3,1);
c2.afisare();
c2.afisare(1);
return 0;
}

2. Implementaþi programul prezentat în exemplul 1 ºi examinaþi erorile date la compilare.
Modificaþi programul astfel încât sã se poatã accesa din funcþia main, prin intermediul
obiectului obiect_derivat, ºi funcþiile aduna ºi scade.

#include <iostream>
using namespace std;
class Baza
{
int i, j;
public:
void aduna(int a, int b)
{
i = a+ b;
}
void scade(int a, int b)
{
j = a - b;
}
void afiseaza_baza()
{
cout << i << " " << j << "\n";
}
};
class Derivata : public Baza
{
int m;
public:
void inmulteste(int a,int b)
{
m = a * b;
}
void afiseaza_derivat()
{
cout << m << "\n";
}
};
int main(void)
{
Derivata obiect_derivat;
obiect_derivat.inmulteste(5, 6);
// nici o problema
obiect_derivat.afiseaza_derivat();
// afisarea rezultatului inmultirii
obiect_derivat.aduna(100, 200);
obiect_derivat.scade(50, 100);
// eroare (nu are acces la functia aduna)
return 0;
}

3. Folosind modelul claselor din exemplul 3, implementaþi douã clase, astfel:
- clasa de bazã contine metode pentru:
-codarea unui ºir de caractere (printr-un algoritm oarecare)
=> public;
-afiºarea ºirului autentic ºi a celui rezultat din transformare
= > public;
- clasa derivata contine o metoda pentru:
-scrirea rezultatului codãrii într-un fiºier, la sfârºitul acestuia.
Fiecare inregistrare are forma: nr_inregistrare: ºir_codat;
Accesul la funcþiile ambelor clase se face prin intermediul unui obiect rezultat prin
instanþierea clasei derivate. Programul care foloseºte clasele citeºte un ºir de caractere de la
tastaturã ºi apoi, în funcþie de opþiunea utilizatorului, afiºeazã rezultatul codãrii sau îl scrie în
fiºier.

#include <iostream>
using namespace std;
class Sir
{
protected:
char *sir;
public:
Sir(char *sir)
{
this->sir=new char[strlen(sir)+1];
strcpy(this->sir,sir);
}
void afiseaza()
{
cout<<sir;
}

};
class Codare : public Sir
{
char c;
public:

Codare(char *sir,char c):Sir(sir)
{
this->c=c;
}
void codeaza(char d=0)
{
for(int i=0;i<(int)strlen(sir);i++)
{
d?sir[i]+=d:sir[i]+=c;
}
}
void decodeaza(char d=0)
{
for(int i=0;i<(int)strlen(sir);i++)
{
d?sir[i]-=d:sir[i]-=c;
}
}
void decripteaza()//algoritm facut de plictiseala
{
char *sir_tmp=new char[strlen(sir)+1];
sir_tmp[strlen(sir)]='\0';
for(int i=-127;i<128;i++)
{
for(int j=0;j<(int)strlen(sir);j++)
{
sir_tmp[j]=sir[j]+i;
}
char minus;
int i_tmp;
if(i>=0)
{
minus=' ';
i_tmp=i;
}
else
{
minus='-';
i_tmp=i*-1;
}
cout<<"Sirul decodat cu "<<minus<<(char)i_tmp<<" este: \""<<sir_tmp<<"\""<<endl;
}
delete sir_tmp;
}
};
void main(void)
{
char *sir;
char sir_i[]="Salut";
sir=new char[strlen(sir_i)+1];
strcpy(sir,sir_i);
Codare ob1(sir,'x');
cout<<"Ob1 initial: \"";ob1.afiseaza();cout<<"\""<<endl;
ob1.codeaza();
//ob1.decripteaza();
cout<<"Ob1 codat: \"";ob1.afiseaza();cout<<"\""<<endl;
ob1.decodeaza();
cout<<"Ob1 Decodat: \"";ob1.afiseaza();cout<<"\""<<endl;
delete sir;
}

4. Sã se implementeze o clasã de bazã cu douã variabile de tip întreg care conþine o metoda ce
preia de la tastaturã douã numere întregi ºi o metoda care afiºeazã pe ecran un întreg trimis ca
parametru. Sã se scrie o a doua clasã derivatã din aceasta care implementeazã operaþiile
matematice elementare: +, -, *, / asupra variabilelor din clasã. Sã se scrie o a III-a clasã,
derivatã din cea de-a doua, care implementeazã în plus metode pentru extragerea rãdãcinii
pãtrate dintr-un numãr trimis ca parametru ºi de ridicare la tărie (atât baza cât ºi forța sunt
trimiºi ca parametri).

#include<iostream>
#include<math.h>
using namespace std;
class Baza
{
protected:
int x;
int y;
public:
void get()
{
cout<<"Introduceti un numar intreg x: ";cin>>x;
cout<<"Introduceti un numar intreg y: ";cin>>y;
}
void afis_int(int x)
{
cout<<"Intregul trimis ca parametru este: "<<x<<endl;
}
};
class Aritmetic : public Baza
{
public:
void op_plus()
{
cout<<"x+y="<<x+y;
}
void op_minus()
{
cout<<"x-y="<<x-y;
}
void op_ori()
{
cout<<"x*y="<<x*y;
}
void op_impartit()
{
cout<<"x/y="<<x/y;
}
};
class SQRT : public Aritmetic
{
void Radical(int x)
{
cout<<"Radical din "<<x<<"= "<<sqrt((double)x)<<endl;
}
void Putere(int x,int p)
{
cout<<"Radical din "<<x<<"= "<<pow((double)x,p);
}
};

5. Definiþi o clasã numita Triangle care are o metoda care calculeazã perimetrul unui triunghi ale
cãrui laturi sunt trimise ca parametri ºi apoi o clasã Triangle_extended, care, în plus,
calculeazã ºi aria triunghiului.

#include<iostream>
#include<math.h>
using namespace std;

class Triangle
{
public:
double Perimetru(int a,int b,int c)
{

return a+b+c;
}
};
class Triangle_extended : public Triangle
{

double Aria(int a,int b,int c)
{
double p=Perimetru(a,b,c)/2;
return sqrt(p*(p-a)*(p-b)*(p-c));
}
};

6. Adaugaþi în clasa derivatã din exemplul anterior o metodã care calculeazã înalþimea
triunghiului.

#include<iostream>
#include<math.h>
using namespace std;

class Triangle
{
public:
double Perimetru(int a,int b,int c)
{

return a+b+c;
}
};
class Triangle_extended : public Triangle
{
public:
double Aria(int a,int b,int c)
{
double p=Perimetru(a,b,c)/2;
return sqrt(p*(p-a)*(p-b)*(p-c));
}
double Inaltimea(int a,int b,int c,char l='a')
{
switch(l)
{
case 'a': return 2*Aria(a,b,c)/a;break;
case 'b': return 2*Aria(a,b,c)/b;break;
case 'c': return 2*Aria(a,b,c)/c;break;
default: return 2*Aria(a,b,c)/a;
}
}

};

7. Definiþi o clasã numitã Aria care calculeazã aria unei figuri geometrice (la alegere) ºi o altã
clasã Perimetru care calculeazã perimetrul aceluiaºi tip de figurã geometricã. Se defineºte
apoi o altã clasã care le moºteneºte pe primele douã clase create, ºi prin intermediul unei
metode proprii de preluare a variabilelor necesare, calculeazã aria ºi perimetrul figurii date.

#include<iostream>
#include<math.h>
using namespace std;

class Perimetru
{
protected:
double Calcul(int a,int b,int c)
{
return a+b+c;
}
};
class Aria
{
protected:
double Calcul(int a,int b,int c)
{
double p=(double)(a+b+c)/2;
return sqrt(p*(p-a)*(p-b)*(p-c));
}
};
class Triunghi : public Perimetru, public Aria
{
public:
double Get(int a,int b,int c)
{
cout<<"Perimetrul triunghiului solicitat este: "<<Perimetru::Calcul(a,b,c)<<endl;
cout<<"Aria triunghiului solicitat este: "<<Aria::Calcul(a,b,c)<<endl;
}
};

_________________
Detinator MiniZone
www.zappdivercity.blogspot.com