T. O. Y. O. Together Open Youth Opportunities Education, Fraternity, Peace

C++: Supraincarcarea operatorilor speciali - aplicatii rezolvate

1) Sa se realizeze un program care creeaza o anumita clasa putere, ce calculeaza rezultatul dat de ridicarea unui numar la o putere (presupunem exponentul puterii un întreg pozitiv), folosind pointerul this (rezolvare...)

2) Folosindu-se o clasa cu membrii: un vector de 3 elemente, iniaializat printr-un constructor sa se implementeze operatorul de indexare.
Se cere a se efectua o indexare sigura a unei marice, in caz contrar, se cere parasirea programului (rezolvare...)

3) Sa se realizeze un program care foloseste supraincarcarea operatorului "=" (rezolvare...)

4) Sa se dezvolte un tip abstract de date pentru prelucrarea unei matrice bidimensionate, si realizarea principalelor operatii pe aceasta, prin operatori supraincarcati (rezolvare...)

Rezolvari

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

class putere
{
	double b;
	int e;
	double val;
public:
	putere(double baza, int exp);
	double calculeaza() {return this->val ;}
};
putere::putere(double baza, int exp)
{
this->b=baza;
this->e=exp;
this->val=1;
if(exp==0) return;
for(;exp>0;exp--)
this->val=this->val*this->b;
}
void main()
{
	putere x(4,3);
	putere y(2.5,1);
	putere z(5.7,0);
	cout<<x.calculeaza()<<endl;
	cout<<y.calculeaza()<<endl;
	cout<<z.calculeaza()<<endl;
	getch();
  
  int k;
  cin>>k;
}

2) Folosindu-se o clasa cu membrii: un vector de 3 elemente, iniaializat printr-un constructor sa se implementeze operatorul de indexare. Se cere a se efectua o indexare sigura a unei marice, in caz contrar, se cere parasirea programului.

#include <iostream>
using namespace std;
#include<conio.h>
#include<stdlib.h>

class index{
	int a[3];
public:
	index(int i,int j,int k)
	{
		a[0]=i;
		a[1]=j;
		a[2]=k;
	}
	int& operator[](int i);
};
int& index::operator[](int i)
{
	if(i<0 || i>2)
	{
		cout<<endl<<"Eroare la limita."<<'\n';
		exit(1);
	}
	return a[i];
}
void main()
{
	index ob(1,2,3);
	for(int i=0;i<3;i++)
		cout<<ob[i]<<endl;
ob[2]=25; //aceasta atribuire este posibila doar datorita valorii returnate ca referinta
         
	cout<<ob[2];
	getch();
	ob[3]=30;
 
  int k;
  cin>>k;
}

3) Sa se realizeze un program care foloseste supraincarcarea operatorului "=".

#include <iostream>
using namespace std;
#include<conio.h>
#include<string.h>

class sir
{
	char* a;
public:
	//constructor
	sir (char b[]);
 
	//constructor de copiere
	sir (sir &x);
 
	void operator=(sir &x);
	void afis(char *);
};
inline sir::sir(char b[])
{
	a=new char[strlen(b)+1];
	strcpy(a,b);
}
inline sir::sir(sir &x)
{
	a=new char[strlen(x.a)+1];
	strcpy(a,x.a);
}
void sir::operator=(sir& x)
{
	delete a;
	a=new char[strlen(x.a)+1];
	strcpy(a,x.a);
}
void sir::afis(char *z)
{
	cout<<"Sirul "<<z<<" este: "<<a<<endl;
}
void main()
{
	sir a("un sir ");
	cout<<"Dati un sir dorit: ";
	char s[256];
	cin.getline(s,sizeof(s),'\n');
	sir b(s);
	sir c=a;
	a.afis("a");
	b.afis("b");
	c.afis("c");
	a=b;
	a.afis("a");
	b.afis("b");
	getch();
 
  int k;
  cin>>k;
}

4) Sa se dezvolte un tip abstract de date pentru prelucrarea unei matrice bidimensionate, si realizarea principalelor operatii pe aceasta, prin operatori supraincarcati.

#include <iostream>
using namespace std;
#include<conio.h>
#include<string.h>

class matrice
{
	int m,n; // m - numarul de linii, n - numarul de coloane
	int* mat; // matricea, pentru se va aloca memorie in zona de memorare HEAP
public:
	matrice(int=1,int=1); // constructor de initializare cu parametri
	int* operator()(int,int); /* supraincarcarea operatorului special 'apel de functie' pentru 
	determinarea unui element al matricei dintr-o anumita pozitie, pozitie data ca parametru*/
	friend istream& operator>>(istream&,matrice&); /* supraincarcarea operatorului 'extragere 
							din flux' pentru citirea elementelor unei matrice*/
	friend ostream& operator<<(ostream&,matrice); /*  supraincarcarea operatorului 'insertie in 
												flux' pentru afisarea elementelor unei matrice*/
	friend matrice operator+(matrice&,matrice&); /* supraincarcarea operatorului '+' pentru adunarea 
												a doua matrice*/
	friend matrice operator-(matrice&); /* supraincarcarea operatorului '-' pentru determinarea opusei 
											unei matrice*/
	friend matrice operator-(matrice&,matrice&); /* supraincarcarea operatorului '-' pentru diferenta 
												a doua matrice*/
	friend matrice operator~(matrice&); // transpusa unei matrice
};
// constructor de initializare cu parametri
inline matrice::matrice(int i,int j)
{
	m=i;
	n=j;
	mat=new int[m*n]; /*alocam memorie suficienta in zona HEAP 
			pentru pastrarea unui tablou m*n elemente intregi*/
}
/*supraincarcarea operatorului special 'apel de functie' pentru determinarea 
unui element al matricei dintr-o anumita pozitie, pozitie data ca parametru*/
int* matrice::operator()(int i,int j)
{
	return mat+i*n+j; // elementul de pe pozitia de linie i si coloana j a unei matrice
}
// supraincarcarea operatorului 'extragere din flux' pentru citirea elementelor unei matrice
istream& operator>>(istream& x,matrice& a)
{
	for(int i=0;i<a.m;i++)
	for(int j=0;j<a.n;j++)
	{
		cout<<"\telem["<<i+1<<"]["<<j+1<<"]= ";
		x>>*a(i,j); // apel al operatorului '()' supraincarcat
	}
return x;
}
// supraincarcarea operatorului 'insertie in flux' pentru afisarea elementelor unei matrice
ostream& operator<<(ostream& x,matrice a)
{
	for(int i=0;i<a.m;i++)
	{
		for(int j=0;j<a.n;j++)
		x<<'\t'<<*a(i,j);
		x<<endl;
	}
return x;
}
// supraincarcarea operatorului '+' pentru adunarea a doua matrice
matrice operator+(matrice& a,matrice& b)
{
	matrice c;
	c.m=a.m; //sau, c.m=b.m;
	c.n=a.n; //sau, c.n=b.n;
	for(int i=0;i<c.m;i++)
		for(int j=0;j<c.n;j++)
			*c(i,j)=*a(i,j)+*b(i,j);
	return c;
}
// supraincarcarea operatorului '-' pentru determinarea opusei unei matrice
matrice operator-(matrice& a)
{
	matrice c;
	c.m=a.m;
	c.n=a.n;
	for(int i=0;i<c.m;i++)
		for(int j=0;j<c.n;j++)
			*c(i,j)=-*a(i,j);
	return c;
}
// supraincarcarea operatorului '-' pentru diferenta a doua matrice
matrice operator-(matrice& a,matrice& b)
{
	return a+(-b);
}
// supraincarcarea operatorului '~' pentru transpusa unei matrice
matrice operator~(matrice& a)
{
	matrice c;
	c.m=a.m;
	c.n=a.n;
	for(int i=0;i<c.m;i++)
		for(int j=0;j<c.n;j++)
			*c(j,i)=*a(i,j);
	return c;
}
void main()
{
	int m,n; // m - nr de linii, n - nr de coloane
	cout<<"Dati dimensiunea matricelor:\n";
	cout<<"\tnumarul de linii: ";
	cin>>m;
	cout<<"\tnumarul de coloane: ";
	cin>>n;
matrice a(m,n),b(m,n); // apel al constructorului de initializare cu parametri
                          
	cout<<"Citim matricea A:\n";
	cin>>a; // apel al functiei ce supraincarca operatorul '>>'
	cout<<"Citim matricea B:\n";
	cin>>b;
	cout<<"Afisam matricea A:\n";
	cout<<a; // apel al functiei ce supraincarca operatorul '<<'
	cout<<"Afisam matricea B:\n";
	cout<<b;
	cout<<endl<<"Dati o tasta ptr. a continua..."<<endl;
	getch();
 
	cout<<"Afisam A+B:\n";
	cout<<a+b; // apel al functiilor ce supraincarca operatorii '+' si '<<'
	matrice c(m,n);
	c=(-a)-(~b); // apel al functiilor ce supraincarca operatorii '- unar', '- binar' si '~'
                      
	cout<<"Afisam expresia -A - ~B:\n";
	cout<<c;
 
  int k;
  cin>>k;
}