Question

所以，我已经让内部运算符重载为obj1 + obj2工作：

fraction operator+ (fraction op);

类似地，cout＆lt;＆lt; obj正在通过重载运算符重载ostream：

ostream& operator<< (ostream& os, fraction& frac);

然而，如果我试图将两者结合起来，那么一切都会破裂。

fraction.cpp:77:27: error: no match for ‘operator<<’ in 
‘std::operator<< [with _Traits = std::char_traits<char>]((* & std::cout), ((const char*)"Sum: ")) 
<< f1.fraction::operator+(f2)’

以下是代码：

#include <iostream>
using namespace std;

class fraction
{
    private:
        int n, d;

    public:
        fraction ()
        {
            this->n = 1;
            this->d = 0;
        }

        fraction (int n, int d)
        {
            this->n = n;
            this->d = d;
        }

        int getNumerator ()
        {
            return n;
        }

        int getDenominator ()
        {
            return d;
        }

        fraction operator+ (fraction op)
        {
            return *(new fraction(this->n*op.d + op.n*this->d, this->d*op.d));
        }

        fraction operator- (fraction op)
        {

            return *(new fraction(this->n*op.d - op.n*this->d, this->d*op.d));
        }

        fraction operator* (fraction op)
        {
            return *(new fraction(this->n*op.n, this->d*op.d));
        }

        fraction operator/ (fraction op)
        {
            return *(new fraction(this->n*op.d, this->d*op.n));
        }
};

ostream& operator<< (ostream& os, fraction& frac)
{
    int n = frac.getNumerator();
    int d = frac.getDenominator();

    if(d == 0 && n == 0)
        os << "NaN";
    else if(d == 0 && n != 0)
        os << "Inf";
    else if(d == 1)
        os << n;
    else
        os << n << "/" << d;
}

int main ()
{
    fraction f1(2, 3);
    fraction f2(1, 3);

    cout << f1 << " " << f2 << endl;

    /*
    cout << "Sum: " << f1+f2 << endl;
    cout << "Difference: " << f1-f2 << endl;
    cout << "Product: " << f1*f2 << endl;
    cout << "Quotient: " << f1/f2 << endl;
    */

    return 0;
}

帮助。 d：

Answer 1

当前的问题是

ostream& operator<< (ostream& os, fraction& frac)

不会接受临时因为frac不是const引用 - 将其更改为

ostream& operator<< (ostream& os, const fraction& frac)

两个分数之间的

operator+将返回一个不能绑定到非const引用的临时值。

在这些情况下还存在非常严重的内存泄漏：

fraction operator+ (fraction )
{
   return *(new fraction(this->n*op.d + op.n*this->d, this->d*op.d)); 
}

new将返回一个动态分配的对象，然后从该函数复制并返回该对象。

就像大多数人一样：

fraction operator+ (const fraction& op) const
{
   return fraction(this->n*op.d + op.n*this->d, this->d*op.d); 
}

（注意两个额外的争论和参考传递）

制作“cout＆lt;＆lt;＆lt; obj1 + obj2＆lt;＆lt; endl;”工作

1 个答案: