Typename

In C++'s generic programming feature known as "templates", typename can be used for introducing a template parameter:^[3][4]

// Define a generic function that returns the greater of its two arguments
template <typename T>
[[nodiscard]]
const T& max(const T& x, const T& y) noexcept {
    return y < x ? x : y;
}

An alternative and semantically equivalent keyword in this scenario is "class":

// Define a generic function that returns the greater of its two arguments
template <class T>
[[nodiscard]]
const T& max(const T& x, const T& y) noexcept {
    return y < x ? x : y;
}

When using concepts, a means of constraining the generic type to satisfy some set of rules, the name of the concept replaces the keyword typename.

import std;

using std::is_base_of_v;
using std::vector;

class Player {
    // ...
};

template <typename T>
concept ExtendsPlayer = is_base_of_v<Player, T>;

// T is required to be a type whose inheritance upper bound is Player,
// blocking any type that does not inherit from Player
template <ExtendsPlayer T>
void processListOfPlayers(vector<T> players) {
    // ...
}

Consider this invalid code:^[5]

template <typename T>
void foo(const T& t) {
     // declares a pointer to an object of type T::bar
     T::Bar* p;  // error (see text)
}

struct UsesBar {
    using Bar = int;
};

int main() {
    UsesBar x;
    foo(x);
}

This code looks like it should compile, but it is incorrect because the compiler does not know if T::Bar is a type or a value. The reason it doesn't know is that T::Bar is a "template-parameter dependent name", or "dependent name" for short, which then could represent anything named "Bar" inside a type passed to foo(), which could include typedefs, enums, variables, etc.

To resolve this ambiguity, the C++ Language Standard declares:

A name used in a template declaration or definition and that is dependent on a template-parameter is assumed not to name a type unless the applicable name lookup finds a type name or the name is qualified by the keyword typename.

In short, if the compiler can't tell if a dependent name is a value or a type, then it will assume that it is a value.

In our example, where T::Bar is the dependent name, that means that rather than declaring a pointer to T::Bar named p, the line

T::Bar* p;

will instead multiply the "value" T::Bar by p (which is nowhere to be found) and throw away the result. The fact that in UsesBar the dependent Bar is in fact a type does not help since foo() could be compiled long before UsesBar is seen. Furthermore, if there is also a class like:

struct HoldsBar {
    int Bar;
};

then the compiler would be obliged to interpret the T::Bar in foo() as an access to data member HoldsBar::Bar when instantiated. But since Bar is not a static data member it will flag an error.

The solution to this problem is to explicitly tell the compiler that T::Bar is in fact a type. For this, the typename keyword is used:^[3][4]

template <typename T>
void foo(const T& t) {
    // declares a pointer to an object of type T::Bar
    typename T::Bar* p;
}

Now the compiler knows for sure that T::Bar is a type, and will correctly make p a pointer to an object of that type.

• Argument-dependent name lookup – another C++ name lookup rule