Typename

" " is a keyword in the C++ programming language used when writing templates. It is used for specifying that a dependent name in a template definition or declaration is a type. In the original C++ compilers before the first ISO standard was completed, the  keyword was not part of the C++ language and Bjarne Stroustrup used the   keyword for template arguments instead. While  is now the preferred keyword, older source code may still use the   keyword instead (for example see the difference in source code examples between The Design and Evolution of C++ by Bjarne Stroustrup published in 1994 and the source code examples in The C++ Programming Language: Fourth Edition by Bjarne Stroustrup published in 2013).

A synonym for " " in template parameters
In C++'s generic programming feature known as "templates",  can be used for introducing a template parameter:

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

A method for indicating that a dependent name is a type
Consider this invalid code:

This code looks like it should compile, but it is incorrect because the compiler does not know if  is a type or a value. The reason it doesn't know is that  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." 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  is the dependent name, that means that rather than declaring a pointer to   named , the line T::bar * p; will instead multiply the "value"  by   (which is nowhere to be found) and throw away the result. The fact that in  the dependent   is in fact a type does not help since   could be compiled long before   is seen. Furthermore, if there is also a class like:

then the compiler would be obliged to interpret the  in   as an access to data member   when instantiated. But since  is not a static data member it will flag an error.

The solution to this problem is to explicitly tell the compiler that  is in fact a type. For this, the  keyword is used:

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