问题：为什么必须在何处以及为什么要放置"模板"和"类型名"关键字？

在模板中，为什么必须在何处以及为什么将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> {
    };
};

我遇到的问题是在typedefTail::inUnion虚拟行中。我相当确定inUnion是一个从属名称，而VC ++对此是正确的选择。我也知道我应该能够在某处添加template来告诉编译器inUnion是一个模板ID。但是到底在哪里？然后是否应该假设inUnion是一个类模板，即inUnion命名一个类型而不是一个函数？

标签：c++,templates,typename,c++-faq,dependent-name

回答1：

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

t * f;

应如何解析？对于许多语言，编译器不需要知道名称的含义即可进行解析，并且基本上知道一行代码会执行什么操作。然而，在C ++中，根据t的含义，以上内容可能会产生截然不同的解释。如果是类型，则它将是指针f的声明。但是，如果不是类型，它将是一个乘法。因此，C ++标准在第(3/7)段中说：

某些名称表示类型或模板。通常，无论何时遇到名称，都必须在继续解析包含该名称的程序之前确定该名称是否表示这些实体之一。确定此过程的过程称为名称查找。

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

您可能建议等到用户实例化模板后：

让我们等到用户实例化模板，然后再找出t::x*f;。
的真实含义。

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

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

"类型名称"关键字

答案是：我们决定编译器应如何解析它。如果t::x是从属名称，那么我们需要在其前面加上typename前缀，以告诉编译器以某种方式对其进行解析。标准在(14.6 / 2)中说：

除非在适用的名称查找中找到类型名称或该名称由关键字typename限定，否则假定模板声明或定义中使用的名称依赖于模板参数，而该名称不命名类型。

有许多名称不需要使用typename，因为编译器可以通过模板定义中的适用名称查找来弄清楚如何解析结构本身-例如使用 T * f; ，当T是类型模板参数时。但是要使t::x*f;成为声明，必须将其写为typenamet::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 -因此，可以理解的是，通常知道非限定名称会引用类型。

在介绍性文字中暗示，存在一个类似的陷阱，表示模板的名称。

"模板"关键字

还记得上面的引号吗？《标准》又如何要求对模板进行特殊处理？让我们看下面的示例：

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 现实中的是模板，因此编译器知道(14.2 / 3)：

在名称查找(3.4)发现名称是模板名称之后，如果此名称后跟<，则始终将<用作模板参数列表的开头，而永远不会将其作为模板名称小于运算符。>

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

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

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

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

依赖项

对于那些书架上藏有大量Standardese书并且想知道我到底在说什么的人，我将再谈一谈标准中对此的具体规定。

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

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

从属类型(例如：类型模板参数T)
与值相关的表达式(例如：非类型模板参数N)
与类型有关的表达式(例如：对类型模板参数(T)0的强制转换)

大多数规则都是直观的，并且是递归建立的：例如，如果N是一个值，则构造为T[N]的类型是从属类型-从属表达式或T是从属类型。有关此类型的详细信息，请参见(14.6.2/1)部分中的相关类型，(14.6.2.2)中类型相关的表达式和(14.6.2.3)表示值相关的表达式。

从属名称

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

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

名称是对表示实体或标签(6.6的标识符)(2.11)，操作员功能ID(13.5)，转换功能ID(12.3.2)或模板ID(14.2)的使用.4，6.1)

标识符只是一个简单的字符/数字序列，而后两个是operator+和operatortype形式。最后一种形式是template-name。所有这些都是名称，按照标准中的常规用法，名称也可以包含限定词，该限定词表示应在其中查找名称空间或类。

依赖于值的表达式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 
 { };
```

在使用声明中，不能在最后一个::之后使用template，并且C ++委员会说不适用于解决方案。

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

回答2：

C ++ 11

问题

虽然C ++ 03中有关何时需要typename 和template的规则在很大程度上是合理的，但其制定存在一个令人讨厌的缺点

template<typename T>
struct A {
  typedef int result_type;

  void f() {
    // error, "this" is dependent, "template" keyword needed
    this->g<float>();

    // OK
    g<float>();

    // error, "A<T>" is dependent, "typename" keyword needed
    A<T>::result_type n1;

    // OK
    result_type n2; 
  }

  template<typename U>
  void g();
};

可以看出，即使编译器可以完美地指出A::result_type只能是int(因此是一个类型)，并且this->g只能是稍后声明的成员模板g(即使A在某处显式专门化，也不会会影响该模板中的代码，因此以后的A！专业化不会影响其含义！)。

当前实例

为改善这种情况，在C ++ 11中，该语言会跟踪类型引用封闭模板的时间。要知道，该类型必须通过使用某种形式的名称来形成，该名称是其自己的名称(在上面，A，A，< code> :: A )。此类名称引用的类型称为 当前实例化。如果形成名称的类型是成员/嵌套类(那么 A::NestedClass和 A是两个当前实例)。

基于此概念，该语言表示CurrentInstantiation::Foo，Foo和CurrentInstantiationTyped->Foo(例如* a = this; a-> Foo )都是当前实例的成员如果，它们被发现是当前实例的类的成员实例化或其非依赖基类之一(只需立即执行名称查找)。

如果限定符是当前实例的成员，则现在不再需要关键字typename和template。这里要记住的一个关键点是A仍然是 still 依赖类型的名称(毕竟T也是依赖类型的)。但是已知A ::result_type是一种类型-编译器将"神奇地"研究这种依赖类型以弄清楚这一点。

struct B {
  typedef int result_type;
};

template<typename T>
struct C { }; // could be specialized!

template<typename T>
struct D : B, C<T> {
  void f() {
    // OK, member of current instantiation!
    // A::result_type is not dependent: int
    D::result_type r1;

    // error, not a member of the current instantiation
    D::questionable_type r2;

    // OK for now - relying on C<T> to provide it
    // But not a member of the current instantiation
    typename D::questionable_type r3;        
  }
};

这令人印象深刻，但是我们可以做得更好吗？该语言甚至走得更远，并且要求，实例化D::f时，实现再次查找D::result_type(即使它找到了它的)。意味着已经在定义时间了)。当现在查找结果不同或导致歧义时，程序格式错误，必须给出诊断。想象一下，如果我们这样定义C，会发生什么情况

template<>
struct C<int> {
  typedef bool result_type;
  typedef int questionable_type;
};

实例化D ::f时，需要编译器来捕获错误。因此，您可以充分利用两个世界的优势："延迟"查找可以保护您，如果您可能遇到依赖基类的麻烦；还可以通过"即时"查找将您从typename和template中解放出来。

未知专业

在D的代码中，名称typenameD::questionable_type不是当前实例的成员。相反，该语言将其标记为未知专业名称的成员。特别是，当您执行DependentTypeName::Foo或DependentTypedName->Foo且其中一个依赖类型为 not 时，情况总是如此。当前实例化(在这种情况下，编译器可以放弃并说"我们稍后再看Foo是什么)或它是当前实例化，并且在其中找不到名称或其非依赖基类，并且还有依赖基类。

想象一下，如果在上面定义的A类模板中有成员函数h，会发生什么情况？

void h() {
  typename A<T>::questionable_type x;
}

在C ++ 03中，该语言允许捕获此错误，因为永远不可能有一种有效的方法来实例化A ::h(无论您给T)。在C ++ 11中，现在对该语言进行了进一步检查，以使编译器有更多理由实施此规则。由于A没有依赖的基类，并且A没有声明成员questionable_type，因此名称为A ::questionable_type 既不是当前实例的成员，也不是未知专业化的成员。在这种情况下，应该无法在实例化时有效地编译该代码，因此该语言禁止使用限定符作为当前实例化的名称，该名称既不是未知专业化的成员，也不是当前实例化的成员(但是，仍然不需要诊断出这种违规行为。

 示例和琐事
 您可以在此答案上尝试这些知识，并查看上述定义在现实世界中是否对您有意义示例(在该答案中重复的内容略少一些)。 
  C ++ 11规则使以下有效的C ++ 03代码格式错误(这不是C ++委员会想要的，但可能不会修复)
 struct B { void f(); };
struct A : virtual B { void f(); };

template<typename T>
struct C : virtual B, T {
  void g() { this->f(); }
};

int main() { 
  C<A> c; c.g(); 
}
 此有效的C ++ 03代码将在实例化时将this->f绑定到A::f，一切都很好。但是C ++ 11立即将其绑定到B::f，并且在实例化时需要仔细检查，以检查查找是否仍然匹配。但是，当实例化C::g时，应用统治规则，查找将查找A::f。

回答3：

前言

这篇文章旨在代替 litb的帖子。

基本目的是相同的；对"何时？"的解释和"为什么？"必须使用typename和template。

`typename`和`template`的目的是什么？

类型名和template在声明模板以外的其他情况下可用。

在 C ++ 中有某些上下文，必须明确告知编译器如何处理名称，所有这些上下文有一个共同点；它们至少取决于一个 template-parameter 。

我们将此类名称(可能在解释上存在歧义)称为： " 从属名称"。

这篇文章将解释依赖名称与两个关键字之间的关系。

片段多于1000个单词

尝试向自己，朋友或您的猫解释以下功能模板中发生的事情；标记为( A )的语句中发生了什么？

template<class T> void f_tmpl () { T::foo * x; /* <-- (A) */ }

可能并不像人们想象的那么容易，更具体地说，评估( A )严重取决于的结果作为模板参数T传递的类型的定义。

不同的T可以大大改变所涉及的语义。

struct X { typedef int       foo;       }; /* (C) --> */ f_tmpl<X> ();
struct Y { static  int const foo = 123; }; /* (D) --> */ f_tmpl<Y> ();

两种不同的情况：

如果我们使用( C )中的类型 X 实例化函数模板，则将声明 pointer-to int 命名为 x ，但是;
如果我们实例化类型为 Y 的模板，例如( D )，则( A )将包含一个计算 123 乘以一些已经声明的变量 x 的乘积的表达式。

理据

至少在这种情况下，C ++标准关心我们的安全和福祉。

为了防止实现可能遭受令人讨厌的意外，该标准要求我们通过明确阐明依赖名称的含糊不清之处， d希望将名称视为 type-name 或 template-id 。

如果未指定任何内容，则依赖名称将被视为变量或函数。

如何处理相关名称？

如果这是一部好莱坞电影，依赖名称将是通过身体接触传播的疾病，立即影响其主人，使之困惑。混乱可能会导致格式错误的pers.-erhm ..程序。

从属名称是直接或间接取决于 template-parameter 的任何名称。

template<class T> void g_tmpl () {
   SomeTrait<T>::type                   foo; // (E), ill-formed
   SomeTrait<T>::NestedTrait<int>::type bar; // (F), ill-formed
   foo.data<int> ();                         // (G), ill-formed    
}

在以上代码段中，我们有四个 dependent 名称：

E )
- "类型" 取决于SomeTrait的实例化，其中包括T和；
F )
- "嵌套特性" ，它是一个 template-id ，取决于SomeTrait和；
- "类型" 取决于 NestedTrait ，后者取决于SomeTrait和；
G )
- "数据" ，看起来像一个成员函数模板，由于的类型而间接地是一个依赖名称。 foo 取决于SomeTrait的实例化。

如果编译器将解释依赖项，则( E )，( F )或( G )语句均无效-名称作为变量/函数(如前所述，如果我们没有明确说明，则会发生这种情况)。

解决方案

要使g_tmpl具有有效的定义，我们必须明确告知编译器我们期望( E )中的类型， template-id 和( F )中的 type ，以及( G )中的 template-id 。

template<class T> void g_tmpl () {
   typename SomeTrait<T>::type foo;                            // (G), legal
   typename SomeTrait<T>::template NestedTrait<int>::type bar; // (H), legal
   foo.template data<int> ();                                  // (I), legal
}

每次名称表示一种类型时，涉及的所有名称必须是 type-names 或< em>命名空间，考虑到这一点，很容易看出我们在完全限定名称的开头应用了typename。

但是，

模板在这方面是不同的，因为无法得出这样的结论： "哦，这是模板，那么另一件事也必须是模板" 。这意味着我们将template直接应用在我们要这样对待的任何 name 前面。

我可以在任何名字的前面粘贴关键字吗？

" 我可以只将typename和template放在任何名称的前面吗？我不想担心它们出现的上下文。 "-一些C++开发人员

标准中的规则规定，只要您使用的是限定名称( K )，就可以应用关键字，但是如果名称不是' t 合格应用程序格式不正确( L )。

namespace N {
  template<class T>
  struct X { };
}

         N::         X<int> a; // ...  legal
typename N::template X<int> b; // (K), legal
typename template    X<int> c; // (L), ill-formed

^{注意：在不需要的情况下应用typename或template并不被认为是一种好习惯；仅仅因为您可以做某事，并不意味着您应该做。}

此外，在某些情况下，显式明确禁止了typename和template：

在指定类继承的基础时

在派生类的 base-specifier-list 中编写的每个名称都已经存在视为类型名称，显式指定typename既不正确，又多余。

                   // .------- the base-specifier-list
 template<class T> // v
 struct Derived      : typename SomeTrait<T>::type /* <- ill-formed */ {
   ...
 };

当 template-id 是派生类的 using-directive
中引用的那个 pre>

回答4：

typedef typename Tail::inUnion<U> dummy;

但是，我不确定您对inUnion的实现是否正确。如果我理解正确，则不应实例化此类，因此"失败"选项卡将永远不会失败。也许最好使用简单的布尔值指示类型是否在联合中。

template <typename T, typename TypeList> struct Contains;

template <typename T, typename Head, typename Tail>
struct Contains<T, UnionNode<Head, Tail> >
{
    enum { result = Contains<T, Tail>::result };
};

template <typename T, typename Tail>
struct Contains<T, UnionNode<T, Tail> >
{
    enum { result = true };
};

template <typename T>
struct Contains<T, void>
{
    enum { result = false };
};

PS：看看 Boost :: Variant

PS2：看看类型列表，尤其是在Andrei Alexandrescu的书：Modern C ++ Design < / p>

回答5：

_{此答案是一个相当简短的答案，用于回答标题问题(的一部分)。如果您想获得更详细的答案来解释为什么必须将其放在此处，请在此处。}

例如，当您使用模板参数并且想要访问嵌套的typedef或使用别名时，放置typename关键字的一般规则通常是：

template<typename T>
struct test {
    using type = T; // no typename required
    using underlying_type = typename T::type // typename required
};

请注意，这也适用于元函数或带有通用模板参数的事物。但是，如果提供的模板参数是显式类型，则不必指定typename，例如：

template<typename T>
struct test {
    // typename required
    using type = typename std::conditional<true, const T&, T&&>::type;
    // no typename required
    using integer = std::conditional<true, int, float>::type;
};

添加template限定词的一般规则与大多数规则相似，除了它们通常涉及本身已模板化的struct / class的模板化成员函数(静态或其他)，例如：

给出以下结构和功能：

template<typename T>
struct test {
    template<typename U>
    void get() const {
        std::cout << "get\n";
    }
};

template<typename T>
void func(const test<T>& t) {
    t.get<int>(); // error
}

尝试从函数内部访问t.get ()会导致错误：

main.cpp:13:11: error: expected primary-expression before 'int'
     t.get<int>();
           ^
main.cpp:13:11: error: expected ';' before 'int'

因此，在这种情况下，您需要预先使用template关键字并按如下方式调用它：

t.templateget ()

这样，编译器将正确解析此内容，而不是t.get。

回答6：

我正在将JLBorges出色的响应逐字地发给类似的问题cplusplus.com，因为这是我在该主题上读得最简洁的解释。

在我们编写的模板中，可以使用两种名称-从属名称和非从属名称。从属名称是取决于模板参数的名称。无论模板参数是什么，一个非依赖名称的含义都相同。

例如：
template< typename T > void foo( T& x, std::string str, int count )
{
    // these names are looked up during the second phase
    // when foo is instantiated and the type T is known
    x.size(); // dependant name (non-type)
    T::instance_count ; // dependant name (non-type)
    typename T::iterator i ; // dependant name (type)

    // during the first phase, 
    // T::instance_count is treated as a non-type (this is the default)
    // the typename keyword specifies that T::iterator is to be treated as a type.

    // these names are looked up during the first phase
    std::string::size_type s ; // non-dependant name (type)
    std::string::npos ; // non-dependant name (non-type)
    str.empty() ; // non-dependant name (non-type)
    count ; // non-dependant name (non-type)
}
对于模板的每个不同实例，从属名称所指的含义可能有所不同。因此，C ++模板需要进行"两阶段名称查找"。最初分析模板时(在进行任何实例化之前)，编译器将查找非相关名称。当发生模板的特定实例化时，模板参数到此为已知，并且编译器将查找相关名称。

在第一阶段中，解析器需要知道从属名称是类型的名称还是非类型的名称。默认情况下，从属名称被假定为非类型的名称。在从属名称前面的typename关键字指定它是一种类型的名称。

摘要

仅在模板声明和定义中使用关键字typename，前提是您具有引用类型且取决于模板参数的限定名称。

回到顶部