C++Winrt how to throw and handle exception without terminating program

Question

I have following code

IAsyncOperation<bool> trythiswork()
    {
        bool contentFound{ false };
        try
        {
            auto result = co_await someAsyncFunc();
            winrt::check_bool(result)
            if (result)
            {
                contentFound = true;
            }
        }
        catch (...)
        {
            LOG_CAUGHT_EXCEPTION();
        }
        co_return contentFound;
    }

When the result is false, it fails and throws but catch goes to fail fast and program terminates. How does log function terminate the program? Isn't it supposed to only log the exception? I assumed that I am handling this exception so program won't crash but it is crashing. So how to throw and catch so that program does not terminate? I do want to throw. And also catch and preferably log the exception as well. Thanks

Answer 1

The issue can be reproduced using the following code:

IAsyncOperation<bool> someAsyncFunc() { co_return false; }

IAsyncOperation<bool> trythiswork()
{
    auto contentFound { false };
    try
    {
        auto result = co_await someAsyncFunc();
        winrt::check_bool(result);
        // throw std::bad_alloc {};
        contentFound = true;
    }
    catch (...)
    {
        LOG_CAUGHT_EXCEPTION();
    }
    co_return contentFound;
}

int main()
{
    init_apartment();
    auto result = trythiswork().get();
}

As it turns out, everything works as advertised, even if not as intended. When running the code with a debugger attached you will see the following debug output:

The exception %s (0x [trythiswork]

Not very helpful, but it shows that logging itself works. This is followed up by something like

FailFast(1) tid(b230) 8007023E {Application Error}

causing the process to terminate. The WIL only recognizes exceptions of type std::exception, wil::ResultException, and Platform::Exception^. When it handles an unrecognized exception type it will terminate the process by default. This can be verified by commenting out the call to check_bool and instead throwing a standard exception (such as std::bad_alloc). This produces a program that will log exception details, but continue to execute.

The behavior can be customized by registering a callback for custom exception types, giving clients control over translating between custom exception types and HRESULT values. This is useful in cases where WIL needs to interoperate with external library code that uses its own exception types.

For C++/WinRT exception types (based on hresult_error) the WIL already provides error handling helpers that can be enabled (see Integrating with C++/WinRT). To opt into this all you need to do is to #include <wil/cppwinrt.h> before any C++/WinRT headers. When using precompiled headers that's where the #include directive should go.

With that change, the program now works as desired: It logs exception information for exceptions that originate from C++/WinRT, and continues to execute after the exception has been handled.