What is the extra argument used for when overloading the decrement operator?

Question

When I overload the post-decrement operator, I have to include a extra argument:

#include <iostream>

template<class T>
class wrap
{
public:
    bool operator >(T &&v)
    {
        return value > v;
    }
    T operator --(int v) // Remove 'int v' and you get a compilation error
    {
        return (value -= 1) + 1;
    }
    wrap(T v)
    {
        value = v;
    }
private:
    T value;
};

int main(void)
{
    wrap<int> i(5);
    while(i --> 0)
        std::cout << "Why do we need the extra argument?\n";
    return 0;
}

If I remove this seemingly unneeded argument, I get a compilation error:

test.cpp: In function ‘int main()’:
test.cpp:26:13: error: no ‘operator--(int)’ declared for postfix ‘--’ [-fpermissive]
     while(i --> 0)
           ~~^~

What is this argument used for? What does its value represent?

Answer 1

There are two separate but related overloads of operator++ - pre-increment and post-increment. Both are overridable. Since they both have the same name, the designers of C++ had to decide on a syntax to let the compiler differentiate between them. They chose to use a dummy int parameter on the post-increment operator.

When you write code like this:

wrap<int> i(5);
++i; // <-- calls i.operator++();

The compiler emits code to call the parameter-less operator++().

When you write code like this instead:

wrap<int> i(5);
i++; // <-- calls i.operator++(0);

The compiler emits code to call the parametered operator++(int), passing 0 for the dummy parameter.

The value of the parameter is meaningless, its mere presence is enough to let each overload of operator++ be overriden individually since they have different signatures.

BTW, the same rules apply to the pre/post-decrement operator-- as well.

Answer 2

Every ratified ANSI and ISO C++ standard, and every working draft, describes this, although the precise wording changes between versions.

For example, according to the "Working Draft, Standard for Programming Language C++", document number N4659, dated 2017-03-21, Section 16.5.7 "Increment and decrement [over.inc]", para 1

The user-defined function called operator++ implements the prefix and postfix ++ operator. If this function is a non-static member function with no parameters, or a non-member function with one parameter, it defines the prefix increment operator ++ for objects of that type. If the function is a non-static member function with one parameter (which shall be of type int) or a non-member function with two parameters (the second of which shall be of type int), it defines the postfix increment operator ++ for objects of that type. When the postfix increment is called as a result of using the ++ operator, the int argument will have value zero.

At the end of the preceding para, there is a reference to footnote 134, which says

Calling operator++ explicitly, as in expressions like a.operator++(2), has no special properties: The argument to operator++ is 2.

After para 1, the standard even provides an example.

[ Example:

struct X {
    X& operator++(); // prefix ++a
    X operator++(int); // postfix a++
};

struct Y { };
  Y& operator++(Y&); // prefix ++b
  Y operator++(Y&, int); // postfix b++

void f(X a, Y b) {
    ++a; // a.operator++();
    a++; // a.operator++(0);
    ++b; // operator++(b);
    b++; // operator++(b, 0);

    a.operator++(); // explicit call: like ++a;
      a.operator++(0); // explicit call: like a++;
      operator++(b); // explicit call: like ++b;
      operator++(b, 0); // explicit call: like b++;
}

— end example ]

Para 2 then goes on to say

The prefix and postfix decrement operators -- are handled analogously.

Answer 3

From cppreference:

The int parameter is a dummy parameter used to differentiate between prefix and postfix versions of the operators. When the user-defined postfix operator is called, the value passed in that parameter is always zero, although it may be changed by calling the operator using function call notation (e.g., a.operator++(2) or operator++(a, 2)).

Though I would highly advise against making functionality around those explicit calls (as to anyone else it'll look extremely weird).

Answer 4

Because you're using postfix decrement:

 while (i-- > 0)

which should decrement i but return the original value:

T operator--(int) // dummy int param for postfix
{
    T temp = value;
    value -= 1;
    return temp;
}

the dummy int parameter is just a placeholder to distinguish between postfix and the prefix decrement:

T operator--() // no param for prefix
{
    value -= 1;
    return value;
}