待决名

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

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)
}

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

非待决名用到的类型在定义点不完整但在实例化点完整

模板定义中对名字的查找找到 using 声明，但实例化中对应作用域找不到任何声明，因为该 using 声明是包展开而对应的包为空

(C++17 起)

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

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

查找规则

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

非 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<<
    }
}

在上例中，假如允许从实例化语境对 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 限定版本
从待决类型构成的复合类型
元素类型待决或边界（如果存在）是值待决的数组类型

形参包含一个或多个函数形参包的函数类型

(C++11 起)

异常说明是值待决的函数类型

(C++17 起)

模板标识，其中

模板名是某个模板形参，或者
有任何类型待决，或值待决，或者是包展开 (C++11 起)的模板实参（即使用到的模板标识不带实参列表，如注入类名）

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

应用到类型待决表达式的 decltype 的结果是唯一的待决类型。两个这样的结果只有在它们的表达式等价时才指代同一类型。

(C++11 起)

注意；当前实例化的 typedef 成员只有在它指代的类型待决时才会是待决的。

类型待决表达式

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

含有类型待决的子表达式的表达式
this，如果它的类是待决类型
不是概念标识的 (C++20 起)标识表达式，且

包含某个能被自身的名字查找找到至少一个待决声明的标识符
包含待决的模板标识

包含特殊标识符 __func__（如果某个外围函数是模板，类模板的非模板成员，或泛型 lambda (C++14 起)）

(C++11 起)

包含到某个待决类型的转换函数名
包含作为未知特化成员的嵌套名说明符或有限定标识
指名当前实例化的某个待决成员，且该成员是“未知边界的数组”类型的静态数据成员

包含某个能被自身的名字查找找到一个或更多的声明为具有返回类型推导的当前实例化的成员函数声明的标识符	(C++14 起)
包含能被自身的名字查找找到一个初始化器为类型待决的结构化绑定声明的标识符包含能被自身的名字查找找到类型含占位符 `auto` 的非类型模板形参的标识符包含能被自身的名字查找找到以包含占位符类型的类型声明且初始化器是类型待决的变量（例如 `auto` 静态数据成员）的标识符，	(C++17 起)

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

折叠表达式

(C++17 起)

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

值待决表达式

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

为概念标识，而其实参有任何待决的

(C++20 起)

为类型待决的
为某个非类型模板形参的名字
指名某个作为当前实例化的待决成员的静态数据成员，且未被初始化。
指名某个作为当前实例化的待决成员的静态成员函数
为具有整数或枚举 (C++11 前)字面 (C++11 起)类型的常量，并从值待决表达式初始化

alignof、noexcept、 (C++11 起)sizeof、typeid 表达式，其实参是类型待决表达式或待决的类型标识
任何向待决类型转换或从值待决表达式转换的转型表达式
取址表达式，其实参是指名某个当前实例化的待决成员的有限定标识
取址表达式，其实参是求值为核心常量表达式的，指代某个作为具有静态或线程 (C++11 起)存储期的对象或成员函数的模板化实体。

折叠表达式

(C++17 起)

待决名

当前实例化

在类模板定义内（包含它的成员函数和嵌套类），一些名字可以推导为指代当前实例化。这样就可以在定义点，而非在实例化点检测某些错误，并移除对待决名上的 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 的有限定名字查找找到了数据成员
}

关键词 typename 只能在模板声明和定义中使用，而且只能用于可以使用待决名的语境中。这排除了显式特化声明和显式实例化声明。	(C++11 前)
关键词 typename 即便在模板外也可以使用。 #include <vector> int main() { typedef typename std::vector<T>::const_iterator iter_t; // C++11 中 OK typename std::vector<int> v; // C++11 中也 OK }	(C++11 起)

某些语境中，只有类型名能合法地出现。在这些语境中，假定待决的限定名指名的就是类型而不必使用 typename：

用作以下各项的（顶层）声明说明符序列中的声明说明符的限定名：

位于命名空间作用域的简单声明或函数声明；
类成员声明；
类成员声明（包括友元函数声明）中的形参声明，不包括默认实参；
名字有限定的函数或函数模板的声明符的形参声明，不包括默认实参；
lambda 表达式的形参声明，不包括默认实参；
requires 表达式的形参声明；
非类型模板形参声明中的类型；

在类型标识中出现的限定名，其中最小的外围类型标识是：

不对其类型加括号的 new 表达式中的类型；
别名声明中的类型标识；
尾随返回类型，
类型模板形参的默认实参，或
static_cast、dynamic_cast、const_cast，或 reinterpret_cast 的类型标识。

(C++20 起)

待决名的 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 消歧义符：

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

(C++17 起)

根据无限定名字查找针对成员访问表达式中的模板名的特殊规则，当非待决的模板名在成员访问表达式中出现时（-> 或 . 后），如果通过表达式语境中的常规名字查找找到了的具有相同名字的类或别名 (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++23 前)

缺陷报告

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

DR	应用于	出版时的行为	正确行为
CWG 1413	C++98	未初始化静态数据成员、静态成员函数和类模板的成员的地址未列为值待决	已列入
CWG 1850	C++98	含义在定义语境和实例化点之间变更的情况列表不完整	使之完整
CWG 2100	C++98	类模板的静态成员常量地址未列为值待决	已列入
CWG 2457	C++11	带函数形参包的函数类型未列为待决类型	已列入

语言
标准库头文件
自立与有宿主实现
具名要求
语言支持库
概念库 (C++20)
诊断库
工具库
字符串库
容器库
迭代器库
范围库 (C++20)
算法库
数值库
本地化库
输入/输出库
文件系统库 (C++17)
正则表达式库 (C++11)
原子操作库 (C++11)
线程支持库 (C++11)
技术规范

形参与实参
类模板
函数模板
类成员模板
变量模板(C++14)
模板实参推导
类模板实参推导(C++17)
显式（全）特化
部分特化
待决名
形参包(C++11)
sizeof... (C++11)
折叠表达式(C++17)
SFINAE
制约与概念(C++20)

待决名

绑定规则

查找规则

待决类型

类型待决表达式

值待决表达式

待决名

当前实例化

未知特化

待决名的 typename 消歧义符

待决名的 template 消歧义符

缺陷报告

导航