Re: Returning a BSTR value from a property

Danielle, if you want to be completely correct with this, you will
need something like:

STDMETHODIMP CMyObj::get_String(BSTR *pVal)
{
  try
  {
    *pVal = _bstr_t( _my_wrappered_obj->GetProperty().c_str() )->Detach
();
  }
  catch(const _com_error& e)
  {
    return e.Error(); // Or something better.
  }
  catch(const std::exception& e)
  {
    return SafelyConvertExceptionObjectToHRESULT(e);
    // You must make sure that the above doesn't throw.
  }
}

Why?

Per COM rules, you need to make sure that exceptions don't escape any
COM call, hence try/catch. By default, _bstr_t may throw _com_error
(you can use _set_com_error_handler to override this). Also, since you
are using standard library, you run the danger of getting
std::exception, too. That's why I put two catches there.

In reality, in your code, probably nothing can go wrong except that
you can run out of memory. For example, constructor of _bstr_t will
throw if it can't create BSTR for a copy of ...c_str() that you want
to "detach" to the caller. For your code to be "by the book", it
should catch this error and return E_OUTOFMEMORY. (By the way, [out,
retval] param *pVal, as others have said, is in the hands of the
caller once you return - nothing to do there).

It's normally a bad idea to have multiple "base" exception classes,
because you want to avoid multiple catch clauses left and right. To
account for that with "compiler COM support" classes, such as _bstr_t,
you should use _set_com_error_handler. You can pass it a callback
function that will throw desired exception type (in this case,
something derived from std::exception seems good). At that point, one
catch in every STDMETHODIMP function is OK.

You should also take case to override AtlThrow in the same vein (look
for _ATL_CUSTOM_THROW and AtlThrowImpl in your ATL headers). If your
code also uses MFC, then _set_com_error_handler should get something
that throws CException*-based exception and there's nothing to do for
AtlThrow, MFC handles that.

This all may seem scary, but, frankly, there's no C++ without
exceptions. Standard library doesn't work without them, MFC doesn't
work without them, nor are simplest things like s=string1+string2
possible (or at least, correct) without them (granted, only reasonable
exception type in s1+s2 is out-of-memory, and that's almost always
only a theoretic possibility).

You might also say that you don't care about out-of-memory case and
that it's OK to just crash. At that point, however, you would probably
want to rig malloc and operator new to do that for you. But that's not
really in the spirit of the C and C++ languages ;-). And you're on
Windows, so there's no e.g. OOM killer to use as a cheap cop-out ;-).

HTH,
Goran.