{"id":4179,"date":"2021-03-15T10:17:43","date_gmt":"2021-03-15T08:17:43","guid":{"rendered":"https:\/\/mariusbancila.ro\/blog\/?p=4179"},"modified":"2021-03-19T15:53:03","modified_gmt":"2021-03-19T13:53:03","slug":"typename-or-class","status":"publish","type":"post","link":"https:\/\/mariusbancila.ro\/blog\/2021\/03\/15\/typename-or-class\/","title":{"rendered":"The choice between typename and class"},"content":{"rendered":"\n

When working with C++ templates, you have probably seen typename<\/code> and class<\/code> used interchangeably. Is there a difference between them? This post will explain when these two keywords can be used in templates.<\/p>\n\n\n\n

Let’s consider the following example:<\/p>\n\n\n\n

template <class T>\nclass foo {};\n\ntemplate <typename T>\nclass foo {};<\/pre>\n\n\n\n
In this context, when declaring a type template parameter<\/em>, there is no difference, they are interchangeable. They can also be mixed together, as in the following example:<\/p>\n\n\n\n
template<class A, typename B>\nstruct foo\n{\n   A a;\n   B b;\n};<\/pre>\n\n\n\n
Here is what the C++ standard has to say about it (\u00a713.2.2):<\/p>\n\n\n\n
There is no semantic difference between class and typename in a type-parameter-key.<\/p><\/blockquote>\n\n\n\n
So which one should be used then? It’s all a matter of style. In fact, the standard itself is using both of them in what seems to be a completely random style, which I believe actually depended on the preferred style of the people that wrote the proposals that made it to the standard.<\/p>\n\n\n\n
You can find here<\/a> links to various version of the C++ standard if you want to have a look.<\/p>\n\n\n\n
A recent poll I run on twitter with more than 100 respondents showed that 9 out of 10 people prefer to use typename<\/tt> instead of class<\/tt>. I personally prefer the same.
\"\"<\/a><\/p>\n\n\n\n
However, there are cases when these two cannot be used interchangeably. One case is dependent types<\/em>, which are names that are dependent on a template parameter. Here is an example:<\/p>\n\n\n\n
template <typename T>\nstruct wrapper\n{\n   using value_type = T;\n\n   value_type value;\n};\n\ntemplate <typename T>\nstruct foo\n{\n   T wrapped_value;\n\n   typename T::value_type get_wrapped_value() { return wrapped_value.value; }\n};\n\nint main()\n{\n   foo<wrapper<int>> f{ {42} };\n   std::cout << f.get_wrapped_value() << '\\n';\n}<\/pre>\n\n\n\n
In this snippet, foo<\/code> is a class that contains an object of a type that wraps another value and contains a public data member called value<\/code>. wrapper<\/code> is such a type. However, foo<\/code> has a method that returns the wrapped value. That is T::value_type<\/code>. However, if you use it without the typename<\/code> keyword, as seen in the snippet, you get a compiler error. The following is from the VC++ compiler:<\/p>\n\n\n\n
warning C4346: 'value_type': dependent name is not a type\nmessage : prefix with 'typename' to indicate a type\nerror C2061: syntax error: identifier 'value_type'\n<\/pre>\n\n\n\n
This is where you must use typename<\/code> but where class<\/code> is not allowed.<\/p>\n\n\n\n
The following is an alternative solution where an alias is introduced in the foo<\/code> class template, which, of course, requires the typename<\/code> keyword.<\/p>\n\n\n\n
template <typename T>\nstruct foo\n{\n   using wrapped_value_type = typename T::value_type;\n\n   T wrapped_value;\n\n   wrapped_value_type get_wrapped_value() { return wrapped_value.value; }\n};<\/pre>\n\n\n\n
As a parenthesis, there is another alternative solution to this particular problem from this example (given than we only need the wrapped value type for the return type of a function). That is the use of auto for the return type.<\/p>\n\n\n\n
template <typename T>\nstruct foo\n{\n   T wrapped_value;\n\n   auto get_wrapped_value() { return wrapped_value.value; }\n};<\/pre>\n\n\n\n
Prior to C++17, there was another case where these two could not be used interchangeably. It is the case of template template parameters<\/em>, where class<\/tt> had to be used. Let’s look at an example.<\/p>\n\n\n\n
First, consider there is another class template that has two type parameters, as shown in the following snippet.<\/p>\n\n\n\n
template <typename T, typename U>\nstruct dual_wrapper\n{\n   using value_type1 = T;\n   using value_type2 = U;\n\n   value_type1 value;\n   value_type2 another_value;\n};<\/pre>\n\n\n\n
Having the foo<\/code> class template from the previous example, we could write the following:<\/p>\n\n\n\n
foo<wrapper<int>> f{ {42} };\nstd::cout << f.get_wrapped_value() << '\\n';\n   \nfoo<dual_wrapper<int, double>> f2{ {43, 15.0} };\nstd::cout << f2.get_wrapped_value() << '\\n';<\/pre>\n\n\n\n
However, what if you want to restrict the instantiation to wrappers that have a single type parameter? Then, you can modify the foo<\/code> class template as follows:<\/p>\n\n\n\n
template <typename V, template <typename> class T>\nstruct foo\n{\n   T<V> wrapped_value;\n\n   auto get_wrapped_value() { return wrapped_value.value; }\n};<\/pre>\n\n\n\n
The template <typename> class T<\/code> part is a template template parameter. It used to require the keyword class<\/code> but as of C++17, typename<\/code> can be used here to, as in template <typename> typename T<\/code>.<\/p>\n\n\n\n
We need to change a bit the way objects of type foo<\/code> are declared. However, attempting to use dual_wrapper<\/code> now results in a compiler error.<\/p>\n\n\n\n
foo<int, wrapper> f{ {42} };\nstd::cout << f.get_wrapped_value() << '\\n';\n   \nfoo<int, dual_wrapper> f2{ {43, 15.0} };     \/\/ error<\/pre>\n\n\n\n
Can anything else be used in place of a the typename<\/code> or class<\/code> keywords? As of C++20, when declaring a type template parameter, the answer is yes. A concept name can be used instead. Here is an example:<\/p>\n\n\n\n
template <typename T>\nconcept Numeric = std::is_arithmetic_v<T>;\n\ntemplate <Numeric T>\nstruct wrapper\n{\n   T value;\n};\n\nwrapper<int> vi{ 42 };\nwrapper<std::string> vs{ \"42\"s }; \/\/ error: 'wrapper': the associated constraints are not satisfied<\/pre>\n\n\n\n
In this snippet, Numeric<\/code> is a concept used to ensure that the wrapper<\/code> class template can only be instantiated with numerical types, such as int<\/code> or double<\/code>. The type template parameter has the form Numeric T<\/code> instead of class T<\/code> or typename T<\/code>.<\/p>\n\n\n\n
There is an alternative syntax to declaring the wrapper class template with the same semantics. This is shown below:<\/p>\n\n\n\n
template <typename T> requires Numeric<T>\nstruct wrapper\n{\n   T value;\n};<\/pre>\n\n\n\n
We have discussed so far type template parameters and template template parameters. However, there is a 3rd category of template parameters, non-type template parameters<\/em>. These ones are introduced not with typename<\/code>, class<\/code>, or the name of a concept, but with the name of a structural type<\/em> which can be a lvalue reference types, an integral type, a pointer type, a pointer to member type, an enumeration type, std::nullptr_t<\/code>, and, as of C++20, a floating-point type, or a literal class type that satisfies some conditions. Here are some examples:<\/p>\n\n\n\n
template <typename T, size_t Size>\nstruct fixed_size_array\n{\n   T[Size] values;\n};\n\nfixed_size_array<int, 4> arr;<\/pre>\n\n\n\n
The placeholder auto<\/code> can be used instead of the actual type, with the forms auto<\/code>, auto**<\/code>, auto&<\/code> and decltype(auto)<\/code>.<\/p>\n\n\n\n
template <auto V>\nstruct foo \n{\n   decltype(V) const value = V;\n};\n\nfoo<42> f1;\nstd::cout << f1.value << '\\n';\n\nfoo<42.0> f2;\nstd::cout << f2.value << '\\n';<\/pre>\n\n\n\n
\n
\n
To summarize all this:<\/p>\n\n\n\n