C++,이 goto 문이 보증되어 있습니까?

Question

좀 더 적절한 질문이라고 생각해서 약간의 제목을 변경했습니다.

리팩터링 하시겠습니까 (goto의 합법적 인 사용처럼 보입니까)? go 명령문을 제거하려면 다음 코드를 어떻게 리팩토링합니까?

#ifdef HAVE_GPU 
      // attempt to use GPU device 
      if (data.device) { 
       try { 
        Integral::Gpu eri(S, R, Q, block.shell()); 
        eri(basis.centers(), quartets, data.device); 
       } 
       // if GPU fails, propagate to cpu 
       catch(std::exception) { goto done; } 
       data.device += size; 
       host_index.extend(block_index); 
       block_index.data.clear(); 
      done: ; 
      } 
#endif 

if (data.device) { 
    try { 
     ... 
    } 
    catch(const std::exception&) { goto done; } 
    ... // more things which should not be caught 
done: ; 
} 

완전한 문을 사용하면

대부분의 선호도를 본 후, 나는 플래그와 함께 가기로 결정하지만, 씨 뉴욕의 의견에 감사드립니다.

감사합니다 모두

Answer 1

if (data.device) 
{ 
    bool status = true; 

    try 
    { 
     ... 
    } 
    catch(std::exception) 
    { 
     status = false; 
    } 

    if (status) 
    { 
    ... // more things which should not be caught 
    } 
} 

Answer 2

if 외부에서 예외를 catch 할 수 있습니까?

Answer 3

if (data.device) { 
    bool ok = true; 
    try { 
     ... 
    } 
    catch(std::exception) { ok = false; } 

    if(ok) { 
     ... // more things which should not be caught 
    } 
} 

Answer 4

당신은 예외를 잡아 조건 블록 외부에서 처리 할 수있는 특정 예외를 다시 발생 할 수 있습니다.

// obviously you would want to name this appropriately... 
struct specific_exception : std::exception { }; 

try { 
    if (data.device) { 
     try { 
      // ... 
     } 
     catch(const std::exception&) { 
      throw specific_exception(); 
     } 

     // ... more things which should not be caught ... 
    } 
} 
catch (const specific_exception&) { 
    // handle exception 
} 

Answer 5

일부 플래그를 사용하고 조건문을 추가하는 것은 어떨까요?

int caught = 0; 
if (data.device) { 
    try { 
     /* ... */ 
    } catch (std::exception e) { caught = 1; } 
    if (!caught) { 
     // more stuff here 
    } 
    // done: ... 
} 

Answer 6

첫 번째 : goto는 본질적으로 위험하지 않습니다. 당신의 코드에 "goto"라는 글자가없는 순수한 술을 리펙토링하는 것은 말도 안됩니다. 같은 것을 고토보다 깔끔하게 처리 할 수있는 것으로 리팩토링하는 것이 좋습니다. 나쁜 디자인을 더 나은 것으로 바꾸거나 고토 또는 교체를 필요로하지 않는 디자인으로 바꾸는 것도 좋습니다.

내가 말했듯이, 귀하의 코드는 마침내 발명 된 것과 같습니다. 너무 슬픈 C++에는 이와 같은 것이 없습니다 ... 그래서 가장 쉬운 해결책은 그것을 그대로 두는 것입니다.

Answer 7

일부 조건에 따라 종료해야하는 코드가있는 경우 필자가 선호하는 구성은 "do {} while (0)"루프를 사용하고 적절한 경우 "중단"을 사용하는 것입니다. 나는 무엇이 붕괴하는지 모른다. 그래도 잡을 것입니다. "중단"이 작동하지 않으면 "goto"가 최선의 방법 일 수 있습니다.

Answer 8

catch(std::exception) { return; } 

트릭을 수행해야합니다. 나는 물론 done이 실제로 함수의 끝 부분에 있다고 가정합니다.

예외가 발생할 때 추가 코드를 실행해야하는 경우 상태를 반환하거나보다 적절한 추상화 수준의 예외를 throw합니다 (James의 대답 참조).

나는 같은 것을 상상 해요 : try 블록 내부의 추가 코드를 이동하지 왜

doStuff(...) { 
    bool gpuSuccess = doGPUStuff(...); 
    if (!gpuSuccess) { 
     doCPUStuff(...); 
    } 
} 

Answer 9

?

#ifdef HAVE_GPU 
      // attempt to use GPU device 
      if (data.device) { 
       try { 
        Integral::Gpu eri(S, R, Q, block.shell()); 
        eri(basis.centers(), quartets, data.device); 
        data.device += size; 
        host_index.extend(block_index); 
        block_index.data.clear(); 
       } 
       // if GPU fails, propagate to cpu 
       catch(std::exception) { /* handle your exception */; } 
      } 
#endif 

Answer 10

을 나는이의 변형이 당신을 위해 일 것 같아요.

// attempt to use GPU device 
if (data.device) 
{ 
    try 
    { 
     Integral::Gpu eri(S, R, Q, block.shell()); 
     eri(basis.centers(), quartets, data.device); 

     data.device += size; 
     host_index.extend(block_index); 
     block_index.data.clear(); 
    } 
    catch (const std::bad_alloc&) 
    { 
     // this failure was not because 
     // of the GPU, let it propagate 
     throw; 
    } 
    catch(...) 
    { 
     // handle any other exceptions by 
     // knowing it was the GPU and we 
     // can fall back onto the CPU. 
    } 
} 

// do CPU 

는 GPU 라이브러리를 편집하고 모든 GPU 예외를 gpu_exception 같은 몇 가지 기본을 줄 수 있다면, 코드는 훨씬 간단하게 이러한 작업의 지옥, 내가 생각하는 경우

// attempt to use GPU device 
if (data.device) 
{ 
    try 
    { 
     Integral::Gpu eri(S, R, Q, block.shell()); 
     eri(basis.centers(), quartets, data.device); 

     data.device += size; 
     host_index.extend(block_index); 
     block_index.data.clear(); 
    } 
    catch (const gpu_exception&) 
    { 
     // handle GPU exceptions by 
     // doing nothing and falling 
     // back onto the CPU. 
    } 

    // all other exceptions, not being 
    // GPU caused, may propagate normally 
} 

// do CPU 

는 차선책이다 Steve's answer.

Answer 11

깃발을 조금씩 사용합니다. 나는 Amardeep보다 낫다고 생각합니다.

전체 지점 예외가 마지막 항목이 작동했는지 여부를 확인하지 않기 때문에 예외가 전파되었는지 여부를 나타내는 플래그보다 오히려 마지막 것이 작동했는지 여부를 나타내는 플래그보다 플래그를 사용합니다. 아이디어는 우리가 이것을 가지고 있다면, 모든 것이 작동하고 계속할 수 있도록 코드를 작성하는 것입니다.

#ifdef HAVE_GPU 
    // attempt to use GPU device 
    if (data.device) { 
     bool dont_catch = false; 
     try { 
      ... 
      dont_catch = true; 
      ... // more things which should not be caught 
     } catch (...) { 
      if (dont_catch) throw; 
     } 
    } 
#endif 

Answer 12

오전 뭔가 누락, 또는이 try 블록 내부의 catch와 done: 라벨의 일부를 이동 동등하지 않을까요?

#ifdef HAVE_GPU 
      // attempt to use GPU device 
      if (data.device) { 
       try { 
        Integral::Gpu eri(S, R, Q, block.shell()); 
        eri(basis.centers(), quartets, data.device); 
        data.device += size; 
        host_index.extend(block_index); 
        block_index.data.clear(); 
       } 
       // if GPU fails, propagate to cpu 
       catch(std::exception) {} 
      } 
#endif 

Answer 13

그 자체의 기능/방법 (그 이후의 모든 것을 포함)으로 분해하고 return 키워드를 사용하십시오. 모든 변수가 소멸자를 가지거나 스택 할당 (또는 피할 수없는 경우 똑똑한 지적)되는 한 괜찮습니다. 나는 지속적인 플래그 검사보다는 조기 종료 함수/메소드에 대한 큰 팬이다. 예를 들어

:

void myFunc() 
{ 
    String mystr("heya"); 
    try 
    { 
     couldThrow(mystr); 
    } 
    catch(MyException& ex) 
    { 
     return; // String mystr is freed upon returning 
    } 

    // Only execute here if no exceptions above 
    doStuff(); 
} 

이 방법이 잘못 어렵다

Answer 14

오늘에 눈살을 찌푸렸다되는 이유 고토 우리가이 멋진 일을 대신 "기능"이라고 가지고있다. GPU 코드를 자체 함수로 랩핑하십시오. 실패 할 경우 일찍 리턴 할 수 있습니다.

그런 다음 원래 함수에서 호출하십시오. 그들은 아마도 (data, host_index 및 block_index, 그것은 모양) 몇 가지 변수를 공유해야하기 때문에

는 클래스에 넣어, 그것의 두 가지 기능 회원을합니다.

void RunOnGpu(){ 
     // attempt to use GPU device 
     if (data.device) { 
      try { 
       Integral::Gpu eri(S, R, Q, block.shell()); 
       eri(basis.centers(), quartets, data.device); 
      } 
      // if GPU fails, propagate to cpu 
      catch(std::exception) { return; } 
      data.device += size; 
      host_index.extend(block_index); 
      block_index.data.clear();  
} 
void DoStuff() { 
#ifdef HAVE_GPU 
    RunOnGpu(); 
#endif 
}