Throwing C++ exceptions with CoInitialize and CoUninitialize

Question

I have a function like this:

bool op1();
bool op2();

bool foo() {
  CoInitialize(nullptr);
  if (!op1()) {
    CoUninitialize();
    return false;
  }
  // do more stuff, then call op2...
  if (!op2()) {
    CoUninitialize();
    return false;
  }
  // happy path
  CoUninitialize();
  return true;
}

I want to refactor foo() to throw exceptions:

void foo() {
  CoInitialize(nullptr);
  if (!op1()) {
    CoUninitialize(); // I'm lazy, can't I automate this call?
    throw std::exception("Failed");
  }
  // ...

But I have to call CoUninitialize() each time I have an error.

I thought about wrapping the COM init calls inside a class, so the destructor will do the cleanup, but having an unused object feels strange to my eyes:

class comlib {
public:
  comlib() { CoInitialize(nullptr); }
  ~comlib() { CoUninitialize(); } // automated!
};

void foo() {
  comlib nobodyEverCallsMe;
  if (!op1()) {
    throw std::exception("Failed");
  }
  // ...

Is there a better approach to this?

Answer 1

Raymond Chen has been using this method for a while so I'm sure it's OK, just remember to only call CoUninitialize if CoInitialize SUCCEEDED!

class CCoInitialize {
  HRESULT m_hr;
public:
  CCoInitialize() : m_hr(CoInitialize(NULL)) { }
  ~CCoInitialize() { if (SUCCEEDED(m_hr)) CoUninitialize(); }
  operator HRESULT() const { return m_hr; }
};


void Something()
{
  CCoInitialize init;
  ...
}

Some people might want to throw in the constructor if CoInitialize fails but I feel that's unnecessary because other COM calls down the line will fail. Only do it if you need to capture the exact HRESULT failure code from CoInitialize.

Answer 2

Is there a better approach to this?

No.

Using the RAII (Responsibility¹ Acquisition is Initialization) idiom to clean up upon exit is the standard C++ solution to the problem you are trying to solve. In case of COM, I would propose the following implementation:

#include <Windows.h>
#include <comdef.h>

struct com_init
{
    com_init()
    {
        HRESULT hr{::CoInitialize(nullptr)};
        if (FAILED(hr))
        {
            throw _com_error{hr};  // _com_error is declared in comdef.h
        }
    }
    com_init(com_init const&) = delete;
    com_init& operator=(com_init const&) = delete;

    ~com_init()
    {
        ::CoUninitialize();
    }
};

Which is used in your example like this:

void foo()
{
    com_init guard{};

    if (!op1())
        throw std::exception{"Failed"};
    // ...

With C++17 it is possible to mark objects as [[maybe_unused]], to both prevent compiler warnings as well as communicate intent.

Rationale:

The implementation uses a constructor that throws an exception upon failure. There are many good reasons to do so:

• Space: This implementation does not need to store any state information to allow the destructor to conditionally perform cleanup.
• Consistency: C++ is built around exceptions. Interleaving exception based code with code that reports errors through error codes is both confusing as well as harder to comprehend.
• Reliability: Failure to initialize COM is a catastrophic failure. There is no conceivable way to recover from it. It must not be ignored. You cannot ignore exceptions. The default for error codes is to ignore them; you need not do anything to do so.

---

¹ Usually tagged "Resource", but that doesn't quite live up to the versatility it provides. I prefer "Responsibility".