unify (continue)
9964 case PTRMEM_CST:
9965 {
9966 /* A pointer-to-member constant can be unified only with
9967 another constant. */
9968 if (TREE_CODE (arg) != PTRMEM_CST)
9969 return 1;
9970
9971 /* Just unify the class member. It would be useless (and possibly
9972 wrong, depending on the strict flags) to unify also
9973 PTRMEM_CST_CLASS, because we want to be sure that both parm and
9974 arg refer to the same variable, even if through different
9975 classes. For instance:
9976
9977 struct A { int x; };
9978 struct B : A { };
9979
9980 Unification of &A::x and &B::x must succeed. */
9981 return unify (tparms, targs, PTRMEM_CST_MEMBER (parm),
9982 PTRMEM_CST_MEMBER (arg), strict);
9983 }
9984
9985 case POINTER_TYPE:
9986 {
9987 if (TREE_CODE (arg) != POINTER_TYPE)
9988 return 1;
9989
9990 /* [temp.deduct.call]
9991
9992 A can be another pointer or pointer to member type that can
9993 be converted to the deduced A via a qualification
9994 conversion (_conv.qual_).
9995
9996 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
9997 This will allow for additional cv-qualification of the
9998 pointed-to types if appropriate. */
9999
10000 if (TREE_CODE (TREE_TYPE (arg)) == RECORD_TYPE)
10001 /* The derived-to-base conversion only persists through one
10002 level of pointers. */
10003 strict |= (strict_in & UNIFY_ALLOW_DERIVED);
10004
10005 return unify (tparms, targs, TREE_TYPE (parm),
10006 TREE_TYPE (arg), strict);
10007 }
10008
10009 case REFERENCE_TYPE:
10010 if (TREE_CODE (arg) != REFERENCE_TYPE)
10011 return 1;
10012 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
10013 strict & UNIFY_ALLOW_MORE_CV_QUAL);
10014
10015 case ARRAY_TYPE:
10016 if (TREE_CODE (arg) != ARRAY_TYPE)
10017 return 1;
10018 if ((TYPE_DOMAIN (parm) == NULL_TREE)
10019 != (TYPE_DOMAIN (arg) == NULL_TREE))
10020 return 1;
10021 if (TYPE_DOMAIN (parm) != NULL_TREE
10022 && unify (tparms, targs, TYPE_DOMAIN (parm),
10023 TYPE_DOMAIN (arg), UNIFY_ALLOW_NONE) != 0)
10024 return 1;
10025 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
10026 strict & UNIFY_ALLOW_MORE_CV_QUAL);
10027
10028 case REAL_TYPE:
10029 case COMPLEX_TYPE:
10030 case VECTOR_TYPE:
10031 case INTEGER_TYPE:
10032 case BOOLEAN_TYPE:
10033 case ENUMERAL_TYPE:
10034 case VOID_TYPE:
10035 if (TREE_CODE (arg) != TREE_CODE (parm))
10036 return 1;
10037
10038 if (TREE_CODE (parm) == INTEGER_TYPE
10039 && TREE_CODE (TYPE_MAX_VALUE (parm)) != INTEGER_CST)
10040 {
10041 if (TYPE_MIN_VALUE (parm) && TYPE_MIN_VALUE (arg)
10042 && unify (tparms, targs, TYPE_MIN_VALUE (parm),
10043 TYPE_MIN_VALUE (arg), UNIFY_ALLOW_INTEGER))
10044 return 1;
10045 if (TYPE_MAX_VALUE (parm) && TYPE_MAX_VALUE (arg)
10046 && unify (tparms, targs, TYPE_MAX_VALUE (parm),
10047 TYPE_MAX_VALUE (arg),
10048 UNIFY_ALLOW_INTEGER | UNIFY_ALLOW_MAX_CORRECTION))
10049 return 1;
10050 }
10051 /* We have already checked cv-qualification at the top of the
10052 function. */
10053 else if (!same_type_ignoring_top_level_qualifiers_p (arg, parm))
10054 return 1;
10055
10056 /* As far as unification is concerned, this wins. Later checks
10057 will invalidate it if necessary. */
10058 return 0;
10059
10060 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
10061 /* Type INTEGER_CST can come from ordinary constant template args. */
10062 case INTEGER_CST:
10063 while (TREE_CODE (arg) == NOP_EXPR)
10064 arg = TREE_OPERAND (arg, 0);
10065
10066 if (TREE_CODE (arg) != INTEGER_CST)
10067 return 1;
10068 return !tree_int_cst_equal (parm, arg);
10069
10070 case TREE_VEC:
10071 {
10072 int i;
10073 if (TREE_CODE (arg) != TREE_VEC)
10074 return 1;
10075 if (TREE_VEC_LENGTH (parm) != TREE_VEC_LENGTH (arg))
10076 return 1;
10077 for (i = 0; i < TREE_VEC_LENGTH (parm); ++i)
10078 if (unify (tparms, targs,
10079 TREE_VEC_ELT (parm, i), TREE_VEC_ELT (arg, i),
10080 UNIFY_ALLOW_NONE))
10081 return 1;
10082 return 0;
10083 }
看一下 9971 行的注释，它解释了为什么推导 PTRMEM_CST_MEMBER ，而不是整个结构。并且注意到对于标量的类型（从 REAL_TYPE 到 ENUMERATE_TYPE ，而 VOID_TYPE 是一个反常，它不能够被用作模板形参，但可以被传递作为缺省实参），它们对应非类型模板形参（不包括 VOID_TYPE ）。
unify (continue)
10085 case RECORD_TYPE:
10086 case UNION_TYPE:
10087 if (TREE_CODE (arg) != TREE_CODE (parm))
10088 return 1;
10089
10090 if (TYPE_PTRMEMFUNC_P (parm))
10091 {
10092 if (!TYPE_PTRMEMFUNC_P (arg))
10093 return 1;
10094
10095 return unify (tparms, targs,
10096 TYPE_PTRMEMFUNC_FN_TYPE (parm),
10097 TYPE_PTRMEMFUNC_FN_TYPE (arg),
10098 strict);
10099 }
10100
10101 if (CLASSTYPE_TEMPLATE_INFO (parm))
10102 {
10103 tree t = NULL_TREE;
10104
10105 if (strict_in & UNIFY_ALLOW_DERIVED)
10106 {
10107 /* First, we try to unify the PARM and ARG directly. */
10108 t = try_class_unification (tparms, targs,
10109 parm, arg);
10110
10111 if (!t)
10112 {
10113 /* Fallback to the special case allowed in
10114 [temp.deduct.call]:
10115
10116 If P is a class, and P has the form
10117 template-id, then A can be a derived class of
10118 the deduced A. Likewise, if P is a pointer to
10119 a class of the form template-id, A can be a
10120 pointer to a derived class pointed to by the
10121 deduced A. */
10122 t = get_template_base (tparms, targs,
10123 parm, arg);
10124
10125 if (! t || t == error_mark_node)
10126 return 1;
10127 }
10128 }
10129 else if (CLASSTYPE_TEMPLATE_INFO (arg)
10130 && (CLASSTYPE_TI_TEMPLATE (parm)
10131 == CLASSTYPE_TI_TEMPLATE (arg)))
10132 /* Perhaps PARM is something like S<U> and ARG is S<int>.
10133 Then, we should unify `int' and `U'. */
10134 t = arg;
10135 else
10136 /* There's no chance of unification succeeding. */
10137 return 1;
10138
10139 return unify (tparms, targs, CLASSTYPE_TI_ARGS (parm),
10140 CLASSTYPE_TI_ARGS (t), UNIFY_ALLOW_NONE);
10141 }
10142 else if (!same_type_ignoring_top_level_qualifiers_p (parm, arg))
10143 return 1;
10144 return 0;
在上面的 10101 行，如果 CLASSTYPE_TEMPLATE_INFO 不是 null ，表示 parm 是一个类模板。看到在该函数的 9741 行， strict_in 拷贝自参数 strict ，其中的 UNIFY_ALLOW_DERIVED 是，当通过函数调用推导模板实参时，在 type_unification_real 中设置的（参考在 maybe_adjust_types_for_deduction 之前的段落）。
9486 static tree
9487 try_class_unification (tree tparms, tree targs, tree parm, tree arg) in pt.c
9488 {
9489 tree copy_of_targs;
9490
9491 if (!CLASSTYPE_TEMPLATE_INFO (arg)
9492 || (most_general_template (CLASSTYPE_TI_TEMPLATE (arg))
9493 != most_general_template (CLASSTYPE_TI_TEMPLATE (parm))))
9494 return NULL_TREE;
9495
9496 /* We need to make a new template argument vector for the call to
9497 unify. If we used TARGS, we'd clutter it up with the result of
9498 the attempted unification, even if this class didn't work out.
9499 We also don't want to commit ourselves to all the unifications
9500 we've already done, since unification is supposed to be done on
9501 an argument-by-argument basis. In other words, consider the
9502 following pathological case:
9503
9504 template <int I, int J, int K>
9505 struct S {};
9506
9507 template <int I, int J>
9508 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
9509
9510 template <int I, int J, int K>
9511 void f(S<I, J, K>, S<I, I, I>);
9512
9513 void g() {
9514 S<0, 0, 0> s0;
9515 S<0, 1, 2> s2;
9516
9517 f (s0, s2);
9518 }
9519
9520 Now, by the time we consider the unification involving `s2', we
9521 already know that we must have `f<0, 0, 0>'. But, even though
9522 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
9523 because there are two ways to unify base classes of S<0, 1, 2>
9524 with S<I, I, I>. If we kept the already deduced knowledge, we
9525 would reject the possibility I=1. */
9526 copy_of_targs = make_tree_vec (TREE_VEC_LENGTH (targs));
9527
9528 /* If unification failed, we're done. */
9529 if (unify (tparms, copy_of_targs, CLASSTYPE_TI_ARGS (parm),
9530 CLASSTYPE_TI_ARGS (arg), UNIFY_ALLOW_NONE))
9531 return NULL_TREE;
9532
9533 return arg;
9534 }
这里有一个长的注释解释了为什么使用拷贝的模板实参的 vector ，并给出了一个作为错误的例子。进一步的，如果为在 9517 行的 f 交换 s0 及 s2 ，这是好的代码。对于形参“ S<I, I, I> ”，“ S<0, 1, 2> ”不是好的结果，因为“ S<0, 1, 2> ”派生自“ S<0, 0, 0> ”及“ S<1, 1, 1> ”，两者都匹配“ S<I, I, I> ”这个形式。回忆【 3 】规定实参推导是以每个实参为单位进行的，在推导之后，所推导的实参应该与之前推导出的结果，或显式给定的实参相匹配。但看到这里对 unify 的调用，只是一个尝试，通过使用模板实参 vector 的拷贝，就可以不改变得到之前推导的实参。
对于上面注释中给出的例子， s2 是不同于 S<I, I, I> 的模板，因此 try_class_unification 在 9494 行返回，然后进入下面的函数来检查基类是否可以统一（因为现在使用了 UNIFY_ALLOW_DERIVED ）。
9614 static tree
9615 get_template_base (tree tparms, tree targs, tree parm, tree arg) in pt.c
9616 {
9617 tree rval;
9618 tree arg_binfo;
9619
9620 my_friendly_assert (IS_AGGR_TYPE_CODE (TREE_CODE (arg)), 92);
9621
9622 arg_binfo = TYPE_BINFO (complete_type (arg));
9623 rval = get_template_base_recursive (tparms, targs,
9624 parm, arg_binfo,
9625 NULL_TREE,
9626 GTB_IGNORE_TYPE);
9627
9628 /* Since get_template_base_recursive marks the bases classes, we
9629 must unmark them here. */
9630 dfs_walk (arg_binfo, dfs_unmark, markedp, 0);
9631
9632 return rval;
9633 }
这个函数遍历该类的继承树，以前序在基类上执行 try_class_unification 。看到对于 s2 ，其基类“ S<0, 0, 0> ”及“ S<1, 1, 1> ”依次在 9554 行进入 try_class_unification 。但是在最后一次的递归中，分别由 rval 及 r 所指向的，不相等的“ S<0, 0, 0> ”及“ S<1, 1, 1> ”导致该函数在 9566 行返回 error_mark_node 。
9540 static tree
9541 get_template_base_recursive (tree tparms, in pt.c
9542 tree targs,
9543 tree parm,
9544 tree arg_binfo,
9545 tree rval,
9546 int flags)
9547 {
9548 tree binfos;
9549 int i, n_baselinks;
9550 tree arg = BINFO_TYPE (arg_binfo);
9551
9552 if (!(flags & GTB_IGNORE_TYPE))
9553 {
9554 tree r = try_class_unification (tparms, targs,
9555 parm, arg);
9556
9557 /* If there is more than one satisfactory baseclass, then:
9558
9559 [temp.deduct.call]
9560
9561 If they yield more than one possible deduced A, the type
9562 deduction fails.
9563
9564 applies. */
9565 if (r && rval && !same_type_p (r, rval))
9566 return error_mark_node;
9567 else if (r)
9568 rval = r;
9569 }
9570
9571 binfos = BINFO_BASETYPES (arg_binfo);
9572 n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
9573
9574 /* Process base types. */
9575 for (i = 0; i < n_baselinks; i++)
9576 {
9577 tree base_binfo = TREE_VEC_ELT (binfos, i);
9578 int this_virtual;
9579
9580 /* Skip this base, if we've already seen it. */
9581 if (BINFO_MARKED (base_binfo))
9582 continue ;
9583
9584 this_virtual =
9585 (flags & GTB_VIA_VIRTUAL) || TREE_VIA_VIRTUAL (base_binfo);
9586
9587 /* When searching for a non-virtual, we cannot mark virtually
9588 found binfos. */
9589 if (! this_virtual)
9590 BINFO_MARKED (base_binfo) = 1;
9591
9592 rval = get_template_base_recursive (tparms, targs,
9593 parm,
9594 base_binfo,
9595 rval,
9596 GTB_VIA_VIRTUAL * this_virtual);
9597
9598 /* If we discovered more than one matching base class, we can
9599 stop now. */
9600 if (rval == error_mark_node)
9601 return error_mark_node;
9602 }
9603
9604 return rval;
9605 }
回到 unify ，如果 10108 行的 try_class_unification ，或 10122 行的 get_template_base ，任一成功，表明推导是可以成功的，那么在 10139 行执行真正的推导。
而在 10142 行，对于普通类，除了最顶层的 cv- 限定词， arg 及 parm 应该是同一个类型。
在下面，如 [temp.deduct.type] 的条款 3 所描述：
“一个函数类型包括该函数每个形参的类型及返回类型。
一个指向成员的指针类型包括所指向类对象的类型，及所指向成员的类型。”
这部分代码相应地处理这些情形。再下面的代码，节点 MINUS_EXPR 可能和 ARRAY_TYPE 一起来，关联的注释给出了一个清楚的解释。
unify (continue)
10146 case METHOD_TYPE:
10147 case FUNCTION_TYPE:
10148 if (TREE_CODE (arg) != TREE_CODE (parm))
10149 return 1;
10150
10151 if (unify (tparms, targs, TREE_TYPE (parm),
10152 TREE_TYPE (arg), UNIFY_ALLOW_NONE))
10153 return 1;
10154 return type_unification_real (tparms, targs, TYPE_ARG_TYPES (parm),
10155 TYPE_ARG_TYPES (arg), 1,
10156 DEDUCE_EXACT, 0, -1);
10157
10158 case OFFSET_TYPE:
10159 if (TREE_CODE (arg) != OFFSET_TYPE)
10160 return 1;
10161 if (unify (tparms, targs, TYPE_OFFSET_BASETYPE (parm),
10162 TYPE_OFFSET_BASETYPE (arg), UNIFY_ALLOW_NONE))
10163 return 1;
10164 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
10165 strict);
10166
10167 case CONST_DECL:
10168 if (DECL_TEMPLATE_PARM_P (parm))
10169 return unify (tparms, targs, DECL_INITIAL (parm), arg, strict);
10170 if (arg != decl_constant_value (parm))
10171 return 1;
10172 return 0;
10173
10174 case FIELD_DECL:
10175 case TEMPLATE_DECL:
10176 /* Matched cases are handled by the ARG == PARM test above. */
10177 return 1;
10178
10179 case MINUS_EXPR:
10180 if (tree_int_cst_equal (TREE_OPERAND (parm, 1), integer_one_node)
10181 && (strict_in & UNIFY_ALLOW_MAX_CORRECTION))
10182 {
10183 /* We handle this case specially, since it comes up with
10184 arrays. In particular, something like:
10185
10186 template <int N> void f(int (&x)[N]);
10187
10188 Here, we are trying to unify the range type, which
10189 looks like [0 ... (N - 1)]. */
10190 tree t, t1, t2;
10191 t1 = TREE_OPERAND (parm, 0);
10192 t2 = TREE_OPERAND (parm, 1);
10193
10194 t = fold (build (PLUS_EXPR, integer_type_node, arg, t2));
10195
10196 return unify (tparms, targs, t1, t, strict);
10197 }
10198 /* Else fall through. */
10199
10200 default :
10201 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (parm))))
10202 {
10203
10204 /* We're looking at an expression. This can happen with
10205 something like:
10206
10207 template <int I>
10208 void foo(S<I>, S<I + 2>);
10209
10210 This is a "nondeduced context":
10211
10212 [deduct.type]
10213
10214 The nondeduced contexts are:
10215
10216 --A type that is a template-id in which one or more of
10217 the template-arguments is an expression that references
10218 a template-parameter.
10219
10220 In these cases, we assume deduction succeeded, but don't
10221 actually infer any unifications. */
10222
10223 if (!uses_template_parms (parm)
10224 && !template_args_equal (parm, arg))
10225 return 1;
10226 else
10227 return 0;
10228 }
10229 sorry ("use of `%s' in template type unification",
10230 tree_code_name [(int) TREE_CODE (parm)]);
10231 return 1;
10232 }
10233 }
最后，如果是一个构成非推导上下文的表达式，则进入 default 块。 [temp.deduct.type] 的条款 4 给出了标准的定义。这里仅是其中之一，其余的在 9789 行 switch 块的开头来处理。
try_one_overload (continue)
9421 /* First make sure we didn't deduce anything that conflicts with
9422 explicitly specified args. */
9423 for (i = nargs; i--; )
9424 {
9425 tree elt = TREE_VEC_ELT (tempargs, i);
9426 tree oldelt = TREE_VEC_ELT (orig_targs, i);
9427
9428 if (elt == NULL_TREE)
9429 continue ;
9430 else if (uses_template_parms (elt))
9431 {
9432 /* Since we're unifying against ourselves, we will fill in template
9433 args used in the function parm list with our own template parms.
9434 Discard them. */
9435 TREE_VEC_ELT (tempargs, i) = NULL_TREE;
9436 continue ;
9437 }
9438 else if (oldelt && ! template_args_equal (oldelt, elt))
9439 return 0;
9440 }
9441
9442 for (i = nargs; i--; )
9443 {
9444 tree elt = TREE_VEC_ELT (tempargs, i);
9445
9446 if (elt)
9447 TREE_VEC_ELT (targs, i) = elt;
9448 }
9449
9450 return 1;
9451 }
如果这对形参 / 实参的推导成功，在这一点上， tempargs 包含了这一次推导的实参，而 orig_targs 包含了之前推导的实参。如果两者对应的项都不为空，且不依赖于模板参数，它们必须是相同的。如果一切顺利，最后把 tempargs 中的结果合并入 targs 。
记得 try_one_overload 是被 resolve_overloaded_unification 调用来推导被怀疑是重载的指针的参数。而对于其他的参数，它们被 type_unification_real 中 9229 行的代码块处理。注意 9240 行， len 来自参数 xlen ，如果它大于 0 ，则指定了在成功返回前需要考虑的函数参数的个数。如果已成功处理所有参数，我们来到如下的代码中。
type_unification_real (continue)
9243 /* Fail if we've reached the end of the parm list, and more args
9244 are present, and the parm list isn't variadic. */
9245 if (args && args != void_list_node && parms == void_list_node)
9246 return 1;
9247 /* Fail if parms are left and they don't have default values. */
9248 if (parms
9249 && parms != void_list_node
9250 && TREE_PURPOSE (parms) == NULL_TREE)
9251 return 1;
9252
9253 done:
9254 if (!subr)
9255 for (i = 0; i < ntparms; i++)
9256 if (TREE_VEC_ELT (targs, i) == NULL_TREE)
9257 {
9258 tree tparm = TREE_VALUE (TREE_VEC_ELT (tparms, i));
9259
9260 /* If this is an undeduced nontype parameter that depends on
9261 a type parameter, try another pass; its type may have been
9262 deduced from a later argument than the one from which
9263 this parameter can be deduced. */
9264 if (TREE_CODE (tparm) == PARM_DECL
9265 && uses_template_parms (TREE_TYPE (tparm))
9266 && !saw_undeduced++)
9267 goto again;
9268
9269 if (!allow_incomplete)
9270 error ("incomplete type unification");
9271 return 2;
9272 }
9273 return 0;
9274 }
在上面 type_unification_real 的最后一部分中，在 9254 行的 subr ，如果非 0 ，表示 type_unification_real 正在递归调用中，这个情形，如我们前面所见，是内层模板参数依赖于外层模板参数。但对于最外层的模板，所有的模板参数都必须被推导出来。
如果有未推导的参数，而且它是函数的形参，考虑以下例子：
template <class T> void func (int a[sizeof (T)], T t) {}
int main () {
int a[sizeof (int)];
func (a, int(5));
return 0;
}
在第一轮推导中，第一个形参无法推导出来，因为那时 T 尚未知。那么它将满足上面 9264 行的条件，通过 9267 行的 goto 语句再进行一轮推导。与上一轮不同的是， targs 中增加了上一轮推导的结果，现在 T 已知，因而顺利地推导出第一个形参。
如果推导成功，推导出的实参被放入 targs ，那么该模板的具现将由下面的 instantiate_template 产生（记得如果该具现已经产生，这个函数只是返回这个对象）。
add_template_candidate_real (continue)
2063 if (i != 0)
2064 return NULL;
2065
2066 fn = instantiate_template (tmpl, targs, tf_none);
2067 if (fn == error_mark_node)
2068 return NULL;
2069
2070 /* In [class.copy]:
2071
2072 A member function template is never instantiated to perform the
2073 copy of a class object to an object of its class type.
2074
2075 It's a little unclear what this means; the standard explicitly
2076 does allow a template to be used to copy a class. For example,
2077 in :
2078
2079 struct A {
2080 A (A&);
2081 template <class T> A(const T&);
2082 };
2083 const A f ();
2084 void g () { A a (f ()); }
2085
2086 the member template will be used to make the copy. The section
2087 quoted above appears in the paragraph that forbids constructors
2088 whose only parameter is (a possibly cv-qualified variant of) the
2089 class type, and a logical interpretation is that the intent was
2090 to forbid the instantiation of member templates which would then
2091 have that form. */
2092 if (DECL_CONSTRUCTOR_P (fn) && list_length (arglist) == 2)
2093 {
2094 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (fn);
2095 if (arg_types && same_type_p (TYPE_MAIN_VARIANT (TREE_VALUE (arg_types)),
2096 ctype))
2097 return NULL;
2098 }
2099
2100 if (obj != NULL_TREE)
2101 /* Aha, this is a conversion function. */
2102 cand = add_conv_candidate (candidates, fn, obj, access_path,
2103 conversion_path, arglist);
2104 else
2105 cand = add_function_candidate (candidates, fn, ctype,
2106 arglist, access_path,
2107 conversion_path, flags);
2108 if (DECL_TI_TEMPLATE (fn) != tmpl)
2109 /* This situation can occur if a member template of a template
2110 class is specialized. Then, instantiate_template might return
2111 an instantiation of the specialization, in which case the
2112 DECL_TI_TEMPLATE field will point at the original
2113 specialization. For example:
2114
2115 template <class T> struct S { template <class U> void f(U);
2116 template <> void f(int) {}; };
2117 S<double> sd;
2118 sd.f(3);
2119
2120 Here, TMPL will be template <class U> S<double>::f(U).
2121 And, instantiate template will give us the specialization
2122 template <> S<double>::f(int). But, the DECL_TI_TEMPLATE field
2123 for this will point at template <class T> template <> S<T>::f(int),
2124 so that we can find the definition. For the purposes of
2125 overload resolution, however, we want the original TMPL. */
2126 cand->template = tree_cons (tmpl, targs, NULL_TREE);
2127 else
2128 cand->template = DECL_TEMPLATE_INFO (fn);
2129
2130 return cand;
2131 }
在【 3 】的 207 页，进一步解释了 2070 行的注释：
“因为一个模板构造函数不可能是一个拷贝构造函数，这样一个模板的存在不能压制拷贝构造函数的隐式声明。模板构造函数与其他构造函数，包括拷贝构造函数，一起参予重载解析，并且一个模板构造函数可以被用于拷贝一个对象，如果它能提供比其它构造函数更好的匹配。 ”
通过这个检查，这个具现后的模板函数就是合资格的候选者； 2100 行的 obj 为 NULL 则表明是根据提供的类型，而不是对象，来找到候选者（因此 add_function_candidate 关注的是指定的源类型及目标类型，而 add_conv_candidate 则关注指定的对象及目标类型；而在这里是查找转换指定类型的函数，这就是为什么这里只调用 add_function_candidate ）。回到 build_user_type_conversion_1 ，接下来的工作与找到转换操作符后的情况类似。
build_user_type_conversion_1 (continue)
2420 if (convs)
2421 args = build_tree_list (NULL_TREE, build_this (expr));
2422
2423 for (; convs; convs = TREE_CHAIN (convs))
2424 {
2425 tree fns;
2426 tree conversion_path = TREE_PURPOSE (convs);
2427 int convflags = LOOKUP_NO_CONVERSION;
2428
2429 /* If we are called to convert to a reference type, we are trying to
2430 find an lvalue binding, so don't even consider temporaries. If
2431 we don't find an lvalue binding, the caller will try again to
2432 look for a temporary binding. */
2433 if (TREE_CODE (totype) == REFERENCE_TYPE)
2434 convflags |= LOOKUP_NO_TEMP_BIND;
2435
2436 for (fns = TREE_VALUE (convs); fns; fns = OVL_NEXT (fns))
2437 {
2438 tree fn = OVL_CURRENT (fns);
2439
2440 /* [over.match.funcs] For conversion functions, the function
2441 is considered to be a member of the class of the implicit
2442 object argument for the purpose of defining the type of
2443 the implicit object parameter.
2444
2445 So we pass fromtype as CTYPE to add_*_candidate. */
2446
2447 if (TREE_CODE (fn) == TEMPLATE_DECL)
2448 cand = add_template_candidate (&candidates, fn, fromtype,
2449 NULL_TREE,
2450 args, totype,
2451 TYPE_BINFO (fromtype),
2452 conversion_path,
2453 flags,
2454 DEDUCE_CONV);
2455 else
2456 cand = add_function_candidate (&candidates, fn, fromtype,
2457 args,
2458 TYPE_BINFO (fromtype),
2459 conversion_path,
2460 flags);
2461
2462 if (cand)
2463 {
2464 tree ics = implicit_conversion (totype,
2465 TREE_TYPE (TREE_TYPE (cand->fn)),
2466 0, convflags);
2467
2468 cand->second_conv = ics;
2469
2470 if (ics == NULL_TREE)
2471 cand->viable = 0;
2472 else if (candidates->viable == 1 && ICS_BAD_FLAG (ics))
2473 cand->viable = -1;
2474 }
2475 }
2476 }
不像可以作为转换转换函数的构造函数，转换操作符可以返回与目标类型不同的类型，不过它们必须可以通过 2464 行的 implicit_conversion 来匹配，而这个转换在 2468 行被记录为 second_conv （比较对于构造函数，在 2417 行的 IDENTITY_CONV ）。
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
