lab 9

1. Pornind de la exemplul 4 indepliniti urmatoarele cerinte:
a. scrieti metode pentru citirea/scrierea unei matrici
b. testati toti operatorii supraincarcati

#include <iostream>
using namespace std;
const int Linii=2;
const int Coloane=3;
class Matrix
{
private:
const short rows;
const short cols;
int *elems;
public:
Matrix(const short rows, const short cols);
Matrix (const Matrix&);
~Matrix (void){delete elems;}
int& operator () (const short row, const short col);
Matrix& operator=(const Matrix&);
friend Matrix operator+(Matrix&, Matrix&);
friend Matrix operator-(Matrix&, Matrix&);
friend Matrix operator*(Matrix&, Matrix&);
void Read(const char c='M');
void Show(void);
const short Rows (void) {return rows;}
const short Cols (void) {return cols;}
};
Matrix::Matrix (const short r, const short c) : rows(r), cols(c)
{
if (rows > 0 && cols > 0)
elems = new int[rows * cols];
}
Matrix::Matrix (const Matrix &m) : rows(m.rows), cols(m.cols)
{
int n = rows * cols;
if (rows > 0 && cols > 0)
elems = new int[n];
for (int i = 0; i < n; i++)
elems[i] = m.elems[i];
}
int& Matrix::operator () (const short row, const short col)
{
if (row >= 0 && row < rows)
if (col >= 0 && col < cols)
return elems[row*cols + col];
}
Matrix& Matrix::operator = (const Matrix &m)
{
if (rows == m.rows && cols == m.cols)
{
int n = rows * cols;
for (int i = 0; i < n; i++)
elems[i] = m.elems[i];
}
return *this;
}
Matrix operator + (Matrix &p, Matrix &q)
{
if (p.rows == q.rows && p.cols == q.cols)
{
Matrix m(p.rows, p.cols);
for (int r = 0; r < p.rows; ++r)
for (int c = 0; c < p.cols; ++c)
m(r,c) = p(r,c) + q(r,c);
return m;
}
}
Matrix operator - (Matrix &p, Matrix &q)
{
if (p.rows == q.rows && p.cols == q.cols)
{
Matrix m(p.rows, p.cols);
for (int r = 0; r < p.rows; ++r)
for (int c = 0; c < p.cols; ++c)
m(r,c) = p(r,c) - q(r,c);
return m;
}
}
Matrix operator * (Matrix &p, Matrix &q)
{
if (p.cols == q.rows)
{
Matrix m(p.rows, q.cols);
for (int r = 0; r < p.rows; ++r)
for (int c = 0; c < q.cols; ++c)
{
m(r,c) = 0.0;
for (int i = 0; i < p.cols; ++i)
m(r,c) += p(r,i) * q(i,c);
}
return m;
}
}
void Matrix::Read(const char c)
{
int buf;
for(int i=0;i<rows;i++)
{
for(int j=0;j<cols;j++)
{
cout<<c<<"["<<i<<","<<j<<"]=";
cin>>buf;
elems[i*cols + j]=buf;
}
}
cout<<endl;
}
void Matrix::Show(void)
{
for(int i=0;i<rows;i++)
{
cout<<endl;
for(int j=0;j<cols;j++)
cout<<elems[i*cols + j]<<"\t";
}
cout<<endl;
}
void main (void)
{
int i, j;
Matrix m(Linii,Coloane);
m.Read('A');
Matrix a=m+m;
Matrix b(Coloane,Linii);
b.Read('B');
cout<<"Matricea A:"<<endl;
a.Show();
cout<<"Matricea B:"<<endl;
b.Show();
Matrix c(Coloane,Coloane);
c=a*b;
cout<<endl<<"Matricea C:"<<endl;
c.Show();
}//end main

2. Sã se supraîncarce operatorul [] astfel încât, folosit fiind asupra unor obiecte din clasa Departament, ce contine
un tablou de obiecte de tip Angajat (clasa Angajat contine variabilele nume (ºir de caractere) ºi salariu (float)),
sã returneze toatã informaþia legatã de angajatul al cãrui numãr de ordine este trimis ca parametru.

#include<iostream>
#include<string.h>
using namespace std;
class Angajat
{
char nume[256];
float salariu;
public:
Angajat() {}
Angajat(char *n,float s) { strcpy(nume,n);salariu=s; }
Angajat& operator=(const Angajat&);
char *get_nume(void) { return nume; }
float get_salariu(void) { return salariu; }
};
class Departament
{
Angajat a[5];
public:
Departament(Angajat a0,Angajat a1,Angajat a2,Angajat a3,Angajat a4);
void operator[] (const int i);
};
Angajat& Angajat::operator = (const Angajat &a)
{
strcpy(nume,a.nume);
salariu=a.salariu;
return *this;
}
Departament::Departament(Angajat a0,Angajat a1,Angajat a2,Angajat a3,Angajat a4)
{
a[0]=a0;
a[1]=a1;
a[2]=a2;
a[3]=a3;
a[4]=a4;
}
void Departament::operator[] (const int i)
{
cout<<"Angajatul cu indexul "<<i<<", se numeste: "<<a[i].get_nume()<<" si are salariul de: "<<a[i].get_salariu()<<endl;
}
void main()
{
Angajat a0("Alexe Tudor",15);
Angajat a1("Alexe Mihai",10);
Angajat a2("Alexe Romeo",50);
Angajat a3("Alexe Corina",40);
Angajat a4("Alexe Puf",5);
Departament d(a0,a1,a2,a3,a4);
d[4];
}

3. Sã se supraîncarce operatorii new ºi delete într-una din clasele cu care s-a confecționat anterior, în vederea alocarii ºi
eliberarii de memorie pentru un obiect din clasa respectivã.

#include<iostream>
#include<string.h>
using namespace std;
class Angajat
{
char nume[256];
float salariu;
public:
Angajat() {}
Angajat(char *n,float s) { strcpy(nume,n);salariu=s; }
Angajat& operator=(const Angajat&);
char *get_nume(void) { return nume; }
float get_salariu(void) { return salariu; }
};
class Departament
{
Angajat a[5];
public:
Departament(Angajat a0,Angajat a1,Angajat a2,Angajat a3,Angajat a4);
Departament() {}
void set(Angajat a0,Angajat a1,Angajat a2,Angajat a3,Angajat a4);
void operator[] (const int i);
void *operator new(size_t dim);
void operator delete(void *p);
};
Angajat& Angajat::operator = (const Angajat &a)
{
strcpy(nume,a.nume);
salariu=a.salariu;
return *this;
}
Departament::Departament(Angajat a0,Angajat a1,Angajat a2,Angajat a3,Angajat a4)
{
a[0]=a0;
a[1]=a1;
a[2]=a2;
a[3]=a3;
a[4]=a4;
}
void Departament::set(Angajat a0,Angajat a1,Angajat a2,Angajat a3,Angajat a4)
{
a[0]=a0;
a[1]=a1;
a[2]=a2;
a[3]=a3;
a[4]=a4;
}
void Departament::operator[] (const int i)
{
cout<<"Angajatul cu indexul "<<i<<", se numeste: "<<a[i].get_nume()<<" si are salariul de: "<<a[i].get_salariu()<<endl;
}
void* Departament::operator new(size_t dim)
{
return new Departament;
}
void Departament::operator delete(void *p)
{delete p;}

void main()
{
Angajat a0("Alexe Tudor",15);
Angajat a1("Alexe Mihai",10);
Angajat a2("Alexe Romeo",50);
Angajat a3("Alexe Corina",40);
Angajat a4("Alexe Puf",5);
Departament d(a0,a1,a2,a3,a4);
Departament *e=new Departament;
d[4];
e->set(a0,a1,a2,a3,a4);
e[2];
}

4. Sã se scrie programul care implementeazã metoda int myFunction(…), care în funcþie de numãrul de parametri
primiþi, returneazã fie valoarea primitã, fie bunul variabilelor de intrare.

#include<iostream>
#include<stdarg.h>
using namespace std;
class Produs
{
public:
int myFunction(int max, ...)
{
int r=1;
va_list vl;
va_start(vl,max);
for(int i=0;i<max;i++)
r*=va_arg(vl,int);
va_end(vl);
return r;
}
};
int main(void)
{
Produs prod;
cout<<"Produsul este: "<<prod.myFunction(10,4,5,6,7,8,9,10,11,12,13)<<endl;
return 0;
}

5. Sã se scrie programul care utilizeazã o clasã numitã Calculator ºi care are în componenþa sa (definite ca
metode publice) funcþiile:
- int calcul(int x) care returneazã pãtratul valorii primite;
- int calcul(int x, int y) care returneazã produsul celor douã valori primite;
float calcul(int x, int y, int z) care returneazã rezultatul înlocuirii în formula f(x,y,z) = (x-y)(x+z)/2 a valorilor
primite;
Programul primeºte prin linia de comandã toþi parametrii necesari.

#include<iostream>
#include<math.h>
#include<stdlib.h>
using namespace std;
class Calculator
{
public:
int calcul(int x);
int calcul(int x,int y);
float calcul(int x,int y,int z);
};
int Calculator::calcul(int x)
{
return (int)pow((double)x,2);
}
int Calculator::calcul(int x, int y)
{
return x*y;
}
float Calculator::calcul(int x, int y, int z)
{
return (float)(x-y)*(x+z)/2;
}
int main(int argc, char* argv[])
{
float afis;
Calculator calc;
switch(argc)
{
case 2: afis=(float)calc.calcul(atoi(argv[1]));break;
case 3: afis=(float)calc.calcul(atoi(argv[1]),atoi(argv[2]));break;
case 4: afis=calc.calcul(atoi(argv[1]),atoi(argv[2]),atoi(argv[3]));break;
default: cout<<"Numar invalid de argumente primite de la linia de comanda";return 1;
}
cout<<"Rezultatul in functie de parametrii este: "<<afis<<endl;
return 0;
}

6. Sã se defineascã clasa Student conținând ca date membre private: numele (?ir de caractere), note (pointer de tip
întreg) ?i nr_note (int). Clasa mai con?ine un constructor cu parametri, un constructor de copiere, o func?ie de
supraîncãrcare a operatorului de atribuire, o metodã de setare a notelor, o metodã de afi?are a atributelor ?i un
destructor. Sã se instan?ieze obiecte întrebuințând constructorul cu parametri, un alt obiect folosind constructorul de
copiere, afi?ând de fiecare data atributele obiectului creat. Realiza?i o opera?ie de copiere a unui obiect în alt
obiect, ambele fiind create in prealabil. Afi?ati rezultatul copierii.

#include<iostream>
#include<string.h>
#include<memory.h>
#include<stdarg.h>
using namespace std;
class Student
{
char nume[256];
int *note;
int nr_note;
public:
Student(char *nume_a,int *note_a,int nr_note_a);
Student(char *nume_a,int nr_note_a);
Student(Student &stud);
Student& operator = (const Student &s);
void set_note(...);
void afis_student(void);
~Student(void);
};
Student::Student(char *nume_a, int *note_a, int nr_note_a)
{
strcpy_s(nume,nume_a);
note=new int[nr_note_a];
memcpy(note,note_a,nr_note_a*sizeof(int));
nr_note=nr_note_a;
}
Student::Student(char *nume_a, int nr_note_a)
{
strcpy_s(nume,nume_a);
note=new int[nr_note_a];
nr_note=nr_note_a;
}
Student::Student(Student &stud)
{
strcpy_s(nume,stud.nume);
note=new int[stud.nr_note];
memcpy(note,stud.note,stud.nr_note*sizeof(int));
nr_note=stud.nr_note;
}
Student& Student::operator =(const Student &s)
{
strcpy_s(nume,s.nume);
note=new int[s.nr_note];
memcpy(note,s.note,s.nr_note*sizeof(int));
nr_note=s.nr_note;
return *this;
}
void Student::set_note(...)
{
va_list vl;
va_start(vl,nr_note);
for(int i=0;i<nr_note;i++)
{
note[i]=va_arg(vl,int);
}
va_end(vl);
}
void Student::afis_student(void)
{
int media=0;
cout<<"Nume: "<<nume<<endl;
cout<<"Note("<<nr_note<<"):"<<endl;
for(int i=0;i<nr_note;i++)
{
cout<<"Nota "<<i<<": "<<note[i]<<endl;
media+=note[i];
}
cout<<"Media: "<<(float)media/nr_note<<endl;
}
Student::~Student(void)
{
nume[0]='\n';
delete note;
nr_note=0;
}
void main(void)
{
int note_ana[]={5,5,7,8,10};
Student ana("Ana-Maria",note_ana,5);
ana.afis_student();
Student tudor("Tudor-Stefan",5);
tudor.set_note(10,10,5,9,9);
tudor.afis_student();
Student clona_ana=ana;
clona_ana.afis_student();
clona_ana=tudor;
clona_ana.afis_student();
}

7. Sã se implementeze clasa Complex care supraîncarcã operatorii aritmetici cu scopul de a efectua adunãri,
scãderi, inmulþiri ºi împãrþiri de numere complexe.
Observaþie: numerele complexe vor fi definite ca având o parte realã ºi una imaginarã, ambii coeficienþi fiind
reprezentaþi prin numere în virgulã mobilã.

#include<stdio.h>
#include<math.h>
class Complex
{
float r;
float i;
public:
Complex();
Complex(float real);
Complex(float real,float imaginar);
Complex& operator=(const Complex&);
friend Complex operator+(Complex&, Complex&);
friend Complex operator-(Complex&, Complex&);
friend Complex operator*(Complex&, Complex&);
friend Complex operator/(Complex&, Complex&);
float get_modul(Complex);
float get_faza(Complex);
float get_re();
float get_im();
void print();
};
Complex::Complex() { r=0; i=0; }
Complex::Complex(float real) { r=real; i=0; }
Complex::Complex(float real,float imaginar) { r=real; i=imaginar; }
Complex& Complex::operator = (const Complex &c)
{
i=c.i;
r=c.r;
return *this;
}
Complex operator + (Complex &a, Complex &b)
{
Complex rez;
rez.i=a.i+b.i;
rez.r=a.r+b.r;
return rez;
}
Complex operator - (Complex &a, Complex &b)
{
Complex rez;
rez.i=a.i-b.i;
rez.r=a.r-b.r;
return rez;
}
Complex operator * (Complex &a, Complex &b)
{
Complex rez;
rez.i=a.r*b.i+a.i*b.r;
rez.r=a.r*b.r-a.i*b.i;
return rez;
}
Complex operator / (Complex &a, Complex &b)
{
Complex rez;
rez.i=(a.i*b.r-a.r*b.i)/pow(b.r,2)-pow(b.i,2);
rez.r=(a.r*b.r+a.i*b.i)/pow(b.r,2)-pow(b.i,2);
return rez;
}
float Complex::get_modul(Complex c) { return sqrt(pow(c.r,2)+pow(c.i,2)); }
float Complex::get_faza(Complex c) { return atan(c.i/c.r); }
float Complex::get_re() { return r; }
float Complex::get_im() { return i; }
void Complex::print() { printf("%.2f+%.2fi",r,i); }
int main(void)
{
Complex a(5,4),b(4,2),s,d,p,i;
s=a+b;
d=a-b;
p=a*b;
i=a/b;
printf("a=");a.print();printf("\n");
printf("b=");b.print();printf("\n");
printf("a+b=");s.print();printf("\n");
printf("a-b=");d.print();printf("\n");
printf("a*b=");p.print();printf("\n");
printf("a/b=");i.print();printf("\n");
}

_________________
Detinator MiniZone
www.zappdivercity.blogspot.com