Surcharge des opérateurs spécials en C++ - Applications résolues


1) Realiser un programme pour creer une classe puissence, pour calculer le resultat donné par elever un nombre à une puissance (on suppose l’exponent du pouvoir un entier positif) en employant le pointeur this.
#include <iostream>
using namespace std;
#include<conio.h>

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

2) Employer une classe avec les membres: un vecteur de 3 elements, iniaialize par un constructeur et implementer l’operateur d’indexation. On doit efectuer une indexation sure d’une matrice, sinon, on demande quitter le programme.
#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<<"Erreur de limite."<<'\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; /*cette attribution est possible seulement
         a cause de la valeur retournee comme reference*/
	cout<<ob[2];
	getch();
	ob[3]=30;
 
  int k;
  cin>>k;
}

3) Realiser un programme qui utilise surcharge d’operateur "=".
#include <iostream>
using namespace std;
#include<conio.h>
#include<string.h>

class chaine
{
	char* a;
public:
	//constructeur
	chaine (char b[]);
 
	//constructeur de copier
	chaine (chaine &x);
 
	void operator=(chaine &x);
	void afis(char *);
};
inline chaine::chaine(char b[])
{
	a=new char[strlen(b)+1];
	strcpy(a,b);
}
inline chaine::chaine(chaine &x)
{
	a=new char[strlen(x.a)+1];
	strcpy(a,x.a);
}
void chaine::operator=(chaine& x)
{
	delete a;
	a=new char[strlen(x.a)+1];
	strcpy(a,x.a);
}
void chaine::afis(char *z)
{
	cout<<"chaineul "<<z<<" est: "<<a<<endl;
}
void main()
{
	chaine a("un chaine ");
	cout<<"Donnez la chaine: ";
	char s[256];
	cin.getline(s,sizeof(s),'\n');
	chaine b(s);
	chaine 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) Developper un type abstrait de dates pour travailler une matrice bidimensionee et la realisation des principales opperations sur elle, par les operateurs surchargés.
#include <iostream>
using namespace std;
#include<conio.h>
#include<string.h>

class matrice
{
	int m,n; // m – nombre de lignes, n – nombre de colonnes
	int* mat; // la matrice, aloquer memoire dans la zone HEAP
public:
	matrice(int=1,int=1); // constructeur d’initialization avec parametres
	int* operator()(int,int); /* surcharge d’operateur special 'appel de 
					fonction' pour determiner un element de matrice 
					d’une surcharge d’operateur 'extrction de fluxe' 
					pour lire les elements d’une matrice*/
	friend istream& operator>>(istream&,matrice&); /* La surcharge d'opérateur 
					'extraction de flux »pour lire 
					des éléments d'une matrice*/
	friend ostream& operator<<(ostream&,matrice); /* surcharge d’operateur 
					'insertion dans le fluxe' pour 
					afficher les elements d’une matrice*/
	friend matrice operator+(matrice&,matrice&); /* surcharge d’operateur '+' pour ajputer deux matrices*/
	friend matrice operator-(matrice&); /*surcharge d’operateur '-' pour 
					determiner l’oposante d/’une matrice*/
	friend matrice operator-(matrice&,matrice&); /*surcgarge d’operateur '-' pour 
							la diference de deux matrices*/
	friend matrice operator~(matrice&);	/*transpose d’une matrice*/
};
// constructeur d’initialisation avec parametres
inline matrice::matrice(int i,int j)
{
	m=i;
	n=j;
	mat=new int[m*n]; /*aloquer memoire sufisante dans la zone HEAP 
			pour garder un tableau m*n elements entiers*/
 
}
/*// surcharge d’operateur special 'appel de function' pour determiner 
un element d’une matrice d’une position comme parametre*/
int* matrice::operator()(int i,int j)
{
	return mat+i*n+j; /*l’element de la position de ligne i et la colonne j d’une matrice*/
}
/* surcharge d’operateur 'extraction de fluxe' pour lire les elements d’une 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); /*appel d’operateur '()' surchargé*/
	}
return x;
}
/*surcharge d’operateur 'insertion en fluxe' pour afficher les elements d’une 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;
}
/*  surcharge d’operateur '+' pour l’adition de deux matrices  */
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;
}
/* surcharge d’operateur '-' pour determiner l’oposante d’une 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;
}
/* surcharge d’operateur '-' pour la difference de deux matrices */
matrice operator-(matrice& a,matrice& b)
{
	return a+(-b);
}
/* surcharge d’operateur '~' pour la transpose d’une 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<<"Donnez la dimension des matrices:\n";
	cout<<"\tnombre des lignes: ";
	cin>>m;
	cout<<"\tnombre des colonnes: ";
	cin>>n;
matrice a(m,n),b(m,n); /* appel du constructeur d’initialisation
                          avec des parametres */
 
	cout<<"Lire la matrice A:\n";
	cin>>a; // appel de fonction surcharge d;operateur '>>'
	cout<<"Lire la matrice B:\n";
	cin>>b;
	cout<<"Afficher la matrice A:\n";
	cout<<a; // appel fonction surcharge d’operateur '<<'
	cout<<"Afficher la matrice B:\n";
	cout<<b;
	cout<<endl<<"Appuyez une taste pour continuer..."<<endl;
	getch();
 
 
	cout<<"Afficher A+B:\n";
	cout<<a+b; // appel des fonctions surcharge d’operateurs '+' si '<<'
	matrice c(m,n);
	c=(-a)-(~b); // appel des fonctions surcharge d’operateurs  '- unar', '- binar' si '~'
                     
	cout<<"Afisam expresia -A - ~B:\n";
	cout<<c;
 
  int k;
  cin>>k;
}
Cookies help us deliver our services. By using our services, you agree to our use of cookies.