Overloading Postfix and Prefix Operators

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.

how to apply operator overloading for unary postfix operator

if you want post-inc/dec then the code will be :

  Distance operator++ (int) {
     feet = feet+1;
     inches = inches+1;
     
     return Distance(feet, inches);
  }

we use int in formal parameter . it is just crate different between post/pre-fix.
The prefix form of the operator is declared exactly the same way as any other unary operator; the postfix form accepts an extra argument of type int.

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.

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.

c++ postfix / prefix operator overload as non-member function

Perhaps I misunderstood, but if you're struggling with proper declaration of both operators, you can still do this with free operators like members. You do, however, need to pass the object as the first parameter by-reference. You're correct that as member functions they get their object for free via this. As a free function, you need to push it yourself.

#include <iostream>

struct my_array
{
    // your members here.
};

my_array& operator ++(my_array& obj)
{
    // access to members is through obj.member
    std::cout << "++obj called." << std::endl;
    return obj;
}

my_array operator ++(my_array& obj, int)
{
    my_array prev = obj;

    // modify obj, but return the previous state.        
    std::cout << "obj++ called." << std::endl;

    return prev;
}

int main(int argc, char *argv[])
{
    my_array obj;
    ++obj;
    obj++;
    return 0;
}

Output

++obj called.
obj++ called.

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();
}

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.

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.

Trying to overload increment operator in C++

You need to use (int) or () as a suffix to operator++. This will tell the compiler whether you want the ++ operator to be pre, or postfix. I.e. int++ or ++int.

It's just an idiosyncrasy.

class Point  
{  
public:  
    // Declare prefix and postfix increment operators.  
    Point& operator++();       // Prefix increment operator.  
    Point operator++(int);     // Postfix increment operator.
private:
    int x;
};

// Define prefix increment operator.  
Point& Point::operator++()  
{  
    x++;   
    return *this;  
}  

// Define postfix increment operator.  
Point Point::operator++(int)  
{  
    Point temp = *this;  
    ++*this;  
    return temp;  
} 

---

Related Topics