整数类和分数类的添加和比较数据的操作符重载

Operator overloading for add and compare data of Integer and Fraction classes

本文关键字：数据 操作符 重载 比较 添加 整数      更新时间：2023-10-16

类似这个问题张贴在这里。我需要创建三个类:

  1. "数字"类支持三种操作:"显示"、"=="、
    和"+";
  2. 用整数表示的"整型类";
  3. "分数"类用分子和分母表示。

要求:

  1. 应支持以下操作:(a) Integer (I) + Fraction (F);(b) F+I， (c) F+F， (d) I+I，并比较它们
  2. +操作的调用者不需要知道返回类型。

我可以解决这个问题，直到要求# 1。然而，第二个要求我还没想好。任何帮助都会很感激。为了简短起见，我将在下面分享我的代码的头文件，如果需要，可以共享代码的函数定义。

  1. Number.h 

#pragma once
template<class T>
class Number
{
public:
    bool operator== (const T&)
    {
        return impl().operator == ();
    }
    T operator+ (const T &) const
    {
        return impl().operator+();
    }
    template <typename Stream>
    void display(Stream& os) const
    {
        impl().display(os);
    }
private:
    T& impl() {
        return *static_cast<T*>(this);
    }
    T const & impl() const {
        return *static_cast<T const *>(this);
    }
};

  • Integer.h 

    • #pragma once
#include "Number.h"
class Integer : public Number<Integer>
{
    int intValue{0};
public:
    template <typename Stream>
    void display(Stream& os) const
    {
        os << this->intValue << 'n';
    }
    Integer() = default;
    ~Integer() = default;
    Integer(int num);
    int getIntValue() const;
    bool operator== (const Integer &);
    Integer operator+ (const Integer &) const;
};

  • Fraction.h 

    • #pragma once
#include <math.h>
#include "Number.h"
#include "Integer.h"
#include <iostream>
class Fraction : public Number<Fraction>
{
    int _numerator{0};
    int _denominator{1};
    int gcdCalculate(int val1, int val2) const;
    int lcmCalculate(const int val1, const int val2) const;
public:
    template <typename Stream>
    void display(Stream& os) const
    {int tempNum = this->_numerator;
    int tempDen = this->_denominator;
    double tempFrac = (double)tempNum/(double)tempDen;
    double intpart;
        if (this->_denominator==0)
        {
        std::cout << "Undefined " << this->_numerator << "/" << this->_denominator << "(Divide by zero exception)";
        }
    else if (this->_denominator==1){
        std::cout << this->_numerator << std::endl;
        }
    else {
        os << this->_numerator << "/";
        os << this->_denominator << 'n';}
    }
    Fraction() = default;
    Fraction(int num, int den);
    ~Fraction() = default;
    bool operator== (const Fraction &);
    bool operator== (const Integer &);
    friend bool operator== (const Integer&, const Fraction&);
    Fraction operator+ (const Fraction &) const;
    Fraction operator+ (const Integer &) const;
    friend Fraction operator+ (const Integer&, const Fraction&);
};

    main.cpp 

    #include <iostream>
using namespace std;
template <typename INumberType>
void GenericDisplay(const Number<INumberType>& num) //Here we are calling through the Number<> Interface
{
    num.display(cout);
}
int main()
{
    Fraction fracOne(1,4);
    Fraction fracTwo(2,8);
    Integer intOne(30);
    Integer intTwo(30);
    Fraction sumOfFractionOneTwo = fracOne + fracTwo;
    Integer sumOfIntegerOneTwo = intOne + intTwo;
    Fraction sumOfFractionOneAndIntegerOne = integerOne + fracOne;
    Fraction sumOfFractionTwoAndIntegerTwo = fracTwo + intTwo;
    return 0;
}

    在这段代码中，+操作符的调用者知道返回类型，例如，在int main()调用者定义的返回类型"Fraction sumOfFractionOneAndIntegerOne = integerOne + fracOne;"。这是不正确的!

    我想要的方式是，调用者不应该知道返回类型。例如，"Number sumOfFractionOneAndIntegerOne = integerOne + fracOne;"

    由于类型是静态已知的，调用者可以对变量的类型使用auto，这样就可以推导类型，而不是显式指定类型。否则，您可能会寻找虚拟继承，它允许将抽象基类用作类型，而派生类则为进一步的操作符提供实现。

    相关文章：