overloading postfix and prefix operators

Question

please consider following code

#include 
using namespace std;
class Digit
{

private:
    int m_digit;
public:
    Digit(int ndigit=0){
             


        

Answer 1

The pre- and post-increment are two distinct operators, and require separate overloads.

C++ doesn't allow overloading solely on return type, so having different return types as in your example wouldn't be sufficient to disambiguate the two methods.

The dummy argument is the mechanism that the designer of C++ chose for the disambiguation.

Answer 2

In Pre-Increment/Decrement and Post-Increment/decrement, the difference is based on only dummy parameter in overloaded function

operator++()         => Prefix Increment
operator--()         => Prefix Decrement

operator++(int)      => Postfix Increment
operator--(int)      => Postfix Decrement

return type may be same. you can also refer: http://www.tutorialspoint.com/cplusplus/increment_decrement_operators_overloading.htm

Answer 3

The operator, just as any function, is identified by the signature. The return type and modifiers before the function/operator name is not included in this. Your operators names are here

operator++()
operator++(int)

This is the only way the compiler distinguishes between the two. As for the Digit& and Digit return values; They are needed because of the way ++x, and x++ are supposed to operate.

Answer 4

In C++ functions/methods can't be overloaded by return type, only by parameter list. Ignoring the fact that the prefix and postfix operators are operators, imagine if they were just simple other functions, how would the compiler work out which to use based on the return type? E.g.

int x = 2;

const int DoIt()
{
    return 1;
}

int& DoIt()
{
    return x;
}

int y = DoIt();

Since operator overloads are really just functions at heart, there's no way for the compiler to differentiate between them by return type.

See http://www.parashift.com/c++-faq-lite/operator-overloading.html#faq-13.14