Question

Adam Ko has provided a magnificent solution to this question, thanks Adam Ko.

BTW if, like me, you love the c preprocessor (the thing that handles #defines), you may not be aware there is a handy thing in XCode: right click on the body of one of your open source files, go down near the bottom .. "Preprocess". It actually runs the preprocessor, showing you the overall "real deal" of what is going to be compiled. It’s great!

---

This question is a matter of style and code clarity. Consider it similar to questions about subtle naming issues, or the best choice (more readable, more maintainable) among available idioms.

As a matter of course, one uses loops like this:

for(NSUInteger _i=0; _i<20; ++_i)
  {
  .. do this 20 times ..
  }

To be clear, the effect is to to do something N times. (You are not using the index in the body.)

I want to signal clearly for the reader that this is a count-based loop — ie, the index is irrelevant and algorithmically we are doing something N times.

Hence I want a clean way to do a body N times, with no imperial entanglements or romantic commitments. You could make a macro like this:

 #define forCount(N) for(NSUinteger __neverused=0; __neverused<N; ++__neverused)

and that works. Hence,

forCount(20)
  {
  .. do this 20 times ..
  }

However, conceivably the "hidden" variable used there could cause trouble if it collided with something in the future. (Perhaps if you nested the control structure in question, among other problems.)

To be clear efficiency, etc., is not the issue here. There are already a few different control structures (while, do, etc etc) that are actually of course exactly the same thing, but which exist only as a matter of style and to indicate clearly to the reader the intended algorithmic meaning of the code passage in question. "forCount" is another such needed control structure, because "index-irrelevant" count loops are completely basic in any algorithmic programming.

Does anyone know the really, really, REALLY cool solution to this? The #define mentioned is just not satisfying, and you’ve thrown in a variable name that inevitably someone will step on.

Thanks!

---

Later…

A couple of people have asked essentially "But why do it?"

Look at the following two code examples:

for ( spaceship = 3; spaceship < 8; ++spaceship )
   {
   beginWarpEffectForShip( spaceship )
   }

forCount( 25 )
   {
   addARandomComet
   }

Of course the effect is utterly and dramatically different for the reader.

After all, there are alresdy numerous (totally identical) control structures in c, where the only difference is style: that is to say, conveying content to the reader.

We all use "non-index-relative" loops ("do something 5 times") every time we touch a keyboard, it’s as natural as pie.

So, the #define is an OKish solution, is there a better way to do it? Cheers

Answer 1

A better way is to do this to allow nested forCount structure –

#define $_TOKENPASTE(x,y)   x##y
#define $$TOKENPASTE(x,y)   $_TOKENPASTE(x, y)

#define $itr          $$TOKENPASTE($_itr_,__LINE__)
#define forCount(N)   for (NSUInteger $itr=0; $itr<N; ++$itr)

Then you can use it like this

forCount(5)
{
    forCount(10)
    {
        printf("Hello, World!\n");
    }
}

Edit:
The problem you suggested in your comment can be fixed easily. Simply change the above macro to become

#define $_TOKENPASTE(x,y)   x##y
#define $$TOKENPASTE(x,y)   $_TOKENPASTE(x, y)

#define UVAR(var)           $$TOKENPASTE(var,__LINE__)
#define forCount(N)         for (NSUInteger UVAR($itr)=0, UVAR($max)=(NSUInteger)(N); \
                                 UVAR($itr)<UVAR($max); ++UVAR($itr))

What it does is that it reads the value of the expression you give in the parameter of forCount, and use the value to iterate, that way you avoid multiple evaluations.