typedef typename Tail::inUnion<U> dummy;

然而，我不确定你的inUnion的实现是正确的。如果我理解正确，这个类不应该被实例化，因此“fail”选项卡永远不会实际失败。也许用一个简单的布尔值来指示类型是否在联合中会更好。

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的书:现代c++设计

typedef typename Tail::inUnion<U> dummy;

然而，我不确定你的inUnion的实现是正确的。如果我理解正确，这个类不应该被实例化，因此“fail”选项卡永远不会实际失败。也许用一个简单的布尔值来指示类型是否在联合中会更好。

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的书:现代c++设计

(这里也有我c++ 11的答案)

为了解析c++程序，编译器需要知道某些名称是否是类型。下面的例子说明:

t * f;

这应该如何解析?对于许多语言来说，编译器不需要知道名称的含义来进行解析，并且基本上知道一行代码的操作。然而，在c++中，根据t的含义不同，上面的解释可能会有很大的不同。如果它是一个类型，那么它将是一个指针f的声明。但是如果它不是一个类型，它将是一个乘法。所以c++标准在第(3/7)段说:

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

如果t指的是一个模板类型参数，编译器将如何找出一个名称t::x指的是什么?X可以是一个静态int数据成员，它可以被相乘，也可以同样是一个嵌套类或类型定义，可以产生一个声明。如果一个名称具有这个属性——在知道实际的模板参数之前无法查找它——那么它被称为依赖名称(它“依赖”于模板形参)。

你可能会建议等待用户实例化模板:

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

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

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

“typename”关键字

答案是:我们决定编译器应该如何解析它。如果t::x是一个依赖名称，那么我们需要在它前面加上typename来告诉编译器以某种方式解析它。标准是14.6/2:

在模板声明或定义中使用且依赖于模板形参的名称为 假设不指定类型，除非适用名称查找找到类型名称或名称是限定的 通过关键字typename。

有许多名称不需要使用typename，因为编译器可以通过模板定义中适用的名称查找，找出如何解析结构本身——例如，当T是类型模板形参时，使用T *f;。但对于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与0 (int())进行比较，然后使用大于操作符将结果bool与f进行比较。然而，您可能已经知道，boost::function在现实生活中是一个模板，因此编译器知道(14.2/3):

在名称查找(3.4)发现一个名称是template-name之后，如果该名称后面跟着一个<，则<为 总是作为模板参数列表的开头，从不作为名称后面跟着小于号 操作符。

现在我们又回到了与typename相同的问题。如果在解析代码时还不知道名称是否是模板，该怎么办?我们需要在模板名称之前插入模板，就像14.2/4所指定的那样。这看起来像:

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

模板名称不仅可以出现在::后面，还可以出现在->或。在类成员访问中。你还需要在这里插入关键字:

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

---

依赖关系

对于那些书架上有厚厚的标准书的人，他们想知道我到底在说什么，我将谈谈标准中是如何指定的。

在模板声明中，一些构造有不同的含义，这取决于你使用什么模板实参来实例化模板:表达式可能有不同的类型或值，变量可能有不同的类型，函数调用可能最终调用不同的函数。这种构造通常被认为依赖于模板参数。

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

依赖类型(例如:类型模板参数T) 值依赖表达式(例如:非类型模板形参N) 依赖类型的表达式(例如:转换为类型模板参数(T)0)

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

相关的名字

标准对从属名称的定义有些不清楚。简单地读一下(您知道，最小惊喜原则)，它定义的所有依赖名称都是下面函数名的特殊情况。但是由于T::x显然也需要在实例化上下文中查找，所以它也需要是一个依赖名称(幸运的是，从c++ 14中期开始，委员会已经开始研究如何修复这个令人困惑的定义)。

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

名称是标识符(2.11)、operator-function-id(13.5)、conversion-function-id(12.3.2)或template-id(14.2)的使用，表示实体或标签(6.6.4,6.1)。

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

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

关键字模板并不总是必须出现在名称的最后一部分。它可以出现在用作作用域的类名之前的中间，如下面的示例所示

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

在某些情况下，关键字是禁止的，具体如下所示

在依赖基类的名称上不允许写入typename。假设给出的名称是类类型名。基类列表和构造函数初始化列表中的名称都是这样: template <typename T> struct derive_from_Has_type: /* typename */ SomeBase<T>::type {}; 在using-declarations中，不可能在last::之后使用模板，c++委员会说不做解决方案。 template <typename T> struct derive_from_Has_type: SomeBase<T> { 使用SomeBase<T>::模板类型/ /错误 使用typename SomeBase<T>::type;// typename *is* allowed };

依赖名称是一个依赖于模板参数的名称，我们需要指示编译器，以便在实际初始化模板类/函数之前正确编译它们。

Typename ->告诉编译器依赖项名称是实际类型 模板<类T> struct DependentType ｛ typename T::type a; 使用Type=typename T:: Type; }; Template ->告诉编译器依赖的名称是一个模板函数/类 模板<类T> struct DependentTemplate ｛ //模板函数 模板<类U> 静态无效func() {} //模板类 模板<类U> struct类名{}; }; 模板<类T1，类T2> 空白foo () ｛ //调用依赖模板函数的3种方法 DependentTemplate < T1 >::模板函数< T2 > (); DependentTemplate < T1 >()。模板函数< T2 > (); (new DependentTemplate<T1>()))->template func<T2>(); //你需要同时使用typename和template来引用依赖的模板类 typename DependentTemplate<T1>::template ClassName<T2> obj; 使用Type=typename DependentTemplate<T1>::template ClassName<T2>; ｝

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 <T>，:: a <T>)。通过这样的名称引用的类型就是当前实例化。如果形成名称的类型是一个成员/嵌套类，则可能有多个类型都是当前实例化(那么，a::NestedClass和a都是当前实例化)。

基于这个概念，该语言说CurrentInstantiation::Foo, Foo和CurrentInstantiationTyped->Foo(例如A * A = this;a->Foo)都是当前实例化的成员，如果它们被发现是当前实例化的类或其非依赖基类的成员(通过立即进行名称查找)。

如果限定符是当前实例化的成员，关键字typename和template现在不再是必需的。这里需要记住的关键点是A<T>仍然是一个依赖类型的名称(毕竟T也是依赖类型的)。但是A<T>::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<int>::f时，需要编译器来捕获错误。因此，您可以获得两个世界的最佳效果:“延迟”查找保护您，如果您可能遇到依赖基类的麻烦，以及“立即”查找将您从typename和template中解放出来。

未知的专门化

在D的代码中，名称typename D::questionable_type不是当前实例化的成员。相反，该语言将其标记为未知专门化的成员。特别是，当你在执行DependentTypeName::Foo或DependentTypedName->Foo时，依赖类型不是当前实例化(在这种情况下，编译器可以放弃并说“我们稍后会查看Foo是什么)，或者它是当前实例化，并且在它或它的非依赖基类中没有找到名称，也有依赖基类。

想象一下，如果我们在上面定义的a类模板中有一个成员函数h会发生什么

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

在c++ 03中，语言允许捕捉这个错误，因为永远都不可能有一个有效的方法来实例化a <T>::h(无论你给T的参数是什么)。在c++ 11中，语言现在有了进一步的检查，为编译器实现这个规则提供了更多的理由。由于A没有依赖的基类，且A没有声明成员questionable_type，因此名称A<T>::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代码将在实例化时将->f绑定到A::f，一切正常。然而，c++ 11立即将其绑定到B::f，并要求在实例化时进行双重检查，检查查找是否仍然匹配。然而，当实例化C<A>::g时，优势规则应用，查找将找到A::f。

这个答案是一个相当简短和甜蜜的回答，以回答标题问题(部分)。如果你想要一个更详细的答案来解释为什么你要把它们放在那里，请点击这里。

---

使用typename关键字的一般规则主要是当你使用模板形参并且你想要访问一个嵌套的typedef或使用-alias时，例如:

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<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<int>()将导致错误:

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

因此，在这种情况下，你需要事先使用template关键字，并像这样调用它:

t.template get<int>（）

这样编译器就会正确地解析它，而不是t.get < int。