我必须在何处以及为何要使用"模板"和"typename"关键字？

为了解析C++程序,编译器需要知道某些名称是否是类型.以下示例演示了:

t * f;

该怎么解析？对于许多语言,编译器不需要知道名称的含义就可以解析并基本知道代码行的作用.但是,在C++中,上述内容可以根据具体的t含义产生截然不同的解释.如果它是一个类型,那么它将是一个指针的声明f.但是,如果它不是一个类型,它将是一个乘法.所以C++标准在段落(3/7)中说:

某些名称表示类型或模板.通常,只要遇到名称,就必须在继续解析包含它的程序之前确定该名称是否表示这些实体之一.确定此过程的过程称为名称查找.

t::x如果t引用模板类型参数,编译器将如何找出名称所指的内容？x可以是一个静态的int数据成员,可以成倍增加,或者同样可以是一个可以产生声明的嵌套类或typedef.如果名称具有此属性 - 在实际模板参数已知之前无法查找 - 那么它将被称为依赖名称(它"取决于"模板参数).

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

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

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

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

"typename"关键字

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

假定模板声明或定义中使用的名称以及依赖于模板参数的名称不会命名类型,除非适用的名称查找找到类型名称或名称由关键字typename限定.

有许多名称typename不是必需的,因为编译器可以在模板定义中使用适用的名称查找,找出如何解析构造本身 - 例如T *f;,when 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 在现实生活中是一个模板,所以编译器知道(14.2/3):

在名称查找(3.4)发现名称是模板名称后,如果此名称后跟一个<,则<始终作为模板参数列表的开头,并且从不作为名称后跟较少的名称 - 比操作员.

现在我们回到了同样的问题typename.如果在解析代码时我们还不知道名称是否是模板怎么办？我们需要template在模板名称之前插入,如下所示14.2/4.这看起来像:

t::template f(); // call a function template

模板名称不仅可以在一个成员访问之后::,也可以在一个->或.多个类成员访问之后发生.您还需要在其中插入关键字:

this->template f(); // 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++中期开始,委员会已经开始研究如何解决这个令人困惑的定义).

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

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

标识符只是一个简单的字符/数字序列,而接下来的两个是operator +和operator type表单.最后一种形式是template-name .所有这些都是名称,并且通过标准中的常规用法,名称还可以包括限定符,用于说明应该查找名称的名称空间或类.

值依赖表达式1 + N不是名称,而是名称N.作为名称的所有依赖构造的子集称为依赖名称.但是,函数名称在模板的不同实例化中可能具有不同的含义,但遗憾的是,这个一般规则并未捕获.

依赖函数名称

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

附加说明和示例

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

template 
struct UnionNode : public Tail {
    // ...
    template struct inUnion {
        typedef typename Tail::template inUnion dummy;
    };
    // ...
};

typename t::template iterator::value_type v;

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

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

template
struct A {
  typedef int result_type;

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

    // OK
    g();

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

    // OK
    result_type n2; 
  }

  template
  void g();
};

struct B {
  typedef int result_type;
};

template
struct C { }; // could be specialized!

template
struct D : B, C {
  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 to provide it
    // But not a member of the current instantiation
    typename D::questionable_type r3;        
  }
};

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

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

struct B { void f(); };
struct A : virtual B { void f(); };

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

int main() { 
  C c; c.g(); 
}

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

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

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

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

namespace N {
  template
  struct X { };
}

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

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

 struct Base {
   template
   struct type { };
 };

 struct Derived : Base {
   using Base::template type; // ill-formed
   using Base::type;          // legal
 };

typedef typename Tail::inUnion dummy;

template  struct Contains;

template 
struct Contains >
{
    enum { result = Contains::result };
};

template 
struct Contains >
{
    enum { result = true };
};

template 
struct Contains
{
    enum { result = false };
};

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

template
struct test {
    // typename required
    using type = typename std::conditional::type;
    // no typename required
    using integer = std::conditional::type;
};

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

template
void func(const test& t) {
    t.get(); // error
}

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