5.13.1.1.2.2. 确定最优
在收集了所有的候选者后，需要挑出可行的候选者（因为收集的时候，我们只考虑了类型，没有别的），并为涉及的转换函数评估等级，以选出最优的候选。下面的代码执行这个处理。
build_user_type_conversion_1 (continue)
2478 candidates = splice_viable (candidates, pedantic , &any_viable_p);
2479 if (!any_viable_p)
2480 return 0;
2481
2482 cand = tourney (candidates);
5.13.1.1.2.2.1. 挑选可行的候选者
在下面的函数中，其参数 strict_p 被传递入 pedantic 的值，它如果非 0 ，就要求编译器对标准所禁止的一切给出警告。回忆如果隐式转换不能奏效， implicit_conversion 将返回 NULL ；而对于标准所禁止的转换，将设置 ICS_BAD_FLAG 标记。
2165 static struct z_candidate *
2166 splice_viable (struct z_candidate *cands, in call.c
2167 bool strict_p,
2168 bool *any_viable_p)
2169 {
2170 struct z_candidate *viable;
2171 struct z_candidate **last_viable;
2172 struct z_candidate **cand;
2173
2174 viable = NULL;
2175 last_viable = &viable;
2176 *any_viable_p = false;
2177
2178 cand = &cands;
2179 while (*cand)
2180 {
2181 struct z_candidate *c = *cand;
2182 if (strict_p ? c->viable == 1 : c->viable)
2183 {
2184 *last_viable = c;
2185 *cand = c->next;
2186 c ->next = NULL;
2187 last_viable = &c->next;
2188 *any_viable_p = true;
2189 }
2190 else
2191 cand = &c->next;
2192 }
2193
2194 return viable ? viable : cands;
2195 }
5.13.1.1.2.2.2. 选出最优
【 3 】的条文 13.3.3 .2 “隐式转换序列排名“给出了挑选最优候选者的规则 [over.ics.rank ] 。
而 implicit_conversion 通过，首先尝试标准转换及引用绑定，如果失败，才尝试用户定义转换，实现了规则 2 的第一部分。
| 1. 13.3 .3.2 基于更好的转换序列与更好的转换之间的关系，定义了隐式转换序列的一个偏序（ partial ordering ）。如果一个隐式转换序列 S1 被这些规则定义为比 S2 更好的转换序列，那么同时 S2 亦是比 S1 更差的转换序列。如果转换序列 S1 不比转换序列 S2 好，也不比它差，就说 S1 与 S2 是不可区分（ indistinguishable ）的转换序列。 2. 当比较隐式转换序列的基本形式（如 13.3.3 .1 所定义）时 — 一个标准转换序列（ 13.3.3 .1.1 ）是比一个用户定义转换序列或一个省略转换序列更好的转换序列，而 — 一个用户定义转换序列（ 13.3.3 .1.2 ）是比一个省略转换序列（ 13.3.3.1.3 ）更优的转换序列。 3. 两个具有相同形式的隐式转换序列是不可区分的转换序列，除非适用下面其中任一规则： — 标准转换序列 S1 是比标准转换序列 S2 更好的转换序列，如果 — S1 是 S2 的一个正确的子序列（比较 13.3.3 .1.1 所定义的规范形式的转换序列，不包括任意左值转型（ Lvalue Transformation ）；恒等转换序列被认为是任意非恒等转换序列的一个子序列）；否则， — S1 的等级比 S2 的等级高，或 S1 及 S2 具有相同的等级，并且根据下面段落的规则是不可区分的；否则， — S1 与 S2 仅是它们的限定转换不同，并且分别产生相似的类型 T1 及 T2 （ 4.4 ），而类型 T1 的 cv- 限定是类型 T2 的 cv- 限定的一个正确子集，并且 S1 不是不推荐的字符串数组到指针的转换（ 4.2 ）。 [ 例子： int f(const int *); int f(int *); int i; int j = f(&i); // Calls f(int *) — 例子结束 ] ；否则， — S1 及 S2 都是引用绑定（ 8.5.3 ），并且除了最顶层的 cv- 限定词，这些引用的类型都相同，并且由 S2 的援引所初始化的引用的类型，比由 S1 的援引所初始化的引用的类型，具有更多的 cv- 限定。 [ 例如： int f(const int &); int f(int &); int g(const int &); int g(int); int i; int j = f(i); // Calls f(int &) int k = g(i); // ambiguous class X { public : void f() const ; void f(); }; void g(const X& a, X b) { a.f(); //Calls X::f() const b.f(); //Calls X::f() } — 例子结束 ] — 用户定义转换序列 U1 是比另一个用户定义转换序列更好的转换序列，如果它们包含了相同的用户定义转换函数或构造函数，并且如果 U1 的第二标准转换序列优于 U2 的第二标准转换序列。 [ 例如： struct A { operator short(); } a; int f(int); int f(float); int i = f(a); // Calls f(int), because short → int is better than short → float. — 例子结束 ] 4. 标准转换序列根据它们的等级排序：一个精确匹配（ Exact Match ）优于提升（ Promotion ），提升优于转换。两个具有相同等级的转换序列是不可区分，除非适用以下任一规则： — 一个不是指针转换，或成员指针转换，或布尔转换的转换要优于这些转换。 — 如果类 B 从类 A 直接或间接派生， B* 到 A* 的转换优于 B* 到 void* 的转换， A* 到 void* 的转换优于 B* 到 void* 的转换。 — 如果类 B 从类 A 直接或间接派生，而类 C 从 B 直接或间接派生， C* 到 B* 的转换优于 C* 到 A* 的转换， [ 例如： struct A {}; struct B : public A {}; struct C : public B {}; C *pc; int f(A *); int f(B *); int i = f(pc); // Calls f(B *) — 例子结束 ] — 绑定一个具有类型 C 的表达式到一个具有类型“ B& ”的引用，要优于绑定一个具有类型 C 的表达式到一个具有类型“ A& ”的引用， — A::* 到 B::* 的转换优于 A::* 到 C::* 的转换， — C 到 B 的转换优于 C 到 A 的转换， — B* 到 A* 的转换优于 C* 到 A* 的转换， — 绑定一个具有类型 B 的表达式到一个具有类型“ A& ”的引用，要优于绑定一个具有类型 C 的表达式到一个具有类型“ A& ”的引用， — B::* 到 C::* 的转换优于 A::* 到 C::* 的转换，并且 — B 到 A 的转换优于 C 到 A 的转换。 [ 注意：仅在比较一个自用户定义的初始化转换的第二标准转换序列的上下文中，被比较的转换序列将具有不同的源类型（参见 see 13.3.3 ）；在其他上下文中，源类型必须是相同，而目标类型不同 ] 。 |
5936 static struct z_candidate *
5937 tourney (struct z_candidate *candidates) in call.c
5938 {
5939 struct z_candidate *champ = candidates, *challenger;
5940 int fate;
5941 int champ_compared_to_predecessor = 0;
5942
5943 /* Walk through the list once, comparing each current champ to the next
5944 candidate, knocking out a candidate or two with each comparison. */
5945
5946 for (challenger = champ->next; challenger; )
5947 {
5948 fate = joust (champ, challenger, 0);
5949 if (fate == 1)
5950 challenger = challenger->next;
5951 else
5952 {
5953 if (fate == 0)
5954 {
5955 champ = challenger->next;
5956 if (champ == 0)
5957 return 0;
5958 champ_compared_to_predecessor = 0;
5959 }
5960 else
5961 {
5962 champ = challenger;
5963 champ_compared_to_predecessor = 1;
5964 }
5965
5966 challenger = champ->next;
5967 }
5968 }
5969
5970 /* Make sure the champ is better than all the candidates it hasn't yet
5971 been compared to. */
5972
5973 for (challenger = candidates;
5974 challenger != champ
5975 && !(champ_compared_to_predecessor && challenger->next == champ);
5976 challenger = challenger->next)
5977 {
5978 fate = joust (champ, challenger, 0);
5979 if (fate != 1)
5980 return 0;
5981 }
5982
5983 return champ;
5984 }
通过 joust 候选者被一个个比较来选出最佳者，该函数返回 1 如果 champ 是更优的， -1 如果 challenger 是更优的，或者 0 如果具有二义性。注意到 champ 总是指向列表中的前一个候选者，而 challenger 是紧跟 champ 之后的候选者。看到在 5946 行的 FOR 循环中 champ 总是指向两个中较佳者，如果能确定的话。
在 5973 行的 FOR 循环中，如果 champ_compared_to_predecessor 为 0 ，那么退出的条件变成：“ challenger != champ ”；否则就变成：“ challenger != champ && challenger->next != champ ”。注意到仅当 challenger 最后一次发现优于 champ （因而 champ 被 challenger 更新），并之后没有出现二义性的结果时， champ_compared_to_predecessor 可以是 1 ；而这个标记 0 ，仅当最后一次比较的结果是 champ 优于 chanlleger 。因此对于该标记为 1 ， champ 之前的候选者不需要比较，但当标记为 0 时需要包括之。为什么需要第二个 FOR 循环呢？首先注意到如果找到最佳候选者，最后一次的比较必然不会出现二义性，否则该函数将在 5957 行返回 0 。另外看到如果出现二义性，这两个候选者都被跳过，比较在后面的候选者中重新开始。因此有可能具有二义性的候选者要优于在第一个 FOR 循环中找到的最佳候选者，而这个情形，在第二 FOR 循环中，将被发现为一个错误，并在 5980 行返回 0 。
在上面看到，被选出的可行候选者的 viable 域是非 0 值。并记得如果该转换不为标准所允许，这个域将保存值 -1 。作为一个快速的挑选，不同的 viable 值显示谁为更优。毫无疑问，标准所允许的转换总是更优胜。
5653 static int
5654 joust (struct z_candidate *cand1, struct z_candidate *cand2, bool warn) in call.c
5655 {
5656 int winner = 0;
5657 int i, off1 = 0, off2 = 0, len;
5658
5659 /* Candidates that involve bad conversions are always worse than those
5660 that don't. */
5661 if (cand1->viable > cand2->viable)
5662 return 1;
5663 if (cand1->viable < cand2->viable)
5664 return -1;
5665
5666 /* If we have two pseudo-candidates for conversions to the same type,
5667 or two candidates for the same function, arbitrarily pick one. */
5668 if (cand1->fn == cand2->fn
5669 && (TYPE_P (cand1->fn) || DECL_P (cand1->fn)))
5670 return 1;
5671
5672 /* a viable function F1
5673 is defined to be a better function than another viable function F2 if
5674 for all arguments i, ICSi(F1) is not a worse conversion sequence than
5675 ICSi(F2), and then */
5676
5677 /* for some argument j, ICSj(F1) is a better conversion sequence than
5678 ICSj(F2) */
5679
5680 /* For comparing static and non-static member functions, we ignore
5681 the implicit object parameter of the non-static function. The
5682 standard says to pretend that the static function has an object
5683 parm, but that won't work with operator overloading. */
5684 len = TREE_VEC_LENGTH (cand1->convs);
5685 if (len != TREE_VEC_LENGTH (cand2->convs))
5686 {
5687 if (DECL_STATIC_FUNCTION_P (cand1->fn)
5688 && ! DECL_STATIC_FUNCTION_P (cand2->fn))
5689 off2 = 1;
5690 else if (! DECL_STATIC_FUNCTION_P (cand1->fn)
5691 && DECL_STATIC_FUNCTION_P (cand2->fn))
5692 {
5693 off1 = 1;
5694 --len;
5695 }
5696 else
5697 abort ();
5698 }
5699
5700 for (i = 0; i < len; ++i)
5701 {
5702 tree t1 = TREE_VEC_ELT (cand1->convs, i+off1);
5703 tree t2 = TREE_VEC_ELT (cand2->convs, i+off2);
5704 int comp = compare_ics (t1, t2);
5705
5706 if (comp != 0)
5707 {
5708 if (warn_sign_promo
5709 && ICS_RANK (t1) + ICS_RANK (t2) == STD_RANK + PROMO_RANK
5710 && TREE_CODE (t1) == STD_CONV
5711 && TREE_CODE (t2) == STD_CONV
5712 && TREE_CODE (TREE_TYPE (t1)) == INTEGER_TYPE
5713 && TREE_CODE (TREE_TYPE (t2)) == INTEGER_TYPE
5714 && (TYPE_PRECISION (TREE_TYPE (t1))
5715 == TYPE_PRECISION (TREE_TYPE (t2)))
5716 && (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (t1, 0)))
5717 || (TREE_CODE (TREE_TYPE (TREE_OPERAND (t1, 0)))
5718 == ENUMERAL_TYPE)))
5719 {
5720 tree type = TREE_TYPE (TREE_OPERAND (t1, 0));
5721 tree type1, type2;
5722 struct z_candidate *w, *l;
5723 if (comp > 0)
5724 type1 = TREE_TYPE (t1), type2 = TREE_TYPE (t2),
5725 w = cand1, l = cand2;
5726 else
5727 type1 = TREE_TYPE (t2), type2 = TREE_TYPE (t1),
5728 w = cand2, l = cand1;
5729
5730 if (warn)
5731 {
5732 warning ("passing `%T' chooses `%T' over `%T'",
5733 type, type1, type2);
5734 warning (" in call to `%D'", w->fn);
5735 }
5736 else
5737 add_warning (w, l);
5738 }
5739
5740 if (winner && comp != winner)
5741 {
5742 winner = 0;
5743 goto tweak;
5744 }
5745 winner = comp;
5746 }
5747 }
候选者中有可能同时包括了静态转换函数及非静态转换函数。如果相比较的候选者在一者是静态的，另一者不是；就需要在比较过程中忽略隐含的‘ this ’指针。因此在 5702 及 5703 行的 t1 及 t2 拷贝出需要的参数，并传递给如下的函数。
5293 static int
5294 compare_ics (tree ics1, tree ics2) in call.c
5295 {
5296 tree from_type1;
5297 tree from_type2;
5298 tree to_type1;
5299 tree to_type2;
5300 tree deref_from_type1 = NULL_TREE;
5301 tree deref_from_type2 = NULL_TREE;
5302 tree deref_to_type1 = NULL_TREE;
5303 tree deref_to_type2 = NULL_TREE;
5304 int rank1, rank2;
5305
5306 /* REF_BINDING is nonzero if the result of the conversion sequence
5307 is a reference type. In that case TARGET_TYPE is the
5308 type referred to by the reference. */
5309 tree target_type1;
5310 tree target_type2;
5311
5312 /* Handle implicit object parameters. */
5313 maybe_handle_implicit_object (&ics1);
5314 maybe_handle_implicit_object (&ics2);
5315
5316 /* Handle reference parameters. */
5317 target_type1 = maybe_handle_ref_bind (&ics1);
5318 target_type2 = maybe_handle_ref_bind (&ics2);
5319
5320 /* [over.ics.rank]
5321
5322 When comparing the basic forms of implicit conversion sequences (as
5323 defined in _over.best.ics_)
5324
5325 --a standard conversion sequence (_over.ics.scs_) is a better
5326 conversion sequence than a user-defined conversion sequence
5327 or an ellipsis conversion sequence, and
5328
5329 --a user-defined conversion sequence (_over.ics.user_) is a
5330 better conversion sequence than an ellipsis conversion sequence
5331 (_over.ics.ellipsis_). */
5332 rank1 = ICS_RANK (ics1);
5333 rank2 = ICS_RANK (ics2);
下面在 5258 行的注释来自【 3 】条文 13.3.1 “候选函数及实参列表”，条款 4 。它解释到现在需要把‘ this ’指针转换为相匹配 cv- 限定的引用。
5253 static void
5254 maybe_handle_implicit_object (tree *ics) in call.c
5255 {
5256 if (ICS_THIS_FLAG (*ics))
5257 {
5258 /* [over.match.funcs]
5259
5260 For non-static member functions, the type of the
5261 implicit object parameter is "reference to cv X"
5262 where X is the class of which the function is a
5263 member and cv is the cv-qualification on the member
5264 function declaration. */
5265 tree t = *ics;
5266 tree reference_type;
5267
5268 /* The `this' parameter is a pointer to a class type. Make the
5269 implicit conversion talk about a reference to that same class
5270 type. */
5271 reference_type = TREE_TYPE (TREE_TYPE (*ics));
5272 reference_type = build_reference_type (reference_type);
5273
5274 if (TREE_CODE (t) == QUAL_CONV)
5275 t = TREE_OPERAND (t, 0);
5276 if (TREE_CODE (t) == PTR_CONV)
5277 t = TREE_OPERAND (t, 0);
5278 t = build1 (IDENTITY_CONV, TREE_TYPE (TREE_TYPE (t)), NULL_TREE);
5279 t = direct_reference_binding (reference_type, t);
5280 *ics = t;
5281 }
5282 }
既然我们知道的具体的引用类型，就可以直接构建这个转换序列。这个需要增加的转换序列应该仅是 REF_BIND 。注意上面 5274 到 5277 行的代码，看到在 standard_conversion 的 603 行， PTR_CONV 总是构建在 QUAL_CONV 中，如果它们都出现。
895 static tree
896 direct_reference_binding (tree type, tree conv) in call.c
897 {
898 tree t;
899
900 my_friendly_assert (TREE_CODE (type) == REFERENCE_TYPE, 20030306);
901 my_friendly_assert (TREE_CODE (TREE_TYPE (conv)) != REFERENCE_TYPE,
902 20030306);
903
904 t = TREE_TYPE (type);
905
906 /* [over.ics.rank]
907
908 When a parameter of reference type binds directly
909 (_dcl.init.ref_) to an argument expression, the implicit
910 conversion sequence is the identity conversion, unless the
911 argument expression has a type that is a derived class of the
912 parameter type, in which case the implicit conversion sequence is
913 a derived-to-base Conversion.
914
915 If the parameter binds directly to the result of applying a
916 conversion function to the argument expression, the implicit
917 conversion sequence is a user-defined conversion sequence
918 (_over.ics.user_), with the second standard conversion sequence
919 either an identity conversion or, if the conversion function
920 returns an entity of a type that is a derived class of the
921 parameter type, a derived-to-base conversion. */
922 if (!same_type_ignoring_top_level_qualifiers_p (t, TREE_TYPE (conv)))
923 {
924 /* Represent the derived-to-base conversion. */
925 conv = build_conv (BASE_CONV, t, conv);
926 /* We will actually be binding to the base-class subobject in
927 the derived class, so we mark this conversion appropriately.
928 That way, convert_like knows not to generate a temporary. */
929 NEED_TEMPORARY_P (conv) = 0;
930 }
931 return build_conv (REF_BIND, type, conv);
932 }
那么在上面的 5317 行， maybe_handle_ref_bind 获取了转换的余下部分，并返回由 REF_BIND 所得引用的援引的类型。
5270 static tree
5271 maybe_handle_ref_bind (tree *ics) in call.c
5272 {
5273 if (TREE_CODE (*ics) == REF_BIND)
5274 {
5275 tree old_ics = *ics;
5276 tree type = TREE_TYPE (TREE_TYPE (old_ics));
5277 *ics = TREE_OPERAND (old_ics, 0);
5278 ICS_USER_FLAG (*ics) = ICS_USER_FLAG (old_ics);
5279 ICS_BAD_FLAG (*ics) = ICS_BAD_FLAG (old_ics);
5280 return type;
5281 }
5282
5283 return NULL_TREE;
5284 }
ICS_RANK 被定义为如下。前面我们看到 C++ 标准为标准转换定义了内部的等级，这个等级就保存在 ICS_STD_RANK 中，而标准转换之外的转换都只有唯一的等级。
352 #define ICS_RANK (NODE) / in call.c
353 (ICS_BAD_FLAG (NODE) ? BAD_RANK /
354 : ICS_ELLIPSIS_FLAG (NODE) ? ELLIPSIS_RANK /
355 : ICS_USER_FLAG (NODE) ? USER_RANK /
356 : ICS_STD_RANK (NODE))
如果我们可以来到这里， BAD_RANK 表示该转换不为标准所允许，但作为扩展还是 OK 的。
compare_ics (continue)
5335 if (rank1 > rank2)
5336 return -1;
5337 else if (rank1 < rank2)
5338 return 1;
5339
5340 if (rank1 == BAD_RANK)
5341 {
5342 /* XXX Isn't this an extension? */
5343 /* Both ICS are bad. We try to make a decision based on what
5344 would have happened if they'd been good. */
5345 if (ICS_USER_FLAG (ics1) > ICS_USER_FLAG (ics2)
5346 || ICS_STD_RANK (ics1) > ICS_STD_RANK (ics2))
5347 return -1;
5348 else if (ICS_USER_FLAG (ics1) < ICS_USER_FLAG (ics2)
5349 || ICS_STD_RANK (ics1) < ICS_STD_RANK (ics2))
5350 return 1;
5351
5352 /* We couldn't make up our minds; try to figure it out below. */
5353 }
5354
5355 if (ICS_ELLIPSIS_FLAG (ics1))
5356 /* Both conversions are ellipsis conversions. */
5357 return 0;
5358
5359 /* User-defined conversion sequence U1 is a better conversion sequence
5360 than another user-defined conversion sequence U2 if they contain the
5361 same user-defined conversion operator or constructor and if the sec-
5362 ond standard conversion sequence of U1 is better than the second
5363 standard conversion sequence of U2. */
5364
5365 if (ICS_USER_FLAG (ics1))
5366 {
5367 tree t1, t2;
5368
5369 for (t1 = ics1; TREE_CODE (t1) != USER_CONV; t1 = TREE_OPERAND (t1, 0))
5370 if (TREE_CODE (t1) == AMBIG_CONV)
5371 return 0;
5372 for (t2 = ics2; TREE_CODE (t2) != USER_CONV; t2 = TREE_OPERAND (t2, 0))
5373 if (TREE_CODE (t2) == AMBIG_CONV)
5374 return 0;
5375
5376 if (USER_CONV_FN (t1) != USER_CONV_FN (t2))
5377 return 0;
5378
5379 /* We can just fall through here, after setting up
5380 FROM_TYPE1 and FROM_TYPE2. */
5381 from_type1 = TREE_TYPE (t1);
5382 from_type2 = TREE_TYPE (t2);
5383 }
5384 else
5385 {
5386 /* We're dealing with two standard conversion sequences.
5387
5388 [over.ics.rank]
5389
5390 Standard conversion sequence S1 is a better conversion
5391 sequence than standard conversion sequence S2 if
5392
5393 --S1 is a proper subsequence of S2 (comparing the conversion
5394 sequences in the canonical form defined by _over.ics.scs_,
5395 excluding any Lvalue Transformation; the identity
5396 conversion sequence is considered to be a subsequence of
5397 any non-identity conversion sequence */
5398
5399 from_type1 = ics1;
5400 while (TREE_CODE (from_type1) != IDENTITY_CONV)
5401 from_type1 = TREE_OPERAND (from_type1, 0);
5402 from_type1 = TREE_TYPE (from_type1);
5403
5404 from_type2 = ics2;
5405 while (TREE_CODE (from_type2) != IDENTITY_CONV)
5406 from_type2 = TREE_OPERAND (from_type2, 0);
5407 from_type2 = TREE_TYPE (from_type2);
5408 }
上面在 5365 行，如果满足条件，表示该序列包含了用户定义转换，而在那一点上， ics1 与 ics2 具有相同的等级，因此它们要么同时包含用户定义转换，要么都不包含。在 5376 行的 USER_CONV_FN 保存了为这个 USER_CONV 所找出的转换函数。如果这两个候选的参数所使用的用户定义转换不相同，它们是包括区分的（等级上）。
而对于标准转换序列，【 3 】的条文 13.3.3 .1.1 ，条款 2 ，强调以规范的次序应用转换，依次为：左值转型（ Lvalue Transformation ），提升（ Promotion ）或转换（ Conversion ），限定调整（ Qualifier Adjustment ）；回到 standard_conversion ，看到它确实会产生这个序列，但次序相反。
compare_ics (continue)
5410 if (same_type_p (from_type1, from_type2))
5411 {
5412 if (is_subseq (ics1, ics2))
5413 return 1;
5414 if (is_subseq (ics2, ics1))
5415 return -1;
5416 }
进一步的，【 3 】的条文 13.3.3 .2 ，条款 3 （ 5386 行的注释），在等级评估过程中，左值转型应该被排除；在前端中，这对应着 LVALUE_CONV 及 RVALUE_CONV 。因此 is_subseq 根据标准，如果 ics1 是 ics2 的一个正确子序列，就返回 true 。
5177 static bool
5178 is_subseq (tree ics1, tree ics2) in call.c
5179 {
5180 /* We can assume that a conversion of the same code
5181 between the same types indicates a subsequence since we only get
5182 here if the types we are converting from are the same. */
5183
5184 while (TREE_CODE (ics1) == RVALUE_CONV
5185 || TREE_CODE (ics1) == LVALUE_CONV)
5186 ics1 = TREE_OPERAND (ics1, 0);
5187
5188 while (1)
5189 {
5190 while (TREE_CODE (ics2) == RVALUE_CONV
5191 || TREE_CODE (ics2) == LVALUE_CONV)
5192 ics2 = TREE_OPERAND (ics2, 0);
5193
5194 if (TREE_CODE (ics2) == USER_CONV
5195 || TREE_CODE (ics2) == AMBIG_CONV
5196 || TREE_CODE (ics2) == IDENTITY_CONV)
5197 /* At this point, ICS1 cannot be a proper subsequence of
5198 ICS2. We can get a USER_CONV when we are comparing the
5199 second standard conversion sequence of two user conversion
5200 sequences. */
5201 return false;
5202
5203 ics2 = TREE_OPERAND (ics2, 0);
5204
5205 if (TREE_CODE (ics2) == TREE_CODE (ics1)
5206 && same_type_p (TREE_TYPE (ics2), TREE_TYPE (ics1))
5207 && same_type_p (TREE_TYPE (TREE_OPERAND (ics2, 0)),
5208 TREE_TYPE (TREE_OPERAND (ics1, 0))))
5209 return true;
5210 }
5211 }
5012
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
