Suppose you have a base class, and you want to get a strong reference to your derived class. You may need to do this, for example, if your base class has a method which is a coroutine, and it needs to retain a strong reference to itself so that it can extend its lifetime into the coroutine body, thereby preventing the object from being destroyed after the coroutine reaches its first suspension point.<\/p>\n
\/\/ C++\/WinRT style\r\n\r\nstruct Base\r\n{\r\n winrt::IAsyncAction DoSomethingAsync()\r\n {\r\n auto lifetime = get_strong(); \/\/ ????\r\n\r\n co_await this->step1();\r\n\r\n this->step2();\r\n }\r\n};\r\n\r\nstruct Derived : DerivedT<Derived>, Base\r\n{\r\n};\r\n\r\n\/\/ PPL style\r\n\r\nstruct Base\r\n{\r\n Concurrency::task<void> DoSomethingAsync()\r\n {\r\n auto lifetime = shared_from_this(); \/\/ ????\r\n\r\n co_await this->step1();\r\n\r\n this->step2();\r\n }\r\n};\r\n\r\nstruct Derived : std::enable_shared_from_this<Derived>, Base\r\n{\r\n};\r\n<\/pre>\nFirst, let’s forget about coroutines. They are the motivation for the question, but they aren’t really relevant to the solution.<\/p>\n
If you have an instance of a base class and you want to get an instance of the derived class, what can you do?<\/p>\n
Well, if you know what the derived class is, you can downcast to it.<\/p>\n
\/\/ C++\/WinRT style\r\nstruct Base\r\n{\r\n void BaseMethod()\r\n {\r\n auto lifetime = static_cast<Derived*>(this)-><\/span>get_strong();\r\n\r\n ...\r\n }\r\n};\r\n\r\n\/\/ PPL style\r\n\r\nstruct Base\r\n{\r\n void BaseMethod()\r\n {\r\n auto lifetime = static_cast<Derived*>(this)-><\/span>shared_from_this();\r\n\r\n ...\r\n }\r\n};\r\n<\/pre>\nThis trick works only if you are absolutely certain that the Base<\/code> is the base portion of a Derived<\/code>. Now, maybe you want to use the Base<\/code> as the base of multiple derived classes. In that case, you can pass the derived class as a template parameter, turning this into a case of CRTP:<\/p>\n\/\/ C++\/WinRT style\r\n\r\ntemplate<typename D><\/span>\r\nstruct Base\r\n{\r\n void BaseMethod()\r\n {\r\n auto lifetime = static_cast<D*>(this)-><\/span>get_strong();\r\n\r\n ...\r\n }\r\n};\r\n\r\nstruct Derived : DerivedT<Derived>, Base<Derived><\/span>\r\n{\r\n};\r\n\r\n\/\/ PPL style\r\n\r\ntemplate<typename D><\/span>\r\nstruct Base\r\n{\r\n void BaseMethod()\r\n {\r\n auto lifetime = static_cast<D*>(this)-><\/span>shared_from_this();\r\n\r\n ...\r\n }\r\n};\r\n\r\nstruct Derived : std::enable_shared_from_this<Derived>, Base<Derived><\/span>\r\n{\r\n};\r\n<\/pre>\nAnother solution is to give the Base<\/code> a weak reference to the container. This removes the need to know what the container is.<\/p>\n\/\/ C++\/WinRT style\r\n\r\nstruct Base\r\n{\r\n winrt::weak_ptr<IInspectable> derived_weak;\r\n\r\n void BaseMethod()\r\n {\r\n auto lifetime = derived_weak.get()<\/span>;\r\n\r\n ...\r\n }\r\n};\r\n\r\nstruct Derived : DerivedT<Derived>, Base\r\n{\r\n Derived()\r\n {\r\n derived_weak = get_weak();<\/span>\r\n }\r\n};\r\n\r\n\/\/ PPL style\r\n\r\ntemplate<typename D><\/span>\r\nstruct Base\r\n{\r\n std::weak_ptr<void> derived_weak;\r\n\r\n void BaseMethod()\r\n {\r\n auto lifetime = derived_weak.lock()<\/span>;\r\n\r\n ...\r\n }\r\n};\r\n\r\nstruct Derived : std::enable_shared_from_this<Derived>, Base\r\n{\r\n Derived()\r\n {\r\n \/\/ doesn't work!\r\n }\r\n};\r\n<\/pre>\nUh-oh, we’re kind of stuck in the PPL case because the weak pointer hiding inside enable_shared_from_this<\/code> is not initialized at the point the Derived<\/code> is constructed. (It gets set by std::make_shared<\/code> after the object has been constructed.)<\/p>\nAnother option is to have a pure virtual method which derived classes must implement in order to provide the necessary strong pointer.<\/p>\n
\/\/ C++\/WinRT style\r\n\r\nstruct Base\r\n{\r\n virtual winrt::IInspectable derived_strong() const = 0;\r\n\r\n void BaseMethod()\r\n {\r\n auto lifetime = derived_strong();\r\n\r\n ...\r\n }\r\n};\r\n\r\nstruct Derived : DerivedT<Derived>, Base\r\n{\r\n winrt::IInspectable derived_strong() const override\r\n {\r\n return *this;\r\n }\r\n};\r\n\r\n\/\/ PPL style\r\n\r\nstruct Base\r\n{\r\n virtual std::shared_ptr<const void> derived_strong() const = 0;\r\n\r\n void BaseMethod()\r\n {\r\n auto lifetime = derived_strong();\r\n\r\n ...\r\n }\r\n};\r\n\r\nstruct Derived : std::enable_shared_from_this<Derived>, Base\r\n{\r\n std::shared_ptr<const void> derived_strong() const override\r\n {\r\n return shared_from_this();\r\n }\r\n};\r\n<\/pre>\nAnd C++23’s “deducing this” adds another option:<\/p>\n
\/\/ C++\/WinRT style\r\n\r\nstruct Base\r\n{\r\n template<typename Derived><\/span>\r\n winrt::IAsyncAction DoSomethingAsync(this Derived&& self<\/span>)\r\n {\r\n auto lifetime = self.<\/span>get_strong();\r\n\r\n co_await this->step1();\r\n\r\n this->step2();\r\n }\r\n}\r\n\r\nstruct Derived : DerivedT<Derived>, Base\r\n{\r\n};\r\n\r\n\/\/ PPL style\r\n\r\nstruct Base\r\n{\r\n template<typename Derived><\/span>\r\n Concurrency::task<void> DoSomethingAsync(this Derived&& self<\/span>)\r\n {\r\n auto lifetime = self.<\/span>shared_from_this();\r\n\r\n co_await this->step1();\r\n\r\n this->step2();\r\n }\r\n};\r\n\r\nstruct Derived : std::enable_shared_from_this<Derived>, Base\r\n{\r\n};\r\n<\/pre>\nWhich should you choose?<\/p>\n
Well, it’s up to you. My preference is to use the CRTP pattern for C++\/WinRT types, since that avoids extra data members and vtables, and it is consistent with other C++\/WinRT patterns. And that leads me to prefer the CRTP pattern for the PPL case, too, for consistency.<\/p>\n
And if you can assume C++23, then the “deducing this” form lets you get the benefits of CRTP without having to do CRTP. So that’s my first choice.<\/p>\n
But that’s just my opinion. You might prefer something else.<\/p>\n
Bonus chatter<\/b>: You might think of having Base<\/code> derive from enable_shared_from_this<\/code>. That would work, but it also means that Derived<\/code> cannot derive from enable_shared_from_this<\/code>, and it also means that Derived<\/code> cannot derive from both Base1<\/code> and Base2<\/code> if both of the base classes derive from enable_shared_from_this<\/code>. The general convention is that the most derived class is the one that gets to derive from enable_shared_from_this<\/code>.<\/p>\n","protected":false},"excerpt":{"rendered":"A variety of patterns are available.<\/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":[],"class_list":["post-107732","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-oldnewthing"],"acf":[],"blog_post_summary":"
A variety of patterns are available.<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/107732","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=107732"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/107732\/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=107732"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/categories?post=107732"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/tags?post=107732"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}