What makes C developers so curious if “i++ == ++i”?

Question

Just a random observation, it seems that on StackOverflow.com, there are questions about if "++i == i++". That question gets asked all the time though, I think I saw it asked about 6 or 7 times in the past 2 months.

I just wonder why C developers are so interested in it? The same concept/question exists for C# and Java devs as well, but I think I saw only one C# related question.

Is it because so many examples use ++i? Is it because there is some popular book or tutorial? Is it because C developers just love to cram as much as possible into a single line for 'efficiency'/'performance' and therefore encounter 'weird' constructs using the ++ operator more often?

Answer 1

I suspect that at least part of it is a bit simpler: even now, we see a lot of questions like this starting around the beginning of the school year, and they gradually taper off throughout the year.

As such, I think it's fair to guess that quite a few of them are simply a result of classes in which the teacher talks at least a little about it, but doesn't explain his point(s) very well (as often as not because he doesn't really understand them himself). Especially based on the people who seem to ask these questions, few are based on actual coding.

Answer 2

Because C programmers HAVE to understand order of operations. C# developers don't necessarily use the bitwise operators (&, |, ~) or prefix operators since we're normally more worried about other stuff. However, what we C# devs don't realize is that we should know what the operators we use on a daily basis do and how to use them properly. Most of us just avoid the places where this may be a problem.

Off the top of your head, what is the output of this snippet?

    double x = 5.5;
    Console.WriteLine(x++);
    x = 5.5;
    Console.WriteLine(++x);

I would say a good number of seasoned C# devs have no idea what the output to the Console is.

Answer 3

Most likely because in C, it really matters if you write i++ or ++i when you're doing pointer arithmetic. There, increasing i before or after an operation could be crucial. I'd give you an example but the last time I wrote C was 10 years ago...

In C#, I've never come across a situation that would require me to think about i++ or ++i because AFAIK, for the for/while loops, it doesn't really matter.

Answer 4

I think this is obvious. In C#, for an int i, i++ == ++i is always false while ++i == i++ is always true, reliably, and everyone who’s interested can find this out easily just by learning the rules of C# (or indeed by just running it).

In C and C++, on the other hand, it’s close to undefined because it depends on the compiler, the execution environment, the platform, etc., so it’s a much harder question to answer, so lots of people ask it.

Answer 5

A few years ago I read that these operators were considered dangerous so I tried to dig more info on it. If stackoverflow had been up at that time, I would have asked it there.

Now it is because some twisted people write loops such as

while( [something] )
{
  a[++j] = ++j;
}

Even now, I'm not too sure about what will/should happen, but it's pretty clear to me that multiple ++[var] on the same line is asking for trouble.

Answer 6

Two reasons.

The correct implementation of ++i is to increment i and then return it. The correct implementation of i++ is to save the current value, increment i, and return the saved value. Knowing these are not implemented as synonymns is important.

The question then becomes when does the compiler apply them while evaluating an expression, such as equality.

If the equality test is done first, then the pre- and post- increment operators, you're going to have to write different logic than if the left hand side (lhs) and the right hand side (rhs) are evaluated first, then the equality.

It's all about order of operations, and that in turn affects the code one writes. And, not too surprisingly, not all languages are in agreement.

Basic tests list this allow developers to test to see if their assumptions are correct, as well as if the actual implementation matches the language specification.

This can have all kinds of impact when working with pointers, loops, or returning values.

Answer 7

It's a popular question because it's a trick question. It's undefined.

Answer 8

I think it's a culture shock thing.

As already pointed out, the behaviour of an expression in C or C++ can be undefined because the order of execution of the post-increments etc isn't strictly defined. Undefined behaviour is pretty common in C, and of course a lot of that was imported into C++.

To someone who has done some programming in another language - someone who has picked up the idea that programming languages are supposed to be precise, and that computers are supposed to do what they're told to do... well, it's a shock to discover that C is intentionally vague about some things.

Answer 9

Perhaps it's just that C developers use ++ incrementation more often in general -- seeing as how C has no "foreach" or similar statement to iterate through arrays. Oh, and of course pointer arithmatic, as previously mentioned!

Answer 10

The difference between both parts : the post and preincrement are working the way these two pieces of code should function in every language. THIS IS NOT BE LANGUAGE DEPENDENT!!!

++i

This is pre increment. This piece of code will first increase the value of i before it sends the value to the line where it is used.

i++

This is the post increment. This piece of code will return the value of i before it increases the value of i on the line where it is used.

In another small example :

int main(void)
{
  int i = 0; 
  int result; 
  result = 10 + ++i; 
  printf("%d \n", result); // = 11 

  int j = 0; 
  result = 10 + j++; 
  printf("%d \n", result);// = 10
  return 0;
}

This code compiling with results on codepad.

This has to do with the internal implementation of the operator overloading.

++i increases directly the value (and is therefore a little bit faster)

i++ first creates a copy that is returned to the place where needed and afterwards the original value of the i variable is increased by one.

I hope this is clear now.

Answer 11

Guessing: is C a more boring language than C#? If so, it might explain why you get questions on "++i == i++" in the former rather than the latter.

Also, is comparing the LHS and the RHS like comparing a conveyor belt with an airplane?