什么是未建立的环境？

Question

我偶然发现了 为什么模板参数扣除在这里不起作用？ 最近可以答案是总结到“这是一个未建立的上下文”。

具体来说，第一个说这是这样的事情，然后将其重定向到标准的“详细信息”，而第二个则引用标准，至少可以说是隐秘的。

有人可以向像我这样的凡人解释一下， 什么时候发生，为什么会发生？

Answer 1

扣除是指从给定参数确定模板参数类型的过程。它适用于功能模板， auto 和其他一些情况（例如部分专业化）。例如，请考虑：

template <typename T> void f(std::vector<T>);

现在，如果您说 f（x），则在其中声明 std :: vector＆lt; int＆gt; x; ，然后 t 是 defuced 作为 int ，您将获得专业化 f＆lt; int＆gt; 。

为了扣除工作，要推论的模板参数类型必须出现在可推论的上下文中。在此示例中， f 的函数参数是这样的可推论上下文。也就是说，函数呼叫表达式中的一个参数使我们能够确定模板参数 t 应该是什么，以使呼叫表达式有效。

但是，也有非 non dded的上下文，在不可能的情况下。 的左侧显示的模板参数

template <typename> struct Foo;

template <typename T> void g(typename Foo<T>::type);

规范的示例是“ :: 上下文。 /em> foo＆lt; t＆gt; ::类型

 template <> struct Foo<int>       { using type = double; };
 template <> struct Foo<char>      { using type = double; };
 template <> struct Foo<float>     { using type = bool; };
 template <> struct Foo<long>      { int type = 10; };
 template <> struct Foo<unsigned>  { };

。 > t ，如果您调用 g（int {}）通常没有答案，则类模板参数和类成员之间没有关系。 。

---

参数扣除 > to foo＆lt; t＆gt; ，例如或其他转换（思考 std :: String 和 char const *）。现在假设您有一个免费的功能：

template <typename T> bool binary_function(Foo<T> lhs, Foo<T> rhs);

如果您调用 binary_function（t，u），则扣除可能是模棱两可的，因此失败了。但是，仅推断出一个论点，而不是推断另一种论点，从而允许隐式转换是合理的。现在需要明确的非养活上下文，例如这样：（

template <typename T>
struct type_identity {
    using type = T;
};

template <typename T>
bool binary_function(Foo<T> lhs, typename type_identity<Foo<T>>::type rhs)
{
    return binary_function(lhs, rhs);
}

您可能已经遇到了 std :: min（1U，2L）。）

注意： std :: type_identity 自从C ++以来都可以使用20。

Answer 2

什么是未建立的环境？

非伪造的上下文是无法从某些构造中推导的模板参数的上下文。
例如：

template <int N>
void foo(int x = N * N); // called like foo()

从默认参数 n * n * n 中推导出非类型模板参数的参数显然是不可能的。编译器不仅必须取下 n * n 的平方根（尽管语言没有这种“平方根扣除”），还必须为>提出一个值n * n 稀薄的空气。

非循证上下文列表 c ++ 20

在下面的列表中，假设

• t 是某些模板类型参数
• n 是某些非类型模板参数

template <typename T, int N>

每个标题引用，并在

1。 foo＆lt; t＆gt; ::类型

使用A 使用A 。 id.qual＃nt：合格 - id“ rel =” nofollow noreferrer“> commified-id 。

无法推断出 t ，因为类型只是一个别名，例如 std :: vector＆lt; t＆gt; :: size_type 。仅知道 size_type （在这种情况下为 std :: size_t ），我们如何才能找出 t ？我们不能，因为 std :: size_t 中没有包含信息。

开发人员遇到此问题的最常见方法是试图从迭代器中推导容器。

template <typename T>
void foo(typename T::iterator it); // attempt to deduce T from an iterator

int main() {
    std::array<int> v;
    foo(v.begin()); // error, trying to deduce std::array<int> from int* (probably)
}                   // which is obviously imposssible

2。 electType（n）

expression A 。

template <int N>
void foo(decltype(N * N - N) n);

exltype 的表达式可以任意复杂，并且 exltype specifier是一种类型。如果 n 是一个非类型模板参数，那么我们怎么可能只知道类型（例如猜测 123 来自 int> int ）的值？

3。 foo＆lt; 0 + n＆gt; ， int（＆amp;）[0 + n]

一个非型模板参数或一个绑定的数组，其中亚表达引用了模板参数。

可以从 n 从 foo＆lt; n＆gt; 或从数组绑定中推导出通常是不可能的。从理论上讲，诸如 0 + n 之类的简单表达式是可能的，但是对于更复杂的表达式（例如 n * n * n ），这很快就失控了。

4。 void foo（t x = t {}）

在函数参数的参数类型中使用的模板参数，该参数具有默认参数，该参数正在用于进行参数扣除的调用中。

如果我们称之为这样的功能，例如 foo（），则扣除将需要一些循环逻辑。类型 t 将从默认参数 t {} 中推断出其类型为 t ，这是从默认参数中推断出来的。 。

---

​

​

关联参数为重载集的函数参数（ 。

• 多个函数匹配函数参数类型（导致含糊的扣除）或
• 不匹配函数参数类型，或
• 作为参数提供的过载集包含一个或多个函数模板。

这可能不是那么明显，因此我将提供一个示例：

void take(int);
void take(float);

template <typename T>
void foo(T* function_pointer) { function_pointer(0); }
// note: T(*function_pointer)(int)  would work, and T would deduce to void

int main() { foo(&take); } // error

take（int）和 take（float）匹配函数参数，因此是否模棱两可，无论 t 应推论 void（int）或 void（float）。

6。 std :: prinitizer_list 函数参数

关联参数为初始化列表的函数参数（）但是该参数没有指定从初始化器列表中扣除的类型（ [temp.deduct.call] ）。

C ++标准中的示例很好地证明了这一点：

  template＆lt; class t＆gt; void g（t）;
g（{1,2,3}）; //错误：t没有推论
 

在所有子弹中，这种限制是最人造的。 {1，2，3} 可以通过考虑 std :: prinitizer_list＆lt; int＆gt; ，但有意决定不进行此扣除。

7。 void foo（ts ...，int）

参数 - 删除列表 。

无法推导模板参数包 ts ... 。
基本问题是，如果我们称为 foo（0）这在提供 0 作为包的参数或 int 之间是模棱两可的。范围。
在功能模板中，通过将参数包解释为一个空包来解决这种歧义，从而解决了某些情况，但不是全部：

template <typename... Ts>
void foo(Ts..., int);

int main() {
    foo(0);     // OK, Ts... is an empty pack
    foo(0, 0);  // ill-formed despite being intuitively unambiguous
}

进一步的注意到

，需要遵循许多规则才能扣除。
不从非养活的上下文中推论只是其中之一。
[temp.deduct.deduct.type] p8 列出一种类型必须具有扣除的形式。

与数组相关的另一个间接规则是：

template <int N> foo(int(&)[N]); // N can be deduced from array size
template <int N> foo(int[N]);    // N cannot be deduced because arrays in parameters
                                 // are adjusted to pointers

故意禁用类型扣除

有时会故意禁用扣除额，因为他们希望函数模板的用户明确地提供参数。
可以用 std :: type_identity 在C ++ 20中，或在C ++ 20之前使用用户定义的版本。

template <typename T>
void foo(std::type_identity<T>::type); // non-deduced context in function parameter