待决名

在模板（类模板和函数模板）定义中，某些构造的含义可以在不同的实例化间有所不同。特别是，类型和表达式可以取决于类型模板形参的类型，和非类型模板形参的值。

template<typename T>
struct X : B<T> // "B<T>" 取决于 T
{
    typename T::A* pa; // "T::A" 取决于 T
                       // （此 "typename" 的使用见下文）
    void f(B<T>* pb) {
        static int i = B<T>::i; // "B<T>::i" 取决于 T
        pb->j++; // "pb->j" 取决于 T
    }
};

对待决名和非待决名的名字查找和绑定有所不同。

绑定规则

非待决名在模板定义点查找并绑定。即使在模板实例化点有更好的匹配，也保持此绑定：

#include <iostream>
void g(double) { std::cout << "g(double)\n"; }
 
template<class T>
struct S {
    void f() const {
        g(1); // "g" 是非待决名，现在绑定
    }
};
 
void g(int) { std::cout << "g(int)\n"; }
 
int main()
{
    g(1); // 调用 g(int)
 
    S<int> s;
    s.f(); // 调用 g(double)
}

若非待决名的含义在定义点和模板特化的实例化点间有所改变，则程序非良构，不要求诊断。这在下列情形可能出现：

• 用于非待决名的类型在定义点不完整但在实例化点完整
• (C++17) 实例化使用了在定义点尚未定义的默认实参或默认模板实参
• (C++17) 实例化点的某个常量表达式使用了整型或无作用域枚举类型的 const 对象的值，constexpr 对象的值，引用的值，或者 constexpr 函数的定义，而该对象/引用/函数在模板的定义点尚未定义
• (C++17) 该模板在实例化点使用了非待决的类模板特化或变量模板特化，而它所用的这个模板，或者从某个于定义点处尚未定义的部分特化所实例化，或者指名了某个于定义点处尚未声明的显式特化。

待决名的绑定则延迟到查找发生时。

查找规则

如名字查找中所讨论的，对于模板中所使用的待决名的查找延迟到模板实参已知时，届时

• 非 ADL 查找检验从模板定义的语境可见的具有外部连接的函数声明
• ADL 一并检验从模板定义的语境或从模板实例化的语境可见的具有外部连接的函数声明

（换言之，在模板定义后添加新函数声明不会令其可见，除非通过 ADL）。

此规则的目的是帮助模板实例化抵御 ODR 违规：

// 某个外部库
namespace E {
  template<typename T>
  void writeObject(const T& t) {
    std::cout << "Value = " << t << '\n';
  }
}
 
// 翻译单元 1：
// 程序员 1 希望允许 E::writeObject 与 vector<int> 一同使用
namespace P1 {
  std::ostream& operator<<(std::ostream& os, const std::vector<int>& v) {
      for(int n: v) os << n << ' '; return os;
  }
  void doSomething() {
    std::vector<int> v;
    E::writeObject(v); // 错误：找不到 P1::operator<<
  }
}
 
// 翻译单元 2：
// 程序员 2 希望允许 E::writeObject 与 vector<int> 一同使用
namespace P2 {
  std::ostream& operator<<(std::ostream& os, const std::vector<int>& v) {
      for(int n: v) os << n <<':'; return os << "[]";
  }
  void doSomethingElse() {
    std::vector<int> v;
    E::writeObject(v); // 错误：找不到 P2::operator<<
  }
}

在上例中，若允许从实例化语境进行非 ADL 查找，则 E::writeObject<vector<int>> 的实例化会拥有两个不同定义：一个使用 P1::operator<<，一个使用 P2::operator<<。连接器可能无法检测这种 ODR 违规，导致两个实例中都使用其中一个或另一个。

为使得 ADL 检测用户定义命名空间，要么应当将 std::vector 替换成用户定义类，要么其元素类型应当为用户定义类：

namespace P1 {
  // 若 C 是定义于 P1 命名空间中的类
  std::ostream& operator<<(std::ostream& os, const std::vector<C>& v) {
      for(C n: v) os << n; return os;
  }
  void doSomething() {
    std::vector<C> v;
    E::writeObject(v); // OK：实例化 writeObject(std::vector<P1::C>)
                       //     通过 ADL 找到 P1::operator<<
  }
}

注意：此规则使得为标准库类型重载运算符不适于实践

#include <iostream>
#include <vector>
#include <iterator>
#include <utility>
 
// 坏主意：全局命名空间中的运算符，但其实参处于 std:: 中
std::ostream& operator<<(std::ostream& os, std::pair<int, double> p)
{
    return os << p.first << ',' << p.second;
}
 
int main()
{
    typedef std::pair<int, double> elem_t;
    std::vector<elem_t> v(10);
    std::cout << v[0] << '\n'; // OK，普通查找找到 ::operator<<
    std::copy(v.begin(), v.end(),
              std::ostream_iterator<elem_t>(std::cout, " ")); // 错误：从
    // std::ostream_iterator 定义点的普通查找和 ADL 将只考虑 std 命名空间，
    // 而且将找到 std::operator<< 的多个重载，故这种查找会完成。
    // 之后在查找所找到的集合中，重载决议为 elem_t 寻找 operator<< 会失败。
}

注意：在模板定义时，也会发生待决名的有限制的查找（但非绑定），以便将它们与非待决名进行区分，也用于确定它们是当前实例化的成员还是未知特化的成员。此查找所获得的信息可用于检测错误，见下文。

待决类型

下列类型是待决类型：

• 模板形参
• 未知特化（见下文）的成员
• 作为未知特化（见下文）的待决成员的嵌套类/枚举
• 待决类型的 cv 限定版本
• 从待决类型构成的复合类型
• 元素类型待决或其边界（若存在）为值待决的数组类型

• 模板标识，其中

• 模板名是某个模板形参，或者
• 任何模板实参为类型待决的，值待决的，或为包展开（即使不带其实参列表使用模板标识，如注入类名，也是如此）

• 应用到类型待决表达式的 decltype 的结果

注意；当前实例化的 typedef 成员，仅当其指代的类型待决时才为待决的。

类型待决表达式

下列表达式为类型待决的：

• 任何子表达式为类型待决表达式的表达式
• this，若其类为待决类型。
• 标识表达式，其

• 包含某个标识符，其名字查找找到至少一个待决声明
• 包含待决的模板标识
• 包含特殊标识符 __func__（若某个外围函数是模板，类模板的非模板成员，或泛型 lambda (C++14 起)）
• 包含到某个待决类型的转换函数名
• 包含作为未知特化成员的嵌套名说明符或有限定标识
• 指名当前实例化的某个待决成员，它是“未知边界的数组”类型的静态数据成员

• 到任何待决类型的转型表达式
• 创建待决类型对象的 new 表达式
• 指代当前实例化的某个类型待决的成员的成员访问表达式
• 指代未知特化的某个成员的成员访问表达式

注意：字面量、伪析构函数调用、sizeof、alignof、typeid、delete 表达式、throw 表达式及 noexcept 表达式始终不是类型待决的，因为这些表达式的类型不可能待决。

值待决表达式

• 在要求常量表达式的语境中使用的表达式，且其有任何子表达式是值待决的
• 标识表达式，其

• 为类型待决的
• 为某个非类型模板形参的名字

• 为具有字面类型的常量，并从值待决表达式初始化

• sizeof、alignof、typeid、noexcept 表达式，其实参是类型待决表达式或待决的类型标识
• 任何向待决类型转换或从值待决表达式转换的转型表达式

待决名

当前实例化

在类模板定义内（包含其成员函数和嵌套类），一些名字可推导为指代当前实例化。这允许在定义点，而非在实例化点检测某些错误，并移除对待决名上的 typename 及 template 消歧义符的要求，见下文。

仅下列名字可以指代当前实例化：

• 在类模板特化中：

• 嵌套类、类模板成员、嵌套类成员、模板的注入类名、嵌套类的注入类名

• 在主模板的定义或在其成员的定义中：

• 类模板的名字后随主模板的实参列表（或等价的别名模板特化），其中每个实参等价于其对应形参。注意若表达式用作非类型模板实参（例如，N+0，其中 N 是形参），则它不指名当前实例化，即使其值匹配。

• 在嵌套的类或类模板的定义中：

• 被用作当前实例化成员的嵌套类的名字

• 在部分特化或部分特化的成员的定义中：

• 类模板的名字后随部分特化的模板实参列表，其中每个实参等价于其对应的形参

template <class T> class A {
    A* p1;    // A 是当前实例化
    A<T>* p2; // A<T> 是当前实例化
    ::A<T>* p4; // ::A<T> 是当前实例化
    A<T*> p3; // A<T*> 不是当前实例化
    class B {
        B* p1; // B 是当前实例化
        A<T>::B* p2; // A<T>::B 是当前实例化
        typename A<T*>::B* p3; // A<T*>::B 不是当前实例化
    };
};
template <class T> class A<T*> {
    A<T*>* p1;  // A<T*> 是当前实例化
    A<T>* p2;   // A<T> 不是当前实例化
};
template <int I> struct B {
    static const int my_I = I;
    static const int my_I2 = I+0;
    static const int my_I3 = my_I;
    B<my_I>* b3;  // B<my_I> 是当前实例化
    B<my_I2>* b4; // B<my_I2> 不是当前实例化
    B<my_I3>* b5; // B<my_I3> 是当前实例化
};

注意，如果嵌套类派生于其外围类模板，则基类也可以是当前实例化。是待决类型但非当前实例化的基类为待决基类

template<class T> struct A {
    typedef int M;
    struct B {
        typedef void M;
        struct C;
    };
};
template<class T>
struct A<T>::B::C : A<T> {
    M m; // OK, A<T>::M
};

符合以下情况的名字被归类为当前实例化的成员：

• 未限定名，为无限定查找在当前实例化或其非待决基类中所找到。
• 限定名，若其限定符（:: 左侧的名字）指名当前实例化，且查找在当前实例化或其非待决基类中找到了该名字
• 用于类成员访问表达式的名字（x.y 或 xp->y 中的 y），其中对象表达式（x 或 *xp）是当前实例化，且查找在当前实例化或其非待决基类中找到了该名字

template <class T>
class A {
   static const int i = 5;
   int n1[i];       // i 指代当前实例化的成员
   int n2[A::i];    // A::i 指代当前实例化的成员
   int n3[A<T>::i]; // A<T>::i 指代当前实例化的成员
   int f();
};
template <class T>
int A<T>::f() {
   return i; // i 指代当前实例化的成员
}

当前实例化的成员可为待决的和非待决的。

若某个当前实例化成员的查找在实例化点和定义点给出不同结果，则查找有歧义。但要注意，在成员名被使用时，它不会自动传换成类成员访问表达式，只有显式成员访问表达式才指示当前实例化的成员：

struct A { int m; };
struct B { int m; };
 
template<typename T>
struct C : A, T {
  int f() { return this->m; }// 在模板定义语境找到 A::m
  int g() { return m; }      // 在模板定义语境找到 A::m
};
 
template int C<B>::f(); // 错误：找到 A::m 和 B::m
 
template int C<B>::g(); // OK：并未在模板定义语境之中进行向员访问语法的变换

未知特化

在模板定义内，某些名字被推导为属于某个未知特化，特别是，

• 限定名，若出现于 :: 左侧的任何名字是并非当前实例化成员的待决类型
• 限定名，其限定符是当前实例化，且在当前实例化或任何其非待决基类中找不到该名字，并存在待决基类
• 类成员访问表达式中的成员名（x.y 或 xp->y 中的 y），若对象表达式（x 或 *xp）的类型是待决类型且非当前实例化
• 类成员访问表达式中的成员名（x.y 或 xp->y 中的 y），若对象表达式（x 或 *xp）的类型是当前实例化，且在当前实例化或任何其非待决基类中找不到该名字，并存在待决基类

template<typename T> struct Base {};
 
template<typename T>
struct Derived : Base<T> {
    void f() {
        // Derived<T> 指代当前实例化
        // 当前实例化无 'unknown_type'
        // 但有一个待决基类（Base<T>）
        // 从而 unknown_type 是未知特化的成员
        typename Derived<T>::unknown_type z;
    }
};
 
template<> struct Base<int> { // 此特化提供之
    typedef int unknown_type; 
};

此分类允许在模板定义（而非实例化）点检测下列错误：

• 若任何模板定义拥有某个限定名，其中的限定符指代当前实例化，且该名字既非当前实例化的成员亦非未知特化的成员，则程序非良构（不要求诊断），即使模板始终不被实例化也是如此。

template<class T>
class A {
  typedef int type;
  void f() {
    A<T>::type i; // OK ： 'type' 是当前实例化的成员
    typename A<T>::other j; // 错误：
    // 'other' 不是当前实例化的成员，且非未知特化的成员，
    // 因为 A<T>（指名当前实例化）并无暗藏有 'other' 的待决基类。
  }
};

• 若任何模板定义拥有某个成员访问表达式的，其对象表达式是当前实例化，但其名字既非当前实例化的成员亦非未知特化的成员，则程序非良构，即使模板始终不被实例化也是如此。

未知特化的成员始终为待决的，而且同所有待决名一样，在实例化点进行查找和绑定（见上文）。

待决名的 typename 消歧义符

在模板（包括别名模版）的声明或定义中，非当前实例化成员且取决于某个模板形参的名字，不被认为是类型，除非使用关键词 typename，或除非其已被设立为类型名（例如用 typedef 声明或通过用作基类名）。

#include <iostream>
#include <vector>
 
int p = 1;
template <typename T>
void foo(const std::vector<T> &v)
{
 
    // std::vector<T>::const_iterator 是待决名，
    typename std::vector<T>::const_iterator it = v.begin();
 
    // 若无 'typename'，则下列内容被解析为类型待决的成员变量 
    // 'const_iterator' 和某变量 'p' 的乘法。
    // 因为在此处有一个可见的全局 'p'，所以此模板定义能编译。
    std::vector<T>::const_iterator* p; 
 
    typedef typename std::vector<T>::const_iterator iter_t;
    iter_t * p2; // iter_t 是待决名，但已知它是类型名
}
 
template<typename T>
struct S {
    typedef int value_t; // 当前实例化的成员
    void f() {
        S<T>::value_t n{};  // S<T> 待决，但不需要 'typename'
        std::cout << n << '\n';
    }
};
 
int main()
{
    std::vector<int> v;
    foo(v); // 模板实例化失败：类型 std::vector<int> 中无名为 'const_iterator' 的成员变量
    S<int>().f();
}

关键词 typename 仅可以这种方式用于限定名（例如 T::x）之前，但这些名字不必待决。

对前附 typename 的标识符使用通常的有限定名字查找。这不同于用详述类型说明符的情况，不管限定符如何都不改变查找规则：

struct A { // A 拥有嵌套变量 X 和嵌套类型 struct X
   struct X {};
   int X;
};
struct B {
    struct X { }; // B 拥有嵌套类型 struct X
};
template<class T> void f(T t) {
    typename T::X x;
}
void foo() {
    A a;
    B b;
    f(b); // OK：实例化 f<B>，T::X 指代 B::X
    f(a); // 错误：不能实例化 f<A>：
          // 因为 A::X 的有限定名字查找找到了数据成员
}

#include <vector>
 
int main() {
    typedef typename std::vector<T>::const_iterator iter_t; // C++11 中 OK
    typename std::vector<int> v; // C++11 中亦 OK
 
}

待决名的 template 消歧义符

于此相似，模板定义中，并非当前实例化成员的待决名同样不被认为是模板名，除非使用消歧义关键词 template，或它已被设立为模板名：

template<typename T>
struct S {
    template<typename U> void foo(){}
};
 
template<typename T>
void bar()
{
    S<T> s;
    s.foo<T>(); // 错误：< 被剖析为小于运算符
    s.template foo<T>(); // OK
}

关键词 template 仅可以这种方式用于运算符 ::（作用域解析）、->（通过指针的成员访问）和 .（成员访问）之后，下列表达式是所有合法示例：

• T::template foo<X>();
• s.template foo<X>();
• this->template foo<X>();
• typename T::template iterator<int>::value_type v;

与 typename 的情况一样，即使名字并非待决或其使用并未出现于模板的作用域中 (C++11 起)，也允许使用 template 前缀。

template<typename> struct s {};
::template s<void> q; // 允许，但不必须

根据无限定名字查找针对成员访问表达式中的模板名的特殊规则，当非待决的模板名在成员访问表达式中出现时（-> 或 . 后），如果通过表达式语境中的常规名字查找找到了的具有相同名字的类或别名 (C++11 起)模板，则不需要消歧义符。然而，若表达式语境中的查找所找到的模板与类语境中所找到的不同，则程序非良构。 (C++11 前)

template<int> struct A { int value; };
 
template<class T>
void f(T t) {
    t.A<0>::value; // A 的常规查找找到类模板。A<0>::value 指名类 A<0> 的成员
    // t.A < 0; // 错误：'<' 被当做模板实参列表的起始
}

缺陷报告

下列更改行为的缺陷报告追溯地应用于以前出版的 C++ 标准。