Arithmetische Operationen auf Brüche mit Konstruktoren in C++
- Arithmetische Operationen an Brüchen mit Constructor in C++
- Deklarieren Sie einen Konstruktor und initialisieren Sie seine Datenmember in C++
- Implementieren Sie die Membermethoden zum Ausführen von Operationen in C++
In diesem Artikel wird erläutert, wie Sie Brüche mithilfe von Konstruktoren erstellen, ggT finden, um Vielfache von Brüchen zu reduzieren, und Berechnungen damit durchführen.
Arithmetische Operationen an Brüchen mit Constructor in C++
Der Leser muss die Voraussetzungen des Programms verstehen. Um einen Bruch mit dem Konstruktor zu erstellen,
- der Nenner darf nicht Null sein;
- sind Zähler und Nenner beide miteinander teilbar, so muss auf ihr kleinstes Vielfaches gekürzt werden;
- Das Programm muss so gestaltet sein, dass das Ergebnis gespeichert und über ein neues Datenelement angezeigt wird, während sich bereits vorhandene Variablen nicht ändern dürfen.
Diese Bedingungen machen das Programm durchführbar und in der Lage, Brüche korrekt zu berechnen.
Deklarieren Sie einen Konstruktor und initialisieren Sie seine Datenmember in C++
Der Konstruktor interagiert mit verschiedenen Membermethoden und übergibt einander Werte. Der erste Schritt für jedes Konstruktorprogramm besteht darin, die Importpakete zu laden und Standardkonstruktoren und parametrisierte Konstruktoren zu deklarieren.
-
Paket importieren.
#include <iostream> -
Die Member-Methode
reduce()wird verwendet, um den Bruch auf sein kleinstes Vielfaches zu reduzieren.int reduce(int m, int n); -
Für das Paket
iostreamwird dernamespace stdverwendet.using namespace std; -
Der Klassenname muss den gleichen Namen wie die Mitgliedsmethoden haben.
class computefraction -
Der Standardkonstruktor
private: hat zwei Datenelemente für den Zähler und den Nenner des Bruchs.{ private: int topline; int bottomline; -
Danach wird der parametrisierte Konstruktor
public:deklariert. Datenelemente des Standardkonstruktors werden hier mit zwei neuen Variablen des gleichen Datentyps(int tl = 0, int bl = 1)initialisiert.
Die Konstruktorklasse hat Methoden mit fünf Elementen. Der erste. computefraction() hat denselben Namen wie der Klassenname und speichert die Werte von Brüchen vor und nach der Reduktion.
Die Kürzung von Brüchen muss erfolgen, bevor die Werte an andere Elementmethoden übergeben werden. Vier Elementmethoden werden für 4 Operatorberechnungen deklariert – Addition, Subtraktion, Multiplikation und Division.
Zwei weitere deklarierte Member-Methoden lesen die Brüche und geben sie aus.
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();
Unten ist die Darstellung des ersten Teils des Programms.
#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();
};
Implementieren Sie die Membermethoden zum Ausführen von Operationen in C++
In diesem Teil des Artikels werden Mitgliedsmethoden implementiert, die arithmetische Operationen mit Brüchen in C++ ausführen.
Überladen von Bruchklassenoperatoren in C++
In diesem Programm werden Operatoren in jeder Mitgliedsmethode überladen, um die Werte von zwei Brüchen in ein einzelnes Objekt einzupassen. Das Überladen erfolgt, wenn ein benutzerdefinierter Datentyp anstelle eines integrierten Datentyps verwendet wird und sein Rückgabetyp geändert werden muss.
Dies wird durch den Bereichsauflösungsoperator :: erreicht. Es greift auf die lokalen Variablen eines Konstruktors einer bestimmten Klasse zu.
Die Werte der Brüche werden im Konstruktor computefraction gespeichert. Das Programm übergibt diese Werte an die anderen Member-Methoden, um arithmetische Operationen mit ihnen auszuführen, aber zuerst muss der Bruch reduziert werden, bevor er an andere Member-Methoden übergeben werden kann.
Die Syntax computefraction::computefraction(int tl, int bl) wird verwendet, um auf die lokalen Variablen des Konstruktors computefraction zuzugreifen.
computefraction::computefraction(int tl, int bl) : topline(tl), bottomline(bl)
In ähnlicher Weise wird in der Mitgliedsmethode zum Addieren von zwei Brüchen der Operator sum überladen, um die Werte von zwei Brüchen anzupassen.
Syntax:
return_method class_name::operator(argument)
Diese Syntax greift auf den Operator sum aus der Klasse computefraction zu, überlädt ihn mit dem Kopierobjekt b2 und gibt das Endergebnis an den Konstruktor computefraction zurück.
computefraction computefraction::sum(computefraction b2) const
Member-Methode zum Finden von GCD des Bruchs in C++
Die Funktion gcd findet den ggT, um Vielfache von Brüchen zu kürzen. Zähler und Nenner sind die beiden Datenelemente int m und int n.
Die Funktion prüft zunächst, ob der Wert negativ oder positiv ist. Wenn entweder Zähler oder Nenner einen negativen Wert haben, werden sie positiv, indem m = (m < 0) ? -m : m;.
Die Funktion vergleicht den höheren Wert zwischen den Variablen m und n, um GCD zum Reduzieren von Vielfachen von Brüchen zu finden. Wenn der größere Wert in der Variablen n gespeichert ist, wird er mit m vertauscht.
Die Funktion ist so ausgelegt, dass immer der höhere Wert in der Variablen m gespeichert wird. Die Funktion subtrahiert den niedrigeren Wert vom höheren Wert, bis m auf Null reduziert ist.
Schließlich ist der in der Variablen n verbleibende Wert der GCD und wird zurückgegeben.
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;
}
Member-Methode zum Reduzieren von Zähler und Nenner eines Bruchs in C++
Brüche werden gekürzt, indem Zähler und Nenner durch ihren ggT dividiert werden.
Hier werden zwei Variablen initialisiert, topline für den Zähler und bottomline für den Nenner.
Eine if-else-Bedingung überprüft die bottomline-Variablenwerte. Wenn die Werte Null sind, wird das Programm mit einer Fehlermeldung beendet.
Eine Integer-Variable reduce wird initialisiert, um den ggT der beiden Zahlen zu speichern, die von der Methode gcd zurückgegeben werden.
Dann wird der in reduce gespeicherte Wert sowohl von topline als auch von bottomline dividiert, und das Ergebnis wird wieder in denselben Variablen gespeichert.
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;
}
Erstellen Sie eine Member-Methode zum Addieren von zwei Brüchen in C++
Alle Methoden, die für Rechenoperationen verwendet werden, erzeugen ein Kopierobjekt wie ein Kopierkonstruktor. Das macht die Syntax computefraction computefraction::sum(bounty b2) const.
Das Schlüsselwort bounty b2 erzeugt ein Kopierobjekt b2. Das Erstellen eines Kopierobjekts dient dazu, Objekte für den zweiten Bruchteil wiederzuverwenden, ohne zusätzliche Variablen zu initialisieren.
Die Gleichung zum Addieren zweier Brüche a/b und c/d lautet:
Die Variable int tl speichert das Ergebnis des Zählers, während int bl das Ergebnis des Nenners speichert. Abschließend werden tl und bl übergeben.
computefraction computefraction::sum(bounty b2) const {
int tl = topline * b2.bottomline + b2.topline * bottomline;
int bl = bottomline * b2.bottomline;
return computefraction(tl, bl);
}
Die anderen Elementmethoden werden auf die gleiche Weise erstellt. Zur Überprüfung kann der Leser zum endgültigen Programm in diesem Artikel gehen.
So implementieren Sie die Hauptfunktion mit dem Konstruktor in C++
Sobald alle Member-Methoden erstellt sind, muss die Funktion main() geschrieben werden, damit das Programm die übergebenen Werte zurückgeben und anzeigen kann.
Dieses Programm muss so geschrieben werden, dass der Endbenutzer Auswahlmöglichkeiten und Antworten in dieser Reihenfolge erhält:
- Option zur Auswahl des Operators, d. h. Addition, Subtraktion usw.
- Auslösen einer Ausnahme, wenn die Auswahl nicht in Ordnung ist und das Programm neu lädt.
- Bei richtiger Auswahl wird der Benutzer aufgefordert, Zähler und Nenner des ersten Bruchs einzugeben, gefolgt vom zweiten Bruch.
- Löst eine Fehlerausnahme aus, wenn eine Null in den Nenner eingefügt und beendet wird.
- Wenn die Eingaben korrekt sind, gibt das Programm das Ergebnis als endgültige Antwort aus.
- Das Programm lädt zurück zu Schritt 1.
Initialisierung von lokalen Variablen und Konstruktorobjekten für die Hauptfunktion
Als menügesteuertes Programm wird eine char-Variable ch deklariert. Drei Objekte werden deklariert: up, um den ersten Bruch zu übergeben und zu speichern, down, um den zweiten Bruch zu speichern, und final, um das Ergebnis der beiden Brüche anzuzeigen.
int main() {
char ch;
computefraction up;
computefraction down;
computefraction final;
}
Implementieren Sie menügesteuerte Bedingungen mit einer Do While-Schleife
Das Programm verwendet 5 menügesteuerte Fälle und einen Standardfall in einer do-while-Schleife. Die ersten vier Fälle führen Rechenoperationen aus, während der fünfte für eine Exit-Option reserviert ist.
Der Standard wird für Auswahlen außerhalb des Gültigkeitsbereichs definiert. Das Programm läuft in einer Schleife, bis der Benutzer den fünften Fall auswählt, um daraus auszubrechen und das Programm zu beenden.
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');
Vollständiger Code zum Berechnen von Brüchen mit Constructor in 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;
}
Ausgabe:
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 . . .