依赖名

来自cppreference.com
< cpp‎ | language

模板类模板函数模板)定义中,某些构造的含义可以在不同的实例化间相异。特别是,类型和表达式可以依赖类型模板形参的类型,和非类型模板形参的值。

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 违规:

// an external libary
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 限定版本
  • 从依赖类型构造的复合类型
  • 元素类型为依赖或边界(若存在)为值依赖的数组类型
  • 二者之一的模板 id ,其中
  • 模板名是模板形参,或者
  • 任何模板实参为类型依赖、值依赖或包展开(即使不带其实参列表使用模板标识符,如注入类名)
  • 应用到类型依赖表达式的 decltype 结果

注意;当前实例化的 typedef 成员仅在其指代类型为依赖时为依赖。

[编辑] 类型依赖表达式

下列表达式为类型依赖

  • 任何子表达式为类型依赖表达式的表达式
  • this ,若类是依赖类型。
  • id 表达式
  • 含有名称查找至少找到一个依赖声明的标识符
  • 含有依赖模板 id
  • 含有特殊标识符 __func__ (若某外围函数为模板、类模板的非模板成员或泛型 lambda (C++14 起)
  • 含有到依赖类型的转换函数
  • 含有是未知特化成员的嵌套名称指定符或限定 id
  • 指名当前实例化的依赖成员,而它是“未知边界数组”类型的静态数据成员
  • 含有名称查找找到一或多个当前实例化的,带返回类型推导的成员函数的标识符
(C++14 起)
  • 含有名称查找找到初始化器为类型依赖的结构化绑定声明的标识符
  • 含有名称查找找到非类型模板形参,而其类型含有占位符 auto 的标识符
(C++17 起)
  • 任何到依赖类型的转型表达式
  • 创建依赖类型对象的 new 表达式
  • 指代当前实例化成员的成员访问表达式,且其类型为依赖
  • 指代未知特化成员的成员访问表达式
(C++17 起)

注意:字面量、伪析构函数调用、 sizeofalignoftypeiddelete 表达式、 throw 表达式及 noexcept 表达式决非类型依赖,因为这些表达式的类型不可能是。

[编辑] 值依赖表达式

  • 为类型依赖
  • 为非类型模板形参之名
  • 指名是当前实例化依赖成员的静态数据成员,且未被实例化。
  • 指名是当前实例化依赖成员的静态成员函数
(C++14 起)
  • 为拥有字面类型的常量,从值依赖表达式初始化
  • sizeofalignoftypeidnoexcept 表达式,其中参数是值依赖表达式或依赖类型 id
  • 任何到依赖类型或从值依赖表达式的转型表达式
  • 取址表达式,其参数是指名当前实例化依赖成员的限定 id
  • 取址表达式,其参数是求值为核心常量表达式的,指代是有静态或线程存储期的对象的模板化实体,或指代成员函数的任何表达式。
(C++14 起)
(C++17 起)

[编辑] 依赖名

[编辑] 当前实例化

在类模板定义内(包含其成员函数和嵌套类),一些名称可推导为指代当前实例化。这允许在定义点,而非在实例化点检测某些错误,并移除 typenametemplate 消歧义符对依赖名上的要求,见后述。

仅下列名称能指代当前实例化:

  • 在类模板特化中:
  • 嵌套类、类模板成员、嵌套类成员、模板的注入类名、嵌套类的注入类名
  • 在初等模板定义或在其成员定义中:
  • 后随初等模板的模板实参列表的类名(或等价的别名模板特化),其中每个实参等价于其对应形参。注意若表达式用作非类型模板实参(例如, 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.yxp->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.yxp->y 中的 y ),若对象表达式( x*xp )的类型是依赖类型且非当前实例化
  • 类成员访问表达式中的成员名(x.yxp->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

  • 在下列项目的(顶层) decl-specifier-seq 中用作声明指定符的限定名:
  • 出现于 type-id 的限定名,其中最小的外围 type-id 是:
(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++ 标准。

DR 应用于 出版时的行为 正确行为
CWG 2100 C++14 类模板的静态成员常量地址未被列为值依赖 已列入