Bilet nr 1

1. Pentru clasa fractie, cu datele membre numarator si numitor, intregi, sa se supraincarce operatorii
a) - unar, care schimba semnul unui obiect din clasa fractie
b) -- unar, forma postfixata, pentru un obiect din clasa fractie

2. Pentru clasa complex, cu datele membre p_reala si p_imagin, reale, sa se supraincarce operatorul * binar care
realizeaza operatii de forma c1*c2, unde c1, c2 sunt de tip complex, prin metoda a clasei

3. Pentru clasa sir, sa se supraincarce operatorul de indexare

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

pct1 - clasa fractie

nu se specifica, dar ca totul sa fie ok, aveti nevoie de un constructor cu parametri impliciti si
suprascrierea operatorului << sau o functie de afisare. asa ar fi normal

class fractie{
int numarator, numitor;
public:
fractie(int n, int m);
friend ostream& operator<<(ostream& o, fractie&f);

fractie& operator-();
fractie operator--(int);
};

fractie::fractie(int n=1, int m=1){

numarator = n;
numitor = m;
}

ostream& operator<<(ostream& o, fractie&f){

o<<f.numarator<<"/"<<f.numitor;
return o;
}

//nu are parametri pentru ca este operand unar

fractie& fractie::operator-(){
numarator *= -1; //schimbare semn fractie
return *this; //intorc o referinta la obiectul curent
}

fractie fractie::operator--(int){
fractie p = *this;
numarator -= numitor;//(decrementam valoarea cu 1, deci la numarator)
return p;
}

1
pct2 - clasa complex
*/
class complex{
double p_reala,p_imagin;
public:
complex(double r, double i);
complex operator *(complex& x);
friend ostream& operator<<(ostream& o, complex&f);
};

complex::complex(double r=1,double i=1){

p_reala=r;
p_imagin=i;
}

complex complex::operator *(complex& x){

complex cmp;
cmp.p_reala = p_reala * x.p_reala;
cmp.p_imagin = p_imagin * x.p_imagin;
return cmp;
}

ostream& operator<<(ostream& o, complex&f){

o<<"("<<f.p_reala<<"+i"<<f.p_imagin<<")";
return o;
}

/*
pct 3
*/
class sir{
int lung; //lungime sir
char* sirul; //pointer la primul caracter din sir
public:
sir(const char*);//constructor, pentru test
~sir();//avem nevoie de destructor, pentru ca avem alocare dinamica in constructor
char operator[](int index);

};

sir::sir(const char* siroriginal){

int lungime=strlen(siroriginal);//lungimea sirului
lung = lungime+1;
sirul = new char[lung];
strcpy(sirul,siroriginal);
}

sir::~sir(){
2
 delete sirul;
}

char sir::operator[](int index){

if(index<lung && index >=0)return sirul[index];//verificare minima, verific daca este in limite
return '\0';
}

int main(){
//teste functionare pentru pct1
cout<<"--------------test pentru fractie-----------------\n";
fractie f1(10,10);
cout<<"original: "<<f1<<"\n";
cout<<"minus unar: "<<-f1<<"\n";//minus unar
fractie f2(11,10);
fractie f3 = f2--;
cout<<"inainte de decrementare: "<<f3<<"\n";//post decrementat, deci se intoarce valoarea 11/10
cout<<"dupa decrementare: "<<f2<<"\n";//acum este dupa decrement, deci 1/10

//teste functionare pentru pct2

cout<<"--------------test pentru complex-----------------\n";
complex c1(10,10),c2(10,11);
complex c3 = c1 * c2;
cout<<c1<<"*"<<c2<<"="<<c3<<"\n";

//test functionare pentru pc3

cout<<"--------------test pentru sir-----------------\n";
sir s("un sir meserias");
char c=s[1];
cout<<c<<"\n";//al doilea caracter, care este 'n'

getchar();
}