[–] 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?
[–] 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.
[–] 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...
[–] 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.
[–] WhiteMakesRight ago
Who cares. CoffeeScript took "nice" syntax to it's logical conclusions and ended up with the ugliest and most unreadable language ever created.
[–] 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
[–] RicardoBronson ago (edited ago)
They both suck because of unspecified behavior in some situations. And usually when you want it least. Like for loops using pointers. Trust me, just say "counter += 1" and you will never have to know the pain EDIT: Actually why bother trusting me, do a search: https://www.google.com/search?hl=en&q=postfix%20increment%20unspecified%20behavior
[–] WhiteMakesRight 1 point -1 points 0 points (+0|-1) ago (edited ago)
The operators have nothing to do with the unspecified behaviour you're talking about though -- they're just a succinct way to trigger it. What's actually unspecified is the order of evaluation of function arguments -- which is something you should be aware of even if you never use increment operators.
Not using increment operators at all is a typical example of "scarring on the first cut". If you're going to write software in C, rules-of-thumb will only get you so far. At some point, you have to read and understand the specification in depth.
[–] RicardoBronson ago
I take more of a "when in doubt, do it in python" approach because life is just too short to spend on specifications :) But I'm sure you're right
[–] boredTech 2 points -1 points 1 point (+1|-2) ago
Dumbest argument of all time. Both operations are in O(K) time. Who gives a fuck?