Sunteți pe pagina 1din 9

Implementati clasa om cu attribute nume, prenume, sex, varsta, an, cu o

metoda de initializare a atributelor, o metoda pentru afisarea unei instante


si o metoda ce calculeaza varsta.
#include<iostream.h>
#include<string.h>
#include<conio.h>
class om
{private:
//campuri private ce nu vor
putea fi referite din programul principal ci doar
char nume[20],prenume[20],sex; //din cadrul unor metode publice(din
interiorul obiectului)
int varsta,an;
void display();
int calcul();
public:
//campuri publice
void init(char num0[20],char prn0[20],char sex0);
metoda publica ce va putea fi apelata
din pg principal si va realiza
comunicarea cu exteriorul*/

/*este o

};//inchid clasa
void om::init(char num0[20],char prn0[20],char sex0)
init
{strcpy(nume,num0);
strcpy(prenume,prn0);
sex=sex0;
varsta=calcul();
display();
}
int om::calcul()
{int ac=2014;
cout<<"anul nasterii lui "<<nume;
cin>>an;
return ac-an;}

//definitia metodei

//definitia metodei calcul

void om::display()
//definitia metodei display
{cout<<endl<<"***************DATE PERSONALE**************"<<endl<<endl;
cout<<"NUME:
"<<nume<<endl;
cout<<"PRENUME:
"<<prenume<<endl;
cout<<"SEXUL:
"<<sex<<endl;
cout<<"VARSTA:
"<<varsta<<" ani"<<endl;
cout<<endl<<"*******************************************"<<endl<<endl;
}

void main()
{om x;
clrscr();
char nm[20],pn[20],s;
cout<<"numele ";
//cin>>x.nume; ar genera eroarea om::nume is not accessible

cin>>nm;
cout<<"prenumele ";
cin>>pn;
cout<<"sexul ";
cin>>s;
x.init(nm,pn,s);
// x.display();
getch();

ar genera eroarea om::display() is not accessible

Urmatorul exemplu permite prin intermediul mecanismului de supraincarcare definirea unui


constructor cu doi parametri:
#include<math.h>
#include<iostream.h>
#include<conio.h>
class complex
{public:
float x,y,m; //datele clasei
void display();
float modul(); //metoda clasei
complex()
{cout<<endl<<"mesaj de la constructor"<<endl;}
complex(float yy);
complex(float xx, float yy);
};
complex::complex(float xx)
{x=xx;
y=0;
}
complex::complex(float xx, float yy)
{x=xx; y=yy;
}
float complex::modul()
{return sqrt(x*x+y*y);
}
void complex::display()
{cout<<endl<<x<<"+"<<y<<"*i";
cout<<endl;
}
complex q;
void main()
{cout<<"Obiectul global q=";
q.display();
complex q1;

cout<<"Obiectul local q1, retine valori reziduale";


q1.display();
complex q2(6.7);
cout<<"q2=";
q2.display();
complex q3(1.2,1.3);
cout<<"q3=";
q3.display();
getch();
clrscr();
}

Ca orice alta functie n limbajul C++, constructorii pot avea parametri impliciti , fiind numiti
constructori cu parametri impliciti. Varianta constructorului cu parametri impliciti poate fi
adoptata n toate cazurile n care constructorul nu necesita argumente. Daca toti parametrii
unui constructor sunt impliciti, apelul constructorului are forma unei simple declaratii .
Constructorii pot fi apelati si n mod explicit . n cazul n care dorim sa instantiem obiecte att
initializate, ct si neinitializate se poate folosi un constructor implicit vid, care se va apela la
instantierea obiectelor neinitializate .
Pentru clasa complex s-a definit un constructor cu parametri impliciti; din acest motiv s-a putut
face declaratia "complex q;"
// varianta constructor cu parametri impliciti
// permite declarare de instante de tip complex fara parametri, cu un
parametru sau doi
//foarte flexibil
#include<math.h>
#include<iostream.h>
#include<conio.h>
class complex
{public:
float x,y,m; //datele clasei
void display();
float modul(); //metoda clasei
complex(float xx=0, float yy=0)
{cout<<endl<<"mesaj de la constructorul cu parametri impliciti "<<endl;
x=xx;
y=yy;
}
};
float complex::modul()
{return sqrt(x*x+y*y);
}
void complex::display()
{cout<<endl<<x<<"+"<<y<<"*i";
cout<<endl;
}

complex q; //obiect neinitializat ; apelul nu se face in mod explicit


void main()
{cout<<"Obiectul global q=";
q.display();
complex q1; //obiect neinitializat ; apelul nu se face in mod explicit
cout<<"Obiectul local q1 ";
q1.display();
complex q2(6.7); // obiect initializatt.
cout<<"q2=";
q2.display();
complex q3(1.2,1.3); // obiect initializat.
cout<<"q3=";
q3.display();
complex q4=complex(); // constructorul este apelat n mod explicit.
q4.display();
getch();
clrscr();
}

La apelul explicit al constructorului: complex q4=complex() evaluarea expresiei complex()


conduce la:
- Crearea unui obiect temporar de tip complex (obiect cu o adresa precisa, dar inaccesibil);
- Apelul constructorului pentru acest obiect temporar;
- Copierea acestui obiect temporar n q4.

Definii i implementai clasa Cerc, avnd ca dat membr Raza, un constructor i ca funcii
membre Aria i Circumferinta.
#include<iostream.h>
#include<conio.h>
#define PI 3.14
class cer
c{
float raza;
public:
cerc();
float aria();
float circumferinta();
};
cerc::cerc()
{
cout<<"Raza cercului este = ";
cin>>raza;
}
float cerc::aria()
{
return (PI*raza*raza);
}
float cerc::circumferinta()

{
return (2*PI*raza);
}
int
main(void)
{
cerc c;
clrscr();
cout<<"Aria cercului este = "<<c.aria()<<endl;
cout<<"Circumferinta cercului este = "<<c.circumferinta()<<endl;
getch();
}

Sa se descrie o clasa complex ce permite memorarea partii reale si a celei imaginare ntr-un numar
complex i calculeaza modulul acestuia. Datele nu vor suferi nici o protectie n interiorul clasei astfel
nct se poate avea acces direct la acestea din afara. Sa se realizeze un program care folosete aceasta
clasa i citete date ntr-un numar complex afindu-l mpreuna cu modulul sau.
#include <iostream>
#include <fstream>
#include <math.h>
using namespace std;
class complex
{
public:
float a,b;
float modul()
{
return sqrt(pow(a,2)+pow(b,2));
}
};
void main()
{
complex z;
cout<<"Introduceti nr complex: \n";
cout<<"\tPartea reala: ";
cin>>z.a;
cout<<"\tPartea imaginara: ";
cin>>z.b;
cout<<"\nNumarul complex este: ("<<z.a<<","<<z.b<<")";
cout<<"\nModulul este: "<<z.modul()<<endl;
int g;
cin >>g;
}

Sa se realizeze o aplicatie cu un tip abstract de date (o clasa) ce permite memorarea datelor ntr-un
numar complex, caz n care partea reala i cea imaginara se considera a fi protejate spre vizibilitate n
afara clasei. Clasa va contine elementele de baza, adica, memorarea datelor ntr-un numar complex i
afiarea acestuia.

#include <iostream>
#include <fstream>
#include <math.h>
using namespace std;
class complex
{
private: //era implicit
float a,b; //a - partea reala, b - partea imaginara
public:
void citire(char* s) //functie ptr. introducerea datelor intr-un numar
complex
/*acesta functie va fi dezvoltata in interiorul clasei, catalogata fiind ca
si functie in-line*/
{
cout<<"Introduceti datele nr. complex "<<s<<endl; /*in loc de endl ar fi mers
si '\n' sau "\n"*/
cout<<"\tpartea reala: ";
cin>>a;
cout<<"\tpartea imaginara: ";
cin>>b;
}
void afisare(char*); //functie pentru afisarea datelor intr-un numar
complex
/*functia <afisare> va fi dezvoltata in exteriorul clasei, catalogata find ca
si functie off-line*/
};
void complex::afisare(char* s)
{
cout<<"Nr. complex "<<s<<" este: "<<a;
cout.setf(ios::showpos); //se adauga un semn '+' valorilor pozitive
cout<<b<<"*i"<<endl;
cout.unsetf(ios::showpos); //se anuleaza semnul '+' ptr. valorile
pozitive
}
void main()
{
//declaram un obiect la clasa anterior definita
complex z1;
/*apelam functia de citire pentru obiectul in caz (in situatia de fata el
devine obiect curent)*/
z1.citire("z1");
z1.afisare("z1");
cout<<endl;
/*in cazul de mai sus am facut o declaratie de obiect static.
Ce se intampla in situatia in care obiectul declarat este unul dinamic?*/
complex* z2;
z2=new complex; //am folosit operatorul de alocare de memorie din C++,
si anume <new>
z2->citire("z2");
z2->afisare("z2");
int g;
cin >>g;
}

Sa se realizeze o aplicatie cu un tip abstract de date (o clasa) ce permite memorarea datelor ntr-un
numar complex, caz n care partea reala i cea imaginara se considera a fi protejate spre vizibilitate n
afara clasei. Clasa va contine elementele de baza, adica, memorarea datelor ntr-un numar complex i
afiarea acestuia. Se vor realiza i operatiile de suma, respectiv, produs ntre doua numere complexe.

#include <iostream>
#include <fstream>
#include <math.h>
using namespace std;
class complex
{
private: //era implicit
float a,b; //a - partea reala, b - partea imaginara
public:
void citire(char* s) //functie ptr. introducerea datelor intr-un numar
complex
/*acesta functie va fi dezvoltata in interiorul clasei, catalogata fiind ca
si functie in-line*/
{
cout<<"Introduceti datele nr. complex "<<s<<endl; /*in loc de endl ar fi mers
si '\n' sau "\n"*/
cout<<"\tpartea reala: ";
cin>>a;
cout<<"\tpartea imaginara: ";
cin>>b;
}
void afisare(char*); //functie pentru afisarea datelor intr-un numar
complex
/*functia de mai sus va fi dezvoltata in exteriorul clasei, catalogata find
ca si functie off-line*/
//MAI MULTE VARIANTE DE CALCUL A SUMEI A DOUA NUMERE COMPLEXE
//1. suma in varianta rezultat transmis prin tipul rezultat
complex suma1(complex); /*functia returnea un nr. complex ca si
rezultat al
expresiei suma, iar ca participanti sunt expresii de tipul nr.
complex:
unul este obiectul curent ce va apela functia, iar,
cel de-al doilea este parametrul inclus in lista de parametri ai
functiei*/
//2. suma in varianta rezultat transmis prin linia de parametri - prin
tipul referinta
void suma2(complex, complex&); /*operatorul este binar, deci relatia
trebuie sa aiba doi operanzi:
primul operand participant la relatie este obiectul curent,
iar cel de-al doilea este primul parametru al functiei. Rezultatul
obtinut se transmite prin
cel de-al doilea parametru al functiei, si anume, expresia de tip
referinta*/

//3. suma in varianta rezultat transmis prin linia de parametri - prin


adresa
void suma3(complex, complex*);
//PRODUSUL A DOUA NUMERE COMPLEXE
complex produs(complex);
};
void complex::afisare(char* s)
{
cout<<"Nr. complex "<<s<<" este: "<<a;
cout.setf(ios::showpos); //se adauga un semn '+' valorilor pozitive
cout<<b<<"*i"<<endl;
cout.unsetf(ios::showpos); //anulam optiunea de afisare implicita cu
semn
}
complex complex::suma1(complex z)
{
complex r;
r.a=a+z.a;
r.b=b+z.b;
return r;
}
void complex::suma2(complex z, complex& r)
{
r.a=a+z.a;
r.b=b+z.b;
}
void complex::suma3(complex z, complex* r)
{
r->a=a+z.a;
r->b=b+z.b;
}
void main()
{
//declaram un obiect la clasa anterior definita
complex z1;
/*aplelam functia de citire pentru obiectul in caz (in situatia de
fata el devine obiect curent)*/
z1.citire("z1");
z1.afisare("z1");
cout<<endl;
/*in cazul de mai sus am facut o declaratie de obiect static.
Ce se intampla in situatia in care obiectul declarat este unul
dinamic?*/
complex* z2;
z2=new complex; //am folosit operat. de alocare de memorie din C++, si
anume <new>
z2->citire("z2");
z2->afisare("z2");
cout<<endl; //se trece pe linie noua, dupa caz, lasndu-se un rnd
liber

complex z3;
z3=z1.suma1(*z2); /*se va calcula suma intre nr. complexe z1 si z2,
suma ce se va inscrie in z3*/
z3.afisare("z1+z2");
complex z4;
z1.suma2(*z2,z4);
//z4=z1+z2
z4.afisare("z1+z2");
complex z5;
z1.suma3(*z2,&z5);
//z5=z1+z2
z5.afisare("z1+z2");
int g;
cin >>g;
}

S-ar putea să vă placă și