C++ best way to break out of nested for loops

for a ......

for b .....

if (some_condition)

// break out of both loops

a break will get you out of the inner loop.

but i think only goto will get you out of both, without returning that is.

Put it in the loop statement rather than use break.

for( a = a_init; a != a_end && !condition; a = a_next )
  for( b = b_init; b != b_end && !condition; b = b_next )
    ...

Or break the algorithm out into it's own function and use return.

return always seems cleanest to me.

Or break the algorithm out into it's own function and use return.

return always seems cleanest to me.

yeah, that's what i usually do.

but its just a stupid little nested loop to iterate over a collision map and find the first passable node for use as a test goal for the new A* code in Caveman 3.0.

i'll make it a function call with return.

its faster than looking up goto syntax, and cleaner than stuffing it into the for() statement.

some "patterns" never change, eh?

some "patterns" never change, eh?

void test()
{
  printf( "start\n" );
  for( int x=0; x!=10; ++x )
    for( int y=0; y!=10; ++y )
      if( x == y && x == 5 )
        goto double_break;
      else
        printf( "%d, %d\n", x, y );
  double_break:
  printf( "end\n" );
}

void test()
{
  printf( "start\n" );
  [](){
  for( int x=0; x!=10; ++x )
    for( int y=0; y!=10; ++y )
      if( x == y && x == 5 )
        return;
      else
        printf( "%d, %d\n", x, y );
  }();
  printf( "end\n" );
}

In 2016 can be written as:

less keystrokes, but lower on read-ability too.

just an observation.

Lol yeah you'd never write either of those two bits of code, hopefully :lol:

The lambda syntax comes in handy when you want to reuse a bit of code, but don't want to bother actually breaking it out into it's own independent function, yet. e.g.

void test()
{
  int sum = 0;
  auto SumArray = [&](int* data, int size){
    for( int i=0; i!=size; ++i )
      sum += data[i];
  };
  for( int widgetIdx=0; widgetIdx != numWidgets; ++widgetIdx )
    SumArray( widgets[widgetIdx].data, widgets[widgetIdx].size );
  SumArray( specialWidget.data, specialWidget.size );
  printf( "%d\n", sum );
}

which is shorthand for:

void test()
{
  int sum = 0;
  struct _ { _(int& sum):sum(sum){}int& sum;
    void operator()(int* data, int size){
      for( int i=0; i!=size; ++i )
        sum += data[i];
    };
  }SumArray(sum);
  for( int widgetIdx=0; widgetIdx != numWidgets; ++widgetIdx )
    SumArray( widgets[widgetIdx].data, widgets[widgetIdx].size );
  SumArray( specialWidget.data, specialWidget.size );
  printf( "%d\n", sum );
}

or the more obvious, actually breaking it out into it's own separate function:

namespace { void SumArray(int* data, int size, int& sum){
  for( int i=0; i!=size; ++i )
    sum += data[i];
};}
void test()
{
  int sum = 0;
  for( int widgetIdx=0; widgetIdx != numWidgets; ++widgetIdx )
    SumArray( widgets[widgetIdx].data, widgets[widgetIdx].size, sum );
  SumArray( specialWidget.data, specialWidget.size, sum );
  printf( "%d\n", sum );
}