# 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:

Increment and Decrement Unary Operators

align-center

# 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.
```cpp
// 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.
```cpp
// 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.

#include <iostream>
using namespace std;

int main() {
  int a=10, b=5;
  cout<<a+++++b<<endl;
  return 0;
}

# 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:

#include <iostream>
using namespace std;

int main() {
  int a=10, b=5;
  cout<<a++-++b<<endl;
  return 0;
}

# Explanation of `a++-++b`
* The post-increment expression `a++` returns the  `rvalue` which is `10`.
```cpp
// 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`.
```cpp
// 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`

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

Unary operators in certain combinations lead to syntax and compile errors due to rvalue issues.

Symbol	Meaning	Example	Example
++	Increment (increase the value of variable by 1)	y = ++x; The pre-increment operator first increments x by 1 and then stores the incremented value in y.	y = x++; The post-increment operator first stores the value of x in y and then increments x by 1.
--	Decrement (decrease the value of variable by 1)	y = --x; The pre-decrement operator first decrements x by 1 and then stores the decremented value in y.	y = x--; The post-decrement operator first stores the value of x in y and then decrements x by 1.

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

Unary operators

Increment and Decrement Unary Operators

Why a+++++b is illegal?

Explanation of a+++++b

Why a++-++b is legal?

Explanation of a++-++b

Why `a+++++b` is illegal?

Explanation of `a+++++b`

Why `a++-++b` is legal?

Explanation of `a++-++b`