{"id":109865,"date":"2024-06-07T07:00:00","date_gmt":"2024-06-07T14:00:00","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/oldnewthing\/?p=109865"},"modified":"2024-06-09T10:36:11","modified_gmt":"2024-06-09T17:36:11","slug":"20240607-00","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/oldnewthing\/20240607-00\/?p=109865","title":{"rendered":"What’s the deal with std::type_identity<\/CODE>?"},"content":{"rendered":"

C++20 has this new thing called std::type_identity<\/code>. Its definition is basically<\/p>\n

template<typename T>\r\nstruct type_identity\r\n{\r\n    using type = T;\r\n};\r\n<\/pre>\n
In other words, type_identity<T>::type = T<\/code>.<\/p>\n
This sounds profoundly useless. Why take the type T<\/code>, wrap it in another type, and then unwrap it? Why not just use T<\/code> directly?<\/p>\n
The primary purpose of type_identity<T><\/code> is to allow you to use a type without making it participate in type deduction.<\/p>\n
The classic example is a function like, say, add<\/code>:<\/p>\n
template<typename T>\r\nT add(T a, T b)\r\n{\r\n    return a + b;\r\n}\r\n<\/pre>\n
This says “Add two things of the same type and return the result.”<\/p>\n
So what happens if you pass two things of different type?<\/p>\n
auto sum = add(0.5, 1); \/\/ error: cannot deduce T\r\n<\/pre>\n
Maybe you want the policy to be “The type of the first parameter determines what T<\/code> is, and everybody else has to play along.” You can use type_identity<\/code> to specify that the second parameter is not deducible.<\/p>\n
template<typename T>\r\nT add(T a, std::type_identity_t<T> b)\r\n{\r\n    return a + b;\r\n}\r\n<\/pre>\n
This time, it works:<\/p>\n
auto sum = add(0.5, 1); \/\/ T is \"double\"\r\n<\/pre>\n
The compiler deduces T = double<\/code> when it matches 0.5<\/code> to the a<\/code> parameter. When it gets around to the second parameter, it is told, “Just use the T<\/code> you deduced somewhere else.” So the parameter 1<\/code> is treated as a double<\/code>, which involves a numeric conversion.<\/p>\n
A more complex case for wanting one parameter’s type to be dependent upon another parameter’s type is this example:<\/p>\n
void enqueue(std::function<void(void)> const& work);\r\n\r\ntemplate<typename...Args>\r\nvoid enqueue(std::function<void(Args...)> const& work,\r\n    Args...args)\r\n{\r\n    enqueue([=] { work(args...); });\r\n}\r\n<\/pre>\n
The idea here is that you call enqueue<\/code> with a callable and some optional arguments, and the function enqueues the function call to be run somewhere else (maybe on a worker thread). If you pass arguments, then the arguments are passed to your callable.<\/p>\n
So you decide to give this function a whirl, but it doesn’t compile:<\/p>\n
enqueue([](int v) { std::cout << v; }, 42);\r\n\r\n\/\/ gcc\r\nerror: no matching function for call to 'enqueue(<lambda(int)>, int)'\r\n   |     enqueue([](int){}, 42);\r\n   |     ~~~~~~~^~~~~~~~~~~~~~~\r\nnote: candidate: 'template<class ... Args> void enqueue(const std::function<void(Args ...)>&, Args ...)'\r\n    | void enqueue(\r\n    |      ^~~~~~~\r\nnote:   template argument deduction\/substitution failed:\r\nnote:   '<lambda(int)>' is not derived from 'const std::function<void(Args ...)>'\r\n   |     enqueue([](int){}, 42);\r\n   |     ~~~~~~~^~~~~~~~~~~~~~~\r\n\r\n\/\/ clang\r\nerror: no matching function for call to 'enqueue'\r\n   |     enqueue([](int){}, 42);\r\n   |     ^~~~~~~\r\nnote: candidate template ignored: could not match 'std::function<void (Args...)>' against '(lambda)'\r\n    7 | void enqueue(\r\n      |      ^\r\n\r\n\/\/ msvc\r\nerror C2672: 'enqueue': no matching overloaded function found\r\nnote: 'void enqueue(const std::function<void(Args...)> &,Args...)': could not deduce template argument for 'const std::function<void(Args...)> &' from '<lambda>'\r\n<\/pre>\n
The problem is that template type deduction tries to match types, and it doesn’t consider conversions. Conversions are handled by a later step (overload resolution). The deduction fails because the lambda is not a std::function<\/code>; the fact that the lambda can be converted to<\/i> a std::function<\/code> is irrelevant.<\/p>\n
We can fix this by using type_identity<\/code> to remove the std::function<\/code> from participating in template type deduction.<\/p>\n
template<typename...Args>\r\nvoid enqueue(\r\n    std::type_identity_t<<\/span>\r\n        std::function<void(Args...)>\r\n    ><\/span> const& work,\r\n    Args...args)\r\n{\r\n    enqueue([=] { work(args...); });\r\n}\r\n<\/pre>\n
Now the deduction of Args<\/code> is controlled only by the second and subsequent parameters. Once that’s settled, the compiler then passes the selected function to overload resolution, which says, “Oh, I can convert this lambda to match the type of the first parameter.”<\/p>\n
Bonus chatter<\/b>: You don’t have to use type_identity<\/code> to wrap the entire type. You can scope it down to something smaller, as long as the type you want to exempt from deduction is inside the template type parameter:<\/p>\n
template<typename...Args>\r\nvoid enqueue(\r\n    std::function<void(\r\n        std::type_identity_t<<\/span>Args><\/span>...\r\n    )> const& work,\r\n    Args...args)\r\n{\r\n    enqueue([=] { work(args...); });\r\n}\r\n<\/pre>\n
Bonus bonus chatter<\/b>: In practice, you would probably receive the variadic arguments by universal reference, which means that the std::function<\/code> will probably receive decayed parameters rather than references. The insertion of std::decay_t<\/code> not only decays the Args<\/code>, but it also prevents them from participating in deduction.<\/p>\n
template<typename...Args>\r\nvoid enqueue(\r\n    std::function<void(\r\n        std::decay_t<<\/span>Args><\/span>...\r\n    )> const& work,\r\n    Args&&...args)\r\n{\r\n    enqueue([work, ...args = std::forward<Args>(args)]\r\n            { work(std::move(args)...); });\r\n}\r\n<\/pre>\n
Bonus bonus bonus chatter<\/b>:  The proposal for type_identity<\/code><\/a> lists some other uses: To force programmers to specify the template type explicitly rather than allowing it to be deduced.<\/p>\n
template<typename T>\r\nvoid must_specialize(std::type_identity_t<T> t);\r\n\r\nmust_specialize(42); \/\/ not allowed\r\nmust_specialize<int>(42); \/\/ must state \"int\" explicitly\r\n<\/pre>\n
It can also be used to suppress class template argument deduction (CTAD), and it can be handy as a building block for template metaprogramming. Read the proposal for details.<\/p>\n","protected":false},"excerpt":{"rendered":"
When you want to use a type without participating in type deduction.<\/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-109865","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-oldnewthing","tag-code"],"acf":[],"blog_post_summary":"
When you want to use a type without participating in type deduction.<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/109865","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=109865"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/109865\/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=109865"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/categories?post=109865"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/tags?post=109865"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}