int f()
{
        int failed;
        void *obj1;
        void *obj2;
        failed = construct_obj1(&obj1);
        if (!failed) {
                failed = construct_obj2(&obj2);
                if (!failed) {
                        failed = do_something(obj1, obj2);
                        // Обработка результатов вызова do_something
                        destruct_obj2(obj2);
                }
                destruct_obj1(obj1);
        }
        return failed;
}

• выделена основная ветка кода;
  
• при добавлении в цепочку новых вызовов необходимо вносить минимум изменений;

• код интенсивно уползает вправо;
  
• если необходимо выйти из функции не через конечный return, то приходится вручную вызывать все деструкторы;

int f()
{
        int failed;
        void *obj1;
        void *obj2;

        failed = construct_obj1(&obj1);
        if (failed) {
                goto end1;
        }

        failed = construct_obj2(&obj2);
        if (failed) {
                goto end2;
        }

        failed = do_something(obj1, obj2);
        // Обработка результатов вызова do_something

        destruct_obj2(obj2);
end2:
        destruct_obj1(obj1);
end1:
        return res;
}

• код не уползает вправо

• нелюбимый многими goto
  
• при добавлении в цепочку новых вызовов можно легко забыть добавить деструктор или переход на нужную метку;
  
• если необходимо выйти из функции не через конечный return, то приходится вручную вызывать все деструкты;

int f()
{
        int failed;
        void *obj1;
        void *obj2;

        failed = construct_obj1(&obj1);
        if (failed) {
                return failed;
        }

        failed = construct_obj2(&obj2);
        if (failed) {
                destruct_obj1(obj1);
                return failed;
        }

        failed = do_something(obj1, obj2);
        // Обработка результатов вызова do_something

        destruct_obj2(obj2);
        destruct_obj1(obj1);
        return failed;
}

• код не уползает вправо

• при добавлении в цепочку новых вызовов приходится добавлять деструкторы как минимум в 2 места;

void finallize_f(void* obj1, void* obj2)
{
        if (obj2 != NULL) {
                destruct_obj2(obj2);
        }
        if (obj1 != NULL) {
                destruct_obj1(obj1);
        }
}

int f()
{
        int failed;
        void *obj1 = NULL;
        void *obj2 = NULL;

        failed = construct_obj1(&obj1);
        if (failed) {
                finallize_f(obj1, obj2);
                return failed;
        }

        failed = construct_obj2(&obj2);
        if (failed) {
                finallize_f(obj1, obj2);
                return failed;
        }

        failed = do_something(obj1, obj2);
        // Обработка результатов вызова do_something

        finallize_f(obj1, obj2);
        return failed;
}

• код не уползает вправо
  
• разрушение объектов сосредоточено в одном месте, из функции f можно корректно выйти из любой точки — достаточно вызвать finallize_f;

• лишняя функция;
  
• проверки на NULL режут глаз;

Obj1 obj1;
Obj2 obj2;
do_something(obj1, obj2);

int f()
{
  int stage, failed;
  void *obj1;
  void *obj2;
  for( stage = 0;; ) {
    if( !(failed=construct_obj1(&obj1)) )
      break;
    ++stage;
    if( !(failed=construct_obj2(&obj2)) )
      break;
    ++stage;
    if( !(failed=do_something(obj1,obj2)) )
      break;
    ++stage;
    break;
  }

  switch( stage ) {
  case 3: break;
  case 2: destruct_obj2(obj1);
  case 1: destruct_obj1(obj1);
  }

  return failed;
}

B>int f()
B>{
B>  int stage, failed;
B>  void *obj1;
B>  void *obj2;
B>  for( stage = 0;; ) {
B>    if( !(failed=construct_obj1(&obj1)) )
B>      break;
B>    ++stage;
B>    if( !(failed=construct_obj2(&obj2)) )
B>      break;
B>    ++stage;
B>    if( !(failed=do_something(obj1,obj2)) )
B>      break;
B>    ++stage;
B>    break;
B>  }

B>  switch( stage ) {
B>  case 3: break;
B>  case 2: destruct_obj2(obj1);
B>  case 1: destruct_obj1(obj1);
B>  }

B>  return failed;
B>}
B>

B>+ красиво

int f()
{
    void *obj1;
    void *obj2;
    BEGIN_ERROR()
        BEGIN_INIT()
            ERROR_INIT1(construct_obj1,&obj1)
            ERROR_INIT1(construct_obj2,&obj2)
            ERROR_INIT2(do_something,&obj1,&obj2)
        END_INIT()
        BEGIN_TEST()
            ERROR_TEST(3)
            ERROR_TEST1(2,destruct_obj2,&obj2)
            ERROR_TEST1(1,destruct_obj1,&obj1)
        END_TEST()
    END_ERROR()
}

#define STAGE_VAR \
    stage_unique_name__

#define FAILED VAR \
    failed_unique_name__

#define BEGIN_ERROR() \
    { \
        int STAGE_VAR=0; \
        int FAILED_VAR=0;

#define END_ERROR() \
        return FAILED_VAR; \
    }

#define BEGIN_INIT() \
        while(1) \
        {

#define END_INIT() \
            break; \
        }

#define ERROR_INIT0(f) \
    if(!(FAILED_VAR=f())) \
        break; \
    ++STAGE_VAR;

#define ERROR_INIT1(f,p1) \
    if(!(FAILED_VAR=f(p1))) \
        break; \
    ++STAGE_VAR;

#define ERROR_INIT2(f,p1,p2) \
    if(!(FAILED_VAR=f(p1,p2))) \
        break; \
    ++STAGE_VAR;

#define BEGIN_TEST() \
    switch(STAGE_VAR) \
    {

#define END_TEST() \
    }

#define ERROR_TEST(n) \
    case n: break;

#define ERROR_TEST0(n,f) \
    case n: f();

#define ERROR_TEST1(n,f,p1) \
    case n: f(p1);

#define ERROR_TEST2(n,f,p1,p2) \
    case n: f(p1,p2);