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 suprancarce operatorul [] astfel nct, folosit fiind asupra unor obiecte din
clasa Departament, ce contine
un tablou de obiecte de tip Angajat (clasa Angajat contine variabilele nume (ir d
e caractere) i salariu (float)),
s returneze toat informaia legat de angajatul al crui numr de ordine este trimis ca pa
rametru.
#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()<<" s
i 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 suprancarce operatorii new i delete ntr-una din clasele cu care s-a lucrat a
nterior, 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()<<" s
i 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 funcie de n
umrul de parametri
primii, returneaz fie valoarea primit, fie produsul 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)<<en
dl;
return 0;
}
5. S se scrie programul care utilizeaz o clas numit Calculator i care are n componena s
a (definite ca
metode publice) funciile:
- int calcul(int x) care returneaz ptratul 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 primete prin linia de comand toi 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]));brea
k;
default: cout<<"Numar invalid de argumente primite de la linia de comand
a";return 1;
}
cout<<"Rezultatul in functie de parametrii este: "<<afis<<endl;
return 0;
}
6. S se defineasc clasa Student avnd ca date membre private: numele (?ir de caracte
re), note (pointer de tip
ntreg) ?i nr_note (int). Clasa mai con?ine un constructor cu parametri, un constr
uctor de copiere, o func?ie de
suprancrcare a operatorului de atribuire, o metod de setare a notelor, o metod de af
i?are a atributelor ?i un
destructor. S se instan?ieze obiecte folosind 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 suprancarc operatorii aritmetici cu scopul
de a efectua adunri,
scderi, inmuliri i mpriri de numere complexe.
Observaie: numerele complexe vor fi definite ca avnd o parte real i una imaginar, amb
ii coeficieni fiind
reprezentai 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");
}