5.13.1.1.3. 引用类型的转换
如果目标类型是引用类型（参见 implicit_conversion 的 1106 行），这是由【 3 】条文 13.3.3 .1.4 “引用绑定” [over.ics.ref ] 所指定的引用绑定的情形。
| 1. 当一个引用类型的形参直接绑定（ 8.5.3 ）到一个实参表达式，其隐式转换序列是恒等转换，除非该实参表达式的类型是形参类型的一个派生类，这时其隐式转换序列是一个派生类到基类的转换（ 13.3.3.1 ）。 [ 例子： struct A {}; struct B : public A {} b; int f(A&); int f(B&); int i = f(b); // Calls f(B&), an exact match, rather than // f(A&), a conversion — 例子结束 ] 如果该形参直接绑定到应用在该实参表达式的一个转换函数的结果，其隐式转换序列是一个用户定义转换（ 13.3.3 .1.2 ），其中的第二标准转换序列或者是一个恒等转换，或者，如果该转换函数返回该形参类型的一个派生类的实体，是派生类到基类的转换。 2. 当一个引用类型的形参不是直接绑定到一个实参表达式，其转换序列被要求根据 13.3.3 .1 （亦即，隐式转换序列）把实参表达式转换到该引用的援引类型。在概念上，这个转换序列负责通过该实参表达式拷贝初始化一个该引用援引类型的临时对象。最顶层的 cv- 限定的差别被归入初始化本身，而不构成一个转换。 3. 一个标准转换序列不能形成，如果要求绑定一个非常量引用到一个右值（除了在绑定一个隐含对象参数；参见在 13.3.1 中对这个情形的特殊规则）。 [ 注意：这意味着， 例如，如果一个候选函数具有一个非常量引用参数（隐含对象参数以外），并且对应的实参是一个临时对象，或为了初始化这个引用要求一个临时对象（参见 8.5.3 ） ] 。 4. 不过，绑定一个引用到一个特定的实参的其他限制不影响一个标准转换序列的构成。 [ 例如：一个具有 int 引用参数的函数可以是一个可行候选，即便对应的实参是一个 int 的位域。隐式转换序列把 int 位域作为一个 int 左值处理，并查找形参的一个精确匹配。如果是通过重载解析来选择，这样这个函数的调用将是非法的，因为禁止绑定一个非常量的引用到一个位域（ 8.5.3 ） ] 。 5. 一个引用到一个与引用兼容，带有更多限定的表达式的绑定，会影响一个标准转换序列的等级；参考 13.3.3 .2 及 8.5.3 。 |
940 static tree
941 reference_binding (tree rto, tree rfrom, tree expr, int flags) in call.c
942 {
943 tree conv = NULL_TREE;
944 tree to = TREE_TYPE (rto);
945 tree from = rfrom;
946 bool related_p;
947 bool compatible_p;
948 cp_lvalue_kind lvalue_p = clk_none;
949
950 if (TREE_CODE (to) == FUNCTION_TYPE && expr && type_unknown_p (expr))
951 {
952 expr = instantiate_type (to, expr, tf_none);
953 if (expr == error_mark_node)
954 return NULL_TREE;
955 from = TREE_TYPE (expr);
956 }
5.13.1.1.3.1. 重载引用的解析
如果被援引的目标类型是一个函数或方法的类型，并且被传入的实参表达式一个重载，其类型是 unknown_type_node 并且使得 type_unknown_p 成立（它可能是一个 baselink 或 template-id ）。这也需要为该实参确定正确的候选者。
下面的函数将实例化在中 rhs 给定的表达式的类型，来匹配由 lhstype 给定的类型。
6001 tree
6002 instantiate_type (tree lhstype, tree rhs, tsubst_flags_t flags) in class.c
6003 {
6004 tsubst_flags_t flags_in = flags;
6005
6006 flags &= ~tf_ptrmem_ok;
6007
6008 if (TREE_CODE (lhstype) == UNKNOWN_TYPE)
6009 {
6010 if (flags & tf_error)
6011 error ("not enough type information");
6012 return error_mark_node;
6013 }
6014
6015 if (TREE_TYPE (rhs) != NULL_TREE && ! (type_unknown_p (rhs)))
6016 {
6017 if (same_type_p (lhstype, TREE_TYPE (rhs)))
6018 return rhs;
6019 if (flag_ms_extensions
6020 && TYPE_PTRMEMFUNC_P (lhstype)
6021 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (rhs)))
6022 /* Microsoft allows `A::f' to be resolved to a
6023 pointer-to-member. */
6024 ;
6025 else
6026 {
6027 if (flags & tf_error)
6028 error ("argument of type `%T' does not match `%T'",
6029 TREE_TYPE (rhs), lhstype);
6030 return error_mark_node;
6031 }
6032 }
看到 6015 行的条件如果满足， rhs 的类型是确实已知的，它必须与目标类型（ lhstype ）相同；否则不匹配的类型 rhs 及 lhs 会导致一个错误。如果 rhs 在 TREE_TYPE 中具有 unknown_type_node 或 NULL ，这表示有多个表达式适合 rhs ，就需要由 lhs 的类型来确定最后胜出者。
正如 6042 行的注释所提到的，在 6047 行开始的 SWITCH 块用于区分这是哪种指向函数的指针（事实上也包括引用）。
在下面 6072 行的 NOP_EXPR ，它用于表示不要求任何代码产生的转换。例如，一个‘ char* ’到一个‘ int* ’的转换不要求产生任何代码；这样的一个转换由一个 NOP_EXPR 来代表。其唯一的操作数是要被转换的表达式。从一个指针到一个引用的转换也是由一个 NOP_EXPR 来表示。如果我们来到这个分支， NOP_EXPR 的 TREE_TYPE 必须是 NULL 或者 unknown_type_node 来显示多种选择。在剥除这个顶层的 NOP_EXPR 之后，需要通过设置其操作数的 TREE_TYPE 为 unknown_type_node ，来保留这个显示不确定性的信息。
instantiate_type (continue)
6034 if (TREE_CODE (rhs) == BASELINK)
6035 rhs = BASELINK_FUNCTIONS (rhs);
6036
6037 /* We don't overwrite rhs if it is an overloaded function.
6038 Copying it would destroy the tree link. */
6039 if (TREE_CODE (rhs) != OVERLOAD)
6040 rhs = copy_node (rhs);
6041
6042 /* This should really only be used when attempting to distinguish
6043 what sort of a pointer to function we have. For now, any
6044 arithmetic operation which is not supported on pointers
6045 is rejected as an error. */
6046
6047 switch (TREE_CODE (rhs))
6048 {
6049 case TYPE_EXPR:
6050 case CONVERT_EXPR:
6051 case SAVE_EXPR:
6052 case CONSTRUCTOR:
6053 case BUFFER_REF:
6054 abort ();
6055 return error_mark_node;
6056
6057 case INDIRECT_REF:
6058 case ARRAY_REF:
6059 {
6060 tree new_rhs;
6061
6062 new_rhs = instantiate_type (build_pointer_type (lhstype),
6063 TREE_OPERAND (rhs, 0), flags);
6064 if (new_rhs == error_mark_node)
6065 return error_mark_node;
6066
6067 TREE_TYPE (rhs) = lhstype;
6068 TREE_OPERAND (rhs, 0) = new_rhs;
6069 return rhs;
6070 }
6071
6072 case NOP_EXPR:
6073 rhs = copy_node (TREE_OPERAND (rhs, 0));
6074 TREE_TYPE (rhs) = unknown_type_node;
6075 return instantiate_type (lhstype, rhs, flags);
6076
6077 case COMPONENT_REF:
6078 {
6079 tree addr = instantiate_type (lhstype, TREE_OPERAND (rhs, 1), flags);
6080
6081 if (addr != error_mark_node
6082 && TREE_SIDE_EFFECTS (TREE_OPERAND (rhs, 0)))
6083 /* Do not lose object's side effects. */
6084 addr = build (COMPOUND_EXPR, TREE_TYPE (addr),
6085 TREE_OPERAND (rhs, 0), addr);
6086 return addr;
6087 }
6088
6089 case OFFSET_REF:
6090 rhs = TREE_OPERAND (rhs, 1);
6091 if (BASELINK_P (rhs))
6092 return instantiate_type (lhstype, BASELINK_FUNCTIONS (rhs), flags_in);
6093
6094 /* This can happen if we are forming a pointer-to-member for a
6095 member template. */
6096 my_friendly_assert (TREE_CODE (rhs) == TEMPLATE_ID_EXPR, 0);
6097
6098 /* Fall through. */
6099
6100 case TEMPLATE_ID_EXPR:
6101 {
6102 tree fns = TREE_OPERAND (rhs, 0);
6103 tree args = TREE_OPERAND (rhs, 1);
6104
6105 return
6106 resolve_address_of_overloaded_function (lhstype, fns, flags_in,
6107 /*template_only=*/ true,
6108 args);
6109 }
6110
6111 case OVERLOAD:
6112 case FUNCTION_DECL:
6113 return
6114 resolve_address_of_overloaded_function (lhstype, rhs, flags_in,
6115 /*template_only=*/ false,
6116 /*explicit_targs=*/ NULL_TREE);
6117
6118 case TREE_LIST:
6119 /* Now we should have a baselink. */
6120 my_friendly_assert (BASELINK_P (rhs), 990412);
6121
6122 return instantiate_type (lhstype, BASELINK_FUNCTIONS (rhs), flags);
6123
6124 case CALL_EXPR:
6125 /* This is too hard for now. */
6126 abort ();
6127 return error_mark_node;
6128
6129 case PLUS_EXPR:
6130 case MINUS_EXPR:
6131 case COMPOUND_EXPR:
6132 TREE_OPERAND (rhs, 0)
6133 = instantiate_type (lhstype, TREE_OPERAND (rhs, 0), flags);
6134 if (TREE_OPERAND (rhs, 0) == error_mark_node)
6135 return error_mark_node;
6136 TREE_OPERAND (rhs, 1)
6137 = instantiate_type (lhstype, TREE_OPERAND (rhs, 1), flags);
6138 if (TREE_OPERAND (rhs, 1) == error_mark_node)
6139 return error_mark_node;
6140
6141 TREE_TYPE (rhs) = lhstype;
6142 return rhs;
6143
6144 case MULT_EXPR:
6145 case TRUNC_DIV_EXPR:
6146 case FLOOR_DIV_EXPR:
6147 case CEIL_DIV_EXPR:
6148 case ROUND_DIV_EXPR:
6149 case RDIV_EXPR:
6150 case TRUNC_MOD_EXPR:
6151 case FLOOR_MOD_EXPR:
6152 case CEIL_MOD_EXPR:
6153 case ROUND_MOD_EXPR:
6154 case FIX_ROUND_EXPR:
6155 case FIX_FLOOR_EXPR:
6156 case FIX_CEIL_EXPR:
6157 case FIX_TRUNC_EXPR:
6158 case FLOAT_EXPR:
6159 case NEGATE_EXPR:
6160 case ABS_EXPR:
6161 case MAX_EXPR:
6162 case MIN_EXPR:
6163
6164 case BIT_AND_EXPR:
6165 case BIT_IOR_EXPR:
6166 case BIT_XOR_EXPR:
6167 case LSHIFT_EXPR:
6168 case RSHIFT_EXPR:
6169 case LROTATE_EXPR:
6170 case RROTATE_EXPR:
6171
6172 case PREINCREMENT_EXPR:
6173 case PREDECREMENT_EXPR:
6174 case POSTINCREMENT_EXPR:
6175 case POSTDECREMENT_EXPR:
6176 if (flags & tf_error)
6177 error ("invalid operation on uninstantiated type");
6178 return error_mark_node;
6179
6180 case TRUTH_AND_EXPR:
6181 case TRUTH_OR_EXPR:
6182 case TRUTH_XOR_EXPR:
6183 case LT_EXPR:
6184 case LE_EXPR:
6185 case GT_EXPR:
6186 case GE_EXPR:
6187 case EQ_EXPR:
6188 case NE_EXPR:
6189 case TRUTH_ANDIF_EXPR:
6190 case TRUTH_ORIF_EXPR:
6191 case TRUTH_NOT_EXPR:
6192 if (flags & tf_error)
6193 error ("not enough type information");
6194 return error_mark_node;
6195
6196 case COND_EXPR:
6197 if (type_unknown_p (TREE_OPERAND (rhs, 0)))
6198 {
6199 if (flags & tf_error)
6200 error ("not enough type information");
6201 return error_mark_node;
6202 }
6203 TREE_OPERAND (rhs, 1)
6204 = instantiate_type (lhstype, TREE_OPERAND (rhs, 1), flags);
6205 if (TREE_OPERAND (rhs, 1) == error_mark_node)
6206 return error_mark_node;
6207 TREE_OPERAND (rhs, 2)
6208 = instantiate_type (lhstype, TREE_OPERAND (rhs, 2), flags);
6209 if (TREE_OPERAND (rhs, 2) == error_mark_node)
6210 return error_mark_node;
6211
6212 TREE_TYPE (rhs) = lhstype;
6213 return rhs;
6214
6215 case MODIFY_EXPR:
6216 TREE_OPERAND (rhs, 1)
6217 = instantiate_type (lhstype, TREE_OPERAND (rhs, 1), flags);
6218 if (TREE_OPERAND (rhs, 1) == error_mark_node)
6219 return error_mark_node;
6220
6221 TREE_TYPE (rhs) = lhstype;
6222 return rhs;
6223
6224 case ADDR_EXPR:
6225 {
6226 if (PTRMEM_OK_P (rhs))
6227 flags |= tf_ptrmem_ok;
6228
6229 return instantiate_type (lhstype, TREE_OPERAND (rhs, 0), flags);
6230 }
6231 case ENTRY_VALUE_EXPR:
6232 abort ();
6233 return error_mark_node;
6234
6235 case ERROR_MARK:
6236 return error_mark_node;
6237
6238 default :
6239 abort ();
6240 return error_mark_node;
6241 }
6242 }
上面的代码清楚地显示了关注的是指定类别节点哪个操作数（为表达式构建节点的函数，例如， build_binary_op ，将把操作数统一到同一个类型。因此对于表达式“ ptr+5 ”（ ptr 是类型“ int* ”），这个表达式构建函数将把‘ 5 ’提升为类型“ int* ”）。
如果该重载是合法的（为 TEMPLATE_ID_EXPR ， FUNCITON_DECL ，或 OVERLOAD ），它需要被解析以找出匹配者；显然，多于一个的匹配会导致二义性的问题。看到下面的参数 explicit_targs 仅用于模板的匹配，它保存了显式给定的模板实参。
【 3 】，条文 13.4 “重载函数地址”（ [over.over] ），给出了这个语法成分的意义和用法，连同例子。
| 1. 一个不带参数的重载函数名，在特定上下文中，被解析为一个函数，指向重载函数集中一个特定函数的函数的指针，或指向成员函数的指针。一个函数模板名被视为，在这样的上下文中，命名了一个重载函数集。被选中的函数，其类型与该上下文所要求的目标类型相匹配。这个目标类型可以是 — 要被初始化的一个对象或引用（ 8.5 ， 8.5.3 ）， — 一个赋值的左手侧（ 5.17 ）， — 一个函数的一个参数（ 5.2.2 ）， — 一个用户定义操作符的一个参数（ 13.5 ）， — 一个函数，运算符函数，转换函数的返回值（ 6.6.3 ）， — 一个显式类型转换（ 5.2.3 ， 5.2.9, 5.4 ），或者 — 一个非类型模板参数（ 14.3.2 ）。 该重载函数名之前可以是 & 操作符。一个重载函数名，在那些没有列出的上下文中，不能不带参数来使用。 [ 注意：包围该重载函数名的任意多余括号对被忽略（ 5.1 ） ] 。 2. 如果这个名字是一个函数模板，执行模板实参推导（ 14.8.2 .2 ），并且如果实参推导成功，产生的模板实参列表被用于产生一个函数模板特化，这个特化被加入这个正在关注的重载函数集中。 3. 非成员函数及静态成员函数匹配的目标类型为“函数指针”或“函数引用”。非静态成员函数匹配的目标类型是“成员函数指针”；成员指针中的函数类型用于，从重载成员函数集中，选择成员函数。如果一个非静态成员函数被选中，对该重载函数名的一个引用被要求具有一个成员指针的形式，如 5.3.1 中描述的那样。 4. 如果选中了多于一个函数，如果这个集包含了非模板函数，这个集中的函数模板特化都被淘汰；给定函数模板特化 F1 ，如果在这个集中包含了第二个函数模板特化，其函数模板的特化程度，根据 14.5.5 .2 的偏序规则，比 F1 的函数模板的特化程度高，淘汰 F1 。在这样的淘汰之后，应该只留下一个中选的函数。 5. [ 例子： int f(double); int f(int); int (*pfd)(double) = &f; // selects f(double) int (*pfi)(int) = &f; // selects f(int) int (*pfe)(...) = &f; // error: type mismatch int (&rfi)(int) = f; // selects f(int) int (&rfd)(double) = f; // selects f(double) void g() { (int (*)(int))&f; // cast expression as selector } pfe 的初始化是非法的，因为没有定义具有类型 int(…) 的 f() ，而不是因为二义性。另一个例子， struct X { int f(int); static int f(long); }; int (X::*p1)(int) = &X::f; // OK int (*p2)(int) = &X::f; // error: mismatch int (*p3)(long) = &X::f; // OK int (X::*p4)(long) = &X::f; // error: mismatch int (X::*p5)(int) = &(X::f); // error: wrong syntax for pointer to member int (*p6)(long) = &(X::f); // OK — 例子结束 ] 6. [ 注意：如果 f() 及 g() 都是重载函数，解析 f(&g) ，或相当的表达式 f(g) ，必须考虑可能性的叉积（ cross product ） ] 。 7. [ 注意：这里没有一个函数指针到另一个函数指针的标准转换（条文 4 ）。特别是，即使 B 是 D 的一个公有基类，我们有 D* f(); B* (*p1)() = &f; // error void g(D*); void (*p2)(B*) = &g; // error — 注意结束 ] |
5723 static tree
5724 resolve_address_of_overloaded_function (tree target_type, in class.c
5725 tree overload,
5726 tsubst_flags_t flags,
5727 bool template_only,
5728 tree explicit_targs)
5729 {
5730 /* Here's what the standard says:
5731
5732 [over.over]
5733
5734 If the name is a function template, template argument deduction
5735 is done, and if the argument deduction succeeds, the deduced
5736 arguments are used to generate a single template function, which
5737 is added to the set of overloaded functions considered.
5738
5739 Non-member functions and static member functions match targets of
5740 type "pointer-to-function" or "reference-to-function." Nonstatic
5741 member functions match targets of type "pointer-to-member
5742 function;" the function type of the pointer to member is used to
5743 select the member function from the set of overloaded member
5744 functions. If a nonstatic member function is selected, the
5745 reference to the overloaded function name is required to have the
5746 form of a pointer to member as described in 5.3.1.
5747
5748 If more than one function is selected, any template functions in
5749 the set are eliminated if the set also contains a non-template
5750 function, and any given template function is eliminated if the
5751 set contains a second template function that is more specialized
5752 than the first according to the partial ordering rules 14.5.5.2.
5753 After such eliminations, if any, there shall remain exactly one
5754 selected function. */
5755
5756 int is_ptrmem = 0;
5757 int is_reference = 0;
5758 /* We store the matches in a TREE_LIST rooted here. The functions
5759 are the TREE_PURPOSE, not the TREE_VALUE, in this list, for easy
5760 interoperability with most_specialized_instantiation. */
5761 tree matches = NULL_TREE;
5762 tree fn;
5763
5764 /* By the time we get here, we should be seeing only real
5765 pointer-to-member types, not the internal POINTER_TYPE to
5766 METHOD_TYPE representation. */
5767 my_friendly_assert (!(TREE_CODE (target_type) == POINTER_TYPE
5768 && (TREE_CODE (TREE_TYPE (target_type))
5769 == METHOD_TYPE)), 0);
5770
5771 my_friendly_assert (is_overloaded_fn (overload), 20030910);
5772
5773 /* Check that the TARGET_TYPE is reasonable. */
5774 if (TYPE_PTRFN_P (target_type))
5775 /* This is OK. */ ;
5776 else if (TYPE_PTRMEMFUNC_P (target_type))
5777 /* This is OK, too. */
5778 is_ptrmem = 1;
5779 else if (TREE_CODE (target_type) == FUNCTION_TYPE)
5780 {
5781 /* This is OK, too. This comes from a conversion to reference
5782 type. */
5783 target_type = build_reference_type (target_type);
5784 is_reference = 1;
5785 }
5786 else
5787 {
5788 if (flags & tf_error)
5789 error ("/
5790 cannot resolve overloaded function `%D' based on conversion to type `%T'",
5791 DECL_NAME (OVL_FUNCTION (overload)), target_type);
5792 return error_mark_node;
5793 }
5794
5795 /* If we can find a non-template function that matches, we can just
5796 use it. There's no point in generating template instantiations
5797 if we're just going to throw them out anyhow. But, of course, we
5798 can only do this when we don't *need* a template function. */
5799 if (!template_only)
5800 {
5801 tree fns;
5802
5803 for (fns = overload; fns; fns = OVL_NEXT (fns))
5804 {
5805 tree fn = OVL_CURRENT (fns);
5806 tree fntype;
5807
5808 if (TREE_CODE (fn) == TEMPLATE_DECL)
5809 /* We're not looking for templates just yet. */
5810 continue ;
5811
5812 if ((TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
5813 != is_ptrmem)
5814 /* We're looking for a non-static member, and this isn't
5815 one, or vice versa. */
5816 continue ;
5817
5818 /* Ignore anticipated decls of undeclared builtins. */
5819 if (DECL_ANTICIPATED (fn))
5820 continue ;
5821
5822 /* See if there's a match. */
5823 fntype = TREE_TYPE (fn);
5824 if (is_ptrmem)
5825 fntype = build_ptrmemfunc_type (build_pointer_type (fntype));
5826 else if (!is_reference)
5827 fntype = build_pointer_type (fntype);
5828
5829 if (can_convert_arg (target_type, fntype, fn))
5830 matches = tree_cons (fn, NULL_TREE, matches);
5831 }
5832 }
记得重载被串接在一个以 OVERLOAD 节点开头的链表中，不过在这个头部之后的节点分别包含了 FUNCTION_DECL 节点，它在 5805 行由 OVL_CURRENT 获取。然后，在 5823 行的 fntype 将是确定的 FUNCTION_TYPE ，而不是 unknown_type_node 。因此从它构建指针类型。对于这些类型， can_convert_arg 将检查该类型是否可以被隐式地转换到 target_type ，并且在处理这个指针转换的 standard_conversion 中，在 619 行，我们可以看到函数指针要求精确匹配，就像上面例子所显示的那样。
而在重载函数中，非模板函数优于模板函数，如果找到了非模板函数，就忽略所有的模板函数。如果我们不能找到匹配的非模板函数，那么我们就要查找匹配的模板函数，我们将进入下面 5837 行的 IF 块。
resolve_address_of_overloaded_function (continue)
5834 /* Now, if we've already got a match (or matches), there's no need
5835 to proceed to the template functions. But, if we don't have a
5836 match we need to look at them, too. */
5837 if (!matches)
5838 {
5839 tree target_fn_type;
5840 tree target_arg_types;
5841 tree target_ret_type;
5842 tree fns;
5843
5844 if (is_ptrmem)
5845 target_fn_type
5846 = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (target_type));
5847 else
5848 target_fn_type = TREE_TYPE (target_type);
5849 target_arg_types = TYPE_ARG_TYPES (target_fn_type);
5850 target_ret_type = TREE_TYPE (target_fn_type);
5851
5852 /* Never do unification on the 'this' parameter. */
5853 if (TREE_CODE (target_fn_type) == METHOD_TYPE)
5854 target_arg_types = TREE_CHAIN (target_arg_types);
5855
5856 for (fns = overload; fns; fns = OVL_NEXT (fns))
5857 {
5858 tree fn = OVL_CURRENT (fns);
5859 tree instantiation;
5860 tree instantiation_type;
5861 tree targs;
5862
5863 if (TREE_CODE (fn) != TEMPLATE_DECL)
5864 /* We're only looking for templates. */
5865 continue ;
5866
5867 if ((TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
5868 != is_ptrmem)
5869 /* We're not looking for a non-static member, and this is
5870 one, or vice versa. */
5871 continue ;
5872
5873 /* Try to do argument deduction. */
5874 targs = make_tree_vec (DECL_NTPARMS (fn));
5875 if (fn_type_unification (fn, explicit_targs, targs,
5876 target_arg_types, target_ret_type,
5877 DEDUCE_EXACT, -1) != 0)
5878 /* Argument deduction failed. */
5879 continue ;
5880
5881 /* Instantiate the template. */
5882 instantiation = instantiate_template (fn, targs, flags);
5883 if (instantiation == error_mark_node)
5884 /* Instantiation failed. */
5885 continue ;
5886
5887 /* See if there's a match. */
5888 instantiation_type = TREE_TYPE (instantiation);
5889 if (is_ptrmem)
5890 instantiation_type =
5891 build_ptrmemfunc_type (build_pointer_type (instantiation_type));
5892 else if (!is_reference)
5893 instantiation_type = build_pointer_type (instantiation_type);
5894 if (can_convert_arg (target_type, instantiation_type, instantiation))
5895 matches = tree_cons (instantiation, fn, matches);
5896 }
5897
5898 /* Now, remove all but the most specialized of the matches. */
5899 if (matches)
5900 {
5901 tree match = most_specialized_instantiation (matches);
5902
5903 if (match != error_mark_node)
5904 matches = tree_cons (match, NULL_TREE, NULL_TREE);
5905 }
5906 }
在前一节，我们已经看过了模板实参推导。这里我们就不麻烦再看一遍了。
resolve_address_of_overloaded_function (continue)
5908 Now we should have exactly one function in MATCHES. */
5909 if (matches == NULL_TREE)
5910 {
5911 /* There were *no* matches. */
5912 if (flags & tf_error)
5913 {
5914 error ("no matches converting function `%D' to type `%#T'",
5915 DECL_NAME (OVL_FUNCTION (overload)),
5916 target_type);
5917
5918 /* print_candidates expects a chain with the functions in
5919 TREE_VALUE slots, so we cons one up here (we're losing anyway,
5920 so why be clever?). */
5921 for (; overload; overload = OVL_NEXT (overload))
5922 matches = tree_cons (NULL_TREE, OVL_CURRENT (overload),
5923 matches);
5924
5925 print_candidates (matches);
5926 }
5927 return error_mark_node;
5928 }
5929 else if (TREE_CHAIN (matches))
5930 {
5931 /* There were too many matches. */
5932
5933 if (flags & tf_error)
5934 {
5935 tree match;
5936
5937 error ("converting overloaded function `%D' to type `%#T' is ambiguous",
5938 DECL_NAME (OVL_FUNCTION (overload)),
5939 target_type);
5940
5941 /* Since print_candidates expects the functions in the
5942 TREE_VALUE slot, we flip them here. */
5943 for (match = matches; match; match = TREE_CHAIN (match))
5944 TREE_VALUE (match) = TREE_PURPOSE (match);
5945
5946 print_candidates (matches);
5947 }
5948
5949 return error_mark_node;
5950 }
5951
5952 /* Good, exactly one match. Now, convert it to the correct type. */
5953 fn = TREE_PURPOSE (matches);
5954
5955 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
5956 && !(flags & tf_ptrmem_ok) && !flag_ms_extensions )
5957 {
5958 static int explained;
5959
5960 if (!(flags & tf_error))
5961 return error_mark_node;
5962
5963 pedwarn ("assuming pointer to member `%D'", fn);
5964 if (!explained)
5965 {
5966 pedwarn ("(a pointer to member can only be formed with `&%E')", fn);
5967 explained = 1;
5968 }
5969 }
5970
5971 /* If we're doing overload resolution purely for the purpose of
5972 determining conversion sequences, we should not consider the
5973 function used. If this conversion sequence is selected, the
5974 function will be marked as used at this point. */
5975 if (!(flags & tf_conv))
5976 mark_used (fn);
5977
5978 if (TYPE_PTRFN_P (target_type) || TYPE_PTRMEMFUNC_P (target_type))
5979 return build_unary_op (ADDR_EXPR, fn, 0);
5980 else
5981 {
5982 /* The target must be a REFERENCE_TYPE. Above, build_unary_op
5983 will mark the function as addressed, but here we must do it
5984 explicitly. */
5985 cxx_mark_addressable (fn);
5986
5987 return fn;
5988 }
5989 }
最后，需要把合格的查找结果标记为可取址，这是对代码产生有重要意义的信息。而由该函数返回的 fn 是匹配的重载。并且这个返回值在 952 行被保存入 expr 。而 from 在 955 行被更新到这个类型。
1203
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
