让"cout << obj1 + obj2 << endl;"发挥作用

Making "cout << obj1 + obj2 << endl;" work

本文关键字:lt endl 作用 obj1 cout obj2      更新时间:2023-10-16

因此,我得到了类内运算符重载,用于obj1+obj2:

fraction operator+ (fraction op);

类似地,cout<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:

眼前的问题是

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

(注意两个额外的常量和pass-by-reference)