Overloading postfix operator ++

Question

I have overloaded the prefix version of operator ++. How can I overload the postfix version if the overloaded function is NOT a member of my class*?

#include <iostream>
using namespace std;

class Number{
    int number;
public:
    Number(int inNr):number(inNr){}
    friend void operator++(Number& fst);
};

void operator++(Number& fst){
    fst.number=fst.number+1;
}

int main(){
    Number nr1(1);
    ++nr1;
    //nr1++; error: no 'operator++(int)' declared for postfix '++' 
}

*I understand if it is a member of the class, I can use the dummy int parameter to distinguish them.

Answer 1

Non-member overloads also use a dummy int parameter to distinguish them:

friend void operator++(Number&);      // prefix
friend void operator++(Number&, int); // postfix

Note that some people might expect these to emulate the behaviour of the built-in operator by returning, respectively, the new and old values:

Number& operator++(Number& fst) {
    fst.number=fst.number+1;
    return fst; // reference to new value
}

Number operator++(Number& fst, int) {
    Number old = fst;
    ++fst;
    return old; // copy of old value
}

Answer 2

I believe (I can't test this out at the moment) you use the dummy int as a second parameter to the operator overload, i.e.

void operator++(Number& fst, int /*dummy*/){
    fst.number=fst.number+1;
}