PROFDINFO.COM

Votre enseignant d'informatique en ligne

Laboratoire 7 - Notions avancées

Exercice 7.1 - Les fractions

Vous devez concevoir une classe CFraction qui implémente un nombre rationnel, sous forme numérateur/dénominateur. Par exemple, 3/4 est une fraction, 5/10 aussi.

Votre classe contiendra donc deux attributs entiers: un numérateur et un dénominateur. Attention! Le dénominateur ne peut jamais être 0 car une fraction comme 3/0 signifie une division par zéro, ce qui risque fort de faire imploser l'Univers. Pour simplifier, on dira aussi qu'un dénominateur ne peut pas être un nombre négatif (mais un numérateur pourra être n'importe quel nombre). Des accesseurs et des mutateurs appropriés devront être implémentés.

Une CFraction devra avoir un constructeur paramétrique qui permet de donner les deux nombres qui la composent, seulement le numérateur (1 sera alors utilisé comme dénominateur par défaut) ou rien du tout (0/1 sera alors la fraction par défaut obtenue).

Le gros du travail consistera ensuite à surcharger certains opérateurs pour la classe CFraction. Tel que nous l'avons vu en classe, certains opérateurs seront surchargés dans la classe, d'autres dans le main. Vous devrez surcharger les opérateurs suivants:

Les trois versions de l'opérateur + ainsi que l'opérateur << seront implémentés en dehors de la classe. Tous les autres opérateurs seront à l'intérieur de la classe.

Vous devrez obligatoirement tester votre classe avec le main suivant:

#include "Fraction.h"
#include <iostream>

using namespace std;

// operator<<
{
	// À vous de le coder
}

// operator+ version 1
{
	// À vous de le coder
}

// operator+ version 2
{
	// À vous de le coder
}

// operator+ version 3
{
	// À vous de le coder
}

int main()
{
	CFraction f1(3,4);
	CFraction f2(5,8);
	CFraction f3;
	CFraction f3b;
	CFraction f4(1,2);
	CFraction f5(5,10);

	f3 = f3b = f1;

	cout << f1 << endl; // Affiche 3/4
	cout << f2 << endl; // Affiche 5/8
	cout << f3 << endl; // Affiche 3/4

	f1 += f2;
	cout << f1 << endl; // Affiche 44/32 (ou 11/8)
	
	f2 += 2;
	cout << f2 << endl; // Affiche 21/8

	cout << f4 + f5 << endl; // Affiche 20/20 (ou 1/1)
	cout << f5 + 3 << endl; // Affiche 35/10 (ou 7/2)
	cout << 3 + f5 << endl; // Affiche 35/10 (ou 7/2)

	if (f4 == f5)
	{
		cout << "Fractions equivalentes" << endl; // Devrait être affiché
	}

	if (f4 != f2)
	{
		cout << "Fractions differentes" << endl; // Devrait être affiché
	}

	cout << f4++ << endl; // Affiche 1/2
	cout << f4 << endl; // Affiche 3/2
	cout << ++f4 << endl; // Affiche 5/2
	cout << f4 << endl; // Affiche 5/2
}

Bonus

Afin d'aller chercher des points bonus, vous pouvez ajouter la méthode privée void Reduire() à votre classe CFraction. Cette méthode réduira la fraction le plus possible afin de toujours obtenir des fractions irréductibles. Par exemple 10/20 peut être réduit à 1/2 et 44/100 à 11/25.

Une fraction est réductible si son numérateur et son dénominateur peuvent tous les deux être divisés sans reste par un même nombre entier plus grand que 1.

Pour réduire une fraction le plus possible, il faut trouver le plus grand commun diviseur du numérateur et du dénominateur, c'est-à-dire le plus grand nombre entier qui peut diviser les deux parties de la fraction sans reste en même temps. Une fois ce diviseur trouvé, on divise les deux parties de la fraction par ce même nombre.

Une fois la méthode Reduire() implémentée, assurez-vous de l'appeler à la fin de votre constructeur ainsi que dans les opérateurs += de façon à réduire automatiquement toute fraction modifiée (rappelez-vous que + et ++ appelleront +=, donc inutile de leur faire appeler Reduire() eux aussi).

Notez qu'une fois que vos fractions sont réduites, l'opérateur == pourrait être simplifié en comparant simplement les numérateurs entre eux et les dénominateurs entre eux - il ne sera plus nécessaire de caster et de diviser puisqu'une fraction comme 4/8 ne pourra plus exister et sera réduite à 1/2. Modifiez l'opérateur == si vous le désirez (mais ça fonctionnera bien si vous le laissez comme il est).

 

Exercice 7.2 - Attributs et méthodes statiques

CFraction LaPlusPetite(CFraction f1, CFraction f2, CFraction f3)
{
	CFraction plusPetite;

	//Le reste est à implémenter

	cout << "Dans fonction -- Nombre de fractions: " << CFraction::GetCompteur() << endl;
	  // Affiche 7 (f1, f2, f3 dans le main, plus f1, f2, f3 et plusPetite locales)
	return plusPetite;
}

int main()
{
	CFraction f1(3,4);
	CFraction f2(5,8);
	CFraction f3(6,15);
	
	CFraction pp = LaPlusPetite(f1, f2, f3);
	cout << "La plus petite fraction entre " << f1 << ", " << f2 << " et " << f3 << " est " << pp << endl;
	  // Affiche 6/15 (ou 2/5)

	cout << "Dans main -- Nombre de fractions: " << CFraction::GetCompteur() << endl;
	  // Affiche 4 (f1, f2, f3 et pp)
}

 

Exercice 7.3 - Les exceptions