İç içe geçmiş döngülerden nasıl çıkılır?

Bir breakifade kullanırsam , yalnızca iç döngüyü kırar ve dış döngüyü kırmak için biraz bayrak kullanmam gerekir. Ancak çok sayıda iç içe geçmiş döngü varsa, kod iyi görünmeyecektir.

Tüm döngüleri kırmanın başka bir yolu var mı? (Lütfen kullanmayın 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

Kullanım:

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

Hayır, eğlenceyi bir break. Bu kalan son geçerli kullanımdır goto;)

Bu değilse, derin iç içe döngülerden çıkmak için bayrakları kullanabilirsiniz.

Yuvalanmış bir döngüden çıkmanın başka bir yolu, her iki döngüyü de ayrı bir işleve ayırmak ve çıkmak istediğinizde bu işlevden geri dönmektir.

Özetlenmiş - iç içe döngülerden çıkmak için:

1. kullanım goto
2. bayrakları kullan
3. döngüleri ayrı işlev çağrılarına ayırın

Burada xkcd dahil olmaktan direnemedim :)

kaynak

Goto'lar zararlı olarak kabul edilir, ancak yorumlarda yer alan birçok kişinin söylediği gibi olması gerekmez. Mantıklı bir şekilde kullanılırsa harika bir araç olabilir. Ölçülü olarak kullanılan her şey eğlencelidir.

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

Bunun bir yolu, tüm iç içe döngüleri bir işleve koymak ve tüm döngülerden kopma ihtiyacı durumunda en içteki döngüden geri dönmek.

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

Bence gotosorunu çözecek

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

end:
stmt2 

 

Okunabilmesini istiyorsanız, bir boole değişkenine ihtiyacınız olacak:

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;
}

Daha az okunabilir olmasını istiyorsanız, boole değerlendirmesine katılabilirsiniz:

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

Nihai bir yol olarak, ilk döngüyü geçersiz kılabilirsiniz:

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

LLVM ekibinin bu akıllıca tavsiyesini kullanın:

"Tahmin Döngülerini Tahmin İşlevlerine Dönüştür"

Görmek:

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

Dikkat: Bu cevap gerçekten belirsiz bir yapıyı göstermektedir.

GCC kullanıyorsanız, bu kitaplığa göz atın . PHP'de olduğu gibi, breakçıkmak istediğiniz iç içe döngülerin sayısını kabul edebilir. Bunun gibi bir şey yazabilirsiniz:

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:

İ ve j değerlerine ihtiyacınız varsa, bu işe yaramalı, ancak diğerlerinden daha az performansla

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

Farklı bir yaklaşım, kodu iki for döngüsünden bir for döngüsüne ve bir manuel döngüye yeniden düzenlemektir. Bu şekilde manuel döngüdeki kesinti dış döngü için geçerlidir. Bunu , işlemek için üç iç içe döngü gerektiren bir Gauss-Jordan Eliminasyonunda bir kez kullandım .

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

MANUAL_LOOP:;

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

       j++;
       goto MANUAL_LOOP;
    }
}

Sorunun basitçe "Tüm döngüleri kırmanın başka bir yolu var mı?" Herhangi bir yeterlilik görmüyorum ama öyle değil goto, özellikle OP iyi bir yol istemedi . Peki, longjmpiç döngüden çıksak nasıl olur? :-)

#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);
}

setjmpİşlev iki kez döner. İlk kez 0 döndürür ve program iç içe yerleştirilmiş döngüleri çalıştırır. Daha sonra her ikisi ive j500 olduğunda, çalıştırılır longjmpve bu setjmpda döngüden atlayarak 1 değeriyle tekrar dönmesine neden olur .

longjmpSizi yalnızca iç içe geçmiş döngülerin dışına çıkarmakla kalmaz , aynı zamanda iç içe geçmiş işlevlerle de çalışır!

int i = 0, j= 0;

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

Her iki döngüyü de kıracak.

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);