为什么递增和递减是一元运算

Question

Looks like it's a very strange question, because i've read a lot of documentation, where increment & decrement are unary operations without any explanation.

I could be wrong, but ++i is similar with i+=1 (if there aren't any overriding):

int i = 1;
Console.WriteLine(++i); // 2

int j = 1;
Console.WriteLine(j+=1); // 2

In this case, preincrement is simple syntatic sugar to hide binary operator plus and 1 as second argument.

Isn't it?

Why does increment and decrement are independent unary operations,- isn't it just binary plus operator with predefined second argument with value 1 ?

Answer 1

Your question boils down to why ++ and -- exist in the first place, when normal + and - could do the job.

With today's compiler optimisation capabilities, it's really all for historical reasons. ++ and -- date back to the early (but not earliest ) days of C. The Development of the C Language by late Dennis Ritchie , author of the C language, gives some interesting historical insights:

Thompson went a step further by inventing the ++ and -- operators, which increment or decrement;

[...]

They were not in the earliest versions of B , but appeared along the way.

[...]

a stronger motivation for the innovation was probably his observation that the translation of ++x was smaller than that of x=x+1 .

So the definite reason seems to be lost in the mists of history, but this article by Ritchie strongly suggests that increment and decrement operators owe their existence to performance issues with early compilers.

When C++ was invented, compatibility with C was one of the major design goals by its inventor Bjarne Stroustrup , so it's needless to mention that all C operators also exist in C++. As Stroustrup himself says in his FAQ :

I wanted C++ to be compatible with a complete language with sufficient performance and flexibility for even the most demanding systems programming.

As for C#, one its inventors Eric Lippert once stated here on the Stack Exchange network that the only reason for them being supported in C# is consistency with older languages:

[...] these operators are horrid features. They're very confusing; after over 25 years I still get pre- and post- semantics mixed up. They encourage bad habits like combining evaluation of results with production of side effects. Had these features not been in C/C++/Java/JavaScript/etc, they would not have been invented for C#.

---

PS: C++ is special because, as you have mentioned (even with the incorrect word "overriding"), you can overload all of those operators, which has lead to ++ and -- taking on slightly different semantics in the minds of many programmers. They sometimes read as "go ahead" ("go back") or "make one step forward" ("make one step backward"), typically with iterators. If you look at the ForwardIterator concept in C++, you will see that only the unary ++ is required by it.

Answer 2

The answer is very simple.

Unary Operation means the operator will do the operations on only on operand.

Next i++ and i+=1 both are different actions.

-> when i++ will executes you the compiler will goes the variable location and it will increment the value.

-> i+=1 executes the i and 1 will load into the register/temparory variable and the addition operation will done and the new value will copied into the i address loaction.

So compare to i+=1 will be cost compare to i++.