여러 개의 중첩 된 'for'루프를 종료하기 위해 break를 사용할 수 있습니까?

break함수 를 사용하여 여러 개의 중첩 for루프 를 종료 할 수 있습니까?

그렇다면 어떻게 하시겠습니까? break출구의 루프 수를 제어 할 수 있습니까 ?

AFAIK, C ++는 Java 및 기타 언어처럼 이름 지정 루프를 지원하지 않습니다. goto를 사용하거나 사용하는 플래그 값을 만들 수 있습니다. 각 루프의 끝에서 플래그 값을 확인하십시오. true로 설정되면 해당 반복에서 벗어날 수 있습니다.

아니요,로 망치지 마십시오 break. 사용에 대한 마지막 남은 요새입니다 goto.

람다를 사용하여 명시 적 답변을 추가하려면 다음을 수행하십시오.

  for (int i = 0; i < n1; ++i) {
    [&] {
      for (int j = 0; j < n2; ++j) {
        for (int k = 0; k < n3; ++k) {
          return; // yay we're breaking out of 2 loops here
        }
      }
    }();
  }

물론이 패턴에는 특정 제한이 있으며 분명히 C ++ 11 만 있지만 매우 유용하다고 생각합니다.

중첩 루프를 해제하는 또 다른 방법은 두 루프를 별도의 함수로 분리 return하고 종료하려는 경우 해당 함수에서 분리 하는 것입니다.

물론 이것은 return끝 이외의 다른 곳에서 함수에서 명시 적으로 해야하는지 여부에 대한 또 다른 논쟁을 불러옵니다 .

break 는 그것을 포함하는 가장 안쪽의 루프 만 빠져 나옵니다.

goto 를 사용 하여 여러 루프에서 벗어날 수 있습니다 .

물론 goto 는 종종 유해한 것으로 간주 됩니다.

브레이크 기능 [...]을 사용하는 것이 적절합니까?

break와 goto를 사용하면 프로그램의 정확성에 대해 추론하기가 더 어려워 질 수 있습니다. 이에 대한 토론은 여기를 참조하십시오 : Dijkstra는 미쳤다 .

이 answear가 이미 제시되었지만 좋은 접근 방식은 다음을 수행하는 것입니다.

for(unsigned int z = 0; z < z_max; z++)
{
    bool gotoMainLoop = false;
    for(unsigned int y = 0; y < y_max && !gotoMainLoop; y++)
    {
        for(unsigned int x = 0; x < x_max && !gotoMainLoop; x++)
        {
                          //do your stuff
                          if(condition)
                            gotoMainLoop = true;
        }
    }

}

이건 어때요?

for(unsigned int i=0; i < 50; i++)
{
    for(unsigned int j=0; j < 50; j++)
    {
        for(unsigned int k=0; k < 50; k++)
        {
            //Some statement
            if (condition)
            {
                j=50;
                k=50;
            }
        }
    }
}

goto중첩 루프에서 벗어나는 레이블을 사용하는 코드 예제 :

for (;;)
  for (;;)
    goto theEnd;
theEnd:

여러 개의 중첩 루프를 제거하는 좋은 방법 중 하나는 코드를 함수로 리팩터링하는 것입니다.

void foo()
{
    for(unsigned int i=0; i < 50; i++)
    {
        for(unsigned int j=0; j < 50; j++)
        {
            for(unsigned int k=0; k < 50; k++)
            {
                // If condition is true
                return;
            }
        }
    }
}

goto는 중첩 루프를 끊는 데 매우 도움이 될 수 있습니다

for (i = 0; i < 1000; i++) {
    for (j = 0; j < 1000; j++) {
        for (k = 0; k < 1000; k++) {
             for (l = 0; l < 1000; l++){
                ....
                if (condition)
                    goto break_me_here;
                ....
            }
        }
    }
}

break_me_here:
// Statements to be executed after code breaks at if condition

break문은 가장 가까운 바깥 쪽의 실행 종료 do, for, switch, 또는 while이 나타나는 문을. 제어는 종료 된 명령문 다음에 나오는 명령문으로 전달됩니다.

에서 MSDN .

goto이 상황에서 a 가 유효 하다고 생각합니다 .

break/ 를 시뮬레이트하려면 continue다음을 원합니다.

단절

for ( ;  ;  ) {
    for ( ;  ;  ) {
        /*Code here*/
        if (condition) {
            goto theEnd;
        }
    }
}
theEnd:

계속하다

for ( ;  ; ) {
    for ( ;  ;  ) {
        /*Code here*/
        if (condition) {
            i++;
            goto multiCont;
        }
    }
    multiCont:
}

PHP와 같은 다른 언어는 break (즉, break 2;)에 대한 매개 변수를 허용하여 중단하려는 중첩 루프 수준을 지정하지만 C ++에서는 그렇지 않습니다. 루프 전에 false로 설정 한 부울을 사용하고, 중단하려는 경우 루프에서 true로 설정 한 부울을 사용하고, 중첩 된 루프 다음에 조건부 나누기, 부울이 true로 설정되었는지 확인하여이를 해결해야합니다. 그렇다면 예.

나는 이것이 오래된 포스트라는 것을 안다. 그러나 나는 조금 논리적이고 간단한 대답을 제안 할 것입니다.

for(unsigned int i=0; i < 50; i++)
    {
        for(unsigned int j=0; j < conditionj; j++)
        {
            for(unsigned int k=0; k< conditionk ; k++)
            {
                // If condition is true

                j= conditionj;
               break;
            }
        }
    }

하나의 bool변수로 여러 루프를 분리 하십시오 (아래 참조).

bool check = true;

for (unsigned int i = 0; i < 50; i++)
{
    for (unsigned int j = 0; j < 50; j++)
    {
        for (unsigned int k = 0; k < 50; k++)
        {
            //Some statement
            if (condition)
            {
                check = false;
                break;
            }
        }
        if (!check)
        {
            break;
        }
    }
    if (!check)
    {
        break;
    }
}

이 코드에서 우리는 break;모든 루프입니다.

그만한 가치가 있는지 확실하지 않지만 몇 가지 간단한 매크로를 사용하여 Java의 명명 된 루프를 에뮬레이션 할 수 있습니다.

#define LOOP_NAME(name) \
    if ([[maybe_unused]] constexpr bool _namedloop_InvalidBreakOrContinue = false) \
    { \
        [[maybe_unused]] CAT(_namedloop_break_,name): break; \
        [[maybe_unused]] CAT(_namedloop_continue_,name): continue; \
    } \
    else

#define BREAK(name) goto CAT(_namedloop_break_,name)
#define CONTINUE(name) goto CAT(_namedloop_continue_,name)

#define CAT(x,y) CAT_(x,y)
#define CAT_(x,y) x##y

사용법 예 :

#include <iostream>

int main()
{
    // Prints:
    // 0 0
    // 0 1
    // 0 2
    // 1 0
    // 1 1

    for (int i = 0; i < 3; i++) LOOP_NAME(foo)
    {
        for (int j = 0; j < 3; j++)
        {
            std::cout << i << ' ' << j << '\n';
            if (i == 1 && j == 1)
                BREAK(foo);
        }
    }
}

다른 예시:

#include <iostream>

int main()
{
    // Prints: 
    // 0
    // 1
    // 0
    // 1
    // 0
    // 1

    int count = 3;
    do LOOP_NAME(foo)
    {
        for (int j = 0; j < 3; j++)
        {
            std::cout << ' ' << j << '\n';
            if (j == 1)
                CONTINUE(foo);
        }
    }
    while(count-- > 1);
}

  while (i<n) {
    bool shouldBreakOuter = false;
    for (int j=i + 1; j<n; ++j) {
      if (someCondition) {
          shouldBreakOuter = true;
      }
    }

    if (shouldBreakOuter == true)
      break;

  }

try ... catch를 사용할 수 있습니다.

try {
    for(int i=0; i<10; ++i) {
        for(int j=0; j<10; ++j) {
            if(i*j == 42)
                throw 0; // this is something like "break 2"
        }
    }
}
catch(int e) {} // just do nothing
// just continue with other code

한 번에 여러 루프에서 벗어나야하는 경우 종종 예외입니다.

for-loop의 의미는 일반적으로 지정된 횟수만큼 실행됨을 나타 내기 때문에 for-loop를 해제하는 것은 조금 이상합니다. 그러나 모든 경우에 나쁘지는 않습니다. 컬렉션에서 무언가를 검색하고 그것을 찾은 후에 깨고 싶다면 유용합니다. 그러나 C ++에서는 중첩 루프를 해제 할 수 없습니다. 레이블이 지정된 구분을 사용하여 다른 언어로되어 있습니다. 라벨과 고토를 사용할 수 있지만 밤에 가슴 앓이를 줄 수 있습니다. 그래도 가장 좋은 옵션 인 것 같습니다.