Przeciążony "operator ++" musi być operatorem jednoargumentowym lub binarnym (ma 3 parametry)

Question

Mam plik nagłówkowy i plik .cpp. Próbuję zaimplementować przeciążenie operatora prefiksu i postfiksa, ale nadal otrzymuję ten błąd podczas konfigurowania przeciążenia.

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 
} 

Są to dwa błędy uzyskać:

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)" 

jest błąd prefiks faktycznie błąd z mojej ide? Wiem, że musi to być "int" dla post-inkrementacji, ale próbuję zrobić pre-increment. Używam xcode.

Answer 1

zadeklarowanej operatorów spoza klasy jako funkcji non-klasowych

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

jednak potem próbują definiować je jak funkcji składowych klasy

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

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

Albo zadeklarować je jako funkcji składowych Class w następujący sposób:

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

W tym przypadku definicja Przykładem operatora preincrement może wyglądać

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

Albo zadeklarować je jako non-klasy funkcji, które są przyjaciółmi z klasy, ponieważ muszą mieć dostęp do prywatnych członków danych klasy

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

I w tym przypadku na przykład definicja operatora preincrement może wyglądać

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

Answer 2

zadeklarowanej funkcji w postaci wolnych funkcji

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

ale definiowania ich jako funkcji składowych.

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

Ponieważ funkcje składowe mają niejawny this parametr, twoje funkcje składowe mają trzy parametry (this, Fraction i int).

Zdecyduj, czy chcesz, aby funkcje były wolne, czy członek. Jeśli chcesz, aby były wolne, określ je jako wolne, a nie jako członków. Jeśli chcesz, aby byli członkami, zadeklaruj ich jako członków i dostosuj deklaracje zaznaczone przez @crayzeewulf powyżej.

Answer 3

Funkcja składowa ma domyślny * ten wskaźnik, który zawsze wskazuje obiekt klasy, nad którym pracuje funkcja składowa. Parametr, który musieliśmy wylistować jawnie w wersji funkcji przyjaciel (która nie ma * tego wskaźnika) staje się niejawnym * tym parametrem w wersji funkcji członka.

Spróbuj ustawić ją jako funkcję bez funkcji. Następnie możesz przekazać parametr . W przeciwnym razie usuń parametr.

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