HRESULT hRes = S_OK;

hRes = COMOBJECT1.Initialize();
if ( SUCCEEDED(hRes) )
{
    hRes = COMOBJECT2.Initialize();
    if ( SUCCEEDED(hRes) )
    {
        hRes = COMOBJECT3.Initialize();
        ... и так далее
    }
}

HRESULT hRes = S_OK;

hRes = COMOBJECT1.Initialize();
if ( FAILED(hRes) )
    goto Err;
hRes = COMOBJECT2.Initialize();
if ( FAILED(hRes) )
    goto Err;
    ... и так далее

}

HRESULT hRes = S_OK;

for(; ; ) 
{ 
    hRes = COMOBJECT1.Initialize();
    if ( FAILED(hRes) )
        break;
    hRes = COMOBJECT2.Initialize();
    if ( FAILED(hRes) )
        break;
    ... и так далее
    // Все ОК.
    break;
}
// Проверяем результат тут.
if (FAILED( hRes) 
{
    .....
}

void Check( HRESULT hr )
{
    if( FAILED( hr ) )
    {
      //вытаскиваем инфорамаци
      throw hr;//можно кидать свой
    }
}

...


try
{
  HRESULT hr
  Check( COMOBJECT1.Initialize() );
  Check( COMOBJECT2.Initialize() );
...

} catch( HRESULT hr )
{
  throw hr;
}

try
{
    hRes = COMOBJECT1.Initialize();
    if ( FAILED(hRes) )
        throw CMyExeception(hRes, "Ошибка 1");
    hRes = COMOBJECT2.Initialize();
    if ( FAILED(hRes) )
        throw CMyExeception(hRes, "Ошибка 2");
    ... и так далее
    // Все ОК.
}

}
catch (CMyExeception& e)
{
    //...
}

HRESULT hr;
hr = MyObj->MyMethod();
if (FAILED(hr))
    return hr;

struct ExceptionalHresult
{
    ExceptionalHresult(HRESULT hr = S_OK)
        :    hr_(hr)
    {
        if (FAILED(hr))
            throw std::runtime_error("Failed HRESULT has been got.");
    }

    ExceptionalHresult& operator=(HRESULT hr)
    {
        if (FAILED(hr_ = hr))
            throw std::runtime_error("Failed HRESULT has been got.");
        return *this;
    }
};

HRESULT CoClass::Method()
{
    try
    {
        ExceptionalHresult hRes;
        hRes = COMOBJECT1.Initialize();
        hRes = COMOBJECT2.Initialize();
        return S_OK;
    }
    catch(const exception& e)
    {
        return ATL::AtlReportError(
            __uuidof(CoClass),
            e.what(),
            __uuidof(IMyInterface),
            E_FAIL);
    }
}

catch(const std::exception& e)

int iRes = 0;

i += !SUCCEDED(pObject->SomeMethod());
i += !SUCCEDED(pObject->SomeMethod1());
i += !SUCCEDED(pObject->SomeMethod2());
i += !SUCCEDED(pObject2->SomeMethod());
i += !SUCCEDED(pObject2->SomeMethod1());
i += !SUCCEDED(pObject2->SomeMethod2());

return i ? S_OK : E_FAIL;

В>Это не хорошо Потому что зачастую не имеет смысл ( или даже нельзя ) вызывать все методы, если первый сбоит.

HRESULT hr;
if (SUCCEDED(hr = pObject->SomeMethod())
    && SUCCEDED(hr = pObject->SomeMethod1())
    && SUCCEDED(hr = pObject->SomeMethod2())
    && SUCCEDED(hr = pObject2->SomeMethod())
    && SUCCEDED(hr = pObject2->SomeMethod1())
    && SUCCEDED(hr = pObject2->SomeMethod2())); // do nothing
return hr;

[expr.log.and]
&& guarantees left to right evaluation: the second operand is not evaluated if the first operand is false.

ME>>    catch(const exception& e)
ME>>    {
ME>>        return ATL::AtlReportError(
ME>>            __uuidof(CoClass),
ME>>            e.what(),
ME>>            __uuidof(IMyInterface),
ME>>            E_FAIL);
ME>>    }
ME>>

_alloca
...
There are restrictions to explicitly calling _alloca in an exception handler (EH). EH routines that run on x86-class processors operate in their own memory frame: They perform their tasks in memory space that is not based on the current location of the stack pointer of the enclosing function. The most common implementations include Windows NT structured exception handling (SEH) and C++ catch clause expressions. Therefore, explicitly calling _alloca in any of the following scenarios results in program failure during the return to the calling EH routine:

* Windows NT SEH exception filter expression: __except (_alloca () )
* Windows NT SEH final exception handler: __finally {_alloca () }
* C++ EH catch clause expression

However, _alloca can be called directly from within an EH routine or from an application-supplied callback that gets invoked by one of the EH scenarios previously listed.

catch(int* p = static_cast<int*>(_alloca(sizeof(int)))) // "catch clause"
{
    // "handler"
}

ME>>>    catch(const exception& e)
ME>>>    {
ME>>>        return ATL::AtlReportError(
ME>>>            __uuidof(CoClass),
ME>>>            e.what(),
ME>>>            __uuidof(IMyInterface),
ME>>>            E_FAIL);
ME>>>    }
ME>>>

ME>catch(int* p = static_cast<int*>(_alloca(sizeof(int)))) // "catch clause"
ME>{
ME>    // "handler"
ME>}
ME>

ME>... хотя это бессмыслено.

The following only applies to the MS implementation of EH, I'm not
familiar with enough with any other implementation to comment.

When you throw an exception, the exception object is allocated on the
stack (please don't ask why, I can only guess.) The stack cannot be
physically unwound before entering a catch because the thrown object
might be rethrown from a catch. The stack pointer is restored after the
catch exits normally.

This means that _alloca can be called from within the catch, but the
result cannot be used outside the catch.

There is one other constraint that is really a bug. With VC6, you can't
call _alloca from within a try block. The stack pointer is not restored
correctly after taking an exception. This has been fixed in VC7.

Jason Shirk
VC++ Compiler Team