演算子のオーバーロード：「整数」と私は二つのクラス<strong>整数</strong>と<strong>フラクション</strong>と1つの抽象クラス<strong>数</strong>を持っている

Question

「分数」を追加して、2クラスのデータを比較する方法。私は+をオーバーロードすることによって追加演算を実行すると仮定しており、これらのクラスに対して==演算子のオーバーロードを使用して値の等価性をチェックする必要があります。

1を実行する

操作は整数+整数=整数

2.追加画分+画分を追加=フラクション

3.整数+画分を追加=フラクション

私は1回目と2回目の操作を実行できましたが、追加できませんでした整数と分数の以下

コードスニペットである：

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; 
   } 
   

QUESTION：

1. 私は整数+分数クラスを追加する方法として混乱しています。
2. Numberクラスから継承する別のクラスを作成する必要がありますか。
3. oprator+のオーバーロード方法はNumber Classです。

私を助けてください、私は

例 よう

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

何かを持っているだろう、私はIntegerクラス自体にInteger + Fraction = Fractionを追加しようとします。

Answer 1

最初の質問では、メンバー関数のオーバーロードは使用せず、メンバではない関数オーバーロードを作成することです。

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; 
} 

上記のコードでは、整数を追加するためにFraction::operator+関数を使用しています。

Answer 2

ヨアヒムのように現在のデザインにInteger + Fraction演算子を追加できますが、これはコードの重複や不要な定型文の結果につながります。

代わりに代わりのデザインをお勧めします。Integerconvertible〜Fraction結局のところ、任意の整数はFractionタイプで表すことができます。

次の2つの方法でIntegerを転換することができます：Integerにconversion functionを追加することにより、またはFractionにconverting constructorを追加することによって。

FractionはすでにInteger型に依存しているため、変換演算子のアプローチを選択することをお勧めします。キャスト演算子は、メンバー演算子の試行と同様に循環依存になります。実装を練習問題として残しておきます。変換コンストラクタで

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

を、この関数は（F + F）の任意の組み合わせを扱うことができ、（F + I）：この設計は、加算演算子が非会員の過負荷として実装されている必要

および（I + F）を含む。