{"id":108839,"date":"2023-09-29T07:00:00","date_gmt":"2023-09-29T14:00:00","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/oldnewthing\/?p=108839"},"modified":"2023-09-29T10:31:48","modified_gmt":"2023-09-29T17:31:48","slug":"20230929-00","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/oldnewthing\/20230929-00\/?p=108839","title":{"rendered":"Template meta-programming: Avoiding saying a type before it is complete"},"content":{"rendered":"

As we noted last time, C++\/WinRT’s get_strong()<\/code> will produce a broken strong reference if destruction has already begun<\/a>. The C++ standard library’s enable_shared_from_this<\/code> solves this problem by saving a weak reference in the object itself. But if you tried the analogous trick in versions of C++\/WinRT prior to 2.0.211028.7<\/a>, you got a weird compiler error.<\/p>\n

struct Me : winrt::implements<Me, winrt::IInspectable>\r\n{\r\n    winrt::weak_ref<Me> m_weakSelf;\r\n};\r\n\r\n\/\/ msvc\r\ntype_traits(1173,28): error C2139: 'Me': an undefined class is not allowed as an argument to compiler intrinsic type trait '__is_base_of'\r\ntest.h(16,8): message : see declaration of 'Me'\r\nbase.h(1963,45): message : see reference to variable template 'const bool is_base_of_v<winrt::Windows::Foundation::IUnknown, Me>' being compiled\r\nbase.h(4119,24): message : see reference to alias template instantiation 'winrt::impl::com_ref<T>' being compiled\r\nwith\r\n[\r\n    T=Me\r\n]\r\nTest.cpp(19,25): message : see reference to class template instantiation 'winrt::weak_ref<D>' being compiled\r\nwith\r\n[\r\n    D=Me\r\n]\r\n\r\n\/\/ gcc\r\ntype_traits: In instantiation of 'struct std::is_base_of<winrt::Windows::Foundation::IUnknown, Me>':\r\ntype_traits:3282:69:   required from 'constexpr const bool std::is_base_of_v<winrt::Windows::Foundation::IUnknown, Me>'\r\nrequired from 'struct winrt::weak_ref<Me>'\r\nrequired from here\r\ntype_traits:1447:38: error: invalid use of incomplete type 'struct Me'\r\n|     : public integral_constant<bool, __is_base_of(_Base, _Derived)>\r\n|                                      ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~\r\nnote: forward declaration of 'struct Me'\r\n| struct Me : winrt::implements<Me, winrt::IInspectable>\r\n|        ^^\r\ntype_traits: In instantiation of 'constexpr const bool std::is_base_of_v<winrt::Windows::Foundation::IUnknown, Me>':\r\nrequired from 'struct winrt::weak_ref<Me>'\r\nrequired from here\r\ntype_traits:3282:69: error: 'value' is not a member of 'std::is_base_of<winrt::Windows::Foundation::IUnknown, Me>'\r\n|   inline constexpr bool is_base_of_v = is_base_of<_Base, _Derived>::value;\r\n|                                                                     ^~~~~\r\n\r\n\/\/ clang\r\ntype_traits:3345:68: error: incomplete type 'Me' used in type trait expression\r\n  inline constexpr bool is_base_of_v = __is_base_of(_Base, _Derived);\r\n                                                                   ^\r\nnote: in instantiation of variable template specialization 'std::is_base_of_v<winrt::Windows::Foundation::IUnknown, Me>' requested here\r\n        std::is_base_of_v<winrt::Windows::Foundation::IUnknown,T>, int, int> v);\r\n             ^\r\nnote: in instantiation of template class 'winrt::weak_ref<Me>' requested here\r\n    winrt::weak_ref<Me> m_weakSelf;\r\n                        ^\r\nnote: definition of 'Me' is not complete until the closing '}'\r\nstruct Me : winrt::implements<Me, winrt::IInspectable>\r\n       ^\r\n<\/pre>\n
In this case, clang is the one that pinpoints the problem: “Definition of Me<\/code> is not complete until the closing brace.”<\/p>\n
The problem is that weak_ref<T><\/code> requires that T<\/code> be a complete type because it has a constructor that relies on the completeness of T<\/code>:<\/p>\n
template <typename T>\r\nstruct weak_ref\r\n{\r\n    weak_ref(std::nullptr_t = nullptr) noexcept {}\r\n\r\n    weak_ref(impl::com_ref<T><\/span> const& object)\r\n    {\r\n        \u27e6 implementation elided \u27e7\r\n    }\r\n\r\n    \u27e6 other members \u27e7\r\n};\r\n<\/pre>\n
The impl::com_ref<\/code> template type is an internal C++\/WinRT helper. We can peek at its definition:<\/p>\n
template <typename T>\r\nusing com_ref = std::conditional_t<\r\n    std::is_base_of_v<Windows::Foundation::IUnknown, T>,\r\n    T,\r\n    com_ptr<T>>;\r\n<\/pre>\n
In words, a com_ref<T><\/code> is just a T<\/code> if T<\/code> is itself a projected type. Otherwise, it’s a com_ptr<T><\/code>.<\/p>\n
Now, when you write weak_ref<T><\/code>, this instantiates the template, and the compiler generates declarations for all of the members. One of those members is the second constructor that takes a impl::com_ref<T><\/code> as a parameter. And that’s where the error occurs, because in order to know what impl::com_ref<T><\/code> means, the compiler has to see whether T<\/code> has winrt::Windows::Foundation::IUnknown<\/code> as a base class, and that requires that T<\/code> be a complete type.<\/p>\n
We can solve this problem by templating the second constructor.<\/p>\n
template <typename T>\r\nstruct weak_ref\r\n{\r\n    weak_ref(std::nullptr_t = nullptr) noexcept {}\r\n\r\n    template<typename U><\/span>\r\n    weak_ref(U&&<\/span> object)\r\n    {\r\n        \u27e6 implementation elided \u27e7\r\n    }\r\n\r\n    \u27e6 other members \u27e7\r\n};\r\n<\/pre>\n
This defers the instantiation of the second constructor until somebody tries to call it, which will (we hope) happen after T<\/code> is a complete type.<\/p>\n
But wait, we’re not done yet.<\/p>\n
For one thing, the original constructor specified its parameter as impl::com_ref<T><\/code>, which means that if the caller passed a braced list, that braced list is used to construct a impl::com_ref<T><\/code>. But we don’t get that effect with the forwarding reference. Forwarding references received braced lists as a initializer_list<X><\/code> for some type X<\/code>. In order to tell the compiler, “If you see a braced list, please treat it as the constructor parameters to a impl::com_ref<T><\/code>,” we specify a default type:<\/p>\n
template <typename T>\r\nstruct weak_ref\r\n{\r\n    weak_ref(std::nullptr_t = nullptr) noexcept {}\r\n\r\n    template<typename U = impl::com_ref<T><\/span>>\r\n    weak_ref(U&& object)\r\n    {\r\n        \u27e6 implementation elided \u27e7\r\n    }\r\n\r\n    \u27e6 other members \u27e7\r\n};\r\n<\/pre>\n
Now, the original implementation assumed that object<\/code> was a com_ref<T><\/code>, so if the inbound parameter isn’t one, we need to convert it.<\/p>\n
template <typename T>\r\nstruct weak_ref\r\n{\r\n    weak_ref(std::nullptr_t = nullptr) noexcept {}\r\n\r\n    template<typename U = impl::com_ref<T>>\r\n    weak_ref(U&& objectArg<\/span>)\r\n    {\r\n        impl::com_ref<T> const& object = objectArg;<\/span>\r\n\r\n        \u27e6 implementation elided \u27e7\r\n    }\r\n\r\n    \u27e6 other members \u27e7\r\n};\r\n<\/pre>\n
There’s a subtlety here, though. The conversion from objectArg<\/code> to object<\/code> is an explicit conversion, but parameter conversions use only implicit conversions. We can use SFINAE to limit ourselves to types that support implicit conversion to com_ref<T><\/code>.<\/p>\n
template <typename T>\r\nstruct weak_ref\r\n{\r\n    weak_ref(std::nullptr_t = nullptr) noexcept {}\r\n\r\n    template<typename U = impl::com_ref<T>,\r\n             typename = std::enable_if_t<    <\/span>\r\n                std::is_convertible_v<       <\/span>\r\n                    U&&,                     <\/span>\r\n                    impl::com_ref<T> const&>><\/span>>\r\n    weak_ref(U&& objectArg)\r\n    {\r\n        impl::com_ref<T> const& object = objectArg;<\/span>\r\n\r\n        \u27e6 implementation elided \u27e7\r\n    }\r\n\r\n    \u27e6 other members \u27e7\r\n};\r\n<\/pre>\n
This revision also solves another problem: Without SFINAE, our templated weak_ref<\/code> constructor would also be used as the copy and move constructor, rather than using the compiler-generated default versions. Fortunately, the SFINAE rejects weak_ref const&<\/code> and weak_ref&&<\/code> (since neither is convertible to com_ref<T><\/code>), so adding the SFINAE also magically restores the copy and move constructors.<\/p>\n
Finally, to avoid code size explosion due to each specialization producing a different conversion, we factor the original constructor into a helper that takes only a com_ref<><\/code>. That way, the bulk of the code is shared among all the constructors.<\/p>\n
template <typename T>\r\nstruct weak_ref\r\n{\r\n    weak_ref(std::nullptr_t = nullptr) noexcept {}\r\n\r\n    template<typename U = impl::com_ref<T>,\r\n             typename = std::enable_if_t<\r\n                std::is_convertible_v<\r\n                    U&&,\r\n                    impl::com_ref<T> const&>>>\r\n    weak_ref(U&& object)\r\n    {\r\n        from_com_ref(static_cast<impl::com_ref<T> const&>(object));<\/span>\r\n    }\r\n\r\n    \u27e6 other members \u27e7\r\n\r\n    template<typename U>         <\/span>\r\n    void from_com_ref(U&& object)<\/span>\r\n    {                            <\/span>\r\n        \u27e6 implementation elided \u27e7\r\n    }                            <\/span>\r\n};\r\n<\/pre>\n
Again, the from_com_ref<\/code> method is templated so that it is not instantiated immediately, since it is not allowed to say that its parameter is a com_ref<T><\/code>. Instead, we secretly accept a com_ref<T><\/code> by using a parlor trick from some time ago:  We accept a templated parameter even though in practice, only one type ever gets passed<\/a>.<\/p>\n
What this all means is that starting in C++\/WinRT version  2.0.211028.7<\/a>, you can have a class hold a weak reference to itself.<\/p>\n
struct Me : winrt::implements<Me, winrt::IInspectable>\r\n{\r\n    winrt::weak_ref<Me> m_weakSelf = get_weak();\r\n};\r\n<\/pre>\n","protected":false},"excerpt":{"rendered":"
Deferring use until after the class is defined.<\/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-108839","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-oldnewthing","tag-code"],"acf":[],"blog_post_summary":"
Deferring use until after the class is defined.<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/108839","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=108839"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/108839\/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=108839"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/categories?post=108839"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/tags?post=108839"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}