Überladen von Operatoren: Wie Hinzufügen und Daten von zwei Klassen „Integer“ Vergleich und „Fraction“

Question

Ich habe zwei Klassen Integer und Fraktion und eine abstrakte Klasse Nummer. Ich nehme an, addition Operation durchzuführen, indem ich + überbelaste, und ich muss auch Gleichheit der Werte überprüfen, indem ich == Bediener auf diesen Klassen überbelaste.

Operationen ausgeführt

1. In Integer + Integer = Integer

2. Add Fraktion + Fraktion = Fraktion

3. In Integer + Fraktion = Fraktion werden

Ich war in der Lage, 1. und 2. Betrieb zu tun, aber nicht in der Lage, zu tun von Integer und Bruch.

Unten ist der Code-Schnipsel:

1. Number.h

   #pragma once 
   #include <iostream> 
   template<class T> 
   
   class Number 
   { 
       virtual const T operator+ (const T &) = 0; 
       virtual void display(std::ostream &) const = 0; 
       virtual bool operator==(const T& rhs) const = 0; 
   
   }; 
   

2. Integer.h

   #pragma once 
   #include "Number.h" 
   #include "Fraction.h" 
   class Integer : public Number<Integer> 
   { 
       int intValue; 
   
   public: 
       void display(std::ostream &) const; 
       int getValue() const; 
       void setValue(int); 
       Integer() {} 
       Integer(int num); 
       const Integer operator+ (const Integer &); 
       virtual ~Integer() {} 
       bool operator==(const Integer&) const; 
   
   }; 
   

3. Integer.cpp

   #include "Integer.h" 
   #include "Number.h" 
   #include <iostream> 
   #include <string> 
   
   // parameterized constructor 
   Integer::Integer(int num) 
   { 
       intValue = num; 
   } 
   
   // return integer value 
   
   int Integer::getValue() const 
   { 
       return this->intValue; 
   } 
   
   void Integer::setValue(int x) 
   { 
       this->intValue = x; 
   } 
   
   // operator "+" overloading 
   const Integer Integer::operator+(const Integer &secondNumber) 
   { 
       Integer temp = this->intValue + secondNumber.intValue; 
       return temp; 
   } 
   
   // operator "=" overloading 
   void Integer::display(std::ostream& stream) const 
   { 
       stream << this->intValue; 
   } 
   
   // comparasion operator overload 
   bool Integer::operator==(const Integer& rhs) const 
   { 
       return this->intValue == rhs.intValue; 
   } 
   

4. Fraction.h

   #pragma once 
   #include "Number.h" 
   #include "Integer.h" 
   
   class Fraction : public Number<Fraction> 
   { 
       Integer _numerator; 
       Integer _denominator; 
       public: 
       void display(std::ostream &) const; 
       Fraction() = delete; 
       Fraction(const int &, const int &); 
       const Fraction operator+ (const Fraction &); 
       int gcdCalculate(int val1, int val2); 
       int lcmCalculate(const int val1, const int val2); 
       virtual ~Fraction() {} 
       bool operator==(const Fraction& rhs) const; 
   }; 
   

5. Fraction.cpp

   #include "Fraction.h" 
   #include <iostream> 
   
   // parameterised constructor 
   Fraction::Fraction(const int & num, const int & den) 
   { 
       _numerator.setValue(num); 
       _denominator.setValue(den); 
   } 
   
   // display the fraction value 
   void Fraction::display(std::ostream & stream) const 
   { 
        if (this->_denominator == 0) 
        std::cout << "Undefined: " << this->_numerator.getValue() << "/" << this->_denominator.getValue() << " (Divide By Zero Exception)"; 
   else 
        stream << this->_numerator.getValue() << "/" << this->_denominator.getValue(); 
   } 
   
   // "+" operator overloading 
   const Fraction Fraction::operator+(const Fraction &numberTwo) 
   { 
       int lcm = lcmCalculate(this->_denominator.getValue(), numberTwo._denominator.getValue()); 
       int multiplier1 = 0; 
       if (this->_denominator.getValue()) 
       multiplier1 = lcm/this->_denominator.getValue(); 
       int multiplier2 = 0; 
       if (numberTwo._denominator.getValue()) 
        multiplier2 = lcm/numberTwo._denominator.getValue(); 
       return Fraction((this->_numerator.getValue() * multiplier1) + (numberTwo._numerator.getValue() * multiplier2), lcm); 
   } 
   
   
   // LCM Calculation 
   
   int Fraction::lcmCalculate(const int val1, const int val2) 
   { 
       int temp = gcdCalculate(val1, val2); 
       return temp ? (val1/temp * val2) : 0; 
   } 
   
   // GCD Calculation 
   int Fraction::gcdCalculate(int val1, int val2) 
   { 
       for (;;) 
       {  
        if (val1 == 0) return val2; 
         val2 %= val1; 
        if (val2 == 0) return val1; 
         val1 %= val2; 
       } 
   } 
   
   // comparision operator overload 
   bool Fraction::operator==(const Fraction& rhs) const 
   { 
       Integer numCheck = this->_numerator; 
       Integer denCheck = this->_denominator; 
       if (rhs._numerator.getValue()) 
        numCheck.setValue(numCheck.getValue()/rhs._numerator.getValue()); 
       if (rhs._numerator.getValue()) 
        denCheck.setValue(denCheck.getValue()/rhs._denominator.getValue()); 
       if (numCheck == denCheck) { 
        return true; 
       } 
       return false; 
   } 
   

FRAGE:

1. Ich bin verwirrt, wie Integer + Fraktion Klasse hinzuzufügen.
2. Muss ich eine andere Klasse erstellen, die von der Number-Klasse erbt.
3. Überladen oprator+ vorhanden in Number Class.

Angenommen, ich versuche Integer + Fraction = Fraction in der Integer-Klasse hinzuzufügen, selbst dann werde ich so etwas wie Beispiel haben

class Integer : public Number<Integer> 
{ 
    const Fraction operator+(const Fraction &); 
} 
    const Fraction Integer::operator+(const Fraction &numberTwo) 
{ 
               ^^ I will get error here   
    // Addition opeartion 
} 

Bitte helfen Sie mir.

Answer 1

Für Ihre erste Frage besteht die Lösung darin, keine Memberfunktionsüberlastungen zu verwenden, sondern eine Nichtmitgliedsfunktionsüberlastung, z.

Fraction operator+(Integer const& integer, Fraction const& fraction) 
{ 
    // Logic to add the integer and fraction here 
    // Perhaps something like... 
    Fraction f(integer.getValue(), 1); // Create fraction 
    return f + fraction; 
} 

Der obige Code verwendet die Fraction::operator+ Funktion eine Ganzzahl hinzuzufügen.

Answer 2

Während Sie einen Integer + Fraction Operator zu Ihrem aktuellen Design hinzufügen können, wie Joachim vorgeschlagen hat, wird dies zu Codeverdopplungen oder zumindest zu unnötigen Standardfehlern führen.

Ich schlage stattdessen einen alternativen Entwurf vor: Machen Sie Integerconvertible zu Fraction. Schließlich kann jede ganze Zahl durch den Typ Fraction dargestellt werden, nicht wahr?

können Sie machen Integer auf zwei Arten Cabrio: ein conversion function-Integer Durch das Hinzufügen oder durch einen converting constructor-Fraction hinzufügen.

Ich empfehle die Converting-Konstruktor-Ansatz, weil Fraction bereits von Integer Typ abhängt und so würde der Cast-Operator in einer zirkulären Abhängigkeit, genau wie Ihr Mitglied Betreiber Versuch. Ich überlasse die Implementierung als Übung.

Dieser Entwurf erfordert, daß die Additionsoperator als Dritt Überlastung implementiert:

Fraction operator+(Fraction const& left, Fraction const& right) 

Mit der Umwandlung Konstruktor diese Funktion eine beliebige Kombination von (F + F) verarbeiten kann, (F + I) und (I + F).