{"id":109940,"date":"2024-06-27T07:00:00","date_gmt":"2024-06-27T14:00:00","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/oldnewthing\/?p=109940"},"modified":"2024-06-24T08:35:47","modified_gmt":"2024-06-24T15:35:47","slug":"20240627-00","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/oldnewthing\/20240627-00\/?p=109940","title":{"rendered":"Writing a remove_all_pointers<\/CODE> type trait, part 1"},"content":{"rendered":"

There is a std::remove_pointer<\/code> type trait helper. If you give it a pointer type T*<\/code>, its type<\/code> member type is T<\/code>. Otherwise, the type<\/code> member type is just the template type unchanged.<\/p>\n

But what if you want to remove all<\/i> pointers? For example, remove_all_pointers<int*const*volatile*>::type<\/code> should be int<\/code>.<\/p>\n

You can define this as a recursive operation. In pseudo-code:<\/p>\n

template<typename T>\r\nauto remove_all_pointers\r\n{\r\n    if (std::is_pointer_v<T>) {\r\n        return remove_all_pointers<\r\n            std::remove_pointer_t<T>\r\n        >;\r\n    } else {\r\n        return T;\r\n    }\r\n}\r\n<\/pre>\n
One way to express conditional evaluation in template metaprogramming is to use std::conditional<a, b, c>::type<\/code>, which is b<\/code> if a<\/code> is true<\/code> and is c<\/code> if a<\/code> is false<\/code>.<\/p>\n
Therefore, your first attempt might be to write it as a one-liner built out of std::conditional<\/code>.<\/p>\n
template<typename T>\r\nusing remove_all_pointers_t =\r\n    std::conditional_t<\r\n        std::is_pointer_v<T>,\r\n        remove_all_pointers_t<\r\n            std::remove_pointer_t<T>&gt,;\r\n        T>;\r\n<\/pre>\n
Okay, this doesn’t work because of the recursive reference to remove_all_pointers_t<\/code> before it has completed its declaration. We can sidestep this by using a struct<\/code>.<\/p>\n
template<typename T>\r\nstruct remove_all_pointers\r\n{\r\n  using type = std::conditional_t<\r\n        std::is_pointer_v<T>,\r\n        typename remove_all_pointers<\r\n            std::remove_pointer_t<T>>::type,\r\n        T>;\r\n};\r\n<\/pre>\n
This compiles, but you get an error when you try to use it:<\/p>\n
using test = remove_all_pointers<int*const*volatile*>::type;\r\n\r\n\/\/ gcc\r\nIn instantiation of 'struct remove_all_pointers<int>':\r\n    recursively required from 'struct remove_all_pointers<int* const* volatile>'\r\n    required from 'struct remove_all_pointers<int* const* volatile*>'\r\n    required from here\r\nerror: invalid use of incomplete type 'struct remove_all_pointers<int>'\r\n    |   using type = std::conditional_t<\r\n    |         ^~~~\r\nnote: definition of 'struct remove_all_pointers<int>' is not complete until the closing brace\r\n    | struct remove_all_pointers\r\n    |        ^~~~~~~~~~~~~~~~~~~\r\n\r\n\/\/ clang\r\nerror: no type named 'type' in 'remove_all_pointers<int>'\r\n    |         typename remove_all_pointers<\r\n    |         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\r\n    |             std::remove_pointer_t<T>>::type,\r\n    |             ~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~\r\nnote: in instantiation of template class 'remove_all_pointers<int>' requested here\r\n    |         typename remove_all_pointers<\r\n    |                  ^\r\nnote: in instantiation of template class 'remove_all_pointers<int *const>' requested here\r\nnote: in instantiation of template class 'remove_all_pointers<int *const *volatile>' requested here\r\nnote: in instantiation of template class 'remove_all_pointers<int *const *volatile *>' requested here\r\n   | using test = remove_all_pointers<int*const*volatile*>::type;\r\n   |              ^\r\n\r\n\/\/ msvc\r\nerror C2146: syntax error: missing '>' before identifier 'type'\r\nnote: the template instantiation context (the oldest one first) is\r\nnote: see reference to class template instantiation 'remove_all_pointers<int *const *volatile *>' being compiled\r\nnote: see reference to class template instantiation 'remove_all_pointers<int *const *volatile >' being compiled\r\nnote: see reference to class template instantiation 'remove_all_pointers<int *const >' being compiled\r\nnote: see reference to class template instantiation 'remove_all_pointers<int>' being compiled\r\n<\/pre>\n
Okay, maybe we were too ambitious.<\/p>\n
All the error messages show that the template was able to recurse and strip away pointers, but then it ran into a problem when it reached the base case. Let’s look at that base case:<\/p>\n
struct remove_all_pointers<int>\r\n{\r\n  using type = std::conditional_t<\r\n        std::is_pointer_v<int>,\r\n        remove_all_pointers<\r\n            std::remove_pointer_t<int>>::type,\r\n        int>;\r\n};\r\n<\/pre>\n
After substituting std::remove_pointer_t<int> = int<\/code>, we get<\/p>\n
struct remove_all_pointers<int>\r\n{\r\n  using type = std::conditional_t<\r\n        std::is_pointer_v<int>,\r\n        remove_all_pointers<int>::type<\/span>,\r\n        int>;\r\n};\r\n<\/pre>\n
Now we see the problem. The definition of remove_all_pointers<int>::type<\/code> is dependent on itself.<\/p>\n
The catch here is that std::conditional<\/code> is not a short-circuiting operator. How can it be? It’s a template!<\/p>\n
In order to instantiate a template, the compiler first evaluates the template parameters, and then it looks at the template expansion that results. The compiler doesn’t “look ahead” and say, “Oh, I can tell that the template expansion never uses its second parameter, so I will skip the evaluation of the second parameter.”\u00b9<\/p>\n
One way to solve this problem is to move the expansion of the two parameters to a partial specialization. That way, only the pointer cases invoke the template recursively.<\/p>\n
template<typename T,\r\n    bool = std::is_pointer_v<T>>\r\nstruct remove_all_pointers;\r\n\r\ntemplate<typename T>\r\nstruct remove_all_pointers<T, false>\r\n{\r\n    using type = T;\r\n};\r\n\r\ntemplate<typename T>\r\nstruct remove_all_pointers<T, true>\r\n{\r\n    using type = typename remove_all_pointers<\r\n        std::remove_pointer_t<T>>::type;\r\n};\r\n<\/pre>\n
We add a hidden second template parameter which defaults to std::is_pointer_v<T><\/code>. We then partially specialize the template on that second template parameter: If it’s false<\/code> (T<\/code> is not a pointer), then the type is T<\/code> itself, which provides our base case (no longer accidentally referring to itself). If it’s true<\/code> (T<\/code> is a pointer), then the type is calculated recursively after stripping away one layer of indirection.<\/p>\n
template<typename T>\r\nusing remove_all_pointers_t =\r\n    typename remove_all_pointers<T>::type;\r\n\r\nstatic_assert(std::is_same_v<\r\n    remove_all_pointers_t<int*const*volatile*>,\r\n    int>);\r\n<\/pre>\n
As a small tuning step, we can fold the base case into the initial definition, so that only the recursive case is a partial specialization.<\/p>\n
template<typename T,\r\n    bool = std::is_pointer_v<T>>\r\nstruct remove_all_pointers<\/span>\r\n{                         <\/span>\r\n    using type = T;       <\/span>\r\n};                        <\/span>\r\n\r\ntemplate<typename T>\r\nstruct remove_all_pointers<T, true>\r\n{\r\n    using type = typename remove_all_pointers<\r\n        std::remove_pointer_t<T>>::type;\r\n};\r\n<\/pre>\n
Are we done?<\/p>\n
No, not yet.<\/p>\n
We’ll continue next time.<\/p>\n
\u00b9 Indeed, the “I evaluate all the parameters even if they aren’t used” behavior is one of the things that SFINAE relies on!<\/p>\n","protected":false},"excerpt":{"rendered":"
Delaying the expansion to avoid infinite recursion.<\/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-109940","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-oldnewthing","tag-code"],"acf":[],"blog_post_summary":"
Delaying the expansion to avoid infinite recursion.<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/109940","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=109940"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/109940\/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=109940"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/categories?post=109940"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/tags?post=109940"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}