Why a+++++b is illegal and a++-++b is legal expression?

Unary operators

Unary operators are utilized with a single operand and can perform operations on integers and various data types, similar to binary operators, except for the bool data type.

Unary operators are of two types:

• postfix (x++ and x--)

• prefix (++x and --x).

The table below provides insight into the functioning of increment and decrement unary operators:

Why a+++++b is illegal?

The reason why the expression a+++++b is considered invalid is because the combination of post-increment and pre-increment operators results in undefined behavior, which could lead to unexpected outcomes.

The expression a+++++b works as follows:

The function of expression a++:

This function will return rvalue that cannot be altered.

// assume a = 10
const int operator++(int &a, int d)
{
   temp = a; // temp = 10
   a = a + 1; // a = 11
   return temp; // return 10
}

The function of expression ++b:

This function will return an lvalue that can be modified.

// assume b = 5 
int & operator++(int &b)
{
   b = b + 1; // b = 6
   return b; // return 6
}

The compiler first runs the expression a++, which results in a constant rvalue. The subsequent ++ operation causes a compile error indicating that an lvalue is required, which is not currently available. Thus, the expression will never be executed.

Let’s execute the code below and see the unexpected output.

Explanation of a+++++b

To prevent such issues, it is advisable to write expressions in a clear and unambiguous manner, with well-defined behavior. In this particular instance, rewriting the expression as a + (a++) + b provides a clear meaning to the compiler and ensures the expected results.

Why a++-++b is legal?

The expression a++-++b is considered legal and works as follows:

• The expression a++ increment the value a by 1.
• The expression ++b increment the value b by 1.
• The expression a++ - ++b calculates the subtraction between the original value of a and the new value of b.
• The compiler first evaluates the value of a++, which returns the original value of a, then evaluates the value of ++b, which returns the incremented value of b, and finally performs the subtraction operation on these two values.

Let’s run the code below and observe the results:

Explanation of a++-++b

• The post-increment expression a++ returns the rvalue which is 10.

// assume a = 10
const int operator++(int &a, int d)
{
   temp = a; // temp = 10
   a = a + 1; // a = 11
   return temp; // return 10
}

• The pre-increment expression ++b returns the incremented value of b which is 6.

// assume b = 5 
int & operator++(int &b)
{
   b = b + 1; // b = 6
   return b; // return 6
}

• The post-increment expression a++ returns the value 10, and the pre-increment expression ++b returns the value 6. Subtracting these two values results in 4