{"id":108318,"date":"2023-06-09T07:00:00","date_gmt":"2023-06-09T14:00:00","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/oldnewthing\/?p=108318"},"modified":"2023-06-09T13:39:15","modified_gmt":"2023-06-09T20:39:15","slug":"20230609-00","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/oldnewthing\/20230609-00\/?p=108318","title":{"rendered":"Reordering C++ template type parameters for usability purposes, and type deduction from the future"},"content":{"rendered":"

Suppose you want to write a function that takes any iterable and converts it to a std::vector<\/code>. This is sort of like the C# analogue to the .ToList()<\/code> LINQ method. Here’s a starter kit:<\/p>\n

template<typename Container>\r\nauto to_vector(Container&& c)\r\n{\r\n    using ElementType = std::decay_t<decltype(*c.begin())>;\r\n    std::vector<ElementType> v;\r\n    std::copy(c.begin(), c.end(), std::back_inserter(v));\r\n    return v;\r\n}\r\n<\/pre>\n
This deduces the underlying value type of the vector from the original container, and it uses the default allocator. The std::decay_t<\/code> does multiple things for us here: It removes the references from the dereferenced iterator, and it also removes the const<\/code> and volatile<\/code> attributes. That second step allows a container of const T<\/code> to convert to a vector of T<\/code>.<\/p>\n
But maybe you want to let the caller override the underlying value type. For example, given a std::list<int><\/code>, you want to produce a std::vector<long><\/code> by saying<\/p>\n
std::list<int> l = \/* some expression *\/;\r\nauto v = to_vector<long>(l);\r\n<\/pre>\n
Okay, so you add an ElementType<\/code> type parameter to the template function, and have it default to the container’s underlying type.<\/p>\n
template<typename Container,\r\n    typename ElementType =\r\n        std::decay_t<decltype(*std::declval<Container>().begin())>>\r\nauto to_vector(Container&& c)\r\n{\r\n    std::vector<ElementType> v;\r\n    std::copy(c.begin(), c.end(), std::back_inserter(v));\r\n    return v;\r\n}\r\n<\/pre>\n
This works great, but using it is an annoyance because in order to customize the Element\u00adType<\/code>, you have to restate the Container<\/code> first.<\/p>\n
std::list<int> l = \/* some expression *\/;\r\nauto v = to_vector<std::list<int>&<\/span>, long<\/span>>(l);\r\n<\/pre>\n
You’d much rather say<\/p>\n
std::list<int> l = \/* some expression *\/;\r\nauto v = to_vector<long<\/span>>(l);\r\n<\/pre>\n
This reads much nicer because it looks like you’re saying “I’m converting to vector<long><\/code>.” So you swap the order of the type parameters:<\/p>\n
template<\r\n    typename ElementType =                                         <\/span>\r\n        std::decay_t<decltype(*std::declval<Container>().begin())>,<\/span>\r\n    typename Container>                                            <\/span>\r\nauto to_vector(Container&& c)\r\n{\r\n    std::vector<ElementType> v;\r\n    std::copy(c.begin(), c.end(), std::back_inserter(v));\r\n    return v;\r\n}\r\n<\/pre>\n
Unfortunately, this doesn’t compile because you are trying to default ElementType<\/code> based on a Container<\/code> that hasn’t been declared yet.<\/p>\n
So how can you get a template type parameter to default to a value that is dependent upon a future type parameter?<\/p>\n
You use a trick.<\/p>\n
template<\r\n    typename ElementType = void,<\/span>\r\n    typename Container>\r\nauto to_vector(Container&& c)\r\n{\r\n    using ActualElementType = std::conditional_t<<\/span>\r\n        std::is_same_v<ElementType, void>,       <\/span>\r\n        std::decay_t<decltype(*c.begin())>,      <\/span>\r\n        ElementType>;                            <\/span>\r\n    std::vector<ActualElementType> v;\r\n    std::copy(c.begin(), c.end(), std::back_inserter(v));\r\n    return v;\r\n}\r\n<\/pre>\n
The formal type parameter ElementType<\/code> defaults to void<\/code>, which is a sentinel value that means “Substitute the underlying value type of the collection here.” Inside the function body, after we have successfully deduced the Container<\/code>, we calculate the Actual\u00adElement\u00adType<\/code> by using the explicitly-provided Element\u00adType<\/code> or (if it was defaulted to void<\/code>) using the underlying type of the Container<\/code>.<\/p>\n
Adding support for custom allocators is more complicated because the allocator is a parameter. We have to convert the void<\/code> to an actual allocator by the time we get to the parameter list.<\/p>\n
template<\r\n    typename ElementType = void,\r\n    typename Allocator = void,<\/span>\r\n    typename Container>\r\nauto to_vector(Container&& c,\r\n    std::conditional_t<                                                <\/span>\r\n        std::is_same_v<Allocator, void>,                               <\/span>\r\n        std::allocator<                                                <\/span>\r\n            std::conditional_t<                                        <\/span>\r\n            std::is_same_v<ElementType, void>,                         <\/span>\r\n            std::decay_t<decltype(*std::declval<Container>().begin())>,<\/span>\r\n            ElementType>>,                                             <\/span>\r\n        Allocator> al = {})                                            <\/span>\r\n{\r\n    using ActualElementType = std::conditional_t<                      <\/span>\r\n        std::is_same_v<ElementType, void>,                             <\/span>\r\n        std::decay_t<decltype(*std::declval<Container>().begin())>,    <\/span>\r\n        ElementType>;                                                  <\/span>\r\n    using ActualAllocator = std::conditional_t<                        <\/span>\r\n        std::is_same_v<Allocator, void>,                               <\/span>\r\n        std::allocator<ActualElementType>,                             <\/span>\r\n        Allocator>;                                                    <\/span>\r\n    std::vector<ActualElementType, ActualAllocator<\/span>> v(al)<\/span>;\r\n    std::copy(c.begin(), c.end(), std::back_inserter(v));\r\n    return v;\r\n}\r\n<\/pre>\n
There’s a lot of repetition here: We want to use ActualAllocator<\/code> defined in the function body, but we can’t use it in the function prototype, so we have to inline its definition, producing a big ugly mess.<\/p>\n
One way to solve this is to “save” it in another defaulted template type parameter.<\/p>\n
template<\r\n    typename ElementType = void,\r\n    typename Allocator = void,<\/span>\r\n    typename Container,\r\n    typename ActualElementType = std::conditional_t<                   <\/span>\r\n        std::is_same_v<ElementType, void>,                             <\/span>\r\n        std::decay_t<decltype(*std::declval<Container>().begin())>,    <\/span>\r\n        ElementType>;                                                  <\/span>\r\n    typename ActualAllocator = std::conditional_t<                     <\/span>\r\n        std::is_same_v<Allocator, void>,                               <\/span>\r\n        std::allocator<ActualElementType>,                             <\/span>\r\n        Allocator>>                                                    <\/span>\r\nauto to_vector(Container&& c,\r\n    ActualAllocator al = ActualAllocator()<\/span>)\r\n{\r\n    std::vector<ActualElementType, ActualAllocator<\/span>> v(al)<\/span>;\r\n    std::copy(c.begin(), c.end(), std::back_inserter(v));\r\n    return v;\r\n}\r\n<\/pre>\n
Another solution is to create helper types to do the calculations.<\/p>\n
template<typename ElementType, typename Container>\r\nusing ActualElementType = std::conditional_t<\r\n        std::is_same_v<ElementType, void>,\r\n        std::decay_t<decltype(*std::declval<Container>().begin())>,\r\n        ElementType>;\r\n\r\ntemplate<typename ActualElementType,\r\n    typename ActualAllocator = std::conditional_t<\r\n        std::is_same_v<Allocator, void>,\r\n        std::allocator<ActualElementType<ElementType, Container>>,\r\n        Allocator>;\r\n\r\ntemplate<\r\n    typename ElementType = void,\r\n    typename Allocator = void,\r\n    typename Container>\r\nauto to_vector(Container&& c,\r\n    ActualAllocator<ElementType, Allocator, Container><\/span> al = {})\r\n{\r\n    std::vector<ActualElementType<ElementType, Container>,<\/span>\r\n        ActualAllocator<ElementType, Allocator, Container><\/span>> v(al);\r\n    std::copy(c.begin(), c.end(), std::back_inserter(v));\r\n    return v;\r\n}\r\n<\/pre>\n
Bonus chatter<\/b>: There’s still more work to be done with to_vector<\/code>, since it doesn’t work with vector<bool><\/code>, thanks to vector<bool><\/code>‘s wacko proxy object, and it doesn’t work with C-style arrays since they don’t have a begin()<\/code> method.<\/p>\n
Instead, we can use std::iterator_traits<\/code> to tell us what the iterator produces. and we can use std::begin<\/code> to support C-style arrays.<\/p>\n
template<typename ElementType, typename Container>\r\nusing ActualElementType = std::conditional_t<\r\n        std::is_same_v<ElementType, void>,\r\n        std::decay_t<\r\n            std::iterator_traits<                             <\/span>\r\n                    decltype(                                 <\/span>\r\n                        std::begin(std::declval<Container>()))<\/span>\r\n                 >::value_type>,                              <\/span>\r\n        ElementType>;\r\n\r\ntemplate<typename ActualElementType,\r\n    typename ActualAllocator = std::conditional_t<\r\n        std::is_same_v<Allocator, void>,\r\n        std::allocator<ActualElementType<ElementType, Container>>,\r\n        Allocator>;\r\n\r\ntemplate<\r\n    typename ElementType = void,\r\n    typename Allocator = void,\r\n    typename Container>\r\nauto to_vector(Container&& c,\r\n    ActualAllocator<ElementType, Allocator, Container> al = {})\r\n{\r\n    std::vector<ActualElementType<ElementType, Container>,\r\n        ActualAllocator<ElementType, Allocator, Container>> v(al);\r\n    std::copy(c.begin(), c.end(), std::back_inserter(v));\r\n    return v;\r\n}\r\n<\/pre>\n","protected":false},"excerpt":{"rendered":"
You want them to go first, but you also want to deduce them.<\/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-108318","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-oldnewthing","tag-code"],"acf":[],"blog_post_summary":"
You want them to go first, but you also want to deduce them.<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/108318","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=108318"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/108318\/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=108318"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/categories?post=108318"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/tags?post=108318"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}