do-while (0)을 피하는 더 좋은 방법은 무엇입니까? C ++에서 해킹?

코드 흐름이 다음과 같은 경우 :

if(check())
{
  ...
  ...
  if(check())
  {
    ...
    ...
    if(check())
    {
      ...
      ...
    }
  }
}

위의 지저분한 코드 흐름을 피하기 위해 일반적 으로이 해결 방법을 보았습니다.

do {
    if(!check()) break;
    ...
    ...
    if(!check()) break;
    ...
    ...
    if(!check()) break;
    ...
    ...
} while(0);

이 해결 방법 / 해킹을 피하여 더 높은 수준 (산업 수준) 코드가되는 더 좋은 방법은 무엇입니까?

즉시 사용 가능한 제안은 환영합니다!

이러한 결정을 기능으로 분리하고 returns 대신을 사용하는 것이 허용되는 관행으로 간주됩니다 break. 이러한 모든 검사는 기능과 동일한 추상화 수준에 해당하지만 상당히 논리적입니다.

예를 들면 다음과 같습니다.

void foo(...)
{
   if (!condition)
   {
      return;
   }
   ...
   if (!other condition)
   {
      return;
   }
   ...
   if (!another condition)
   {
      return;
   }
   ... 
   if (!yet another condition)
   {
      return;
   }
   ...
   // Some unconditional stuff       
}

goto적어도 " goto질문이 무엇이든 관계없이 답이 될 수 없다 " 는 종교적 믿음에 얽매이지 않은 사람들에게는 실제로 사용하는 것이 정답 일 때가 있습니다.

이 코드의 해킹 사용 do { ... } while(0);를 드레싱의 목적에 대한 gotoA와를 break. 을 (를) 사용하려는 경우 goto공개하십시오. 코드 HARDER를 읽도록 만드는 것은 중요하지 않습니다.

특정 상황은 매우 복잡한 조건의 코드가 많은 경우입니다.

void func()
{
   setup of lots of stuff
   ...
   if (condition)
   {
      ... 
      ...
      if (!other condition)
      {
          ...
          if (another condition)
          {
              ... 
              if (yet another condition)
              {
                  ...
                  if (...)
                     ... 
              }
          }
      }
  .... 

  }
  finish up. 
}

실제로 그러한 복잡한 논리를 갖지 않으면 코드가 정확하다는 것을 명확하게 할 수 있습니다.

void func()
{
   setup of lots of stuff
   ...
   if (!condition)
   {
      goto finish;
   }
   ... 
   ...
   if (other condition)
   {
      goto finish;
   }
   ...
   if (!another condition)
   {
      goto finish;
   }
   ... 
   if (!yet another condition)
   {
      goto finish;
   }
   ... 
   .... 
   if (...)
         ...    // No need to use goto here. 
 finish:
   finish up. 
}

편집 : 명확히하기 위해, 나는 결코 goto일반적인 해결책으로 의 사용을 제안하지 않습니다 . 그러나 goto다른 솔루션보다 더 나은 솔루션이있는 경우 가 있습니다.

예를 들어 일부 데이터를 수집하고 있고 테스트되는 여러 조건이 일종의 "이것은 수집되는 데이터의 끝"이라고 상상해보십시오. 위치에 따라 달라지는 "계속 / 종료"마커에 따라 다릅니다. 데이터 스트림에 있습니다.

이제 완료되면 데이터를 파일로 저장해야합니다.

그렇습니다. 합리적인 솔루션을 제공 할 수있는 솔루션이 종종 있지만 항상 그런 것은 아닙니다.

bool변수 와 함께 간단한 연속 패턴을 사용할 수 있습니다 .

bool goOn;
if ((goOn = check0())) {
    ...
}
if (goOn && (goOn = check1())) {
    ...
}
if (goOn && (goOn = check2())) {
    ...
}
if (goOn && (goOn = check3())) {
    ...
}

이 실행 체인은을 checkN반환 하자마자 중지됩니다 false. 작업자의 check...()단락으로 인해 더 이상 전화를 걸지 않습니다 &&. 또한, 최적화 컴파일러는 해당 설정을 인식하는 스마트 충분히 goOn에 false일방 통행로이며, 누락을 삽입 goto end당신을 위해. 그 결과, 코드의 성능은 위의 것과 동일한 것 do/ while(0)만 가독성에 고통스러운 타격하지 않고.

1. 코드를 별도의 함수 (또는 둘 이상)로 추출하십시오. 점검에 실패하면 기능에서 복귀하십시오.

2. 주변 코드와 너무 밀접하게 연결되어 있고 커플 링을 줄일 수있는 방법을 찾지 못하면이 블록 뒤의 코드를 확인하십시오. 아마도 함수에서 사용하는 일부 리소스를 정리합니다. RAII 오브젝트를 사용하여 이러한 자원을 관리하십시오 . 그런 다음 각 피지 break를 return(또는 throw더 적절한 경우) 로 바꾸고 객체의 소멸자를 정리하십시오.

3. 프로그램 흐름이 (필요하게) 너무 구불 구불하게되어 정말로 필요하다면 goto이상한 변장을주는 대신 사용하십시오.

4. 맹목적으로 금지하는 코딩 규칙이 goto있고 실제로 프로그램 흐름을 단순화 할 수 없다면 do해킹 으로 위장해야 할 것입니다 .

TLDR : RAII , 트랜잭션 코드 (결과가 이미 설정되어있을 때만 결과를 설정하거나 반환) 및 예외.

긴 대답 :

에서 C 코드의 이런 종류의 가장 좋은 방법은 EXIT / CLEANUP / 추가하는 것입니다 다른 지역 자원의 정리가 발생하고 오류 코드 (있는 경우)이 반환되는 경우, 코드에서 레이블을. 이것은 코드를 자연스럽게 초기화, 계산, 커밋 및 리턴으로 나누기 때문에 모범 사례입니다.

error_code_type c_to_refactor(result_type *r)
{
    error_code_type result = error_ok; //error_code_type/error_ok defd. elsewhere
    some_resource r1, r2; // , ...;
    if(error_ok != (result = computation1(&r1))) // Allocates local resources
        goto cleanup;
    if(error_ok != (result = computation2(&r2))) // Allocates local resources
        goto cleanup;
    // ...

    // Commit code: all operations succeeded
    *r = computed_value_n;
cleanup:
    free_resource1(r1);
    free_resource2(r2);
    return result;
}

C, 대부분의 코드베이스에서, if(error_ok != ...그리고 goto코드는 일반적으로 몇 가지 편리한 매크로 (뒤에 숨겨진 RET(computation_result), ENSURE_SUCCESS(computation_result, return_code)등).

C ++ 을 통해 제공 추가 도구를 C :

• 정리 블록 기능은 RAII로 구현 될 수 있습니다. 즉, 더 이상 전체 cleanup블록이 필요하지 않으며 클라이언트 코드가 초기 리턴 명령문을 추가 할 수 있습니다.

• 계속할 수 없을 때마다 던져 모든 if(error_ok != ...직통 전화로 변환 합니다.

동등한 C ++ 코드 :

result_type cpp_code()
{
    raii_resource1 r1 = computation1();
    raii_resource2 r2 = computation2();
    // ...
    return computed_value_n;
}

이것은 다음과 같은 이유로 모범 사례입니다.

• 명시 적입니다 (즉, 오류 처리가 명시 적이 지 않지만 알고리즘의 주요 흐름은 다음과 같습니다)

• 클라이언트 코드를 작성하는 것은 간단합니다

• 최소한입니다

• 간단하다

• 반복적 인 코드 구성이 없습니다

• 매크로를 사용하지 않습니다

• 이상한 do { ... } while(0)구문을 사용하지 않습니다

• 최소한의 노력으로 재사용 할 수 있습니다 (즉, 호출을 computation2();다른 함수 에 복사하려는 경우 do { ... } while(0)새 코드를 추가 하거나 #definegoto wrapper 매크로 및 정리 레이블을 추가 할 필요가 없습니다. 다른 것).

완전성을 위해 답변을 추가하고 있습니다. 다른 많은 답변은 큰 조건 블록이 별도의 기능으로 나눌 수 있다고 지적했습니다. 그러나 여러 번 지적 했듯이이 접근법은 조건부 코드를 원래 컨텍스트와 분리한다는 것입니다. 이것이 C ++ 11의 언어에 람다가 추가 된 이유 중 하나입니다. 람다 사용은 다른 사람들에 의해 제안되었지만 명확한 샘플은 제공되지 않았습니다. 나는이 답변에 하나를 넣었습니다. 나를 때리는 것은 do { } while(0)여러면 에서 접근 방식 과 매우 유사하다는 느낌입니다. 아마도 여전히 goto위장에 있음을 의미합니다 ....

earlier operations
...
[&]()->void {

    if (!check()) return;
    ...
    ...
    if (!check()) return;
    ...
    ...
    if (!check()) return;
    ...
    ...
}();
later operations

확실히 대답하지만 답변 (완전성을 위해서)

대신에 :

do {
    if(!check()) break;
    ...
    ...
    if(!check()) break;
    ...
    ...
    if(!check()) break;
    ...
    ...
} while(0);

당신은 쓸 수 있습니다 :

switch (0) {
case 0:
    if(!check()) break;
    ...
    ...
    if(!check()) break;
    ...
    ...
    if(!check()) break;
    ...
    ...
}

이것은 아직도이다 고토 변장하지만, 적어도 그것은 루프는 더 이상 아니다. 즉, 일부를 계속 점검하지 않아도 매우 신중하게 확인할 필요가 없습니다. 블록의 숨겨진 곳은.

구조는 컴파일러가 최적화하기를 희망 할 정도로 간단합니다.

@jamesdlin이 제안한 것처럼 매크로 뒤에 숨길 수도 있습니다.

#define BLOC switch(0) case 0:

그리고 그것을 사용하십시오

BLOC {
    if(!check()) break;
    ...
    ...
    if(!check()) break;
    ...
    ...
    if(!check()) break;
    ...
    ...
}

이는 C 언어 구문이 대괄호 블록이 아니라 스위치 뒤의 명령문을 예상하고 해당 명령문 앞에 케이스 레이블을 넣을 수 있기 때문에 가능합니다. 지금까지 나는 그것을 허용하는 요점을 보지 못했지만이 특별한 경우 스위치를 멋진 매크로 뒤에 숨기는 것이 편리합니다.

나는 매트 답변과 비슷한 접근 방식에서 불필요한 것을 뺀 것을 추천합니다 goto. 조건부 논리 만 함수에 넣으십시오. 항상 실행되는 모든 코드는 호출자에서 함수가 호출되기 전후에 수행되어야합니다.

void main()
{
    //do stuff always
    func();
    //do other stuff always
}

void func()
{
    if (!condition)
        return;
    ...
    if (!other condition)
        return;
    ...
    if (!another condition)
        return;
    ... 
    if (!yet another condition)
        return;
    ...
}

코드 흐름 자체는 이미 많은 기능에서 발생하는 코드 냄새입니다. 그것에 대한 직접적인 해결책이 없다면 (함수는 일반적인 검사 기능입니다) RAII 를 사용 하면 함수의 끝 부분으로 건너 뛰는 대신 돌아갈 수 있습니다.

실행 중에 로컬 변수를 도입 할 필요가 없다면 종종 이것을 평평하게 할 수 있습니다 :

if (check()) {
  doStuff();
}  
if (stillOk()) {
  doMoreStuff();
}
if (amIStillReallyOk()) {
  doEvenMore();
}

// edit 
doThingsAtEndAndReportErrorStatus()

dasblinkenlight의 답변과 비슷하지만 if코드 검토자가 "고정"할 수있는 내부 할당을 피하십시오 .

bool goOn = check0();
if (goOn) {
    ...
    goOn = check1();
}
if (goOn) {
    ...
    goOn = check2();
}
if (goOn) {
    ...
}

...

다음 단계 전에 단계 결과를 확인해야 할 때이 패턴을 사용하는데, 이는 모든 검사가 큰 if( check1() && check2()...유형의 패턴 으로 미리 수행 될 수있는 상황과 다릅니다 .

예외를 사용하십시오. 코드가 훨씬 깔끔해 보일 것입니다 (프로그램의 실행 흐름에서 오류를 처리하기 위해 예외가 정확하게 생성되었습니다). 리소스 (파일 설명자, 데이터베이스 연결 등)를 정리하려면 C ++에서 "최종"구문을 제공하지 않는 이유 문서를 읽으십시오 . .

#include <iostream>
#include <stdexcept>   // For exception, runtime_error, out_of_range

int main () {
    try {
        if (!condition)
            throw std::runtime_error("nope.");
        ...
        if (!other condition)
            throw std::runtime_error("nope again.");
        ...
        if (!another condition)
            throw std::runtime_error("told you.");
        ...
        if (!yet another condition)
            throw std::runtime_error("OK, just forget it...");
    }
    catch (std::runtime_error &e) {
        std::cout << e.what() << std::endl;
    }
    catch (...) {
        std::cout << "Caught an unknown exception\n";
    }
    return 0;
}

나를 위해 do{...}while(0)괜찮습니다. 당신이보고 싶지 않으면do{...}while(0) 대체 키워드를 정의 할 수 있습니다.

예:

//--------SomeUtilities.hpp---------
#define BEGIN_TEST do{
#define END_TEST }while(0);

//--------SomeSourceFile.cpp--------
BEGIN_TEST
   if(!condition1) break;
   if(!condition2) break;
   if(!condition3) break;
   if(!condition4) break;
   if(!condition5) break;

   //processing code here

END_TEST

컴파일러가 불필요한 while(0)조건을 제거 할 것이라고 생각합니다 .do{...}while(0) 바이너리 버전에서 하고 나누기를 무조건 점프로 변환 할 . 어셈블리 언어 버전인지 확인할 수 있습니다.

를 사용하면 goto코드가 더 깨끗 해지고 조건 논리 점프 로직이 간단합니다. 다음을 수행 할 수 있습니다.

{
   if(!condition1) goto end_blahblah;
   if(!condition2) goto end_blahblah;
   if(!condition3) goto end_blahblah;
   if(!condition4) goto end_blahblah;
   if(!condition5) goto end_blahblah;

   //processing code here

 }end_blah_blah:;  //use appropriate label here to describe...
                   //  ...the whole code inside the block.

레이블은 닫은 후에 배치됩니다 }. 이것은 goto레이블이 보이지 않기 때문에 실수로 코드를 넣는 문제를 피하는 것 입니다. 그것은 지금 같다do{...}while(0)조건 코드가없는 .

이 코드를보다 명확하고 이해하기 쉽게하려면 다음과 같이하십시오.

//--------SomeUtilities.hpp---------
#define BEGIN_TEST {
#define END_TEST(_test_label_) }_test_label_:;
#define FAILED(_test_label_) goto _test_label_

//--------SomeSourceFile.cpp--------
BEGIN_TEST
   if(!condition1) FAILED(NormalizeData);
   if(!condition2) FAILED(NormalizeData);
   if(!condition3) FAILED(NormalizeData);
   if(!condition4) FAILED(NormalizeData);
   if(!condition5) FAILED(NormalizeData);

END_TEST(NormalizeData)

이를 통해 중첩 블록을 수행하고 종료 / 점프 할 위치를 지정할 수 있습니다.

//--------SomeUtilities.hpp---------
#define BEGIN_TEST {
#define END_TEST(_test_label_) }_test_label_:;
#define FAILED(_test_label_) goto _test_label_

//--------SomeSourceFile.cpp--------
BEGIN_TEST
   if(!condition1) FAILED(NormalizeData);
   if(!condition2) FAILED(NormalizeData);

   BEGIN_TEST
      if(!conditionAA) FAILED(DecryptBlah);
      if(!conditionBB) FAILED(NormalizeData);   //Jump out to the outmost block
      if(!conditionCC) FAILED(DecryptBlah);

      // --We can now decrypt and do other stuffs.

   END_TEST(DecryptBlah)

   if(!condition3) FAILED(NormalizeData);
   if(!condition4) FAILED(NormalizeData);

   // --other code here

   BEGIN_TEST
      if(!conditionA) FAILED(TrimSpaces);
      if(!conditionB) FAILED(TrimSpaces);
      if(!conditionC) FAILED(NormalizeData);   //Jump out to the outmost block
      if(!conditionD) FAILED(TrimSpaces);

      // --We can now trim completely or do other stuffs.

   END_TEST(TrimSpaces)

   // --Other code here...

   if(!condition5) FAILED(NormalizeData);

   //Ok, we got here. We can now process what we need to process.

END_TEST(NormalizeData)

스파게티 코드는 goto의 잘못이 아니라 프로그래머의 잘못입니다. 를 사용하지 않고도 스파게티 코드를 계속 생성 할 수 있습니다 goto.

이것은 기능적 프로그래밍 관점에서 볼 수있는 잘 알려진 문제입니다. 아마도 모나드 일 것입니다.

아래에서받은 의견에 대한 응답으로 여기에서 소개를 편집했습니다 .Rotsor가 제안한 것을 달성 할 수 있는 다양한 장소 에서 C ++ 모나드 구현에 대한 자세한 내용을 찾을 수 있습니다 . 모나드를 잡는 데 시간이 걸리므로 대신 boost :: optional에 대해 알아야 할 빠른 "가난한"모나드 유사 메커니즘을 제안하겠습니다.

다음과 같이 계산 단계를 설정하십시오.

boost::optional<EnabledContext> enabled(boost::optional<Context> context);
boost::optional<EnergisedContext> energised(boost::optional<EnabledContext> context);

boost::none주어진 계산 단계 가 비어 있다면 각 계산 단계는 분명히 return과 같은 것을 할 수 있습니다 . 예를 들어 :

struct Context { std::string coordinates_filename; /* ... */ };

struct EnabledContext { int x; int y; int z; /* ... */ };

boost::optional<EnabledContext> enabled(boost::optional<Context> c) {
   if (!c) return boost::none; // this line becomes implicit if going the whole hog with monads
   if (!exists((*c).coordinates_filename)) return boost::none; // return none when any error is encountered.
   EnabledContext ec;
   std::ifstream file_in((*c).coordinates_filename.c_str());
   file_in >> ec.x >> ec.y >> ec.z;
   return boost::optional<EnabledContext>(ec); // All ok. Return non-empty value.
}

그런 다음 함께 연결하십시오.

Context context("planet_surface.txt", ...); // Close over all needed bits and pieces

boost::optional<EnergisedContext> result(energised(enabled(context)));
if (result) { // A single level "if" statement
    // do work on *result
} else {
    // error
}

이것에 대한 좋은 점은 각 계산 단계마다 명확하게 정의 된 단위 테스트를 작성할 수 있다는 것입니다. 또한 호출은 일반 영어처럼 읽습니다 (보통 기능적 스타일의 경우와 동일).

불변성에 신경 쓰지 않고 shared_ptr 등을 사용하여 변형을 일으킬 수있을 때마다 동일한 객체를 반환하는 것이 더 편리합니다.

if 문을 여분의 함수로 옮기면 숫자 또는 열거 형 결과가 나옵니다.

int ConditionCode (void) {
   if (condition1)
      return 1;
   if (condition2)
      return 2;
   ...
   return 0;
}


void MyFunc (void) {
   switch (ConditionCode ()) {
      case 1:
         ...
         break;

      case 2:
         ...
         break;

      ...

      default:
         ...
         break;
   }
}

아마도 이런 것

#define EVER ;;

for(EVER)
{
    if(!check()) break;
}

또는 예외를 사용하십시오

try
{
    for(;;)
        if(!check()) throw 1;
}
catch()
{
}

예외를 사용하면 데이터를 전달할 수도 있습니다.

나는 특별히 사용하지 break않거나return 이러한 케이스. 일반적으로 이러한 상황에 직면 할 때 일반적으로 비교적 긴 방법입니다.

종료 점이 여러 개인 경우 특정 논리가 실행되는 원인을 알고 자 할 때 어려움을 겪을 수 있습니다. 일반적으로 해당 논리를 포함하는 블록을 계속 올라가고 해당 폐쇄 블록의 기준에 따라 상태:

예를 들어

if (conditionA) {
    ....
    if (conditionB) {
        ....
        if (conditionC) {
            myLogic();
        }
    }
}

둘러싸는 블록을 보면 사실 myLogic()일 때만 발생 한다는 것을 쉽게 알 수 conditionA and conditionB and conditionC있습니다.

조기 반품이있을 때 눈에 띄지 않게됩니다.

if (conditionA) {
    ....
    if (!conditionB) {
        return;
    }
    if (!conditionD) {
        return;
    }
    if (conditionC) {
        myLogic();
    }
}

더 이상을 (를) 탐색 myLogic()하고 조건을 파악하기 위해 둘러싸는 블록을 살펴볼 수 없습니다 .

내가 사용한 다른 해결 방법이 있습니다. 다음 중 하나입니다.

if (conditionA) {
    isA = true;
    ....
}

if (isA && conditionB) {
    isB = true;
    ...
}

if (isB && conditionC) {
    isC = true;
    myLogic();
}

(물론 동일한 변수를 사용하여 모두를 대체하는 것이 좋습니다. isA isB isC 좋습니다.)

이러한 접근 방식은 적어도 독자에게 코드를 제공하며,이 myLogic()경우 실행됩니다 isB && conditionC. 독자에게는 isB가 참이되는 원인을 추가로 찾아보아야한다는 힌트가 제공됩니다.

typedef bool (*Checker)();

Checker * checkers[]={
 &checker0,&checker1,.....，&checkerN,NULL
};

bool checker1(){
  if(condition){
    .....
    .....
    return true;
  }
  return false;
}

bool checker2(){
  if(condition){
    .....
    .....
    return true;
  }
  return false;
}

......

void doCheck(){
  Checker ** checker = checkers;
  while( *checker && (*checker)())
    checker++;
}

어떻게에 대한?

실패 위치에 따라 다른 정리 단계가 필요한 경우 유용한 또 다른 패턴 :

    private ResultCode DoEverything()
    {
        ResultCode processResult = ResultCode.FAILURE;
        if (DoStep1() != ResultCode.SUCCESSFUL)
        {
            Step1FailureCleanup();
        }
        else if (DoStep2() != ResultCode.SUCCESSFUL)
        {
            Step2FailureCleanup();
            processResult = ResultCode.SPECIFIC_FAILURE;
        }
        else if (DoStep3() != ResultCode.SUCCESSFUL)
        {
            Step3FailureCleanup();
        }
        ...
        else
        {
            processResult = ResultCode.SUCCESSFUL;
        }
        return processResult;
    }

저는 C ++ 프로그래머가 아니므로 여기에 코드를 쓰지 않지만 객체 지향 솔루션을 언급 한 사람은 없습니다. 여기에 내 추측이 있습니다.

단일 조건을 평가하는 방법을 제공하는 일반 인터페이스가 있습니다. 이제 해당 메소드가 포함 된 객체에서 해당 조건의 구현 목록을 사용할 수 있습니다. 목록을 반복하고 각 조건을 평가하여 실패하면 조기에 깨질 수 있습니다.

좋은 점은 그러한 디자인이 개방 / 폐쇄 원칙에 매우 잘 부합한다는 것입니다 . 문제의 메소드를 포함하는 객체를 초기화하는 동안 새로운 조건을 쉽게 추가 할 수 있기 때문입니다. 조건에 대한 설명을 반환하는 조건 평가 방법을 사용하여 인터페이스에 두 번째 방법을 추가 할 수도 있습니다. 자체 문서화 시스템에 사용할 수 있습니다.

그러나 단점은 더 많은 객체를 사용하고 목록을 반복하기 때문에 약간 더 많은 오버 헤드가 있다는 것입니다.

이것이 내가하는 방법입니다.

void func() {
  if (!check()) return;
  ...
  ...

  if (!check()) return;
  ...
  ...

  if (!check()) return;
  ...
  ...
}

먼저 gotoC ++에 적합한 솔루션이 아닌 이유를 보여주는 간단한 예입니다 .

struct Bar {
    Bar();
};

extern bool check();

void foo()
{
    if (!check())
       goto out;

    Bar x;

    out:
}

이것을 객체 파일로 컴파일하고 무슨 일이 일어나는지보십시오. 그런 다음 동등한 do+ break+while(0) .

그것은 제쳐두고 있었다. 요점은 다음과 같습니다.

코드의 그 작은 덩어리가 종종 필요 일부 정리 종류의 전체 기능이 실패합니다. 이러한 정리는 일반적 으로 부분적으로 완료된 계산을 "풀기"때문에 청크 자체와 반대 순서 로 발생하려고합니다 .

이러한 의미를 얻는 한 가지 옵션은 RAII입니다. . @utnapistim의 답변을 참조하십시오. C ++은 자동 소멸자가 생성자와 반대 순서로 실행되도록 보장합니다.

그러나 많은 RAII 클래스가 필요합니다. 때로는 더 간단한 옵션이 스택을 사용하는 것입니다.

bool calc1()
{
    if (!check())
        return false;

    // ... Do stuff1 here ...

    if (!calc2()) {
        // ... Undo stuff1 here ...
        return false;
    }

    return true;
}

bool calc2()
{
    if (!check())
        return false;

    // ... Do stuff2 here ...

    if (!calc3()) {
        // ... Undo stuff2 here ...
        return false;
    }

    return true;
}

...등등. "do"코드 옆에 "undo"코드를 넣기 때문에 감사하기 쉽습니다. 쉬운 감사가 좋습니다. 또한 제어 흐름을 매우 명확하게 만듭니다. C에도 유용한 패턴입니다.

calc함수가 많은 인수를 필요로 할 수 있지만 클래스 / 구조체가 잘 응집되어 있으면 일반적으로 문제가되지 않습니다. 즉, 함께 속하는 것은 단일 객체에 존재하므로 이러한 함수는 적은 수의 객체에 대한 포인터 또는 참조를 가져와 여전히 많은 유용한 작업을 수행 할 수 있습니다.

코드에 if..else if..else 문의 긴 블록이 있으면 Functors또는 의 도움으로 전체 블록을 다시 작성해 볼 수 있습니다 function pointers. 항상 올바른 해결책은 아니지만 상당히 자주 있습니다.

http://www.cprogramming.com/tutorial/functors-function-objects-in-c++.html

여기에 제시된 다양한 답변이 놀랍습니다. 그러나 마지막으로 변경 해야하는 코드에서 (예 : 이것을 제거하십시오)do-while(0) 해킹 또는 다른 것을 )에서 여기 언급 된 답변과 다른 것을 수행했으며 아무도 이것을 생각하지 않은 이유가 혼란 스럽습니다. 내가 한 일은 다음과 같습니다.

초기 코드 :

do {

    if(!check()) break;
    ...
    ...
    if(!check()) break;
    ...
    ...
    if(!check()) break;
    ...
    ...
} while(0);

finishingUpStuff.

지금:

finish(params)
{
  ...
  ...
}

if(!check()){
    finish(params);    
    return;
}
...
...
if(!check()){
    finish(params);    
    return;
}
...
...
if(!check()){
    finish(params);    
    return;
}
...
...

따라서 여기서 수행 된 작업은 마무리 작업이 기능으로 분리되어 일이 갑자기 너무 간단하고 깨끗해 졌다는 것입니다.

나는이 솔루션이 언급 할 가치가 있다고 생각했기 때문에 여기에 제공했다.

한 if문장 으로 통합하십시오 .

if(
    condition
    && other_condition
    && another_condition
    && yet_another_condition
    && ...
) {
        if (final_cond){
            //Do stuff
        } else {
            //Do other stuff
        }
}

이것은 goto 키워드가 제거 된 Java와 같은 언어에서 사용되는 패턴입니다.

모든 오류에 대해 동일한 오류 처리기를 사용하고 각 단계에서 성공을 나타내는 부울을 반환합니다.

if(
    DoSomething() &&
    DoSomethingElse() &&
    DoAThirdThing() )
{
    // do good condition action
}
else
{
    // handle error
}

(tyzoid의 답변과 유사하지만 조건은 동작이며 &&는 첫 번째 실패 후 추가 동작이 발생하지 않도록합니다.)

왜 신고 방법에 응답하지 않았습니까?

//you can use something like this (pseudocode)
long var = 0;
if(condition)  flag a bit in var
if(condition)  flag another bit in var
if(condition)  flag another bit in var
............
if(var == certain number) {
Do the required task
}