How to Differentiate (When Overloading) Between Prefix and Postfix Forms of Operator++? (C++)

How to differentiate (when overloading) between prefix and postfix forms of operator++? (C++)

Write a version of the same operator overload, but give it a parameter of type int. You don't have to do anything with that parameter's value.

If you're interested in some history of how this syntax was arrived out, there's a snippet of it here.

Difference between prefix and postfix increment operators overloading implementations for iterators in C++

Actually, both postfix versions are wrong. The postfix iterator must return a copy, not a reference.

The point is that post-increment changes the incremented object, but returns a version of it before the increment. The pre-increment changes the object and returns the incremented version. Their logic must differ accordingly.

This distinction is made because post- and pre-increment have the same semantics on primitive types. Example:

int i = 0;
std::cout << i++ << std::endl;

yields the output 0. Your class with overloaded iterators should imitate that behaviour for consistency. If you had your own integer class with one of the iterator implementations you've shown, the result would be 1, and thereby surprising.

The correct implementation of a postfix increment is in 99% of the cases:

iterator operator++(int)
{
    iterator old = *this;
    ++(*this);
    return old;
}

How does C++ know that an increment ++ is prefix or postfix when overloading the operator

When the compiler reads your source code, it can figure out whether you've used a prefix or a postfix. Very simple: either the ++ comes up before or after some object.

Then the compiler will generate code to call the right function. But what's the name of that function? The people that designed C++ decided to make the function name for overloaded operators operator followed by the operator you're overloading (++, --, = etc), like operator*, operator-, etc.

But the problem now is that both prefix and postfix increment operators are named operator++. How do you differentiate between them? When you encounter ++var and var++, the compiler generates code to call operator++ for both of them, but you don't want that because now you can't differentiate between the definitions between a postfix and a prefix increment operator.

To solve this, the same language designers added a dummy parameter, int. This way, the compiler can call operator++(0), or operator++(42) (or whatever number you feel like, it's not important. It's a dummy parameter) when it encounters a postfix ++, and just an operator++() when it encounters a prefix. The parameter is just there for differentiation.

All in all, this is a language design problem. When it comes to design decisions, naturally, there must've been other solutions (like naming them operator_preinc() and operator_postinc()), but this is what the designers of C++ chose to go with. They could have their reasons, or it could be arbitrarily chosen because maybe all other options weigh about the same.

Pointer to class object in overloading prefix and postfix operators

Your postfix operators return by value, so the object you created with new is copied, and since you don't bind it to anything the copy gets destroyed at the end of the postfix expression in main. By also having the copy constructor output something you can observe this behavior, see for example here.

You prefix operators on the other hand just return a reference to the object you allocated with new, so at the end of the expression in main just the reference is destroyed.

In both cases you're leaking the memory allocated by new.

overloading postfix and prefix operators

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.

C# postfix and prefix increment/decrement overloading difference

This is the wrong way to implement increment and decrement in C#. You will get crazy results if you do it wrong; you did it wrong, you got crazy results, so the system works. :-)

Coincidentally I wrote an article about this very subject last week:

http://ericlippert.com/2013/09/25/bug-guys-meets-math-from-scratch/

As commenter dtb points out, the correct implementation is:

    public static Counter operator ++(Counter c)
    {
        return new Counter(c.v + 1);
    }

In C# the increment operator must not mutate its argument. Rather it must only compute the incremented value and return it, without producing any side effects. The side effect of mutating the variable will be handled by the compiler.

With this correct implementation your program now goes like this:

    Counter c1 = new Counter(1);

Call the object that c1 refers to right now W. W.v is 1.

    Counter c2 = c1++;

This has the semantics of:

temp = c1
c1 = operator++(c1) // create object X, set X.v to 2
c2 = temp

So c1 now refers to X, and c2 refers to W. W.v is 1 and X.v is 2.

    Counter c3 = ++c1;

This has the semantics of

temp = operator++(c1) // Create object Y, set Y.v to 3
c1 = temp
c3 = temp

So c1 and c3 now both refer to object Y, and Y.v is 3.

    c3++;

This has the semantics of

c3 = operator++(c3) // Create object Z, set Z.v to 4

So when the smoke all clears:

c1.v = 3 (Y)
c2.v = 1 (W)
c3.v = 4 (Z)

and X is orphaned.

This should give exactly the same results as if you'd had c1, c2 and c3 as normal integers.

Prefix and Postfix operator overloading in C#

You're trying to adjust a type that is declared as class to behave as a struct. This doesn't make any sense for me. If you change class Test to struct Test, remove the parameterless constructor and override the .ToString method, all the problems are gone.

First, You're creating a new instance of Test each time you increment (Post or Pre). So when you hit this line:

Test obj2 = ++obj;

As if you're writing:

obj = new Test(obj.x + 1);
Test obj2 = obj;

Second and as for the printing issue, just override the ToString:

public override string ToString()
{
    return x.ToString();
}

How to overload the operator++ in two different ways for postfix a++ and prefix ++a?

Should look like this:

class Number 
{
    public:
        Number& operator++ ()     // prefix ++
        {
           // Do work on this.   (increment your object here)
           return *this;
        }

        // You want to make the ++ operator work like the standard operators
        // The simple way to do this is to implement postfix in terms of prefix.
        //
        Number  operator++ (int)  // postfix ++
        {
           Number result(*this);   // make a copy for result
           ++(*this);              // Now use the prefix version to do the work
           return result;          // return the copy (the old) value.
        }
}; 

---

Related Topics