Takes 1 more character, that's bloat.
You forgot to increment your brain's i :P
You can imagine me debuging and going "huh π€¨, I wrote this, what the hell was I thinking π€¦"... it's no fun actually, you rewrite stuff all the time π€·. It's like my brain goes π₯³ for about 10 minutes or so and just does random stupid things.
Isn't the evaluated value different from the expression? i++ returns the value of i before increasing. i-=-1 would return the value after it has been increased. Wouldn't it be more correct to make it equal to ++i
And that's why post- and pre-increment is non-existant in Python and Rust. It's an easy source for bugs for a noncritical abbreviationπ€·
I love iterators so much.
I gave it a shot in Compiler Explorer, with the following code:
#include <stdio.h>
int main() {
for (int i = 0; i < 10; i -= -1) {
printf("%d", i);
}
}
GCC takes the i-=-1 and optimizes it into ADD DWARD PTR [rbp-4], 1, and changing it around to ++i or i++ makes no difference.
So, at least in C and C++, it works all the same. Even on unsigned integers.
It works the same because the value of the last expression in the for loop is not used for anything. It's the side effect of that statement that counts. Eg, the value of i is checked the next time the for loop is executed by the condition check. Try replacing i in the condition check instead with i++ or ++i and you would see different results.
Something like: for (int i = 0; ++i < 10;) { ... }
this is incredibly cursed. i love it.
That won't work if i is unsigned.
Huh. I had to think about it for a moment, but you're right. If the two's-complement representation of -1 is reinterpreted as an unsigned integer and added to another unsigned integer of the same size, it'll wrap all the way around, effectively adding -1.
It's an interesting property of two's complement that you don't usually think about when you're using a strongly-typed language where such shenanigans aren't allowed. I imagine compiler and assembly people are well aware of it, though.
For anyone following along and wondering how this works, here's a quick explanation. Suppose you've got a device that can calculate the sum of any two integers between 0 and 99. If it calculates a sum greater than 99, it wraps around. For example, if you tell it to calculate 99 + 1, you get 0.
Now, suppose you want to add negative integers with this thing. You'll pretend that 99 actually means -1, 98 actually means -2, and so on, for every number between 50 and 99. 0 through 49 will represent positive numbers, and 50 through 99 will represent negative numbers.
So, what if you add 5 and -1? Well, 5 is itself, -1 is 99, and the device wraps around when it calculates a sum greater than 99, so if you add 5 and 99, you getβ¦4! It correctly adds your pretend negative numbers without you having to do anything extra.
This is pretty much the same as how computers work, except binary instead of decimal.
I came here to laugh at the no at the end π€£π€£
I saw while(i --> 0) in someone else's code and thought wth is this --> operator? Then I realized it's while(i-- > 0) and thought cool, I gotta do this!
Someone forgot to set their phone to do not disturb
@programming.dev
Welcome to Programmer Humor!
This is a place where you can post jokes, memes, humor, etc. related to programming!
For sharing awful code theres also Programming Horror.
go to feed...
@programming.dev
Welcome to Programmer Humor!
This is a place where you can post jokes, memes, humor, etc. related to programming!
For sharing awful code theres also Programming Horror.
go to feed...
Thanks, i hate it
save