Les opérateurs surchargés.

Exemple de surcharges d'opérateurs.

operator

Voir version :

Pas de dépendances

Télécharger :

#include <cstdlib>
#include <iostream>

using namespace std;

/* --------------------------- */

int pgcd (int m, int n)            // Algorithme d'Euclide (pour les matheux)
{
  if (n==0) return m;
  else return pgcd( n, m % n);
}

/* ---------------------------- */

class Fraction
{
private:
    int num;
    int denom;
public:
    Fraction();
    Fraction(int,int);
    void Simplifie();
    void Affiche();
    Fraction operator+(Fraction b);
};

Fraction::Fraction()
{
    num=denom=1;
}

Fraction::Fraction(int n,int d)
{
    num=n;
    denom=d;
}

void Fraction::Simplifie()
{
    int p=pgcd(num,denom);
    num/=p;
    denom/=p;
}

void Fraction::Affiche()
{
    cout << num << "/" << denom << endl;
}

Fraction Fraction::operator+(Fraction b)
{
    Fraction res;
    res.denom=denom*b.denom;
    res.num=num*b.denom+b.num*denom;
    res.Simplifie();
    return res;
}

/* ------------------------------ */

int main()
{
    int n,d;
    cout << "entrez numerateur, puis denominateur pour fraction 1" << endl;
    cin >> n;
    cin >> d;
    Fraction f1(n,d);
    cout << "entrez numerateur, puis denominateur pour fraction 2" << endl;
    cin >> n;
    cin >> d;
    Fraction f2(n,d);
    Fraction f3=f1+f2;
    f3.Simplifie();
    cout << "Votre fraction simplifiee" << endl;
    f3.Affiche();
    system("PAUSE");
    return 0;
}



Commentaires


  La ligne importante dans ce tutorial est la suivante :

  Fraction f3=f1+f2;

  J'additionne 2 fractions comme si j'additionnais des int !

  Bon, avant de voir comment cela fonctionne, une petite note :
  On peut constater qu'on réutilise n et d. ça ne pose aucun probleme : quand vous créez f1,
  les valeurs de n et d sont copiées dans f1.num et f1.denom (voir constructeur)
  donc pas de soucis si on veut réutiliser n et d.

  Comment la machine sait commet additionner 2 fractions ? Parce que ce n'est pas évident !

  je rappelle la formule :

  a   c   a*d + c*b 
  - + - = ---------   ça s'apprend au college !! puis apres, on simplifie.
  b   d      b*d

  regardez dans la classe la ligne :

  Fraction operator+(Fraction b);

  en toute logique, c'est une fonction qui s'appelle "operator+" qui prend une Fraction b
  et renvoie une Fraction !
  Alors on est bien embeté, car ça ne prend qu'UNE fraction b (alors qu'une addition en prend a+b = resultat)
  Ici, il nous manque le "a"

  Detrompez vous ! "operator+" est une fonction membre de Fraction. Elle est donc appelée pour une fraction déja existante.
  C'est à dire, tout comme Simplifie() simplifie la fraction courante, "operator+(b)" additionne b avec la fraction courante.

  Regardez l'implémentation de "operator+", vous reconnaissez la formule de maths ci dessus...

  Note :

  vous pouvez constater qu'il y a un constructeur en + : un constructeur qui ne prend aucun parametre :
  Fraction();

  Essayez de l'enlever....
  Vous verrez une erreur sur les lignes :
  Fraction res;
  et Fraction f3=f1+f2

  en effet : pour la 1ere ligne, il essaie de créer res (mais comment le construit il si on ne lui met pas Fraction res(1,1) ?
  Et bien en appelant Fraction();

  Il est donc important de mettre un constructeur par défaut (sans argument) pour vos classes.
  Une fois tout cela en place, vous pouvez additionner vos fractions comme vous le sentez !! aussi simplement que des int...


	exercices :
	1) surchargez la soustraction
	2) surchargez la multiplication


  reponse :
  1)

Fraction Fraction::operator-(Fraction b)
{
	Fraction res;
	res.denom=denom*b.denom;
	res.num=num*b.denom-b.num*denom;
	res.Simplifie();
	return res;
}

2)

Fraction Fraction::operator*(Fraction b)
{
	Fraction res;
	res.denom=denom*b.denom;
	res.num=num*b.num;
	res.Simplifie();
	return res;
}


Laissez un commentaire / post a comment