Making an agile version of a Windows Runtime delegate in C++/WinRT, part 7

Making an agile version of a Windows Runtime delegate in C++/WinRT, part 7 - The Old New Thing

Dev Blogs

All .NET posts

.NET MAUI ASP.NET Core Blazor Entity Framework

C++ C# F# TypeScript

NuGet Servicing .NET Blog in Chinese

Microsoft for Developers Agent Framework Develop from the cloud Xcode ISE Developer TypeScript PowerShell Python Java Java Blog in Chinese Go Microsoft Edge Dev Microsoft 365 Developer Microsoft Entra Identity Developer Microsoft Entra PowerShell

Visual Studio Visual Studio Code Aspire

All things Azure Azure SDK Azure VM Runtime Team Microsoft Azure Azure Cosmos DB Azure DocumentDB Azure Data Studio Azure SQL DevOps DirectX Microsoft Foundry Power Platform

OData Unified Data Model (IDEAs)

Windows Command Line #ifdef Windows Inside MSIX MIDI and music React Native The Old New Thing Windows Developer

Raymond Chen

Last time, we fixed the problem of creating a unique_ptr whose deleter’s constructor was might throw an exception. But we’re not out of the woods yet.

Let’s take another look at what we have:

if (d.try_as()) { void* p; if constexpr (std::is_reference_v) { p = winrt::detach_abi(d); } else { winrt::copy_to_abi(d, p); return [p = std::unique_ptr(p, {}), token = get_context_token()](auto&&...args) { if (token == get_context_token()) { std::remove_reference_t d; winrt::copy_from_abi(d, p.get()); d(std::forward(args)...); } else { throw winrt::hresult_error(CO_E_NOT_SUPPORTED); };

We had originally broken the rule that the unique_ptr(p) constructor requires that the deleter’s default constructor not throw an exception. We fixed it by constructing the deleter explicitly as a parameter, so that the unique_ptr constructor can move it into the stored deleter without an exception.

But wait, if an exception occurs in construction of the in_context_deleter, the raw pointer we created in the previous block will be leaked. It owns a reference count but doesn’t clean up in the case of an exception.

We can fix this by creating the deleter first.

if (d.try_as()) { in_context_deleter del; void* p; if constexpr (std::is_reference_v) { p = winrt::detach_abi(d); } else { winrt::copy_to_abi(d, p); return [p = std::unique_ptr(p, std::move(del)), token = get_context_token()](auto&&...args) { if (token == get_context_token()) { std::remove_reference_t d; winrt::copy_from_abi(d, p.get()); d(std::forward(args)...); } else { throw winrt::hresult_error(CO_E_NOT_SUPPORTED); };

If there is an exception constructing the custom deleter, it happens before we initialze the raw pointer, so there is no leak of the reference owned by that raw pointer.

Okay, so are we done now?

Nope.

More next time.

Category Old New Thing

Topics Code

Author

Raymond Chen

Raymond has been involved in the evolution of Windows for more than 30 years. In 2003, he began a Web site known as The Old New Thing which has grown in popularity far beyond his wildest imagination, a development which still gives him the heebie-jeebies. The Web site spawned a book, coincidentally also titled The Old New Thing (Addison Wesley 2007). He occasionally appears on the Windows Dev Docs Twitter account to tell stories which convey no useful information.

3 comments

Join the discussion.

Making an agile version of a Windows Runtime delegate in C++/WinRT, part 7

Related Articles

(no title)

Scientists reverse brain aging, with a nasal spray

AI has torched the market for junior programmers

Al Vigier: Canada's AI strategy shouldn't include secret Palantir bills

The Anatomy of an AI-Native Org