L'overloading 'operator ++' deve essere un operatore unario o binario (ha 3 parametri)

Question

Ho un file di intestazione e un file .cpp. Sto cercando di implementare un sovraccarico di operatore prefisso e suffisso, ma continuo a ricevere questo errore quando si imposta il sovraccarico.

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 
} 

Questi sono i due errori che ricevo:

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

è l'errore del prefisso in realtà un errore con la mia ide? So che deve essere "int" per post-incremento, ma sto cercando di fare un pre-incremento. Io uso xcode.

Answer 1

È dichiarato gli operatori al di fuori della classe come funzioni non-classe

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

però allora si sta cercando di definirli come le funzioni di membro di classe

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

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

O li dichiarare come funzioni membro classe il seguente modo

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

E in questo caso la definizione per esempio l'operatore preincremento può apparire come

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

o dichiarare come funzione non-classe che sono amici della classe, perché hanno bisogno di avere accesso ai dati membro private della classe

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

E in questo caso la definizione per esempio l'operatore preincremento può apparire come

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

Answer 2

È dichiarato le funzioni come funzioni liberi

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

ma li definisce come funzioni membro.

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

Poiché le funzioni membro hanno un parametro implicito this, le vostre funzioni membro avere tre parametri (this, Fraction e int).

Decidere se le funzioni devono essere libere o associate. Se vuoi che siano liberi, definiscili come liberi piuttosto che come membri. Se si desidera che siano membri, dichiararli come membri e regolare le dichiarazioni come indicato in @crayzeewulf in alto.

Answer 3

Una funzione membro ha un * questo puntatore implicito che punta sempre all'oggetto di classe su cui sta lavorando la funzione membro. Il parametro che dovevamo elencare esplicitamente nella versione della funzione friend (che non ha * questo puntatore) diventa implicito * questo parametro nella versione della funzione membro.

Provare a fare una funzione non membro. Quindi è possibile passare il parametro Altrimenti rimuovere il parametro.

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