为什么必须在何处以及为什么要放置 “模板” 和“类型名”关键字?

在模板中,为什么必须在哪里以及为什么要在依赖名称上放置typenametemplate ?无论如何,从属名称到底是什么?我有以下代码:

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

答案

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

t * f;

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

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

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

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

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

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

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

“类型名称” 关键字

答案是: 我们决定编译器应如何解析它。如果t::x是从属名称,则我们需要在其typename加上类型名,以告知编译器以某种方式对其进行解析。标准在(14.6 / 2)中说:

除非在适用的名称查找中找到类型名称或该名称由关键字 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仅前限定的名字 - 它是为此视为理所当然的认为不合格的名字总是已知是指类型,如果他们这样做。

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

“模板” 关键字

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

boost::function< int() > f;

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

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

这实际上是一个有效的表达式 !它使用小于运算符比较boost::function与零( int() ),然后使用大于运算符比较生成的boolf 。但是,您可能知道, 现实生活中的boost::function是一个模板,因此编译器知道(14.2 / 3):

在名称查找(3.4)发现名称是模板名称之后,如果此名称后跟 <,则始终将 < 视为模板参数列表的开头,而永远不要将其作为后跟 - 的名称。比运算符。

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

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

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

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

依存关系

对于那些架子上堆满 Standardese 书籍,又想知道我到底在说什么的人,我会说一些有关 Standard 中如何指定的内容。

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

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

  • 从属类型(例如:类型模板参数T
  • 依赖于值的表达式(例如:非类型模板参数N
  • 类型相关的表达式(例如:转换为类型模板参数(T)0

大多数规则是直观的,并且是递归建立的:例如,如果N是一个值相关的表达式或T是一个依赖类型,则构造为T[N]的类型是一个依赖类型。有关详细信息,请参阅(14.6.2/1 )部分中的相关类型, (14.6.2.2)中的类型相关表达式,以及(14.6.2.3)中的值相关表达式。

相关名称

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

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

名称是指表示实体或标签(6.6.4,英文)的标识符(2.11),操作员功能 ID(13.5),转换功能 ID(12.3.2)或模板 ID(14.2)的使用 6.1)

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

值相关表达式1 + N不是名称,而N是。名称的所有相关构造的子集称为相关名称 。但是,函数名称在模板的不同实例中可能具有不同的含义,但不幸的是,该通用规则并未捕获它们。

从属函数名称

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

附加说明和示例

在足够的情况下,我们需要typenametemplate 。您的代码应如下所示

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 ++ 委员会表示不致力于解决方案。

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

C ++ 11

问题

尽管 C ++ 03 中有关何时需要typenametemplate的规则在很大程度上是合理的,但其制定存在一个令人讨厌的缺点

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 (因此是类型),我们也需要 dis 歧义关键字,并且this->g只能是稍后声明的成员模板g (即使A在某处显式专用化,也不会影响该模板中的代码,因此,其后的A !专用化不会影响其含义。)

当前实例

为了改善这种情况,在 C ++ 11 中,该语言会跟踪类型引用封闭模板的时间。要知道,该类型必须已经通过使用某种形式的名称来形成,该名称是它自己的名称(在上面, AA<T>::A<T> )。此类名称引用的类型被称为当前实例 。如果形成名称的类型是成员 / 嵌套类(那么A::NestedClassA都是当前实例),则可能有多种类型都是当前实例。

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

如果限定符是当前实例的成员,则现在不再需要关键字typenametemplate 。这里要记住的一个关键点是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时,需要编译器来捕获错误。因此,您可以充分利用两个世界的优势:“延迟” 查找可以保护依赖的基类(如果您可能会遇到麻烦),并且还可以通过 “立即” 查找将您从typenametemplate中解放出来。

未知专业

D的代码中,名称类型名typename D::questionable_type不是当前实例的成员。相反,该语言将其标记为未知专业化成员 。特别是,在执行DependentTypeName::FooDependentTypedName->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 代码将在实例化时将this->f绑定到A::f ,一切都很好。但是,C ++ 11 立即将其绑定到B::f并在实例化时需要仔细检查,以检查查找是否仍然匹配。但是,当实例化C<A>::g ,将应用 “ 优势规则”,并且查找将改为找到A::f

前言

该帖子旨在代替litb 的帖子 易于阅读

基本目的是相同的;对 “何时?” 的解释和 “为什么?” 必须使用typenametemplate


typenametemplate的目的是什么?

typenametemplate在声明模板以外的其他情况下可用。

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实例化函数模板,我们将有一个名为x指向 int指针的声明,但是;

  • 如果我们用( D )实例化类型为Y的模板,则( A )将由一个表达式组成,该表达式计算123乘以一些已经声明的变量x 的乘积。



理据

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

为了防止实现可能遭受令人讨厌的意外,标准要求我们通过明确地在意图将名称视为type-nametemplate - 的任何位置明确说明意图,来解决依赖名称的歧义。 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    
}

上面的代码段中有四个从属名称:

  • E
    • “类型”取决于SomeTrait<T>的实例化,其中包括T和;
  • F
    • “NestedTrait”是一个模板 ID ,取决于SomeTrait<T> ;并且;
    • F )末尾的“类型”取决于NestedTrait ,后者取决于SomeTrait<T> ;并且;
  • G)
    • 看起来像成员函数模板的 “数据”间接地是一个从属名称,因为foo的类型取决于SomeTrait<T>的实例化。

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

解决方案

为了使g_tmpl具有有效的定义,我们必须明确地告诉编译器,我们期望( E )中的类型,在( F )中的模板 ID类型以及在( G )中的模板 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
}

每次名称表示一种类型时,涉及的所有 名称都必须是类型名称名称空间 ,考虑到这一点,很容易看出我们在完全限定名称的开头应用了typename

但是, template在这方面是不同的,因为无法得出如下结论: “哦,这是模板,那么另一件事也必须是模板” 。这意味着我们将template直接应用在我们要这样对待的任何名称的前面。



我可以在任何名字的前面加上关键词吗?

我可以只将typenametemplate放在任何名称的前面吗?我不想担心它们出现的上下文... ”- Some C++ Developer

标准中的规则规定,只要您处理的是限定名称K ),就可以应用关键字,但是如果名称不限定,则应用格式不正确( 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

注意 :在不需要的情况下应用typenametemplate不被认为是一种好习惯;仅仅因为您可以做某事,并不意味着您应该做。


此外,在某些上下文中明确禁止了typenametemplate

  • 指定类继承的基础时

    派生类的base-specifier-list 中写入的每个名称都已被视为type-name ,显式指定typename不正确且具有冗余性。

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


  • template-id是派生类的using-directive 中所引用的

    struct Base {
       template<class T>
       struct type { };
     };
    
     struct Derived : Base {
       using Base::template type; // ill-formed
       using Base::type;          // legal
     };
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 中

这个答案的意思是回答标题问题(的一部分)的简短而甜美的答案。如果您想获得更详细的答案以说明为什么必须将其放在此处,请转到此处


放置typename关键字的一般规则通常是在使用模板参数并且要访问嵌套的typedef或 using-alias 时进行,例如:

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

请注意,这也适用于元函数或带有通用模板参数的事物。但是,如果提供的 template 参数是显式类型,则不必指定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<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

对于来自 cplusplus.com 的类似问题,我将 JLBorges 的出色回答置于最佳位置,因为这是我在该主题上读到的最简洁的解释。

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

例如:

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,前提是您具有引用类型且取决于模板参数的限定名称。