{"id":3141,"date":"2018-09-06T20:20:03","date_gmt":"2018-09-06T18:20:03","guid":{"rendered":"https:\/\/mariusbancila.ro\/blog\/?p=3141"},"modified":"2021-11-16T08:47:54","modified_gmt":"2021-11-16T06:47:54","slug":"when-a-type-is-not-a-type","status":"publish","type":"post","link":"https:\/\/mariusbancila.ro\/blog\/2018\/09\/06\/when-a-type-is-not-a-type\/","title":{"rendered":"When a type is not a type"},"content":{"rendered":"\n

This article has been updated for C++20.<\/p><\/blockquote><\/figure>\n\n\n\n

Let’s take a look at the following code sample:<\/p>\n\n\n\n

template <typename T> \nstruct foo\n{\n   foo(T) {}\n};\n\nint main()\n{\n   std::pair   p{ 1, \"one\" };\n   std::vector v{ 1, 2 };\n   foo         f{ 42 };\n}<\/pre>\n\n\n\n
Here, p<\/tt> is a std::pair<\/tt>, v<\/tt> is a std::vector<\/tt>, and f<\/tt> is a foo<\/tt>. But there is no such thing as a std::vector<\/tt> type (nor std::pair<\/tt> or foo<\/tt>). std::vector<int><\/tt> is a type, and std::vector<T><\/tt> is a type template, but std::vector<\/tt> is just a placeholder that activates a C++17 feature called class template argument deduction<\/em> (which we will call CTAD for short).<\/p>\n\n\n\n\n\n\n\n
Why CTAD?<\/h3>\n\n\n\n
Prior to C++17, you had to explicitly specify all the class template arguments, as all of them must be known in order to instantiate the class template. Therefore, the code above would have looked like this:<\/p>\n\n\n\n
std::pair<int, char const*> p{ 1, \"one\" };\nstd::vector<int>            v{ 1, 2 };\nfoo<int>                    f{ 42 };<\/pre>\n\n\n\n
Since function template argument deduction was available for a long time, the workaround in C++11 was to provide a make_xxx()<\/tt> function that creates instance of the class template, and use auto<\/tt> as placeholder for the type.<\/p>\n\n\n\n
auto p = std::make_pair(1, \"one\");<\/pre>\n\n\n\n
Of course, not all the standard types have such a helper function, so it was often the case that users wrote their own make functions. Here you can see an example of a make_vector()<\/tt> variadic function template that creates a vector:<\/p>\n\n\n\n
template <class T, class... Ts, class Allocator = std::allocator<T>>\nauto make_vector(T&& first, Ts&&... args)\n{\n   return std::vector<std::decay_t<T>, Allocator>{ \n      std::forward<T>(first), \n      std::forward<Ts>(args)... };\n}\n\nauto v = make_vector(1, 2);<\/pre>\n\n\n\n
Here is another example for the user-defined class foo<\/tt>:<\/p>\n\n\n\n
template <typename T>\nconstexpr foo<T> make_foo(T&& value)\n{\n   return foo{ value };\n}\n\nauto f = make_foo(42);<\/pre>\n\n\n\n
How it works<\/h3>\n\n\n\n
When the compiler encounters a declaration of a variable, or a function-style cast using the name of a class template, it builds a set of deduction guides, which is basically fictional functions template representing constructor signatures of a hypothetical class type. These implicit deduction guides created by the compiler can be complemented with user-defined deduction guides. They are then used for performing template argument deduction and overload resolution for initializing objects of this hypothetical class.<\/p>\n\n\n\n
Here are several examples (not the complete list) for the implicit deduction types that the compiler constructs for the std::pair<\/tt> class template:<\/p>\n\n\n\n
template <class T1, class T2>\nstd::pair<T1, T2> F();\n\ntemplate <class T1, class T2>\nstd::pair<T1, T2> F(T1 const& x, T2 const& y);\n\ntemplate <class T1, class T2, class U1, class U2>\nstd::pair<T1, T2> F(U1&& x, U2&& y);<\/pre>\n\n\n\n
The implicit deduction guides are generated from the constructors of the class template (the default constructor, the copy constructor, and all the other constructor with the type arguments copied in their exact order). If the class template does not have any constructor, a deduction guide is created for a hypothetical default constructor. In any case, a deduction guide for a hypothetical copy constructor is created.<\/p>\n\n\n\n
User-defined deduction guides are very similar to function signature with trailing return type but without the auto<\/tt> keyword (after all, they represent fictional constructor signatures). They must be defined in the scope of the class template they apply to. So an example for std::pair<\/tt> could be (although this is actually provided implicitly by the compiler):<\/p>\n\n\n\n
namespace std {\n   template <class T1, class T2>\n   pair(T1&& v1, T2&& v2)->pair<T1, T2>;\n}<\/pre>\n\n\n\n
Consider the following class type bar<\/tt> that has a constructor using iterators:<\/p>\n\n\n\n
template <typename T>\nstruct bar\n{\n   template <class Iter>\n   bar(Iter first, Iter last) {}\n};<\/pre>\n\n\n\n
The idea is to be able to initialize objects of this type template as follows:<\/p>\n\n\n\n
int arr[] = { 1,2,3,4,5 };\nbar b{std::begin(arr), std::end(arr)};<\/pre>\n\n\n\n
However, this does not work. For instance, the VC++ compiler generates the following errors:<\/p>\n\n\n\n
error C2672: 'bar': no matching overloaded function found\nerror C2783: 'bar<T> bar(Iter,Iter)': could not deduce template argument for 'T'<\/pre>\n\n\n\n
These can be fixed using a user-defined deduction guide as shown below:<\/p>\n\n\n\n
template <class Iter>\nbar(Iter first, Iter last)->bar<typename std::iterator_traits<Iter>::value_type>;<\/pre>\n\n\n\n
The deduction guides don’t have to be templates. Considering the class foo<\/tt> from above, we can have the following deduction guide that forces the compiler to always create instances of foo<std::string><\/tt> when a char const*<\/tt> is used as argument.<\/p>\n\n\n\n
foo(char const *)->foo<std::string>;<\/pre>\n\n\n\n
This example can be further applied on the std::pair<\/tt> class template, so that std::string<\/tt> is always used instead of char const*<\/tt>:<\/p>\n\n\n\n
namespace std {\n   template <class T>\n   pair(T&&, char const *)->pair<T, std::string>;\n\n   template <class T>\n   pair(char const *, T&&)->pair<std::string, T>;\n\n   pair(char const *, char const *)->pair<std::string, std::string>;\n}\n\nstd::pair  p1{ 1, \"one\" };    \/\/ std::pair<int, std::string>\nstd::pair  p2{ \"one\", 1 };    \/\/ std::pair<std::string, int>\nstd::pair  p3{ \"1\", \"one\" };  \/\/ std::pair<std::string, std::string><\/pre>\n\n\n\n
Gotchas<\/h3>\n\n\n\n
CTAD does not take place when the template argument list is present. The following two declarations are both legal:<\/p>\n\n\n\n
std::pair<int, std::string> p1 {1, \"one\"};\nstd::pair                   p2 {1, \"one\"};<\/pre>\n\n\n\n
However, none of the following is valid, as CTAD does not take place:<\/p>\n\n\n\n
std::pair<>    p1 { 1, \"one\" };\nstd::pair<int> p2 { 1, \"one\" };<\/pre>\n\n\n\n
If you have aggregate types that you want to initialize taking advantage of CTAD then you probably need to define your own deduction guides. Let’s consider the following class template foo<\/tt>. Initializing objects without providing the template argument list does not work.<\/p>\n\n\n\n
template <typename T> \nstruct foo\n{\n   T t;\n};\n\nfoo f{ 42 };  \/\/ error: no matching overloaded function found<\/pre>\n\n\n\n
To leverage CTAD you need to define your own deduction guide, which in this case is as follows:<\/p>\n\n\n\n
template <typename T>\nfoo(T)->foo<T>;<\/pre>\n\n\n\n
C++20 support for aggregate types<\/h3>\n\n\n\n
The C++20 standard has added support for aggregate types. Defining a deduction rule as mentioned above is no longer needed for aggregates, provided that:<\/p>\n\n\n\n