Yes: that loop is miserable and we should upgrade it to use size_t (and preferably ++i), at which point the undefined behavior required to make that abomination fast wouldn't matter anymore.

Why would you prefer to preincrement an integer? Too much time around C++ iterators?

I mean, why would you ever prefer to post-increment an integer whose prior value you didn't need? Not enough time studying iterators to make that distinction obvious, perhaps? Regardless, the context here is that we should stop relying so much on the compiler to paper over differences in code that don't by the user anything except a form of quaint familiarity with old code: the i++ relies on the optimizer knowing it doesn't have to keep the prior value, while ++i doesn't, and yet somehow I guess you are enamored with i++ despite it being exactly the same characters to type, merely in a different order. Stop using int, stop using post-increment, and sure: maybe even stop using < when you semantically want != (though I explicitly didn't go there because that isn't--as far as I know--going to affect the performance with a dumber compiler).

Pattern matching is a big thing in programming. Not in C++, as ++i executes arbitrary code found an unbounded distance from the programmer (so ++i vs i++ might be a very important distinction) but in other languages it helps a lot.

  for (int i=0, j=0; i < N && j < M; i+=2, j++)

i++ looks like i+=1 so fits better in loops iterating over multiple things.

Also that int says "these values don't overflow" very concisely and the more modern cleverer C++ using iterator facades probably fails to communicate that idea to anyone.

edit: amused to note on checking for typos that I wrote that with < instead of != which violates your other recommendation, which is one I'm in favour of in theory but apparently don't write out by default.

> Do you want a warning on every for (int i = 0; i < n; i++)

If n is of type size_t, yes please!

Also every for (size_t i = sizeof(var)-1; i >= 0; --i)

(I've been burned by that one more often than I want to publicly admit).

Neither of those things are undefined behavior, but gcc with -Wextra already warns about both:

    warn.c:6:21: warning: comparison of integer expressions of different signedness: ‘int’ and ‘size_t’ {aka ‘long unsigned int’} [-Wsign-compare]
        6 |   for (int i = 0; i < n; i++)
          |                     ^

    warn.c:10:36: warning: comparison of unsigned expression >= 0 is always true [-Wtype-limits]
       10 |   for (size_t i = sizeof(var)-1; i >= 0; --i)
          |                                    ^~

Certain compiler settings do produce a warning there, yeah. It’s annoying but an easy fix/habit to change.