超载>>对于分数类 C++

Question

我正在尝试重载 instream 运算符 >>对于分数类。我创建了一个函数，可以从用户处获取字符串并将其解析为我的 Fraction 类的正确参数，但我不确定如何在我的 >> 中实现它重载功能。

用户可以输入三种类型的分数： 1. 整数（例如5） 2.带分数（如2+4/5） 3. 常规分数（例如 1/2）

我的方法是在主函数中接受用户输入的字符串形式，解析它以获取有效的 Fraction 类参数，然后将这个新创建的分数对象返回到流。我只是不知道该怎么做。

在我的运算符重载定义中，我有这样的：

istream& operator>>(istream& in,const Fraction& input)

但是如果我接受一个字符串，那么这里参数的类型不应该是字符串吗？我只是对那部分感到非常困惑。然后我想返回一个 Fraction 对象。这是处理整数的示例。

    int num1 = atoi(input.c_str());
    Fraction output(num1);
    in >> output;
    return in;

我走在正确的轨道上吗？

Answer 1

您的分数需要作为输出参数，因此它不能是 const：

istream& operator>>(istream& in, Fraction& input)

然后在函数中，您将提取到 std::string 中，然后对其进行解析，并将相关数据存储到您的函数中输入 Fraction 对象。

Answer 2

这就是我对演示代码所做的事情，因为其他人已经解释了问题。

class Fraction {
int top, bottom;
public:
    Fraction(int top_, int bottom_) :top(top_), bottom(bottom_) {}
    Fraction(const Fraction& rhs) : top(rhs.top), bottom(rhs.bottom) {}
    Fraction& operator=(const Fraction& rhs) {top=rhs.top; bottom=rhs.bottom; return *this}

    int get_numerator() {return top;}
    int get_denomerator() {return bottom;}
    double get_value() {return double(top)/bottom;}
};

istream& operator>>(istream& in, Fraction& input) {
    int numer;
    int denom=1;
    int whole=0;
    int peekchar;
    bool valid=false;

    in >> numer; //get the numerator
    peekchar = in.peek(); //peek at next character
    if(in && peekchar == '+') { //if next character is a +
        in.get(); //skip the + character
        whole = numer; //then first character was whole, not numerator
        in >> numer; //get the real numerator
        valid = true;
        peekchar = in.peek();
    }
    if(in && peekchar == '/') { //if next character is a /
        in.get(); //skip the / character
        in >> denom; //get the denominator
        valid = true;
    }
    if (in || valid) { //if we succeeded in reading
        if (denom == 0)
            denom = 1;
        numer += (whole*denom);
        input = Fraction(numer, denom);
     }
     return in;
}
ostream& operator<<(ostream& in,const Fraction& output) {
    return in << output.get_numerator() << '/' << output.get_denominator();
}
int main() {
    Fraction my_fract;
    cout << "Enter a fraction\n";
    cin >> my_fract;
    cout << "you entered " << my_fract;
}
}

Answer 3

您应该使用流，而不是字符串。如果用户想要向字符串输入/输出，则始终可以使用stringstream。请注意，您的定义

istream& operator>>(istream& in,const Fraction& input)

在流语言中意味着从 istream 中提取 Fraction，因此您的输入参数不应该是 const。另一方面，要将 Fraction 输出到 ostream，需要声明

ostream& operator<<(ostream& in,const Fraction& input) //Here const is good

另外，最后要注意的是 istream/ostream 是特定的实现，使用 char 作为元素和默认特征。更通用的实现适用于任何类型的流，其运算符定义如下

template< typename Elem, typename Traits >
std::basic_istream< Elem, Traits >& operator>>(std::basic_istream< Elem, Traits >& in, Fraction& input)

template< typename Elem, typename Traits >
std::basic_ostream< Elem, Traits >& operator<<(std::basic_ostream< Elem, Traits >& out, Fraction const& output)

Answer 4

对于要为 Fraction 类重载的 operator>> 函数，而不是获取输入 std::string，请对其进行解析，然后尝试从解析的参数创建一个新的 Fraction 对象，您应该在 operator>>> 重载函数内对用户输入进行所有解析，因为那已经有直接的访问输入流。换句话说，您正在做的事情是多余的，并且有点令人困惑......对于 Fraction 对象的 operator>> 重载，其目的应该是采取整个用户输入并根据该用户输入创建一个 Fraction 对象...在 Fraction 对象完成之前不需要执行几个步骤。

因此，您需要类似：

//set values of Fraction object through pass-by-reference
istream& operator>>(istream& in,Fraction& input);

并使用它：

Fraction new_fraction_obj; //has only default-constructor-set values
std::cin >> new_fraction_obj;  //now will have the user-input values after call

最后，如果在尝试解析用户输入时发现它的格式不正确，或者类型错误等，请设置 的失败位istream 对象通过调用 ios::setstate() 以便流的用户可以检测到输入有问题，并且 Fraction 对象正在通过引用传递处于无效状态。

Answer 5

标准方法是将自定义输入操作分解为多个组成部分：

std::istream & operator>>(std::istream & in, Fraction & input)  // not const!
{
  std::string token;

  if (!(in >> token)) { return in; }  // error

  int num, den;
  const bool res = parse_token(token, num, den);  // write this!

  if (!res)
  {
    in.setstate(std::ios::failbit);
    return in;
  }

  input.set(num, den); // or whatever
}

关键是编写 parse_token(const std::string &, int &, int &) 函数来确定是否一个字符串表示一个有效的分数，如果是，则将分子和分母放入两个相应的变量中。