Hacker News Reader

Comment by kenferry | Hacker News Reader

I know it's "too clever", but if I'm writing code no one else will ever see,

  while (i --> 0) {
      // use array[i]
  }

easy to read (if not understand), and correct!

View on HN

Oh I remember this from the classic SO post, but it was just presented as a funny trick. I never realized that it solves the issue mentioned in the article and there is a legitimate use-case for post-decrement in the comparison itself.

https://stackoverflow.com/questions/1642028/what-is-the-oper...

It's just spacing. X-- > 0 and X --> 0 are the same thing in C.

There is a reason postfix is the idiomatic way in C, it is the correct choice most of the time.

Swift (Lattner) was right, imo, to exclude both.

It's a well-known (ish) idiom that nobody uses. It's very entertaining though, for sure. In some circles it's known as the down-to operator.

I always use unsigned values and do:

  while (i-- != 0) { ... }

It's more clear than the most idiomatic way, which is to drop the explicit comparison:

  while (i--) { ... }

All of it is better than the clunky old for-loop syntax.

if `i` ever gets modified inside the loop, and skips 0 (e.g., got decremented twice when it is at 1), then you might end up with an infinite loop?

Usually, this won't happen of course, but because `i` is not declared inside a for-loop, it must have been declared outside, and thus might even look like a regular variable that could be used by some "clever" coding to multipurpose it!

In any case, it's a niche worry i have, so i usually don't do it if i know there's a for loop that would do.

There is nothing clearer about your way unless someone is just starting with C.

'while (i--)k is a shortcut, which might seem terse when one first encounters it, it is a well-established and trivial to understand construct. On the other hand, your embellishment only adds pointless friction when reading the code.

Never use unsigned values as your loop counter variables if you can help it. It is way too easy to underflow, and no one needs to iterate more than 2^31 or 2^63 times. You will die before exhausting int64.

And from this day, all C code will look like this because LLMs scraped the most popular SO articles.

Praise to the old gods and the new, why?!

This is why we never escape the cycle of rebirth.

I don't think it's too clever at all. Notably it works with both signed and unsigned i. Frankly if I see anyone doing anything other than this, they're wrong.

Code like this is why i prefer human code more than llm.

Reading code should be enjoyable.

Always.

(Hi Ken!)

The part I like is starting from the count rather than count-1. If n is 0, `i --> 0` never enters. Do `size_t i = n - 1` and a zero-length array wraps to SIZE_MAX first, which is the case that actually runs off the front.

Reply on news.ycombinator.com