{"id":108278,"date":"2023-06-02T07:00:00","date_gmt":"2023-06-02T14:00:00","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/oldnewthing\/?p=108278"},"modified":"2023-06-02T09:24:21","modified_gmt":"2023-06-02T16:24:21","slug":"20230602-00","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/oldnewthing\/20230602-00\/?p=108278","title":{"rendered":"C++\/WinRT event handlers that are lambdas with weak pointers to the parent class, part 3"},"content":{"rendered":"

Last time, we created a helper function for creating a delegate from a weak pointer and a lambda<\/a>. The weak pointer in question was a C++\/WinRT weak pointer, but maybe you want to use this from a traditional C++ class, in which case what you have is not a winrt::weak_ref<\/code> but rather a std::weak_ptr<\/code>. Let’s adapt our function to work with std::weak_ptr<\/code> too.<\/p>\n

Recall that we left off last time with this function:<\/p>\n

template<typename T, typename Handler>\r\nauto weak_delegate(\r\n    winrt::weak_ref<T> weak,\r\n    Handler&& handler)\r\n{\r\n  return [weak = std::move(weak),\r\n          handler = std::forward<Handler>(handler)]\r\n    (auto&&... args) mutable\r\n    {\r\n      if (auto strong = weak.get()) {\r\n        handler(std::forward<decltype(args)>(args)...);\r\n      }\r\n    };\r\n}\r\n<\/pre>\n
The only difference that matters (for our purposes) between winrt::weak_ref<\/code> and std::weak_ptr<\/code> is that winrt::weak_ref<\/code> uses the get()<\/code> method to promote the weak reference to a strong reference, whereas the corresponding method on std::weak_ptr<\/code> is called lock()<\/code>.<\/p>\n
What we want to do is something weird like<\/p>\n
template<typename Weak, typename Handler>\r\nauto weak_delegate(\r\n    Weak&& weak,\r\n    Handler&& handler)\r\n{\r\n  return [weak = std::forward<Weak>(weak),\r\n          handler = std::forward<Handler>(handler)]\r\n    (auto&&... args) mutable\r\n    {\r\n      if constexpr (is_specialization_v<Weak, std::weak_ptr>) {<\/span>\r\n        auto strong = weak.lock();\r\n      } else {\r\n        auto strong = weak.get();\r\n      }\r\n      if (strong) {\r\n        handler(std::forward<decltype(args)>(args)...);\r\n      }\r\n    };\r\n}\r\n<\/pre>\n
But that doesn’t work because the scope of strong<\/code> is wrong.\u00b9<\/p>\n
What we could do is turn it into a lambda:<\/p>\n
template<typename Weak, typename Handler>\r\nauto weak_delegate(\r\n    Weak&& weak,\r\n    Handler&& handler)\r\n{\r\n  return [weak = std::forward<Weak>(weak),\r\n          handler = std::forward<Handler>(handler)]\r\n    (auto&&... args) mutable\r\n    {\r\n      auto strong = [&] {<\/span>\r\n        if constexpr (is_specialization_v<Weak, std::weak_ptr>) {\r\n          return<\/span> weak.lock();\r\n        } else {\r\n          return<\/span> weak.get();\r\n        }\r\n      }()<\/span>;\r\n      if (strong) {\r\n        handler(std::forward<decltype(args)>(args)...);\r\n      }\r\n    };\r\n}\r\n<\/pre>\n
Now, writing that is_specialization_v<\/code> thingie is going to be a bit of an annoyance, but it turns out we don’t need to do it. We can let function overloading do the work.<\/p>\n
template<typename... Extra>\r\nauto try_resolve_weak_pointer_to_strong(std::weak_ptr<Extra...> const& weak)\r\n{\r\n    return weak.lock();\r\n}\r\n\r\ntemplate<typename... Extra>\r\nauto try_resolve_weak_pointer_to_strong(winrt::weak_ref<Extra...> const& weak)\r\n{\r\n    return weak.get();\r\n}\r\n\r\ntemplate<typename Weak, typename Handler>\r\nauto weak_delegate(\r\n    Weak&& weak,\r\n    Handler&& handler)\r\n{\r\n  return [weak = std::forward<Weak>(weak),\r\n          handler = std::forward<Handler>(handler)]\r\n    (auto&&... args) mutable\r\n    {\r\n      if (auto strong = try_resolve_weak_pointer_to_strong(weak))<\/span> {\r\n        handler(std::forward<decltype(args)>(args)...);\r\n      }\r\n    };\r\n}\r\n<\/pre>\n
The try_resolve_weak_pointer_to_strong<\/code> functions use a trick we looked at  a little while ago<\/a>.<\/p>\n
Now you can use weak_delegate<\/code> with C++ standard library weak pointers, as well as C++\/WinRT weak references.<\/p>\n
struct MyClass : std::enable_shared_from_this<MyClass>\r\n{\r\n    ...\r\n\r\n    void RegisterSomething(int otherData)\r\n    {\r\n      widget.Something(weak_delegate(weak_from_this(),<\/span>\r\n        [this, otherData]\r\n        (auto&& sender, auto&& args)\r\n        {\r\n          DoThing1(sender);\r\n          DoThing2(args);\r\n          DoThing3(otherData);\r\n        })<\/span>);\r\n    }\r\n};\r\n<\/pre>\n
A benefit of delegating the “resolve a weak pointer to a strong pointer” decision to a function overload is that you can extend support to other weak pointer libraries by adding new overloads.<\/p>\n
\/\/ WRL WeakRef\r\nauto try_resolve_weak_pointer_to_strong(::Microsoft::WRL::WeakRef const& weak)\r\n{\r\n    ::Microsoft::WRL::ComPtr<IInspectable> o;\r\n    weak.As(&o);\r\n    return o;\r\n}\r\n\r\n\/\/ wil com_weak_ptr\r\ntemplate<typename... Extra>\r\nauto try_resolve_weak_pointer_to_strong(\r\n    wil::com_ptr<IWeakReference, Extra...> const& weak)\r\n{\r\n    return weak.try_copy<IUnknown>();\r\n}\r\n\r\n\/\/ Unreal Engine TWeakPtr\r\ntemplate<typename... Extra>\r\nauto try_resolve_weak_pointer_to_strong(TWeakPtr<Extra...> const& weak)\r\n{\r\n    return weak.Pin();\r\n}\r\n\r\n\/\/ Unreal Engine TWeakObjectPtr\r\ntemplate<typename... Extra>\r\nauto try_resolve_weak_pointer_to_strong(TWeakObjectPtr<Extra...> const& weak)\r\n{\r\n    return weak.Get();\r\n}\r\n\r\n\/\/ Qt QWeakPointer\r\ntemplate<typename... Extra>\r\nauto try_resolve_weak_pointer_to_strong(QWeakPointer<Extra...> const& weak)\r\n{\r\n    return weak.toStrongRef();\r\n}\r\n<\/pre>\n
Note that we are using the Extra...<\/code> technique for  accepting any specialization of a C++ template type<\/a>.\u00b2<\/p>\n
The case of wil<\/code> is a little tricky because com_weak_ptr<\/code> is itself a template alias. We have to use the name of the base template type rather than the type alias.<\/p>\n
\u00b9 If you decide to deepen the  sad history of Visual Studios custom __if_exists<\/code> keyword<\/a>, you could write<\/p>\n
template<typename Weak, typename Handler>\r\nauto weak_delegate(\r\n    Weak&& weak,\r\n    Handler&& handler)\r\n{\r\n  return [weak = std::forward<Weak>(weak),\r\n          handler = std::forward<Handler>(handler)]\r\n    (auto&&... args) mutable\r\n    {\r\n      __if_exists(Weak::get)<\/span> {\r\n        auto strong = weak.get();\r\n      }\r\n      __if_exists(Weak::lock)<\/span> {\r\n        auto strong = weak.lock();\r\n      }\r\n      if (strong) {\r\n        handler(std::forward<decltype(args)>(args)...);\r\n      }\r\n    };\r\n}\r\n<\/pre>\n
But please, don’t do that. Use SFINAE instead.<\/p>\n
\u00b2 Others have noted that the Extra...<\/code> trick doesn’t work for templates that take non-type template parameters or other templates, so maybe SFINAE is the way to go after all.<\/p>\n
\/\/ winrt weak_ref\r\ntemplate<typename T>\r\nauto try_resolve_weak_pointer_to_strong(T const& weak)\r\n-> decltype(weak.get())\r\n{\r\n    return weak.get();\r\n}\r\n\r\n\/\/ std weak_ptr\r\ntemplate<typename T>\r\nauto try_resolve_weak_pointer_to_strong(T const& weak)\r\n-> decltype(weak.lock())\r\n{\r\n    return weak.lock();\r\n}\r\n\r\n\/\/ WRL WeakRef (no change)\r\nauto try_resolve_weak_pointer_to_strong(::Microsoft::WRL::WeakRef const& weak)\r\n{\r\n    ::Microsoft::WRL::ComPtr<IInspectable> o;\r\n    weak.As(&o);\r\n    return o;\r\n}\r\n\r\n\/\/ wil com_weak_ptr\r\ntemplate<typename T>\r\nauto try_resolve_weak_pointer_to_strong(T const& weak)\r\n-> decltype(weak.try_copy<IUnknown>())\r\n{\r\n    return weak.try_copy<IUnknown>();\r\n}\r\n\r\n\/\/ Unreal Engine TWeakPtr\r\ntemplate<typename T>\r\nauto try_resolve_weak_pointer_to_strong(T const& weak)\r\n-> decltype(weak.Pin())\r\n{\r\n    return weak.Pin();\r\n}\r\n\r\n\/\/ Unreal Engine TWeakObjectPtr\r\n\/\/ (Would also accidentally match WRL if not for the better overload above)\r\ntemplate<typename T>\r\nauto try_resolve_weak_pointer_to_strong(T const& weak)\r\n-> decltype(weak.Get())\r\n{\r\n    return weak.Get();\r\n}\r\n\r\n\/\/ Qt QWeakPointer\r\ntemplate<typename T>\r\nauto try_resolve_weak_pointer_to_strong(T const& weak)\r\n-> decltype(weak.toStrongRef())\r\n{\r\n    return weak.toStrongRef();\r\n}\r\n<\/pre>\n
One of the risks of using SFINAE for duck typing is that you may detect things that you didn’t mean to. For example, here, we have a name collision: Both WRL WeakRef and Unreal Engine TWeakObjectPtr have a Get<\/code> method, but they do different things. The WRL Get<\/code> method returns the wrapped IWeakReference*<\/code> (no resolving happens), whereas the Unreal Engine Get<\/code> method resolves the weak pointer to a strong pointer. We have to make sure that the WRL specialization gets picked up for WRL WeakRef.<\/p>\n","protected":false},"excerpt":{"rendered":"
Extending to std::weak_ptr<\/CODE>.<\/p>\n","protected":false},"author":1069,"featured_media":111744,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[25],"class_list":["post-108278","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-oldnewthing","tag-code"],"acf":[],"blog_post_summary":"
Extending to std::weak_ptr<\/CODE>.<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/108278","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=108278"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/108278\/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=108278"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/categories?post=108278"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/tags?post=108278"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}