模板推导中的偏序过程是什么

问题描述

阅读C++11标准我无法完全理解以下语句的含义.非常欢迎示例.

Reading the C++11 standard I can't fully understand the meaning of the following statement. Example are very welcome.

使用两组类型来确定偏序.对于每个在所涉及的模板中，有原始函数类型和转换的函数类型.[注:转换类型的创建在 14.5.6.2 中描述.— 尾注] 演绎过程使用转换类型作为参数模板和原始类型其他模板作为参数模板.这个过程做两次对于偏序比较中涉及的每种类型:一次使用转换后的 template-1 作为参数模板，template-2 作为参数模板并再次使用转换后的模板 2 作为参数模板和模板1作为参数模板
-- N3242 14.8.2.4.2

Two sets of types are used to determine the partial ordering. For each of the templates involved there is the original function type and the transformed function type. [Note: The creation of the transformed type is described in 14.5.6.2. — end note ] The deduction process uses the transformed type as the argument template and the original type of the other template as the parameter template. This process is done twice for each type involved in the partial ordering comparison: once using the transformed template-1 as the argument template and template-2 as the parameter template and again using the transformed template-2 as the argument template and template-1 as the parameter template
-- N3242 14.8.2.4.2

推荐答案

虽然 Xeo 给了 评论中的一个很好的描述，我会试着用一个工作示例一步一步地解释.

While Xeo gave a pretty good description in the comments, I will try to give a step-by-step explanation with a working example.

首先，你引用的段落的第一句话是:

First of all, the first sentence from the paragraph you quoted says:

对于每个涉及的模板，都有原始函数类型和转换后的函数类型.[...]

For each of the templates involved there is the original function type and the transformed function type. [...]

等等，这个转换函数类型"是什么?第 14.5.6.2/3 段解释说:

Hold on, what is this "transformed function type"? Paragraph 14.5.6.2/3 explains that:

生成转换后的模板，对于每个类型、非类型或模板模板参数(包括其模板参数包(14.5.3))分别合成一个唯一的类型、值或类模板并将其替换为模板的函数类型中每次出现的该参数 [...]

To produce the transformed template, for each type, non-type, or template template parameter (including template parameter packs (14.5.3) thereof) synthesize a unique type, value, or class template respectively and substitute it for each occurrence of that parameter in the function type of the template [...]

这种形式化的描述可能听起来晦涩难懂，但实际上在实践中非常简单.我们以这个函数模板为例:

This formal description may sound obscure, but it is actually very simple in practice. Let's take this function template as an example:

template<typename T, typename U>
void foo(T, U) // #1

现在由于 T 和 U 是类型参数，上面的段落要求我们为 T 选择一个相应的类型参数(无论如何)并在出现 T 的函数签名中的任何地方替换它，然后对 U 执行相同的操作.

Now since T and U are type parameters, the above paragraph is asking us to pick a corresponding type argument for T (whatever) and substitute it everywhere in the function signature where T appears, then to do the same for U.

现在合成一个独特的类型"意味着你必须选择一个你没有在其他任何地方使用过的虚构类型，我们可以称之为P1(然后为 U 选择一个 P2)，但这会使我们的讨论变得毫无意义.

Now "synthesizing a unique type" means that you have to pick a fictitious type you haven't used anywhere else, and we could call that P1 (and then pick a P2 for U), but that would make our discussion uselessly formal.

让我们简化一下，为 T 选择 int，为 U 选择 bool - 我们没有使用这些类型在其他任何地方，因此就我们的目的而言，它们与 P1 和 P2 一样好.

Let's just simplify things and pick int for T and bool for U - we're not using those types anywhere else, so for our purposes, they are just as good as P1 and P2.

所以在转换之后，我们有:

So after the transformation, we have:

void foo(int, bool) // #1b

这是我们原始 foo() 函数模板的转换后的函数类型.

This is the transformed function type for our original foo() function template.

那么让我们继续解释您引用的段落.第二句说:

So let's continue interpreting the paragraph you quoted. The second sentence says:

推导过程使用转换后的类型作为参数模板，将其他模板的原始类型作为参数模板.[...]

The deduction process uses the transformed type as the argument template and the original type of the other template as the parameter template. [...]

等等，什么其他模板"?到目前为止，我们只有一个 foo() 的重载.是的，但是为了在函数模板之间建立排序，我们至少需要其中两个，所以我们最好创建第二个.让我们使用:

Wait, what "other template"? We only have one overload of foo() so far. Right, but for the purpose of establishing an ordering between function templates, we need at least two of them, so we'd better create a second one. Let's use:

template<typename T>
void foo(T const*, X<T>) // #2

其中 X 是我们的某个类模板.

Where X is some class template of ours.

现在第二个函数模板怎么样?啊，是的，我们需要对 foo() 的第一个重载做与之前相同的操作并转换它:再次，让我们为 T 选择一些类型参数，然后到处替换 T .这次我会选择 char(在这个例子中我们没有在其他任何地方使用它，所以它和一些虚构的 P3 一样好):

Now what with this second function template? Ah, yes, we need to do the same we previously did for the first overload of foo() and transform it: so again, let's pick some type argument for T and replace T everywhere. I'll pick char this time (we aren't using it anywhere else in this example, so that's as good as some fictitious P3):

void foo(char const*, X<char>) #2b

太好了，现在他有两个函数模板和对应的转换函数类型.那么如何判断#1是否比#2更专业，反之亦然?

Great, now he have two function templates and the corresponding transformed function types. So how to determine whether #1 is more specialized than #2 or vice versa?

我们从上面的句子中知道，原始模板和它们转换后的函数类型必须以某种方式匹配.但是如何?这就是第三句话的解释:

What we know from the above sentence is that the original templates and their transformed function types must be matched somehow. But how? That's what the third sentence explains:

这个过程对偏序比较中涉及的每个类型进行两次:一次使用转换后的 template-1 作为参数模板和 template-2 作为参数模板，再次使用转换后的 template-2 作为参数模板和template-1 作为参数模板

This process is done twice for each type involved in the partial ordering comparison: once using the transformed template-1 as the argument template and template-2 as the parameter template and again using the transformed template-2 as the argument template and template-1 as the parameter template

所以基本上第一个模板(#1b)的转换函数类型要与原始第二个模板的函数类型匹配模板(#2).当然反过来，第二个模板(#2b)的转换函数类型将与原始的函数类型匹配 第一个模板(#1).

void foo(int, bool) // #1b

template<typename T>
void foo(T const*, X<T>) // #2

void foo(char const*, X<char>) // #2b

template<typename T, typename U>
void foo(T, U) // #1

template<typename T, typename U>
void bar(X<T>, U)

template<typename T, typename U>
void bar(U, T const*)