Jak wyrwać się z zagnieżdżonych pętli?

Jeśli użyję breakinstrukcji, spowoduje to tylko przerwanie pętli wewnętrznej i muszę użyć flagi, aby przerwać pętlę zewnętrzną. Ale jeśli istnieje wiele zagnieżdżonych pętli, kod nie będzie dobrze wyglądał.

Czy jest inny sposób na przerwanie wszystkich pętli? (Proszę nie używać goto stmt.)

for(int i = 0; i < 1000; i++) {
   for(int j = 0; j < 1000; j++) {
       if(condition) {
            // both of the loops need to break and control will go to stmt2
       }
   }

}

stmt2

Posługiwać się:

if (condition) {
    i = j = 1000;
    break;
}

Nie, nie psuj zabawy plikiem break. To jest ostatnie ważne użycie goto;)

Jeśli nie to, możesz użyć flag, aby wyrwać się z głęboko zagnieżdżonych pętli.

Innym podejściem do wyrwania się z zagnieżdżonej pętli jest rozłożenie obu pętli na osobną funkcję i powrót z tej funkcji, gdy chcesz wyjść.

Podsumowanie - aby wyrwać się z zagnieżdżonych pętli:

1. posługiwać się goto
2. użyj flag
3. rozróżnij pętle na oddzielne wywołania funkcji

Nie mogłem się oprzeć włączeniu tutaj xkcd :)

źródło

Goto są uważane za szkodliwe, ale wiele osób w komentarzach sugeruje, że nie musi. Jeśli jest używany rozsądnie, może być świetnym narzędziem. Wszystko, co jest używane z umiarem, jest zabawne.

bool stop = false;
for (int i = 0; (i < 1000) && !stop; i++)
{
    for (int j = 0; (j < 1000) && !stop; j++)
    {
        if (condition)
            stop = true;
    }
}

Jednym ze sposobów jest umieszczenie wszystkich zagnieżdżonych pętli w funkcji i powrót z najbardziej wewnętrznej pętli na wypadek potrzeby wyrwania się ze wszystkich pętli.

function() 
{    
  for(int i=0; i<1000; i++)
  {
   for(int j=0; j<1000;j++)
   {
      if (condition)
        return;
   }
  }    
}

Myślę, że gotorozwiąże problem

for(int i = 0; i < 1000; i++) {
    for(int j = 0; j < 1000; j++) {
        if (condition) {
            goto end;
        }
    }
}

end:
stmt2 

 

Będziesz potrzebować zmiennej boolowskiej, jeśli chcesz, aby była czytelna:

bool broke = false;
for(int i = 0; i < 1000; i++) {
  for(int j = 0; j < 1000; i++) {
    if (condition) {
      broke = true;
      break;
    }
  }
  if (broke)
    break;
}

Jeśli chcesz, aby była mniej czytelna, możesz dołączyć do oceny boolowskiej:

bool broke = false;
for(int i = 0; i < 1000 && !broke; i++) {
  for(int j = 0; j < 1000; i++) {
    if (condition) {
      broke = true;
      break;
    }
  }
}

Ostatecznym sposobem na unieważnienie początkowej pętli jest:

for(int i = 0; i < size; i++) {
  for(int j = 0; j < 1000; i++) {
    if (condition) {
      i = size;
      break;
    }
  }
}

Skorzystaj z tej mądrej rady od zespołu LLVM:

„Zamień pętle predykatów w funkcje predykatów”

Widzieć:

http://llvm.org/docs/CodingStandards.html#turn-predicate-loops-into-predicate-functions

Uwaga: ta odpowiedź pokazuje naprawdę niejasną konstrukcję.

Jeśli używasz GCC, sprawdź tę bibliotekę . Podobnie jak w PHP, breakmoże zaakceptować liczbę zagnieżdżonych pętli, które chcesz zakończyć. Możesz napisać coś takiego:

for(int i = 0; i < 1000; i++) {
   for(int j = 0; j < 1000; j++) {
       if(condition) {
            // break two nested enclosing loops
            break(2);
       }
   }
}

for(int i = 0; i < 1000; i++) {
   for(int j = 0; j < 1000; i++) {
       if(condition) {
            goto end;
   }
} 

end:

Jeśli potrzebujesz wartości i i j, powinno to działać, ale z mniejszą wydajnością niż inne

for(i;i< 1000; i++){    
    for(j; j< 1000; j++){
        if(condition)
            break;
    }
    if(condition) //the same condition
        break;
}

Innym podejściem jest refaktoryzacja kodu z dwóch pętli for do pętli for i jednej pętli ręcznej. W ten sposób przerwa w pętli ręcznej dotyczy pętli zewnętrznej. Użyłem tego raz w eliminacji Gaussa-Jordana, która wymagała trzech zagnieżdżonych pętli do przetworzenia.

for (int i = 0; i < 1000; i++)
{
    int j = 0;

MANUAL_LOOP:;

    if (j < 1000)
    {
       if (condition)
       {
           break;
       }

       j++;
       goto MANUAL_LOOP;
    }
}

Zauważam, że pytanie brzmi po prostu: „Czy istnieje inny sposób na przerwanie wszystkich pętli?” Nie widzę żadnych zastrzeżeń, ale tak nie jest goto, w szczególności PO nie prosił o dobrą drogę. A co powiesz na longjmpwyjście z wewnętrznej pętli? :-)

#include <stdio.h>
#include <setjmp.h>

int main(int argc, char* argv[]) {
  int counter = 0;
  jmp_buf look_ma_no_goto;
  if (!setjmp(look_ma_no_goto)) {
    for (int i = 0; i < 1000; i++) {
      for (int j = 0; j < 1000; j++) {
        if (i == 500 && j == 500) {
          longjmp(look_ma_no_goto, 1);
        }
        counter++;
      }
    }
  }
  printf("counter=%d\n", counter);
}

setjmpZwraca dwukrotnie. Za pierwszym razem zwraca 0, a program wykonuje zagnieżdżone pętle for. Następnie, gdy oba ii jwynoszą 500, wykonuje się longjmp, co powoduje setjmppowrót z wartością 1, pomijając pętlę.

Nie tylko pozwala longjmpwydostać się z zagnieżdżonych pętli, ale działa również z zagnieżdżonymi funkcjami!

int i = 0, j= 0;

for(i;i< 1000; i++){    
    for(j; j< 1000; j++){
        if(condition){
            i = j = 1001;
            break;
        }
    }
}

Zerwie obie pętle.

for(int i = 0; i < 1000; i++) {
    for(int j = 0; j < 1000; i++) {
       if(condition) {
          func(para1, para2...);
          return;
       }
    }
}

func(para1, para2...) {
    stmt2;
}

i = 0;

do
{
  for (int j = 0; j < 1000; j++) // by the way, your code uses i++ here!
  {
     if (condition)
     {
       break;
     }
  }

  ++i;

} while ((i < 1000) && !condition);