[–] theNakedNecromancer 0 points 2 points 2 points (+2|-0) ago
As long as you're not screwing with the way C performs the action, I don't see why not. In other words: x++ and ++x are two completely different functions.
So, doing x *= ++i will perform:
x = x * (i + 1)
But, doing x *= i++ will act like:
x = (x * i) + 1
Beyond that, style is up to you. Most C-coders (and style guides) won't want whitespace around the variable, or between a variable and increment operator. But, if it's code just for you, who cares?
[–] scandalous-goat ago (edited ago)
I prefer x += 1 for an incrementation statement, as the intent is, IMO clearer. But I'm sure plenty would disagree with me.
I didn't compare the compiler's output for all three syntax, though.
I just did a test. The compiler produces exactly the same code for all three syntaxes if they are used as a statement.
int postfix()
{
0: 55 push %ebp
1: 89 e5 mov %esp,%ebp
3: 83 ec 10 sub $0x10,%esp
int x = 1;
6: c7 45 fc 01 00 00 00 movl $0x1,-0x4(%ebp)
x++;
d: 83 45 fc 01 addl $0x1,-0x4(%ebp)
return x;
11: 8b 45 fc mov -0x4(%ebp),%eax
}
14: c9 leave
15: c3 ret
00000016 <_prefix>:
int prefix()
{
16: 55 push %ebp
17: 89 e5 mov %esp,%ebp
19: 83 ec 10 sub $0x10,%esp
int x = 1;
1c: c7 45 fc 01 00 00 00 movl $0x1,-0x4(%ebp)
++x;
23: 83 45 fc 01 addl $0x1,-0x4(%ebp)
return x;
27: 8b 45 fc mov -0x4(%ebp),%eax
}
2a: c9 leave
2b: c3 ret
0000002c <_statement>:
int statement()
{
2c: 55 push %ebp
2d: 89 e5 mov %esp,%ebp
2f: 83 ec 10 sub $0x10,%esp
int x = 1;
32: c7 45 fc 01 00 00 00 movl $0x1,-0x4(%ebp)
x += 1;
39: 83 45 fc 01 addl $0x1,-0x4(%ebp)
return x;
3d: 8b 45 fc mov -0x4(%ebp),%eax
}
40: c9 leave
41: c3 ret
This is one of the things I think makes programming interesting, the different styles there is. The most interesting example I think of is Fox-Toolkit's style, the author has an, I may say, interesting style...
[–] RevanProdigalKnight ago (edited ago)
Just in case you didn't already know, there is actually a difference between counter++ and ++counter, as the first increments after reading the value and the second before reading the value, e.g.:
int counter = 0;
printf("%d\n", counter++); // 0
printf("%d\n", ++counter); // 2
Most people use counter++ because of this behavior being closer to the logical alternative of counter += 1.
[–] badkangaroo ago
i often see in a for loop (;;++i) or (;;i++) someone suggesting that ++i was better for some reason, any ideas why?
[–] skruf [S] 0 points 1 point 1 point (+1|-0) ago (edited ago)
Even though modern compilers optimize for either of these uses, I'm sure, the idea was that when post-incrementing (i++), 'i' here will return the value and then increment it, which apparently takes more time than pre-increment (++i) where you would increment and then get the new value.
Actually, I'm in the habit of pre-increment in the for-loops, I think it's more of an uncontrolled obsession than anything else...
[–] WhiteMakesRight 1 point -1 points 0 points (+0|-1) ago (edited ago)
It makes zero difference which of the two you use as the third expression in a for loop. Whenever you see someone prescribing rules without explaining their reasoning, it's a good idea to disregard everything they say.
[–] danielabrown ago
the both are perfect. once they are well utilized properly. normally on hackrypton.com there are so many tutorials that will help in securing things like that easily
[–] TheBuddha 0 points 1 point 1 point (+1|-0) ago
https://softwareengineering.stackexchange.com/questions/223313/style-guide-for-c
However, it's more important to be consistent. Whatever you go with, be consistent.
[–] WhiteMakesRight 1 point -1 points 0 points (+0|-1) ago
Consistency is irrelevant when you're talking about two different operators with different semantics though. Use the one you actually need.