Opérations arithmétiques sur les fractions à l'aide du constructeur en C++
- Opérations arithmétiques sur les fractions à l’aide du constructeur en C++
- Déclarer un constructeur et initialiser ses membres de données en C++
- Implémenter les méthodes membres pour effectuer des opérations en C++
Cet article explique comment créer des fractions à l’aide de constructeurs, trouver GCD pour réduire les multiples de fraction et effectuer des calculs sur ceux-ci.
Opérations arithmétiques sur les fractions à l’aide du constructeur en C++
Le lecteur doit comprendre les prérequis du programme. Pour créer une fraction à l’aide du constructeur,
- le dénominateur ne doit pas être nul ;
- si le numérateur et le dénominateur sont tous deux divisibles l’un par rapport à l’autre, alors il doit être réduit à son plus petit multiple ;
- le programme doit être conçu de manière à ce que le résultat soit stocké et affiché via un nouveau membre de données, tandis que les variables préexistantes ne doivent pas changer.
Ces conditions rendront le programme faisable et capable de calculer correctement des fractions.
Déclarer un constructeur et initialiser ses membres de données en C++
Le constructeur interagit avec différentes méthodes membres et se transmet des valeurs. La première étape de tout programme constructeur consiste à charger les packages d’importation et à déclarer les constructeurs par défaut et les constructeurs paramétrés.
-
Importer un paquet.
#include <iostream> -
La méthode membre
reduce()sera utilisée pour réduire la fraction à son plus petit multiple.int reduce(int m, int n); -
Le
namespace stdest utilisé pour le packageiostream.using namespace std; -
Le nom de la classe doit avoir le même nom que les méthodes membres.
class computefraction -
Le constructeur par défaut
private: possède deux données membres pour le numérateur et le dénominateur de la fraction.{ private: int topline; int bottomline; -
Le constructeur paramétré
public:est déclaré ensuite. Les données membres du constructeur par défaut sont ici initialisées avec deux nouvelles variables de même type de données(int tl = 0, int bl = 1).
La classe constructeur a des méthodes à cinq membres. Le premier. computefraction(), partage le même nom que le nom de la classe et stocke les valeurs des fractions avant et après la réduction.
La réduction des fractions doit avoir lieu avant que les valeurs ne soient transmises aux autres méthodes membres. Quatre méthodes membres sont déclarées pour les calculs à 4 opérateurs - addition, soustraction, multiplication et division.
Deux autres méthodes membres déclarées lisent les fractions et les impriment.
public:
computefraction(int tl = 0, int bl = 1);
computefraction sum(computefraction b2) const;
computefraction minus(computefraction b2) const;
computefraction mult(computefraction b2) const;
computefraction rem(computefraction b2) const;
void show() const;
void see();
Ci-dessous la représentation de la première partie du programme.
#include <iostream>
int reduce(int m, int n);
using namespace std;
class computefraction {
private:
int topline;
int bottomline;
public:
computefraction(int tl = 0, int bl = 1);
computefraction sum(computefraction b2) const;
computefraction minus(computefraction b2) const;
computefraction mult(computefraction b2) const;
computefraction rem(computefraction b2) const;
void show() const;
void see();
};
Implémenter les méthodes membres pour effectuer des opérations en C++
Les méthodes membres qui effectuent des opérations arithmétiques sur les fractions en C++ sont implémentées dans cette partie de l’article.
Surcharge d’opérateur de classe de fraction en C++
Dans ce programme, les opérateurs sont surchargés dans chaque méthode membre pour ajuster les valeurs de deux fractions dans un seul objet. La surcharge se produit lorsqu’un type de données défini par l’utilisateur est utilisé à la place d’un type de données intégré et que son type de retour doit être modifié.
Ceci est réalisé par l’opérateur de résolution de portée ::. Il accède aux variables locales d’un constructeur à partir d’une classe particulière.
Les valeurs des fractions sont stockées dans le constructeur computefraction. Le programme transmettra ces valeurs aux autres méthodes membres pour effectuer des opérations arithmétiques sur celles-ci, mais d’abord, la fraction doit être réduite avant de pouvoir être donnée aux autres méthodes membres.
La syntaxe computefraction::computefraction(int tl, int bl) est utilisée pour accéder aux variables locales du constructeur computefraction.
computefraction::computefraction(int tl, int bl) : topline(tl), bottomline(bl)
De même, dans la méthode membre pour additionner deux fractions, l’opérateur sum est surchargé pour s’adapter aux valeurs de deux fractions.
Syntaxe:
return_method class_name::operator(argument)
Cette syntaxe accède à l’opérateur sum de la classe computefraction, le surcharge avec l’objet de copie b2 et renvoie le résultat final dans le constructeur computefraction.
computefraction computefraction::sum(computefraction b2) const
Méthode membre pour trouver GCD de la fraction en C++
La fonction gcd trouve le PGCD pour réduire les multiples de fraction. Le numérateur et le dénominateur sont les deux membres de données int m et int n.
La fonction vérifie d’abord si la valeur est négative ou positive. Si le numérateur ou le dénominateur a une valeur négative, il devient positif en utilisant m = (m < 0) ? -m : m;.
La fonction compare la valeur la plus élevée parmi les variables m et n pour trouver le PGCD pour réduire les multiples de fraction. Si la plus grande valeur est stockée dans la variable n, elle permute avec m.
La fonction est conçue pour que la valeur la plus élevée soit toujours stockée dans la variable m. La fonction soustrait la valeur inférieure de la valeur supérieure jusqu’à ce que m soit réduit à zéro.
Enfin, la valeur laissée dans la variable n est le PGCD, et elle est renvoyée.
int gcd(int m, int n) {
m = (m < 0) ? -m : m;
n = (n < 0) ? -n : n;
while (m > 0) {
if (m < n) {
int bin = m;
m = n;
n = bin;
}
m -= n;
}
return n;
}
Méthode membre pour réduire le numérateur et le dénominateur d’une fraction en C++
Les fractions sont réduites en divisant le numérateur et le dénominateur par son PGCD.
Ici deux variables sont initialisées, topline pour le numérateur et bottomline pour le dénominateur.
Une condition if-else vérifie les valeurs de la variable bottomline. Si les valeurs sont zéro, le programme se termine avec un message d’erreur.
Une variable entière reduce est initialisée pour stocker le PGCD des deux nombres retournés par la méthode gcd.
Ensuite, la valeur stockée dans reduce est divisée à la fois entre topline et bottomline, et le résultat est stocké dans les mêmes variables.
computefraction::computefraction(int tl, int bl) : topline(tl), bottomline(bl) {
if (bl == 0) {
cout << "You cannot put 0 as a denominator" << endl;
exit(0); // program gets terminated
} else
bottomline = bl;
int reduce = gcd(topline, bottomline);
topline /= reduce;
bottomline /= reduce;
}
Créer une méthode membre pour ajouter deux fractions en C++
Toutes les méthodes utilisées pour les opérations de calcul créent un objet de copie comme un constructeur de copie. Cela se fait par la syntaxe computefraction computefraction::sum(bounty b2) const.
Le mot-clé bounty b2 crée un objet de copie b2. Faire une copie d’objet consiste à réutiliser des objets pour la deuxième fraction sans initialiser de variables supplémentaires.
L’équation pour ajouter deux fractions a/b et c/d est,
La variable int tl stocke le résultat du numérateur, tandis que int bl stocke le résultat du dénominateur. Enfin, tl et bl sont passés.
computefraction computefraction::sum(bounty b2) const {
int tl = topline * b2.bottomline + b2.topline * bottomline;
int bl = bottomline * b2.bottomline;
return computefraction(tl, bl);
}
Les autres méthodes membres sont créées de la même manière. Pour vérifier, le lecteur peut se reporter au programme final de cet article.
Comment implémenter la fonction principale à l’aide du constructeur en C++
Une fois toutes les méthodes membres créées, la fonction main() doit être écrite afin que le programme puisse renvoyer les valeurs passées et les afficher.
Ce programme doit être écrit de manière à ce que l’utilisateur final dispose de choix et de réponses dans cet ordre :
- Possibilité de choisir l’opérateur, c’est-à-dire addition, soustraction, etc.
- Lever une exception si le choix est hors service et que le programme se recharge.
- Lorsqu’on lui donne un choix correct, l’utilisateur est invité à entrer le numérateur et le dénominateur de la première fraction, suivis de la deuxième fraction.
- Lève une exception d’erreur si un zéro est inséré dans le dénominateur et quitte.
- Si les entrées sont correctes, le programme donne le résultat comme réponse finale.
- Le programme revient à l’étape 1.
Initialisation des variables locales et des objets constructeur pour la fonction principale
En tant que programme piloté par menu, une variable char ch est déclarée. Trois objets sont déclarés : up pour passer et stocker la première fraction, down pour contenir la seconde fraction, et final pour afficher le résultat des deux fractions.
int main() {
char ch;
computefraction up;
computefraction down;
computefraction final;
}
Implémenter des conditions pilotées par menu à l’aide d’une boucle Do While
Le programme utilise 5 cas pilotés par menu et un cas par défaut sous une boucle do-while. Les quatre premiers cas effectuent des opérations de calcul, tandis que le cinquième est réservé à une option de sortie.
La valeur par défaut sera définie pour les choix hors champ. Le programme s’exécute en boucle jusqu’à ce que l’utilisateur choisisse le cinquième cas pour en sortir et terminer le programme.
do {
switch (ch) {
case '1':
cout << "first fraction: ";
up.see();
cout << "Second fraction: ";
down.see();
final = up.sum(down);
final.show();
break;
... case '5':
break;
default : cerr << "Choice is out of scope" << ch << endl;
break;
}
} while (ch != '5');
Code complet pour calculer des fractions à l’aide du constructeur en C++
// import package
#include <iostream>
// member method to find gcd, with two data members
int gcd(int m, int n);
using namespace std;
class computefraction {
// Default constructor
private:
int topline;
int bottomline;
// Parameterized Constructor
public:
computefraction(int tl = 0, int bl = 1);
computefraction sum(computefraction b2) const;
computefraction minus(computefraction b2) const;
computefraction mult(computefraction b2) const;
computefraction rem(computefraction b2) const;
void show() const;
void see();
};
// Member methods of class type bounty.
// In constructors, the class and constructor names must be the same.
computefraction::computefraction(int tl, int bl) : topline(tl), bottomline(bl) {
if (bl == 0) {
cout << "You cannot put 0 as a denominator" << endl;
exit(0); // program gets terminated
} else
bottomline = bl;
// Below codes reduce the fractions using gcd
int reduce = gcd(topline, bottomline);
topline /= multiple;
bottomline /= multiple;
}
// Constructor to add fractions
computefraction computefraction::sum(computefraction b2) const {
int tl = topline * b2.bottomline + b2.topline * bottomline;
int bl = bottomline * b2.bottomline;
return computefraction(tl, bl);
}
// Constructor to subtract fractions
computefraction computefraction::minus(computefraction b2) const {
int tl = topline * b2.bottomline - b2.topline * bottomline;
int bl = bottomline * b2.bottomline;
return computefraction(tl, bl);
}
// Constructor to multiply fractions
computefraction computefraction::mult(computefraction b2) const {
int tl = topline * b2.topline;
int bl = bottomline * b2.bottomline;
return computefraction(tl, bl);
}
// Constructor to divide fractions
computefraction computefraction::rem(computefraction b2) const {
int tl = topline * b2.bottomline;
int bl = bottomline * b2.topline;
return computefraction(tl, bl);
}
// Method to print output
void computefraction::show() const {
cout << endl << topline << "/" << bottomline << endl;
}
// Method to read input
void computefraction::see() {
cout << "Type the Numerator ";
cin >> topline;
cout << "Type the denominator ";
cin >> bottomline;
}
// GCD is calculated in this method
int gcd(int m, int n) {
m = (m < 0) ? -m : m;
n = (n < 0) ? -n : n;
while (m > 0) {
if (m < n) {
int bin = m;
m = n;
n = bin;
}
m -= n;
}
return n;
}
// Main Function
int main() {
char ch;
computefraction up;
computefraction down;
computefraction final;
do {
cout << " Choice 1\t Sum\n";
cout << " Choice 2\t Minus\n";
cout << " Choice 3\t multiply\n";
cout << " Choice 4\t Divide\n";
cout << " Choice 5\t Close\n";
cout << " \nEnter your choice: ";
cin >> ch;
cin.ignore();
switch (ch) {
case '1':
cout << "first fraction: ";
up.see();
cout << "Second fraction: ";
down.see();
final = up.sum(down);
final.show();
break;
case '2':
cout << "first fraction: ";
up.see();
cout << "Second fraction: ";
down.see();
final = up.minus(down);
final.show();
break;
case '3':
cout << "first fraction: ";
up.see();
cout << "Second fraction: ";
down.see();
final = up.sum(down);
final.show();
break;
case '4':
cout << "first fraction: ";
up.see();
cout << "Second fraction: ";
down.see();
final = up.mult(down);
final.show();
break;
case '5':
break; // exits program.
default:
cerr << "Choice is out of scope" << ch << endl;
break;
}
} while (ch != '5'); // program stops reloading when choice 5 is selected
return 0;
}
Production:
Choice 1 Sum
Choice 2 Minus
Choice 3 multiply
Choice 4 Divide
Choice 5 Close
Enter your choice: 2
first fraction: Type the Numerator 15
Type the denominator 3
Second fraction: Type the Numerator 14
Type the denominator 7
3/1
Choice 1 Sum
Choice 2 Minus
Choice 3 multiply
Choice 4 Divide
Choice 5 Close
Enter your choice: 3
first fraction: Type the Numerator 5
Type the denominator 0
Second fraction: Type the Numerator 6
Type the denominator 8
You cannot put 0 as a denominator
--------------------------------
Process exited after 47.24 seconds with return value 0
Press any key to continue . . .