CC>На асме нет гото. там jmp

#define jmp goto

void HZ()
{
    if(!init1()) jmp d0;
    if(!init2()) jmp d1;
    if(!init3()) jmp d2;
    
d3:    destroy3();
d2: destroy2();
d1: destroy1();
d0: ;
}

void HZ(){
  int flag=0;
  flag+=init1()?1:0+init2()?2:0+init3()?4:0;
    switch(flag){
    case 7:
    case 6:
    case 5:
    case 4:destroy3();
    case 3:
    case 2:destroy2();
    case 1:destroy1();break;
    case 0://TODO...
  }
}

void HZ()
{
    if(!init1()) goto d1;
    if(!init2()) goto d2;
    if(!init3()) goto d3;

d3:
    destroy3();
d2:
    destroy2();
d1:
    destroy1();
}

void YaZnayu()
{
     int n = 2;

     if(!init1()) n = 0;
     else if(!init2()) n = 1;
     else if(!init3()) n = 2;

     switch(n)
     {
     case 2: destroy3();
     case 1: destroy2(); 
     case 0: destroy1();
     }
}

R>

R>void HZ()
R>{
R>    if(!init1()) goto d1;
R>    if(!init2()) goto d2;
R>    if(!init3()) goto d3;

R>d3:
R>    destroy3();
R>d2:
R>    destroy2();
R>d1:
R>    destroy1();
R>}

R>

CC>void HZ()
CC>{
CC>    if (init1())
CC>    {
CC>        if(init2())
CC>        {
CC>            if(init3())
CC>            {
CC>                какой то код
CC>            }
CC>            destroy3();
CC>        }
CC>        destroy2();
CC>    }
CC>    destroy1();
CC>}
CC>

void HZ()
{
    do
    {
        if( !init1() )
        {
            destroy1();
            break;
        }

        if( !init2() )
        {
            destroy2();
            break;
        }

        if( !init3() )
        {
            destroy3();
            break;
        }

    } while (0);

}

R>void HZ()
R>{
R>    if(!init1()) goto d1;
R>    if(!init2()) goto d2;
R>    if(!init3()) goto d3;
    я так понимаю тут еще какой то код должен быть...
R>d3:
R>    destroy3();
R>d2:
R>    destroy2();
R>d1:
R>    destroy1();
R>}

R>

void HZ()
{
    if (init1())
    {
        if(init2())
        {
            if(init3())
            {
                какой то код
            }
            destroy3();
        }
        destroy2();
    }
    destroy1();
}

void HZ()
{
    if (init1()) {
    if (init2()) {
    if (init3()) {
    
    какой то код
    
    }destroy3();
    }destroy2();
    }destroy1();
}

void HZ()
{
    bool ok1 = false, ok2 = false, ok3 = false; // можно заменить на один флаг типа int - тогда выражения будут громоздче

    true && ok1 = init1();
    ok1  && ok2 = init1();
    ok2  && ok3 = init1();
    
    ok3 && (todo(), true);
    
    ok3 && (done3(), true);
    ok2 && (done2(), true);
    ok1 && (done1(), true);
}

void HZ()
{
    if(!init2()) destroy2();
    if(!init3()) 
    {
       destroy3();
      destroy2();        
    }    
    destroy1();
}

void HZ()
{
    if(!init1()) goto d1;
    if(!init2()) goto d2;
    if(!init3()) goto d3;
// TODO: ...
    destroy3();
d3:
    destroy2();
d2:
    destroy1();
d1:
}

void HZ()
{
    if(init1()) {
    if(init2()) {
    if(init3()) {
// TODO: ...
    destroy3();}
    destroy2();}
    destroy1();}
}

void HZ(){if (init1()){if (init2()){if (init3()){какой то код}destroy3();}destroy2();}destroy1();}

void HZ()
{
    if(init1())
    {
        if(init2())
        {
            init3();
            destroy3();
        }
        destroy2();
    }
    destroy1();
}

R>void HZ()
R>{
R>    if(!init1()) goto d1;
R>    if(!init2()) goto d2;
R>    if(!init3()) goto d3;

R>d3:
R>    destroy3();
R>d2:
R>    destroy2();
R>d1:
R>    destroy1();
R>}

void HZ(){
  int flag=0;
  for(int i=0;i<3;i++){
    if(flag) 
      continue;
    switch(i){
      0:flag+=init1()?1:0;break;
      1:flag+=init2()?2:0;break;
      2:flag+=init3()?4:0;break;
     }
  }
    switch(flag){
    case 7:
    case 6:
    case 5:
    case 4:destroy3();
    case 3:
    case 2:destroy2();
    case 1:destroy1();break;
    case 0://TODO...
  }
}

R>void HZ()
R>{
R>    if(!init1()) goto d1;
R>    if(!init2()) goto d2;
R>    if(!init3()) goto d3;

R>d3:
R>    destroy3();
R>d2:
R>    destroy2();
R>d1:
R>    destroy1();
R>}

R>

HRESULT init(void **);
void destroy(void *);

// CHR - Check HRESULT
#define CHR(x)              \
    do                      \
    {                       \
        hr = x;             \
        if (FAILED(hr))     \
        {                   \
            DebugLog(hr);   \
            goto Error;     \
        }                   \
    } while (0)


HRESULT foo()
{
    HRESULT hr = S_OK;
    void * d1 = NULL;
    void * d2 = NULL;
    void * d3 = NULL;

    CHR(init(&d1));
    CHR(init(&d2));
    CHR(init(&d3));

    // .. some code

Error:
    if (d1) destroy(d1);
    if (d2) destroy(d2);
    if (d3) destroy(d3);

    return hr;   // the only return statement in the function
}

    CHR(init(&d1));

    RAIIClass obj;

Error:
    if (d1) destroy(d1);

    return hr;

struct init_s
{
    int (*start_fn)(void *);
    void (*stop_fn)(void *);
    void *context;
    bool initialized;        /* init flag */
};

#define INITIALIZE(init_array, result)                    \
do                                    \
{                                    \
    int i;                                \
    bool successfull = true;                        \
    result = 0;                                \
                                    \
    for (i=0; i < sizeof(init_array) / sizeof(init_array[0]); i++)    \
    {                                    \
                                    \
    init_array[i].initialized =                     \
        (init_array[i].start_fn(init_array[i].context) == 0);    \
                                    \
    successfull &= init_array[i].initialized;            \
                                    \
    if (!successfull)                        \
    {                                \
        result = i+1;                        \
                                    \
        for (--i; i>=0; i--)                    \
        {                                \
        init_array[i].stop_fn(init_array[i].context);        \
        init_array[i].initialized = false;            \
        }                                \
                                    \
        break;                            \
    }                                \
    }                                    \
                                    \
} while (0)

#define FINALIZE(init_array)                        \
do                                    \
{                                    \
    int i;                                \
                                    \
    for (i=sizeof(init_array) / sizeof(init_array[0]) - 1; i>=0; i--)    \
    if (init_array[i].initialized)                    \
    {                                \
        init_array[i].stop_fn(init_array[i].context);        \
        init_array[i].initialized = false;                \
    }                                \
} while (0)

static struct init_s init_array[] = 
{
    { .start_fn = init1, .stop_fn = destroy1 },
    { .start_fn = init2, .stop_fn = destroy2 },
    { .start_fn = init3, .stop_fn = destroy3 },
};

...............

int ret;
INITIALIZE(init_array, ret);

...............

FINALIZE(init_array)

...............

R>void HZ()
R>{
R>    if(!init1()) goto d1;
R>    if(!init2()) goto d2;
R>    if(!init3()) goto d3;

R>d3:
R>    destroy3();
R>d2:
R>    destroy2();
R>d1:
R>    destroy1();
R>}

R>

class Inidestr{
public:
  Inidestr(Inidestr* p):m_pID(p){};

  virtual void destroy() = 0;

  virtual bool init()
  {
    bool b = true;
    if(m_pID){
      b = m_pID->init();
      if(!b){
        m_pID->destroy();
      }
    }
    return b;
  };
private:
  Inidestr* m_pID;
};

class Class1 : Inidestr
{
  bool init()
  {
    return Inidestr::init() && init1();
  }
  void destroy(){destroy1();}
};
class Class2 : Inidestr
{
  bool init()
  {
    return Inidestr::init() && init2();
  }
  void destroy(){destroy2();}
};
class Class3 : Inidestr
{
  bool init()
  {
    return Inidestr::init() && init3();
  }
  void destroy(){destroy3();}
};

void HZ()
{
  Class1* c1 = new Inidestr(0);
  Class2* c2 = new Inidestr(c1);
  Class3* c3 = new Inidestr(c2);
  if(!c3->init()) c3->destroy();
}

void HZ()
{
    if(!init1()) goto d1;
    if(!init2()) goto d2;
    if(!init3()) goto d3;

    destroy3();
d3:
    destroy2();
d2:
    destroy1();
d1:
}

void f(type1 v1,type1 v2,type1 v3,type1 v4,type1 v5) {
  for(int i=0;i<n1;++i) {
    for(int j=i+1;j<n2;++j) {
      for(int k=j+1;j<n3;++k) {
        if(some_exp1(v1,...,v5,i,j,k)) goto skip1;
      }
      if(some_exp2(v1,...,v5,i,j,k)) goto skip2;
    }
    // some code1
    skip1:
    // some code2
  }
  skip2:
  // some code3
}

R>void HZ()
R>{
R>    if(!init1()) goto d1;
R>    if(!init2()) goto d2;
R>    if(!init3()) goto d3;

R>d3:
R>    destroy3();
R>d2:
R>    destroy2();
R>d1:
R>    destroy1();
R>}

R>

void HZ()
{
    try
    {
        T1 t1;
        T2 t2;
        T3 t3;

        // smth else

    }
    catch (...)
    {
    }
}

class T1
{
    T1()
    {
        if(!Init1()) throw new MyException();
    }
    bool Init1()
    {
        return rnd() > rnd();
    }
};

class T1
{
    T1()
    {
        if(!Init1())
        {
             Destroy1();
             throw new MyException();             
        }
    }
    ~T1()
    {
        Destroy1();
    }
    bool Init1()
    {
        return rnd() > rnd();
    }
    void Destroy1()
    {
    }
};

void HZ()
{
    
    int i = 0;    
    if ((init1() && ++i) && (init2() && ++i)  && (init3() && ++i))

    switch (i)
    {
        case 3: destroy3();
        case 2: destroy2();
        case 1: destroy1();

    }

}

void HZ()
{
    
    int i = 0;    
    if ((init1() && ++i) && (init2() && ++i)  && (init3() && ++i));

    switch (i)
    {
        case 3: destroy3();
        case 2: destroy2();
        case 1: destroy1();

    }

}

void HZ()
{
    
    int i = 0;    
    if (init1() && ++i && init2() && ++i && init3() && ++i);

    switch (i)
    {
        case 3: destroy3();
        case 2: destroy2();
        case 1: destroy1();

    }

}