{"id":102456,"date":"2019-04-29T07:00:00","date_gmt":"2019-04-29T14:00:00","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/oldnewthing\/?p=102456"},"modified":"2022-10-05T07:35:21","modified_gmt":"2022-10-05T14:35:21","slug":"20190429-00","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/oldnewthing\/20190429-00\/?p=102456","title":{"rendered":"Spotting problems with destructors for C++ temporaries"},"content":{"rendered":"

Consider the unique_<\/code>handle<\/code><\/a>. It specializes std::<\/code>unique_<\/code>ptr<\/code> to support Windows kernel handles. It lets you get all the niceties of std::<\/code>unique_<\/code>ptr<\/code> with just a handful of lines of code.<\/p>\n

But then you have the problem of interoperating with the rest of the system. For example, how would you use a unique_<\/code>handle<\/code> to receive the result of a duplication?<\/p>\n

unique_handle originalHandle = ...;\r\nunique_handle duplicateHandle;\r\n\r\nif (DuplicateHandle(\r\n      GetCurrentProcess(), originalHandle.get(),\r\n      GetCurrentProcess(), &duplicateHandle,\r\n      0, FALSE, DUPLICATE_SAME_ACCESS)) { ... }\r\n<\/pre>\n
This doesn’t compile because the operator&<\/code> for a unique_<\/code>ptr<\/code> doesn’t give you a pointer to the inner raw pointer. You’ll have to perform the operation in two steps.<\/p>\n
HANDLE rawDuplicateHandle = nullptr;\r\n\r\n\/\/ First, get a raw handle as the duplicate.\r\nauto result = DuplicateHandle(\r\n    GetCurrentProcess(), originalHandle.get(),\r\n    GetCurrentProcess(), &rawDuplicateHandle,\r\n    0, FALSE, DUPLICATE_SAME_ACCESS);\r\n\r\n\/\/ Then set it into the smart pointer.\r\nduplicateHandle.reset(rawDuplicateHandle);\r\n\r\n\/\/ Then see if it worked.\r\nif (result) { ... }\r\n<\/pre>\n
We could tune this a little:<\/p>\n
HANDLE rawDuplicateHandle;\r\n\r\n\/\/ Out with the old.\r\nduplicateHandle.reset();\r\n\r\n\/\/ Try to get a new handle.\r\nif (DuplicateHandle(\r\n      GetCurrentProcess(), originalHandle.get(),\r\n      GetCurrentProcess(), &rawDuplicateHandle,\r\n      0, FALSE, DUPLICATE_SAME_ACCESS)) {\r\n\r\n  \/\/ Save the new handle back into the smart pointer.\r\n  duplicateHandle.reset(rawDuplicateHandle);\r\n\r\n  ...\r\n}\r\n<\/pre>\n
But the underlying issue remains: Bridging the gap between the C++ unique_<\/code>ptr<\/code> and the system function that wants you to pass the address of a HANDLE<\/code>.<\/p>\n
You might decide to create a helper class whose job is to encapsulate this two-step dance, acting as a proxy between the raw handle and the smart pointer.<\/p>\n
struct handle_proxy\r\n{\r\n  handle_proxy(unique_handle& output)\r\n  : m_output(output) { }\r\n\r\n  ~handle_proxy() { m_output.reset(m_rawHandle); }\r\n\r\n  HANDLE* addressof() { return &m_rawHandle; }\r\n\r\n  \/\/ Not copyable, not movable.\r\n  handle_proxy(const handle_proxy&) = delete;\r\n  handle_proxy& operator=(const handle_proxy&) = delete;\r\n\r\n  unique_handle& m_output;\r\n  HANDLE m_rawHandle = nullptr;\r\n};\r\n<\/pre>\n
This proxy object lets you pass a HANDLE*<\/code> to functions that return a handle through a pointer, and when the proxy is destructed, it transfers the raw handle into the smart pointer.<\/p>\n
DuplicateHandle(\r\n    GetCurrentProcess(), originalHandle.get(),\r\n    GetCurrentProcess(), handle_proxy(duplicateHandle).addressof(),\r\n    0, FALSE, DUPLICATE_SAME_ACCESS);\r\n<\/pre>\n
What’s happening here is that we create a temporary handle_<\/code>proxy<\/code> object to pass to the Duplicate\u00adHandle<\/code> function. This temporary object remembers the unique_<\/code>handle<\/code> that it is proxying for, and produces the address of a plain old HANDLE<\/code> which is what gets passed to the to the Duplicate\u00adHandle<\/code> function. After the Duplicate\u00adHandle<\/code> function returns, the temporary is destructed, and the destructor takes the raw handle in m_rawHandle<\/code> and puts it into the smart pointer.<\/p>\n
As a convenience, you could add a conversion operator to save people the hassle of having to say addressof<\/code> all over the place.<\/p>\n
struct handle_proxy\r\n{\r\n  handle_proxy(unique_handle& output)\r\n  : m_output(output) { }\r\n\r\n  ~handle_proxy() { m_output.reset(m_rawHandle); }\r\n\r\n  HANDLE* addressof() { return &m_rawHandle; }\r\n  operator HANDLE*() { return addressof(); }<\/span>\r\n\r\n  \/\/ Not copyable, not movable.\r\n  handle_proxy(const handle_proxy&) = delete;\r\n  handle_proxy& operator=(const handle_proxy&) = delete;\r\n\r\n  unique_handle& m_output;\r\n  HANDLE m_rawHandle = nullptr;\r\n};\r\n\r\nDuplicateHandle(\r\n    GetCurrentProcess(), originalHandle.get(),\r\n    GetCurrentProcess(), handle_proxy(duplicateHandle)<\/span>,\r\n    0, FALSE, DUPLICATE_SAME_ACCESS);\r\n<\/pre>\n
Everything’s looking great, until somebody does this:<\/p>\n
\/\/ Try to duplicate the handle for EVENT_MODIFY_STATE access\r\n\/\/ and reset it.\r\nif (DuplicateHandle(\r\n      GetCurrentProcess(), originalHandle.get(),\r\n      GetCurrentProcess(), handle_proxy(duplicateHandle),\r\n      EVENT_MODIFY_STATE, FALSE, 0) &&\r\n    ResetEvent(duplicateHandle.get()) { ... }\r\n<\/pre>\n
Do you see the problem?<\/p>\n
The C++ rules for temporary objects is that they are destructed at the end of the “full expression” that contains them. This means that the temporary handle_<\/code>proxy<\/code> object doesn’t get destructed until the entire expression inside the if<\/code> statement has been evaluated, which means that the Reset\u00adEvent<\/code> happens before the proxy’s destructor can transfer the raw pointer into the smart pointer.<\/p>\n
    \n
  1. Create temporary handle_<\/code>proxy<\/code>.<\/li>\n
  2. Convert it to a HANDLE*<\/code>.<\/li>\n
  3. Call Duplicate\u00adHandle<\/code>.<\/li>\n
  4. Assuming Duplicate\u00adHandle<\/code> succeeds, call Reset\u00adEvent<\/code> with the duplicate\u00adHandle<\/code>.<\/li>\n
  5. Destruct the handle_<\/code>proxy<\/code>, which copies the raw handle into duplicate\u00adHandle<\/code>.<\/li>\n<\/ol>\n
    We want step 5 to happen before step 4, but the C++ rules for destruction of temporary objects forces the proxy to linger until after the expression has been evaluated.<\/p>\n
    What can we do?<\/p>\n
    One option is to introduce a dreaded macro which forces temporaries to be destructed prematurely.<\/p>\n
    #define DESTRUCT_TEMPORARIES(v) [&]() { return (v); }()\r\n<\/pre>\n
    This macro wraps the argument inside an immediately-evaluated lambda and propagates the value of the expression. This doesn’t seem to accomplish anything, but what it does is pull v<\/code> into its own full expression, thereby forcing its temporaries to be destructed immediately after its evaluation.<\/p>\n
    if (DESTRUCT_TEMPORARIES(<\/span>DuplicateHandle(\r\n      GetCurrentProcess(), originalHandle.get(),\r\n      GetCurrentProcess(), handle_proxy(duplicateHandle),\r\n      EVENT_MODIFY_STATE, FALSE, 0))<\/span> &&\r\n    ResetEvent(duplicateHandle.get()) { ... }\r\n<\/pre>\n
    This is ugly for multiple reasons. One is that it encourages passing multi-line entities to macros<\/a>. Second, it’s a macro used for something other than #ifdef<\/code><\/a>.<\/p>\n
    Another option is to manage the transfer explicitly.<\/p>\n
    struct handle_proxy\r\n{\r\n  handle_proxy(unique_handle& output)\r\n  : m_output(std::addressof(output)) { }\r\n\r\n  ~handle_proxy() { transfer(); }\r\n\r\n  void transfer()\r\n  {\r\n    if (m_output) {\r\n      std::exchange(m_output, {})->reset(m_rawHandle);\r\n    }\r\n  }<\/span>\r\n\r\n  HANDLE* addressof() { return &m_rawHandle; }\r\n  operator HANDLE*() { return addressof(); }\r\n\r\n  \/\/ Not copyable.\r\n  handle_proxy(const handle_proxy&) = delete;\r\n  handle_proxy& operator=(const handle_proxy&) = delete;\r\n\r\n  \/\/ Movable.\r\n  handle_proxy(handle_proxy&& other)\r\n  : m_output(std::exchange(other.m_output, {})),\r\n    m_rawHandle(std::exchange(other.m_rawHandle, {})) { }\r\n\r\n  handle_proxy& operator=(handle_proxy&& other)\r\n  {\r\n    transfer();\r\n    m_output = std::exchange(other.m_output, {});\r\n    m_rawHandle = std::exchange(other.m_rawHandle, {});\r\n  }\r\n\r\n  unique_handle* m_output;\r\n  HANDLE m_rawHandle = nullptr;\r\n};\r\n<\/pre>\n
    In this version, we capture a raw pointer to the unique_<\/code>handle<\/code> so that we have a way to keep track of whether the result has been transferred or not: If the pointer is nullptr<\/code>, then the transfer has already taken place.<\/p>\n
    Now that we have a way to say “Nothing to transfer,” we can add a move constructor and move assignment operator, both of which leave the source in the “Nothing to do” state.<\/p>\n
    You can continue to use this version of the handle_proxy<\/code> the same as the previous version, or you can opt to trigger the transfer early:<\/p>\n
    if (auto proxy = handle_proxy(duplicateHandle);<\/span>\r\n    DuplicateHandle(\r\n      GetCurrentProcess(), originalHandle.get(),\r\n      GetCurrentProcess(), proxy,\r\n      EVENT_MODIFY_STATE, FALSE, 0))<\/span> &&\r\n    (proxy.transfer()<\/span>, ResetEvent(duplicateHandle.get())) { ... }\r\n<\/pre>\n
    This is still pretty ugly. You can clean it up a little by having the transfer function also return the handle that it transferred.<\/p>\n
    struct handle_proxy\r\n{\r\n  ...\r\n  HANDLE<\/span> transfer()\r\n  {\r\n    if (m_output) {\r\n      std::exchange(m_output, {})->reset(m_rawHandle);\r\n    }\r\n    return m_rawHandle;<\/span>\r\n  }\r\n  ...\r\n};\r\n\r\nif (auto proxy = handle_proxy(duplicateHandle);\r\n    DuplicateHandle(\r\n      GetCurrentProcess(), originalHandle.get(),\r\n      GetCurrentProcess(), proxy,\r\n      EVENT_MODIFY_STATE, FALSE, 0)) &&\r\n    ResetEvent(proxy.transfer()<\/span>)) { ... }\r\n<\/pre>\n
    It’s a little less ugly, but also more puzzling.<\/p>\n
    Perhaps the way out is simply to split it into two expressions.<\/p>\n
    if (DuplicateHandle(\r\n      GetCurrentProcess(), originalHandle.get(),\r\n      GetCurrentProcess(), handle_proxy(duplicateHandle),\r\n      EVENT_MODIFY_STATE, FALSE, 0)) {\r\n\r\n  \/\/ Test separately to give handly_proxy's destructor a chance to\r\n  \/\/ put the result into duplicateHandle before we read it out.\r\n  if (ResetEvent(duplicateHandle.get())) { ... }\r\n}\r\n<\/pre>\n
    If you are willing to wrap every system function you need to interact with, you could add a wrapper that returns a unique_<\/code>handle<\/code> directly.<\/p>\n
    unique_handle DuplicateAndReturnHandle(\r\n    HANDLE sourceProcess,\r\n    HANDLE sourceHandle,\r\n    HANDLE targetProcess,\r\n    DWORD desiredAccess,\r\n    BOOL  inheritHandle,\r\n    DWORD options)\r\n{\r\n  HANDLE targetHandle;\r\n  if (DuplicateHandle(sourceProcess, sourceHandle,\r\n                      targetProcess, &targetHandle,\r\n                      desiredAccess, inheritHandle, options)) {\r\n    return unique_handle{ targetHandle };\r\n  }\r\n  return {};\r\n}\r\n\r\nif ((duplicateHandle = DuplicateAndReturnHandle(\r\n      GetCurrentProcess(), originalHandle.get(),\r\n      GetCurrentProcess(), EVENT_MODIFY_STATE, FALSE, 0)) &&\r\n  ResetEvent(duplicateHandle.get())) { ... }\r\n}\r\n<\/pre>\n
    The downside of this is that you have an entire library of wrapper functions you’ll have to maintain. And if the function is like Reg\u00adOpen\u00adKey\u00adEx<\/code> and returns information in addition to the handle, you’ll have to put it into a std::<\/code>tuple<\/code> or a std::<\/code>variant<\/code>, which is another level of bother.<\/p>\n
    Consider the  unique_<\/code>handle<\/code><\/a>. It specializes std::<\/code>unique_<\/code>ptr<\/code> to support Windows kernel handles. It lets you get all the niceties of std::<\/code>unique_<\/code>ptr<\/code> with just a handful of lines of code.<\/p>\n
    But then you have the problem of interoperating with the rest of the system. For example, how would you use a unique_<\/code>handle<\/code> to receive the result of a duplication?<\/p>\n
    unique_handle originalHandle = ...;\r\nunique_handle duplicateHandle;\r\n\r\nif (DuplicateHandle(\r\n      GetCurrentProcess(), originalHandle.get(),\r\n      GetCurrentProcess(), &duplicateHandle,\r\n      0, FALSE, DUPLICATE_SAME_ACCESS)) { ... }\r\n<\/pre>\n
    This doesn’t compile because the operator&<\/code> for a unique_<\/code>ptr<\/code> doesn’t give you a pointer to the inner raw pointer. You’ll have to perform the operation in two steps.<\/p>\n
    HANDLE rawDuplicateHandle = nullptr;\r\n\r\n\/\/ First, get a raw handle as the duplicate.\r\nauto result = DuplicateHandle(\r\n    GetCurrentProcess(), originalHandle.get(),\r\n    GetCurrentProcess(), &rawDuplicateHandle,\r\n    0, FALSE, DUPLICATE_SAME_ACCESS);\r\n\r\n\/\/ Then set it into the smart pointer.\r\nduplicateHandle.reset(rawDuplicateHandle);\r\n\r\n\/\/ Then see if it worked.\r\nif (result) { ... }\r\n<\/pre>\n
    We could tune this a little:<\/p>\n
    HANDLE rawDuplicateHandle;\r\n\r\n\/\/ Out with the old.\r\nduplicateHandle.reset();\r\n\r\n\/\/ Try to get a new handle.\r\nif (DuplicateHandle(\r\n      GetCurrentProcess(), originalHandle.get(),\r\n      GetCurrentProcess(), &rawDuplicateHandle,\r\n      0, FALSE, DUPLICATE_SAME_ACCESS)) {\r\n\r\n  \/\/ Save the new handle back into the smart pointer.\r\n  duplicateHandle.reset(rawDuplicateHandle);\r\n\r\n  ...\r\n}\r\n<\/pre>\n
    But the underlying issue remains: Bridging the gap between the C++ unique_<\/code>ptr<\/code> and the system function that wants you to pass the address of a HANDLE<\/code>.<\/p>\n
    You might decide to create a helper class whose job is to encapsulate this two-step dance, acting as a proxy between the raw handle and the smart pointer.<\/p>\n
    struct handle_proxy\r\n{\r\n  handle_proxy(unique_handle& output)\r\n  : m_output(output) { }\r\n\r\n  ~handle_proxy() { m_output.reset(m_rawHandle); }\r\n\r\n  HANDLE* addressof() { return &m_rawHandle; }\r\n\r\n  \/\/ Not copyable, not movable.\r\n  handle_proxy(const handle_proxy&) = delete;\r\n  handle_proxy& operator=(const handle_proxy&) = delete;\r\n\r\n  unique_handle& m_output;\r\n  HANDLE m_rawHandle = nullptr;\r\n};\r\n<\/pre>\n
    This proxy object lets you pass a HANDLE*<\/code> to functions that return a handle through a pointer, and when the proxy is destructed, it transfers the raw handle into the smart pointer.<\/p>\n
    DuplicateHandle(\r\n    GetCurrentProcess(), originalHandle.get(),\r\n    GetCurrentProcess(), handle_proxy(duplicateHandle).addressof(),\r\n    0, FALSE, DUPLICATE_SAME_ACCESS);\r\n<\/pre>\n
    What’s happening here is that we create a temporary handle_<\/code>proxy<\/code> object to pass to the Duplicate\u00adHandle<\/code> function. This temporary object remembers the unique_<\/code>handle<\/code> that it is proxying for, and produces the address of a plain old HANDLE<\/code> which is what gets passed to the to the Duplicate\u00adHandle<\/code> function. After the Duplicate\u00adHandle<\/code> function returns, the temporary is destructed, and the destructor takes the raw handle in m_rawHandle<\/code> and puts it into the smart pointer.<\/p>\n
    As a convenience, you could add a conversion operator to save people the hassle of having to say addressof<\/code> all over the place.<\/p>\n
    struct handle_proxy\r\n{\r\n  handle_proxy(unique_handle& output)\r\n  : m_output(output) { }\r\n\r\n  ~handle_proxy() { m_output.reset(m_rawHandle); }\r\n\r\n  HANDLE* addressof() { return &m_rawHandle; }\r\n  operator HANDLE*() { return addressof(); }<\/span>\r\n\r\n  \/\/ Not copyable, not movable.\r\n  handle_proxy(const handle_proxy&) = delete;\r\n  handle_proxy& operator=(const handle_proxy&) = delete;\r\n\r\n  unique_handle& m_output;\r\n  HANDLE m_rawHandle = nullptr;\r\n};\r\n\r\nDuplicateHandle(\r\n    GetCurrentProcess(), originalHandle.get(),\r\n    GetCurrentProcess(), handle_proxy(duplicateHandle)<\/span>,\r\n    0, FALSE, DUPLICATE_SAME_ACCESS);\r\n<\/pre>\n
    Everything’s looking great, until somebody does this:<\/p>\n
    \/\/ Try to duplicate the handle for EVENT_MODIFY_STATE access\r\n\/\/ and reset it.\r\nif (DuplicateHandle(\r\n      GetCurrentProcess(), originalHandle.get(),\r\n      GetCurrentProcess(), handle_proxy(duplicateHandle),\r\n      EVENT_MODIFY_STATE, FALSE, 0) &&\r\n    ResetEvent(duplicateHandle.get()) { ... }\r\n<\/pre>\n
    Do you see the problem?<\/p>\n
    The C++ rules for temporary objects is that they are destructed at the end of the “full expression” that contains them. This means that the temporary handle_<\/code>proxy<\/code> object doesn’t get destructed until the entire expression inside the if<\/code> statement has been evaluated, which means that the Reset\u00adEvent<\/code> happens before the proxy’s destructor can transfer the raw pointer into the smart pointer.<\/p>\n
      \n
    1. Create temporary handle_<\/code>proxy<\/code>.<\/li>\n
    2. Convert it to a HANDLE*<\/code>.<\/li>\n
    3. Call Duplicate\u00adHandle<\/code>.<\/li>\n
    4. Assuming Duplicate\u00adHandle<\/code> succeeds, call Reset\u00adEvent<\/code> with the duplicate\u00adHandle<\/code>.<\/li>\n
    5. Destruct the handle_<\/code>proxy<\/code>, which copies the raw handle into duplicate\u00adHandle<\/code>.<\/li>\n<\/ol>\n
      We want step 5 to happen before step 4, but the C++ rules for destruction of temporary objects forces the proxy to linger until after the expression has been evaluated.<\/p>\n
      What can we do?<\/p>\n
      One option is to introduce a dreaded macro which forces temporaries to be destructed prematurely.<\/p>\n
      #define DESTRUCT_TEMPORARIES(v) [&]() { return (v); }()\r\n<\/pre>\n
      This macro wraps the argument inside an immediately-evaluated lambda and propagates the value of the expression. This doesn’t seem to accomplish anything, but what it does is pull v<\/code> into its own full expression, thereby forcing its temporaries to be destructed immediately after its evaluation.<\/p>\n
      if (DESTRUCT_TEMPORARIES(<\/span>DuplicateHandle(\r\n      GetCurrentProcess(), originalHandle.get(),\r\n      GetCurrentProcess(), handle_proxy(duplicateHandle),\r\n      EVENT_MODIFY_STATE, FALSE, 0))<\/span> &&\r\n    ResetEvent(duplicateHandle.get()) { ... }\r\n<\/pre>\n
      This is ugly for multiple reasons. One is that  it encourages passing multi-line entities to macros<\/a>. Second, it’s a macro used  for something other than #ifdef<\/code><\/a>.<\/p>\n
      Another option is to manage the transfer explicitly.<\/p>\n
      struct handle_proxy\r\n{\r\n  handle_proxy(unique_handle& output)\r\n  : m_output(std::addressof(output)) { }\r\n\r\n  ~handle_proxy() { transfer(); }\r\n\r\n  void transfer()\r\n  {\r\n    if (m_output) {\r\n      std::exchange(m_output, {})->reset(m_rawHandle);\r\n    }\r\n  }<\/span>\r\n\r\n  HANDLE* addressof() { return &m_rawHandle; }\r\n  operator HANDLE*() { return addressof(); }\r\n\r\n  \/\/ Not copyable.\r\n  handle_proxy(const handle_proxy&) = delete;\r\n  handle_proxy& operator=(const handle_proxy&) = delete;\r\n\r\n  \/\/ Movable.\r\n  handle_proxy(handle_proxy&& other)\r\n  : m_output(std::exchange(other.m_output, {})),\r\n    m_rawHandle(std::exchange(other.m_rawHandle, {})) { }\r\n\r\n  handle_proxy& operator=(handle_proxy&& other)\r\n  {\r\n    transfer();\r\n    m_output = std::exchange(other.m_output, {});\r\n    m_rawHandle = std::exchange(other.m_rawHandle, {});\r\n  }\r\n\r\n  unique_handle* m_output;\r\n  HANDLE m_rawHandle = nullptr;\r\n};\r\n<\/pre>\n
      In this version, we capture a raw pointer to the unique_<\/code>handle<\/code> so that we have a way to keep track of whether the result has been transferred or not: If the pointer is nullptr<\/code>, then the transfer has already taken place.<\/p>\n
      Now that we have a way to say “Nothing to transfer,” we can add a move constructor and move assignment operator, both of which leave the source in the “Nothing to do” state.<\/p>\n
      You can continue to use this version of the handle_proxy<\/code> the same as the previous version, or you can opt to trigger the transfer early:<\/p>\n
      if (auto proxy = handle_proxy(duplicateHandle);<\/span>\r\n    DuplicateHandle(\r\n      GetCurrentProcess(), originalHandle.get(),\r\n      GetCurrentProcess(), proxy,\r\n      EVENT_MODIFY_STATE, FALSE, 0))<\/span> &&\r\n    (proxy.transfer()<\/span>, ResetEvent(duplicateHandle.get())) { ... }\r\n<\/pre>\n
      This is still pretty ugly. You can clean it up a little by having the transfer function also return the handle that it transferred.<\/p>\n
      struct handle_proxy\r\n{\r\n  ...\r\n  HANDLE<\/span> transfer()\r\n  {\r\n    if (m_output) {\r\n      std::exchange(m_output, {})->reset(m_rawHandle);\r\n    }\r\n    return m_rawHandle;<\/span>\r\n  }\r\n  ...\r\n};\r\n\r\nif (auto proxy = handle_proxy(duplicateHandle);\r\n    DuplicateHandle(\r\n      GetCurrentProcess(), originalHandle.get(),\r\n      GetCurrentProcess(), proxy,\r\n      EVENT_MODIFY_STATE, FALSE, 0)) &&\r\n    ResetEvent(proxy.transfer()<\/span>)) { ... }\r\n<\/pre>\n
      It’s a little less ugly, but also more puzzling.<\/p>\n
      Perhaps the way out is simply to split it into two expressions.<\/p>\n
      if (DuplicateHandle(\r\n      GetCurrentProcess(), originalHandle.get(),\r\n      GetCurrentProcess(), handle_proxy(duplicateHandle),\r\n      EVENT_MODIFY_STATE, FALSE, 0)) {\r\n\r\n  \/\/ Test separately to give handly_proxy's destructor a chance to\r\n  \/\/ put the result into duplicateHandle before we read it out.\r\n  if (ResetEvent(duplicateHandle.get())) { ... }\r\n}\r\n<\/pre>\n
      If you are willing to wrap every system function you need to interact with, you could add a wrapper that returns a unique_<\/code>handle<\/code> directly.<\/p>\n
      unique_handle DuplicateAndReturnHandle(\r\n    HANDLE sourceProcess,\r\n    HANDLE sourceHandle,\r\n    HANDLE targetProcess,\r\n    DWORD desiredAccess,\r\n    BOOL  inheritHandle,\r\n    DWORD options)\r\n{\r\n  HANDLE targetHandle;\r\n  if (DuplicateHandle(sourceProcess, sourceHandle,\r\n                      targetProcess, &targetHandle,\r\n                      desiredAccess, inheritHandle, options)) {\r\n    return unique_handle{ targetHandle };\r\n  }\r\n  return {};\r\n}\r\n\r\nif ((duplicateHandle = DuplicateAndReturnHandle(\r\n      GetCurrentProcess(), originalHandle.get(),\r\n      GetCurrentProcess(), EVENT_MODIFY_STATE, FALSE, 0)) &&\r\n  ResetEvent(duplicateHandle.get())) { ... }\r\n}\r\n<\/pre>\n
      The downside of this is that you have an entire library of wrapper functions you’ll have to maintain. And if the function is like Reg\u00adOpen\u00adKey\u00adEx<\/code> and returns information in addition to the handle, you’ll have to put it into a std::<\/code>tuple<\/code> or a std::<\/code>variant<\/code>, which is another level of bother.<\/p>\n","protected":false},"excerpt":{"rendered":"
      It’s sometimes later than you want.<\/p>\n","protected":false},"author":1069,"featured_media":111744,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[25],"class_list":["post-102456","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-oldnewthing","tag-code"],"acf":[],"blog_post_summary":"
      It’s sometimes later than you want.<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/102456","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/users\/1069"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/comments?post=102456"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/102456\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/media\/111744"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/media?parent=102456"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/categories?post=102456"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/tags?post=102456"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}