Comprehensive Analysis of typename and template Keywords in C++ Templates

Fundamental Concepts of Dependent Names

In C++ template programming, the compiler must accurately identify the type properties of names to correctly parse code. Consider the following simple example:

t * f;

The semantics of this line depend entirely on the meaning of t. If t is a type, this declares a pointer f; if t is a variable, this is a multiplication operation. The C++ Standard explicitly states (3/7): Some names denote types or templates. In general, whenever a name is encountered it is necessary to determine whether that name denotes one of these entities before continuing to parse the program that contains it.

The Role of typename Keyword

When a name depends on template parameters, the compiler cannot determine its type properties at definition time. Such names are called dependent names. The Standard specifies (14.6/2): 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.

Consider the following code example:

template <typename T>
class Container {
    T::value_type * ptr; // May be parsed as multiplication
};

Here T::value_type is a dependent name, and the compiler cannot determine whether it is a type or a static member. The correct implementation should be:

template <typename T>
class Container {
    typename T::value_type * ptr; // Explicitly specified as type
};

Necessity of template Keyword

Similar issues exist in the parsing of template names. Consider this seemingly simple code:

boost::function<int()> f;

If boost::function were not a template, this could actually be parsed as a comparison expression. The Standard states (14.2/3): After name lookup finds that a name is a template-name, if this name is followed by a <, the < is always taken as the beginning of a template-argument-list and never as a name followed by the less-than operator.

For dependent template names, the template keyword must be used:

template <typename T>
void process() {
    T::template factory<int>(); // Call dependent template function
    this->template create<double>(); // Use in member access
}

Classification of Dependent Names

According to the C++ Standard, dependent constructs can be divided into several logical groups:

• Dependent types: Such as type template parameter T
• Value-dependent expressions: Such as non-type template parameter N
• Type-dependent expressions: Such as type cast (T)0

These rules are built recursively. For example, type T[N] is a dependent type if N is a value-dependent expression or T is a dependent type.

Practical Application Examples

Returning to the code from the original problem, the correct implementation should be:

template <typename T, typename Tail>
struct UnionNode : public Tail {
    template<typename U> struct inUnion {
        typedef typename Tail::template inUnion<U> dummy;
    };
    template< > struct inUnion<T> { };
};

template <typename T>
struct UnionNode<T, void> {
    template<typename U> struct inUnion;
    template< > struct inUnion<T> { };
};

Here both typename and template keywords are used: typename specifies that Tail::template inUnion<U> is a type, while template indicates that inUnion is a template.

Special Cases and Limitations

In certain situations, the use of these keywords is restricted:

• typename is not allowed on names of dependent base classes, as the given name is assumed to be a class type name
• template cannot be used after the last :: in using declarations

Example:

template <typename T>
struct Derived : Base<T>::type { // Correct, no typename needed
    using typename Base<T>::type; // Correct
    using Base<T>::template type; // Error
};

Conclusion

Understanding the use of typename and template keywords is essential for mastering C++ template programming. These keywords help the compiler correctly parse dependent names during template definition, preventing unexpected parsing errors during instantiation. By systematically learning the classification of dependent names and usage rules, developers can write more robust and maintainable template code.