c++ - 为什么必须在哪里放置 “template”和 “typename”关键字？

Question

在模板中，为什么必须在哪里以及为什么要将typename和template放在从属名称上？
无论如何，依赖名称到底是什么？

我有以下代码:

template <typename T, typename Tail> // Tail will be a UnionNode too.
struct UnionNode : public Tail {
    // ...
    template<typename U> struct inUnion {
        // Q: where to add typename/template here?
        typedef Tail::inUnion<U> dummy; 
    };
    template< > struct inUnion<T> {
    };
};
template <typename T> // For the last node Tn.
struct UnionNode<T, void> {
    // ...
    template<typename U> struct inUnion {
        char fail[ -2 + (sizeof(U)%2) ]; // Cannot be instantiated for any U
    };
    template< > struct inUnion<T> {
    };
};

我的问题在 typedef Tail::inUnion<U> dummy行中。我相当确定 inUnion是一个从属名称，而VC++恰好可以使它窒息。
我也知道我应该能够在某处添加 template来告诉编译器inUnion是一个模板ID。但是到底在哪里？然后是否应该假设inUnion是一个类模板，即 inUnion<U>命名一个类型而不是一个函数？

Answer 1

(请参阅here also for my C++11 answer)

为了解析C++程序，编译器需要知道某些名称是否为类型。以下示例说明了这一点:

t * f;

应该如何解析？对于许多语言，编译器不需要知道名称的含义即可进行解析，并且基本上知道一行代码会执行什么操作。然而，在C++中，根据 t的含义，以上内容可能会产生截然不同的解释。如果是类型，则它将是指针 f的声明。但是，如果不是类型，它将是一个乘法。因此，C++标准在第(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 process that determines this is called name lookup.

如果 t::x引用模板类型参数，编译器将如何找出 t引用的名称？ x可以是一个静态的int数据成员，可以乘以，也可以是可以产生声明的嵌套类或typedef。 如果名称具有此属性-在知道实际的模板参数之前无法查找，则该名称称为从属名称(“取决于”模板参数)。

您可能建议仅等待用户实例化模板:

Let's wait until the user instantiates the template, and then later find out the real meaning of t::x * f;.

这将起作用，并且实际上是标准允许的一种可能的实现方法。这些编译器基本上将模板的文本复制到内部缓冲区中，并且只有在需要实例化时，它们才会解析模板并可能检测到定义中的错误。但是，其他实现方式并没有使模板的用户(可怜的同事!)受到模板作者的错误困扰，而是选择尽早检查模板并在实例化发生之前尽快给出定义错误。

因此，必须有一种方法告诉编译器某些名称是类型，而某些名称不是。

"typename"关键字

答案是:我们决定编译器应如何解析它。如果 t::x是从属名称，那么我们需要给它加上 typename前缀，以告诉编译器以某种方式对其进行解析。标准在(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.

有许多名称不需要 typename，因为编译器可以使用模板定义中的适用名称查找来弄清楚如何解析结构本身-例如，当 T *f;是类型模板参数时，使用 T。但是要使 t::x * f;成为声明，必须将其写为 typename t::x *f;。如果省略关键字，并且名称被视为非类型，但是当实例化发现它表示类型时，编译器会发出通常的错误消息。有时，错误因此在定义时给出:

// t::x is taken as non-type, but as an expression the following misses an
// operator between the two names or a semicolon separating them.
t::x f;

该语法仅在合格名称之前才允许 typename-因此，可以认为，已知非合格名称总是引用类型。

正如介绍性文字所暗示的，对于表示模板的名称也存在类似的陷阱。

"template"关键字

还记得上面的最初引文，以及该标准又如何要求对模板进行特殊处理？让我们看下面的例子:

boost::function< int() > f;

对于人类读者来说，这似乎很明显。对于编译器则不是这样。想象以下 boost::function和 f的任意定义:

namespace boost { int function = 0; }
int main() { 
  int f = 0;
  boost::function< int() > f; 
}

这实际上是一个有效的表达!它使用小于运算符将 boost::function与零( int())进行比较，然后使用大于运算符将结果 bool与 f进行比较。但是，您可能知道， boost::function in real life是模板，因此编译器知道(14.2/3):

After name lookup (3.4) 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.

现在我们回到与 typename相同的问题。如果在解析代码时我们还不知道名称是否是模板怎么办？根据 template的指定，我们需要在模板名称之前插入 14.2/4。看起来像:

t::template f<int>(); // call a function template

在类成员访问中，模板名称不仅可以出现在 ::之后，而且可以出现在 ->或 .之后。您也需要在其中插入关键字:

this->template f<int>(); // call a function template

依存关系

对于那些架子上堆满Standardese书籍，又想知道我到底在说什么的人，我会谈一谈标准中对此的规定。

在模板声明中，某些构造根据用于实例化模板的模板参数而具有不同的含义:表达式可能具有不同的类型或值，变量可能具有不同的类型，或者函数调用最终可能会调用不同的函数。通常说这样的构建体取决于模板参数。

该标准通过构造是否依赖来精确定义规则。它将它们分成逻辑上不同的组:一个捕获类型，另一个捕获表达式。表达式可能取决于它们的值和/或类型。因此，我们附有典型示例:

依赖类型(例如:类型模板参数T)

值相关的表达式(例如:非类型模板参数N)

类型相关的表达式(例如:类型模板参数(T)0的转换)

大多数规则都是直观的，并且是递归建立的:例如，如果 T[N]是值相关的表达式或 N是相关类型，则构造为 T的类型是相关类型。有关详细信息，请参见 (14.6.2/1)(用于依赖类型)， (14.6.2.2)(用于类型依赖的表达式)和 (14.6.2.3)(用于值依赖的表达式)。

相关名称

对于确切的从属名称，标准尚不清楚。简单阅读(您知道，最少惊讶的原理)后，它定义为从属名称的全部就是下面函数名称的特例。但是由于显然还需要在实例化上下文中查找 T::x，因此它也必须是从属名称(很幸运，从C++ 14开始，委员会已经开始研究如何解决这个令人困惑的定义)。

为避免此问题，我对标准文本进行了简单的解释。在所有表示从属类型或表达式的构造中，它们的一个子集代表名称。因此，这些名称是“从属名称”。名称可以采用不同的形式-标准说:

A name is a use of an identifier (2.11), operator-function-id (13.5), conversion-function-id (12.3.2), or template-id (14.2) that denotes an entity or label (6.6.4, 6.1)

标识符只是一个简单的字符/数字序列，而接下来的两个是 operator +和 operator type形式。最后一种形式是 template-name <argument list>。所有这些都是名称，按照标准中的常规用法，名称还可以包含限定符，该限定符表示应查找名称的 namespace 或类。

值依赖表达式 1 + N不是名称，但 N是名称。所有相关构造的子集即名称都称为相关名称。但是，函数名称在模板的不同实例中可能具有不同的含义，但是不幸的是，该通用规则没有捕获函数名称。

从属函数名称

本文并不是主要关注的问题，但仍然值得一提:函数名称是一个单独处理的异常。标识符函数名称不依赖于自身，而是依赖于调用中使用的依赖于类型的参数表达式。在示例 f((T)0)中， f是从属名称。在标准中，这是在 (14.6.2/1)处指定的。

附加说明和示例

在足够的情况下，我们需要 typename和 template。您的代码应如下所示

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

关键字 template不一定总是出现在名称的最后部分。它可以出现在用作范围的类名的中间，如以下示例所示

typename t::template iterator<int>::value_type v;

在某些情况下，关键字被禁止，如下所述

在依赖基类的名称上，不允许您编写typename。假定给定的名称是类类型名称。对于基类列表和构造函数初始化器列表中的名称都是如此:

 template <typename T>
 struct derive_from_Has_type : /* typename */ SomeBase<T>::type 
 { };

在using-declaration中，不可能在最后一个template之后使用::，并且C++委员会said不能解决问题。

 template <typename T>
 struct derive_from_Has_type : SomeBase<T> {
    using SomeBase<T>::template type; // error
    using typename SomeBase<T>::type; // typename *is* allowed
 };