Question

我有一个头文件和一个.cpp文件。我试图实现前缀和后缀运算符重载，但我在设置重载时不断收到此错误。

fraction.h

#ifndef FRACTION_H
#define FRACTION_H

#include <iostream>

using namespace std;

class Fraction 
{
   public:
      Fraction();
      Fraction(int, int);
      int getTop() {return m_top;}
      int getBottom() {return m_bottom;}
      void set(int t, int b) {m_top=t; m_bottom=b; reduce();
      }

   protected:
   private:
      void reduce();
      int gcf(int, int);

      int m_top;
      int m_bottom;
};

Fraction& operator ++ (Fraction);
Fraction operator++(Fraction, int);

#endif

Main.cpp的

#include <iostream>

using namespace std;
#include "fraction.h"

int main {
   cout << "The fraction is" << f;
   cout << "The output of ++f is " << (++f) << endl;
   cout << "The fraction is" << f;
   cout << "The output of f++ is " << (f++) << endl;
   cout << "The fraction is" << f;

   return 0;
}

Fraction& Fraction::operator ++ (Fraction){
   // Increment prefix
   m_top += m_bottom;
   return *this;
}

Fraction Fraction::operator ++ (Fraction, int){
   //Increment postfix
}

这是我得到的两个错误：

 prefix error: "Parameter of overloaded post-increment operator must have type 'int' (not 'Fraction')"

postfix error: "Overloaded 'Operator++' must be a unary or binary operator (has 3 parameters)"

前缀错误实际上是我的ide错误吗？我知道后增量必须是'int'，但我试图做一个预增量。我用xcode。

Answer 1

您将类外的运算符声明为非类函数

Fraction& operator ++ (Fraction);
Fraction operator++(Fraction, int);

然而，您正在尝试将它们定义为类成员函数

Fraction& Fraction::operator ++ (Fraction){
   // Increment prefix
   m_top += m_bottom;
   return *this;
}

Fraction Fraction::operator ++ (Fraction, int){
   //Increment postfix
}

以下列方式将它们声明为类成员函数

class Fraction
{
public:
    Fraction & operator ++();
    Fraction operator ++( int );
    //...

在这种情况下，preincrement运算符的定义可以看起来像

Fraction & Fraction::operator ++(){
   // Increment prefix
   m_top += m_bottom;
   return *this;
}

或者将它们声明为非类函数，它们是该类的朋友，因为它们需要访问该类的私有数据成员

class Fraction
{
public:
    friend Fraction & operator ++( Fraction & );
    friend Fraction operator ++( Fraction &, int );
    //...

在这种情况下，preincrement运算符的定义可以看起来像

Fraction & operator ++( Fraction &f ){
   // Increment prefix
   f.m_top += f.m_bottom;
   return f;
}

Answer 2

您将函数声明为自由函数

Fraction& operator ++ (Fraction);
Fraction operator++(Fraction, int);

但您将它们定义为成员函数。

Fraction& Fraction::operator ++ (Fraction){ ... }
Fraction& Fraction::operator ++ (Fraction, int){ ... }

由于成员函数具有隐式this参数，因此您的成员函数有三个参数（this，Fraction和int）。

决定您是希望功能是免费还是成员。如果您希望它们是免费的，那么将它们定义为免费而非成员。如果您希望它们成为成员，则将它们声明为成员并调整上面@crayzeewulf所述的声明。

Answer 3

成员函数有一个隐式* this指针，它总是指向成员函数正在处理的类对象。我们必须在友元函数版本中明确列出的参数（没有* this指针）成为成员函数版本中隐含的* this参数。

尝试将其设为非成员函数。然后您可以传递参数否则删除参数。

Answer 4

    int main() {
    Fraction f;
    cout << "The fraction is" << f;
    cout << "The output of ++f is " << (++f) << endl;
    cout << "The fraction is" << f;
    cout << "The output of f++ is " << (f++) << endl;
    cout << "The fraction is" << f;


    return 0;
    }

    Fraction& Fraction::operator++ ()
    {
        // Increment prefix
        m_top += 1;
        return *this;
    }

    const Fraction Fraction::operator++ (int)
    {
        //Increment postfix
        Fraction temp = *this;
        ++(*this);
        return temp;
    }

    ostream& operator<<(ostream &os, const Fraction& f)
    {
        os << f.m_top << endl;
        return os;
    }

    Fraction::Fraction(const Fraction& f)
    {
        m_top = f.m_top;
        m_bottom = f.m_bottom;
    }

    Fraction::Fraction(int t, int b) :m_top(t), m_bottom(b){}
    Fraction::Fraction() : m_top(1), m_bottom(1){}


     class Fraction
    {
    public:
        Fraction();
        Fraction(int, int);
        Fraction(const Fraction& f);
        int getTop() { return m_top; }
        int getBottom() { return m_bottom; }
        void set(int t, int b) {
            m_top = t; m_bottom = b; reduce();
        }
        Fraction& operator ++ ();
        const Fraction operator++(int);

        friend ostream& operator<<(ostream &os,const Fraction& f);

        protected:
        private:
        void reduce();
        int gcf(int, int);

        int m_top;
        int m_bottom;
        };
        #endif

重载'operator ++'必须是一元或二元运算符（有3个参数）

4 个答案: