2 
#include"Fraction.h"

#include<iostream>

using namespace std;


Fraction operator*(const Fraction& left, const Fraction& right)
{
    int newNum = left.getNum() * right.getNum();
    int newDenom = right.getDenom() * left.getDenom();

    Fraction result(newNum, newDenom); //Error is here, cannot convert from Fraction to int
    return result;
}

int main()
{
    Fraction a(3,4);
    Fraction b(1,2);
    Fraction c = a * b;

    cout << c << endl;
}

这是我的代码，我们这周才开始做运算符重载，我很困惑。

main 显然不起作用，但这是我想要通过的输入，但我不明白我得到的错误。任何人都可以为我分解一下吗？我会很感激的。

//This is my Header file for anyone that wants to see it

#ifndef FRACTION_H
#define FRACTION_H

class Fraction
{

public:

    Fraction(int numParam, int denomParam);

    void setNum(int numParam);
    int getNum() const;

    void setDenom(int denomParam);
    int getDenom() const;

private:
    int num;
    int denom;

};

#endif
4

2 回答 2

3

它不知道如何显示分数，添加这个：

std::ostream& operator<<(std::ostream& stream, const Fraction& frac) {
    stream<<"Do something with frac here, like output num/denom\n";
    return stream;
}

尽管它现在不会抱怨您的 cout 行，但当您修复此错误时它会抱怨，因为它不知道如何在 std::ostream 和 Fraction 上执行 <<。

不是这个 - 来自原始答案

您的错误可能是那些“从这里使用”错误标记之一，它告诉您它在哪里感到困惑，它可能试图将 frac 打印为 int ......是的。

实际答案

当你说Fraction A = B*C;编译器看到Fraction A = AnotherFraction;它可以做的事情Fraction A;（默认构造函数）时，Fraction::operator=(Fraction&);或者它可以在这种情况下使用你返回的临时值（移动赋值）。

C++ 允许一级隐式转换，在某处你有“Fraction::Fraction(int);” - 一个采用 int 的构造函数，C++ 想要将您的 Fraction 转换为 int，并使用该 int 构造一个新的 Fraction。

它在抱怨，因为它不能。给它一个复制构造函数，参见规则 3（现在规则 5），你应该总是有你的赋值运算符和复制构造函数，而不是只有一个（没有很好的理由）和 C++11 你的赋值 r-value 运算符和"" 构造函数。

结束时

我们需要你的构造函数，隐式转换给你的错误看起来很奇怪，因为“为什么是 int”，但出于某种原因，C++ 想要使用 Fraction::Fraction(int)，我知道你所说的存在这种情况，它很沮丧，因为它不能去分数-> int（它想做分数-> int->分数）

笔记

这就是为什么 C++ 有一个沉重的学习曲线，因为它是如此强大（它对隐式转换所做的毫无疑问是一件好事！）您可能会遇到错误，这些错误会告诉您它在哪里混淆而不是实际错误。就像当您有一个带有拼写错误的 operator<< 并且它试图将其与标准 operator<< 之一匹配时，您会得到一个 4 页的原因，说明您所说的为什么是错误的以及它如何无法实例化某个 (在人类看来无关）模板。

附录

template<class T>
class Ratio {
public:
    Ratio(): top(0), bottom(1) {}
    Ratio(T& from): top(from), bottom(1) {}
    Ratio(T& top, T& bottom): top(top), bottom(bottom) {}
    Ratio(T&& from): top(from), bottom(1) {}
    Ratio(T&& top, T&& bottom): top(top), bottom(bottom) {}
    Ratio& operator=(Ratio& from) {
        top = from.top;
        bottom = from.bottom;
    }
    Ratio& operator=(Ratio&& from) {
        top = from.top;
        bottom = from.bottom;
    }
    Ratio(const Ratio& from): top(from.top), bottom(from.bottom) {}
    Ratio(Ratio&& from): top(from.top), bottom(from.bottom) {}
    ~Ratio() {}

    const T& getTop() const { return top; }
    const T& getBottom() const { return bottom; }
    T& getTop() { return top; }
    T& getBottom() { return bottom; }


    Ratio operator*(const Ratio& rhs) const { //we are the left hand side
        T newTop = rhs.top*this->top;
        T newBottom = rhs.bottom*this->bottom;
        Ratio result(newTop,newBottom);
        return result;
    }
private:
    T top;
    T bottom;
};

template<class T>
std::ostream& operator<<(std::ostream& stream, const Ratio<T>& ratio) {
    stream<<ratio.getTop()<<"/"<<ratio.getBottom();
    return stream;
}

typedef Ratio<int> Fraction;

int main(int,char**) {
    Fraction a;
    std::cout<<"A: "<<a<<"\n";
    Fraction b(1);
    std::cout<<"B: "<<b<<"\n";
    Fraction c = a*b;
    std::cout<<"A*B=C: "<<c<<"\n";
    Fraction d(5,3);
    std::cout<<"Look! "<<d*d<<"\n";
    return 0;
}

这样可行！

于 2013-10-08T21:53:15.990 回答
1

好的，我想我知道问题出在哪里。在头文件中没有定义构造函数，因此当他运行程序时，它不会发现分数类采用两个整数。因此，通过定义构造函数，程序就可以运行了！

基本上这不在里面。

Fraction::Fraction(int numeratorParam, int denomeratorParam)
{

numerator = numeratorPram;

denumerator = denumeratorParam;

}
于 2013-10-08T22:33:57.523 回答