Question

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

这是我的代码，本周我们刚刚开始执行操作符重载，而且我很困难。

主要显然不起作用，但这是我想要传递的输入，但我不明白我得到的错误。有人可以为我解决这个问题吗？我很感激。

//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

Answer 1

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

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

虽然现在没有抱怨你的cout线，但是当你修复这个错误时，它会因为它不知道如何做＆lt;＆lt;在std :: ostream和Fraction上。

不是 - 来自原始回答

你的错误很可能是那些“从这里使用”的错误标记之一，它告诉你它在哪里混淆，它可能试图将frac打印为int ....是的。

实际答案

当你说Fraction A = B*C;时，编译器会看到类似Fraction A = AnotherFraction;的内容，它可以Fraction A;（默认构造函数），后跟Fraction::operator=(Fraction&);，或者在这种情况下它可以使用r值（移动作业）来自您返回的临时作业。

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

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

结束

我们需要你的构造函数，一个级别的implict cast会给你带来奇怪的错误，因为“为什么是int”但是由于某种原因C ++想要使用Fraction :: Fraction（int），我知道它存在于你的' ve说，它很不高兴，因为它不能去分数＆gt; int（它想要分数 - >＆gt; int-＆gt;分数）

注意

这就是为什么C ++有一个沉重的学习曲线，因为它是如此强大（它与隐含的转换所做的事情毫无疑问是一件好事！）你可以得到错误，告诉你更多的地方混淆比实际上错误。就像你有一个运营商＆lt;＆lt;使用拼写错误并尝试将其与标准运算符＆lt;＆lt;之一匹配，您会得到一个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;
}

有效！

Answer 2

好吧我想我知道问题是什么。在头文件中没有定义构造函数，因此当他运行程序时，它不会发现分数类占用了两个整数。因此，通过定义构造函数，允许程序运行！

基本上这不在其中。

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

numerator = numeratorPram;

denumerator = denumeratorParam;

}

运算符重载分数

2 个答案: