What is the most elegant way to loop TWICE in C

Question

Many times I need to do things TWICE in a for loop. Simply I can set up a for loop with an iterator and go through it twice.

for (i = 0; i < 2; i++)
{
 // Do stuff
}

Now I am interested in doing this as SIMPLY as I can, perhaps without an initializer or iterator ... or any really simple and elegant way ...

How would you do it?

x

Answer 1

If its only twice, and you want to avoid a loop, just write the darn thing twice.

statement1;
statement1;  // (again)

Answer 2

What abelenky said.

And if your { // Do stuff } is multi-line, make it a function, and call that function -- twice.

Answer 3

Encapsulate it in a function and call it twice.

void do_stuff() {
  // Do Stuff
}

// .....

do_stuff();
do_stuff();

Note: if you use variables or parameters of the enclosing function in the stuff logic, you can pass them as arguments to the extracted do_stuff function.

Answer 4

If what you are doing is somewhat complicated wrap it in a function and call that function twice? (This depends on how many local variables your do stuff code relies on).

You could do something like

void do_stuff(int i){
    // do stuff
}

do_stuff(0);
do_stuff(1);

But this may get extremely ugly if you are working on a whole bunch of local variables.

Answer 5

Use function:

func();
func();

Or use macro (not recommended):

#define DO_IT_TWICE(A) A; A

DO_IT_TWICE({ x+=cos(123); func(x); })

Answer 6

If your compiler supports this just put the declaration inside the for statement:

for (unsigned i = 0; i < 2; ++i)
{
 // Do stuff
}

This is as elegant and efficient as it can be. Modern compilers can do loop unrolling and all that stuff, trust them. If you don't trust them, check the assembler.

And it has one little advantage to all other solutions, for everybody it just reads, "do it twice".

Answer 7

If the loop is too verbose for you, you can also define an alias for it:

#define TWICE for (int _index = 0; _index < 2; _index++)

This would result into that code:

TWICE {
    \\ Do Stuff
}

// or

TWICE
    func();

I would only recommend to use this macro if you have to do this very often, I think else the plain for-loop is more readable.

Answer 8

jump instruction is pretty slow,so if you write the lines one after the other,it would work faster,than writing a loop. but modern compilers are very,very smart and the optimizations are great (if they are allowed,of course). if you have turned on your compiler's optimizations,you don't care the way,you write it - with loop or not (:

EDIT : http://en.wikipedia.org/wiki/compiler_optimizations just take a look (:

Answer 9

Good rule: three or more, do a for.

I think I read that in Code Complete, but I could be wrong. So in your case you don't need a for loop.

Answer 10

//dostuff
  stuff;
//dostuff (Attention I am doing the same stuff for the :**2nd** time)
  stuff;

Answer 11

This is elegant because it looks like a triangle; and triangles are elegant.

i = 0; 
here: dostuff(); 
i++; if ( i == 1 ) goto here;

Answer 12

First, use a comment

/* Do the following stuff twice */

then,
1) use the for loop
2) write the statement twice, or
3) write a function and call the function twice
do not use macros, as earlier stated, macros are evil.

(My answer's almost a triangle)

Answer 13

void loopTwice (bool first = true)
{
    // Recursion is your friend
    if (first) {loopTwice(false);}

    // Do Stuff
    ...
}

I'm sure there's a more elegant way, but this is simple to read, and pretty simply to write. There might even be a way to eliminate the bool parameter, but this is what I came up with in 20 seconds.

Answer 14

Many people suggest writing out the code twice, which is fine if the code is short. There is, however, a size of code block which would be awkward to copy but is not large enough to merit its own function (especially if that function would need an excessive number of parameters). My own normal idiom to run a loop 'n' times is

  i = number_of_reps;
  do
  {
    ... whatever
  } while(--i);

In some measure because I'm frequently coding for an embedded system where the up-counting loop is often inefficient enough to matter, and in some measure because it's easy to see the number of repetitions. Running things twice is a bit awkward because the most efficient coding on my target system

  bit rep_flag;

  rep_flag = 0;
  do
  {
    ...
  } while(rep_flag ^= 1); /* Note: if loop runs to completion, leaves rep_flag clear */

doesn't read terribly well. Using a numeric counter suggests the number of reps can be varied arbitrarily, which in many instances won't be the case. Still, a numeric counter is probably the best bet.

Answer 15

What about this??

void DostuffFunction(){}

for (unsigned i = 0; i < 2; ++i, DostuffFunction());

Regards, Pablo.

Answer 16

Unfortunately, this is not for C, but for C++ only, but does exactly what you want:

Just include the header, and you can write something like this:

10 times {
  // Do stuff
}

I'll try to rewrite it for C as well.

Answer 17

What is elegance? How do you measure it? Is someone paying you to be elegant? If so how do they determine the dollar-to-elegance conversion?

When I ask myself, "how should this be written," I consider the priorities of the person paying me. If I'm being paid to write fast code, control-c, control-v, done. If I'm being paid to write code fast, well.. same thing. If I'm being paid to write code that occupies the smallest amount of space on the screen, I short the stock of my employer.

Answer 18

Assuming C++0x lambda support:

template <typename T> void twice(T t)
{
    t();
    t();
}

twice([](){ /*insert code here*/ });

Or:

twice([]()
{ 
    /*insert code here*/ 
});

Which doesn't help you since you wanted it for C.

Answer 19

Close to your example, elegant and efficient:

for (i = 2; i; --i)
{
    /* Do stuff */
}

Here's why I'd recommend that approach:

• It initializes the iterator to the number of iterations, which makes intuitive sense.
• It uses decrement over increment so that the loop test expression is a comparison to zero (the "i;" can be interpreted as "is i true?" which in C means "is i non-zero"), which may optimize better on certain architectures.
• It uses pre-decrement as opposed to post-decrement in the counting expression for the same reason (may optimize better).
• It uses a for loop instead of do/while or goto or XOR or switch or macro or any other trick approach because readability and maintainability are more elegant and important than clever hacks.
• It doesn't require you to duplicate the code for "Do stuff" so that you can avoid a loop. Duplicated code is an abomination and a maintenance nightmare.

If "Do stuff" is lengthy, move it into a function and give the compiler permission to inline it if beneficial. Then call the function from within the for loop.