Chapter 22

Small Improvements for Generic Programming

This chapter presents additional features and extensions of C++20 for generic programming that have not been covered in this book yet.

22.1 Implicit typename for Type Members of Template Parameters

When using type members of template parameters, you usually have to qualify this use with the keyword typename:

template<typename T>

typename T::value_type getElem(const T& cont, typename T::iterator pos)

{

using Itor = typename T::iterator; typename T::value_type elem;

...

return elem;

}

Before C++20, all qualifications of the type members value_type and iterator of T were necessary. Since C++20, you can skip typename in contexts where it is clear that a type is passed. In this case, this applies to the specification of the return type and the type used in the alias declaration (where using introduces a new name for a type):

template<typename T>

T::value_type getElem(const T& cont, typename T::iterator pos)

{

using Itor = T::iterator; typename T::value_type elem;

...

return elem;

}

673

Note that the parameter pos and the variable elem still need typename. The most important places where you can skip typename now are:

•When declaring return types (except for a local forward declaration)

•When declaring members in class templates

•When declaring parameters of member or friend functions in class templates

•When declaring parameters of requires expressions

•For the types in alias declarations

In particular, when declaring a class template, you can now skip typename in most cases:

However, because the rules for implicit typename are pretty subtle to some extent, you might simply still always use typename when using the type member of a template parameter (at least outside class templates).1

22.1.1 Rules for Implicit typename in Detail

Since C++20, you can skip typename when using a type member for a template parameter in the following situations:

•In an alias declaration (i.e., when declaring a type name with using); note that a type declaration with typedef still needs typename

•When defining or declaring the return type of a function (unless the declaration happens inside a function or block scope)

•When declaring a trailing return type

•When specifying the target type for static_cast, const_cast, reinterpret_cast, or dynamic_cast

•When specifying the type for new

•Inside a class when

–Declaring a data member

–Declaring the return type of a member function

–Declaring a parameter of a member or friend function or lambda (a default argument might still need it)

•When declaring parameter types in a requires expression

•When declaring a default value for a type parameter of a template

•When declaring the type of a non-type template parameter

1 Thanks to Arthur O’Dwyer for pointing this out.