GCC-3.4.6源代码学习笔记（145）

5.13.

解析后阶段

5.13.1.

预备知识—转换的细节

5.13.1.1.

确定合适的转换

C++
是一个强类型语言。不过，在实践中，我们总是可以写出这样的代码：“
1 + 5.0f;
”，其中“
1
”
是整数类型，而“
5.0f
”是一个浮点类型。我们甚至可以写出更惊人的代码，像这样：“
a + b;
”，假定“
a
”及“
b
”都是某个类的实例。这是因为编译器将为我们产生执行必要、合适转换的代码。在这一节中，我们将看到编译器在背后使用的转换，及由语言标准所制定的转换规则。

我们首先从函数
can_convert_arg

开始，该函数用于测试两个指定的类型是否匹配。

5996

bool

5997

can_convert_arg

(tree to, tree from,
tree arg)
in
call.c

5998

{

5999

tree t = implicit_conversion
(to, from, arg, LOOKUP_NORMAL);

6000

return
(t
&& ! ICS_BAD_FLAG (t));

6001

}

由其名字所显示，由下面函数执行的转换，是编译器可以自由使用的，只要它觉得合适。
它是
C++
语言一个有趣及强大的特性；而且经常给程序员，甚至老鸟带来困惑。【
3
】，章节
13.3.3
.1
“隐含转换序列”详细解释了什么是隐式转换：

1. 一个隐式转换序列是，把一个函数调用中的一个实参转换到对应形参的类型的，转换序列。如条文 4 所定义，这个转换序列是一个隐式转换，这意味着它遵守对象初始化，及单个表达式引用（ reference by a single expression ）的规则（ 8.5 ， 8.5.3 ）。 2. 隐式转换序列只关心实参的类型， cv- 限定（ cv-qualification ），及左值性（ lvalueness ）；以及如何转换这些来匹配形参的对应属性。其他属性，例如实参的生命周期，存储类别，对齐，或访问性，及实参是否是一个位域（ bit-field ），都被忽略。因而，虽然对于一个指定的形参 - 实参对可以定义出一个隐式转换序列，在最后的分析中，该从实参到形参的转换仍可能被发现是错误的。 3. 一个良好的隐式转换序列是以下形式之一： — 一个标准转换序列（ 13.3.3 .1.1 ）， — 一个用户定义转换序列（ 13.3.3 .1.2 ），或者 — 一个省略（ ellipsis ）转换序列（ 13.3.3 .1.3 ）。 4. 不过，当考虑由 13.3.1 .3 选定的用于一个类拷贝初始化第二步中临时对象拷贝，或由 13.3.1.4 ， 13.3.1.5 ，或 13.3.1.6 中所有情况下选定的，一个用户定义转换函数的实参时，只允许标准转换序列及省略转换序列。 5. 在形参类型是一个引用的情况下，参见 13.3.3 .1.4. （引用绑定 reference binding ） 6. 当形参类型不是一个引用时，隐式转换序列从实参表达式塑造出形参的一个拷贝初始化。该隐式转换序列被要求把实参表达式转换到形参类型的一个右值。 [ 注意：当该形参是一个类类型，这是一个以条文 13 为目的的概念上的转换（ this is a conceptual conversion defined for the purposes of clause 13 ）；事实上的初始化依据构造函数来定义，而不是一个转换 ] 。任何最上层的 cv- 限定上的差异，被初始化本身所包括，不会构成一个转换。 [ 例如：一个具有类型 A 的形参可以被一个具有类型 const A 的实参初始化。这个情形下的隐式转换序列是恒等序列（ the identity sequence ）；从 const A 到 A ，不包含“转换” ] 。当形参具有一个类类型，并且实参表达式具有相同的类型，该隐式转换序列是一个恒等转换（ identity conversion ）。当形参具有一个类类型，而实参表达式具有一个派生类类型，隐式转换序列是一个派生类到基类的 derived-to-base 转换。 [ 注意：没有这样的标准转换；这个 derived-to-base 转换仅存在于隐式转换序列的描述中 ] 。一个 derived-to-base 转换具有转换等级（ Conversion rank ）（ 13.3.3 .1.1 ）。 7. 在所有的上下文中，当转换到隐含对象形参，或转换到一个赋值操作的左侧操作数时， 仅允许不构建用于结果的临时对象的标准转换序列。 8. 如果匹配一个实参到一个形参类型不要求转换，这个隐式转换序列是包含恒等转换的标准转换序列（ 13.3.3 .1.1 ）。 9. 如果不能找到一个转换序列来转换一个实参到形参的类型，或者该转换是错误的，则不能形成隐式转换序列。 10. 如果存在多个不同的转换序列把实参转换到形参的类型，与该形参关联的隐式转换序列被定义为显示出二义性转换序列的唯一的转换序列（ the unique conversion sequence designated the ambiguous conversion sequence ）。出于以 13.3.3 .2 中所描述的隐式转换排名的目的，二义性转换序列被作为用户定义序列来处理，即与其他用户定义转换序列无法区分（二义性转换序列被安排做与用户定义转换序列等级相同，是因为对于一个实参，仅当涉及不同的用户定义转换时，才可能存在多个转换序列。二义性转换序列与其他用户转换序列不可区分，在于它至少代表了 2 个用户定义转换序列，每个具有不同的用户定义转换，而其他用户定义转换序列必然与其中至少一个不能区分。 这个规则防止一个函数因为其某个形参的二义性转换序列，而成为不可行。考虑这个例子， class B; class A { A (B&); }; class B { operator A (); }; class C { C (B&); }; void f(A) { } void f(C) { } B b; f(b); // 二义性的，因为 b -> C 通过构造函数，而 // b -> A 通过构造函数或转换函数 如果没有这个规则，对于调用 f(b) ， f(A) 将被取消作为可行函数，从而导致重载解析选择 f(C) 作为实际的调用，尽管显然地，它不是最佳选择。另一方面，如果声明了一个 f(B) ，那么 f(b) 将被解析为 f(B) ，因为与 f(B) 的完全匹配优于匹配 f(A) 所要求的序列。 如果一个使用二义性转换序列的函数被选择为最佳可行函数，该调用将是错误的，因为该调用中某个实参的转换是有二义性的。 11. 上面提及的隐式转换序列的 3 种形式定义在以下子条文中。

在深入代码之前，我们首先要阐明左值（
lvalue
）及右值（
rvalue
）的概念。一个左值是指一个对象或函数。它必须是一个可取值的实体。即如果它是指对象的话，该对象应该能够被放在一个赋值操作的左手侧（这也是为什么它被称为左值）。而非左值的就被称为右值（它们不能用在赋值操作的左手侧）。

1097

static
tree

1098

implicit_conversion

(tree to, tree from, tree expr, int flags)
in call.c

1099

{

1100

tree conv;

1101

1102

if (from == error_mark_node
|| to == error_mark_node

1103

|| expr ==
error_mark_node)

1104

return
NULL_TREE;

1105

1106

if (TREE_CODE (to) ==
REFERENCE_TYPE)

1107

conv = reference_binding
(to, from, expr, flags);

1108

else

1109

conv = standard_conversion
(to, from, expr, flags);

1110

1111

if (conv)

1112

return
conv;

1113

1114

if (expr != NULL_TREE

1115

&& (IS_AGGR_TYPE
(from)

1116

|| IS_AGGR_TYPE
(to))

1117

&& (flags &
LOOKUP_NO_CONVERSION) == 0)

1118

{

1119

struct
z_candidate
*cand;

1120

1121

cand = build_user_type_conversion_1

1122

(to, expr,
LOOKUP_ONLYCONVERTING);

1123

if (cand)

1124

conv =
cand->second_conv;

1125

1126

/*
We used to try to bind a reference to a temporary here, but that

1127

now
handled by the recursive call to this function at the end

1128

of
reference_binding.
*/

1129

return
conv;

1130

}

1131

1132

return
NULL_TREE;

1133

}

看到转换处理函数可能会相互递归，在这里，为了处理引用类型，该函数再一次调用了
reference_binding

。不过，因为我们正在表达式的树中前进，只要没有回环的依赖，就不会有无限递归。因为
C++
是要求使用前必须声明的语言，相互依赖是非法的；解析器应该能够找出这个非法的形式。

5.13.1.1.1.

标准转换序列

【
3
】章节
13.3.3
.1.1
“标准转换序列”给出关于序列的细节。

1. 表 9 总结了在条文 4 中定义的转换（ “标准转换”，【 3 】的章节 4 ）并划分为 4 个不相交的类别：左值转型（ Lvalue Transformation ），限定调整（ Qualification Adjustment ），提升（ Promotion ），以及转换（ Conversion ）。 [ 注意：这些分类就左值性， cv- 限定性，及数据表达方面而言，是正交的：左值转型不会改变类型的 cv- 限定性及数据表达；限定调整不会改变类型的左值性及数据表达；而提升及转换不会改变类型的左值性及 cv- 限定性。 ] 2. [ 注意： 如条文 4 所描述，应该标准转换序列要么本身是恒等转换（即，没有转换），要么包含其他属于这 4 个类别的 1 到 3 个转换（ consists of one to three conversions from the other four categories ）。在单个标准转换序列中，每个类别最多允许一个转换。如果在该序列中有 2 个或以上的转换，这些转换以规范的次序应用：左值转型 ，提升 或转换 ，限定调整 。 —end note ] 3. 在表 9 中的每个转换都具有关联的等级（精确匹配，提升，或转换）。这些都用于评价标准转换序列（ 13.3.3 .2 ）。一个转换序列的等级通过考察序列中的每个转换的等级，及任意引用绑定的等级（ rank of any reference binding ）（ 13.3.3.1.4 ）来决定。如果任意一个具有转换等级，该序列就是转换等级；否则，如果任意一个具有提升等级，该序列就是提升等级；否则，该序列就是精确匹配等级。 表 9 ： - 转换 转换 类别 等级 子条文 不要求转换 恒等 精确匹配 左值到右值转换 左值转型 4.1 数组到指针转换 4.2 函数到指针转换 4.3 限定转换 限定调整 4.4 整型提升 提升 提升 4.5 浮点型提升 4.6 整型转换 转换 转换 4.7 浮点型转换 4.8 浮点型到整型转换 4.9 指针转换 4.10 指针到成员转换 4.11 布尔型转换 4.12

下面我们跳过
472~479
行对重载的解析（在后面有关引用绑定的章节再来看它，记得
type_unknown_p

返回
true
，如果
expr

是一个重载）。还要记住下面的
standard_conversion

处理隐式转换，它只考虑上面提到的转换；千万不要把它与强制转换混淆。

456

static
tree

457

standard_conversion

(tree to, tree from,
tree expr, int flags)
in
call.c

458

{

459

enum
tree_code fcode, tcode;

460

tree conv;

461

bool fromref = false;

462

463

to = v (to);

464

if (TREE_CODE (from) == REFERENCE_TYPE)

465

{

466

fromref = true;

467

from = TREE_TYPE (from);

468

}

469

to = strip_top_quals (to);

470

from = strip_top_quals (from);

471

472

if ((TYPE_PTRFN_P (to) || TYPE_PTRMEMFUNC_P
(to))

473

&& expr && type_unknown_p
(expr))

474

{

475

expr = instantiate_type (to, expr,
tf_conv);

476

if (expr == error_mark_node)

477

return
NULL_TREE;

478

from = TREE_TYPE (expr);

479

}

480

481

fcode = TREE_CODE (from);

482

tcode = TREE_CODE (to);

483

484

conv = build1
(IDENTITY_CONV, from, expr);

485

486

if (fcode == FUNCTION_TYPE)

487

{

488

from = build_pointer_type
(from);

489

fcode = TREE_CODE (from);

490

conv = build_conv
(LVALUE_CONV, from, conv);

491

}

492

else if (fcode == ARRAY_TYPE)

493

{

494

from = build_pointer_type
(TREE_TYPE (from));

495

fcode = TREE_CODE (from);

496

conv = build_conv
(LVALUE_CONV, from, conv);

497

}

498

else if (fromref || (expr
&& lvalue_p
(expr)))

499

conv = build_conv
(RVALUE_CONV, from, conv);

500

501

/* Allow conversion
between `__complex__' data types.
*/

502

if (tcode == COMPLEX_TYPE && fcode ==
COMPLEX_TYPE)

503

{

504

/* The standard
conversion sequence to convert FROM to TO is

505

the standard
conversion sequence to perform componentwise

506

conversion.
*/

507

tree part_conv = standard_conversion

508

(TREE_TYPE (to), TREE_TYPE (from),
NULL_TREE, flags);

509

510

if (part_conv)

511

{

512

conv = build_conv
(TREE_CODE (part_conv), to, conv);

513

ICS_STD_RANK (conv) = ICS_STD_RANK
(part_conv);

514

}

515

else

516

conv = NULL_TREE;

517

518

return
conv;

519

}

520

521

if (same_type_p (from, to))

522

return
conv;

484
行为恒等转换构建了
IDENTITY_COV
。
*_CONV
节点的
type
表示转换的源类型，而它的第一个操作数是需要转换的表达式。因此转换序列将是一个大的嵌套的
*_CONV
节点，最上层的
*_CONV
是最后执行的，而最里层的是首先执行且永远是
IDENTITY_CONV
。

在前端的内部为转换定义了如下的等级，而不是如上面表
9
所定义的那些。注意到值越小表示等级越优先。

343

#define
IDENTITY_RANK
0
in
call.c

344

#define
EXACT_RANK
1

345

#define
PROMO_RANK
2

346

#define
STD_RANK
3

347

#define
PBOOL_RANK
4

348

#define
USER_RANK
5

349

#define
ELLIPSIS_RANK
6

350

#define
BAD_RANK
7

在内部可以产生的转换有：
IDENTITY_CONV
，
LVALUE_CONV
，
QUAL_CONV
，
STD_CONV
，
PTR_CONV
，
PMEM_CONV
，
BASE_CONV
，
REF_BIND
，
USER_CONV
，
AMBIG_CONV
，及
RVALUE_CONV
。

408

static
tree

409

build_conv

(enum
tree_code code, tree type, tree from)
in
call.c

410

{

411

tree t;

412

int rank = ICS_STD_RANK (from);

413

414

/* We can't use
buildl1 here because CODE could be USER_CONV, which

415

takes two
arguments. In that case, the caller is responsible for

416

filling in the
second argument.

*/

417

t
=
make_node

(code);

418

TREE_TYPE (t) = type;

419

TREE_OPERAND (t, 0) = from;

420

421

switch
(code)

422

{

423

case
PTR_CONV:

424

case
PMEM_CONV:

425

case
BASE_CONV:

426

case
STD_CONV:

427

if
(rank < STD_RANK)

428

rank = STD_RANK;

429

break
;

430

431

case
QUAL_CONV:

432

if (rank < EXACT_RANK)

433

rank = EXACT_RANK;

434

435

default
:

436

break
;

437

}

438

ICS_STD_RANK (t) = rank;

439

ICS_USER_FLAG (t) = (code == USER_CONV || ICS_USER_FLAG (from));

440

ICS_BAD_FLAG (t) = ICS_BAD_FLAG (from);

441

return
t;

442

}

在上面的函数里，
ICS_STD_RANK
将保存所见到的最大的等级值，在后面的章节我们将看到它的使用。

而在上面
standard_conversion

的
486
及
492
行处理函数到指针与数组到指针的转换，它们在【
3
】条文
4.2
“数组到指针转换”及条文
4.3
“函数到指针转换”中描述如下：

1. 具有类型“ array ofN T ”或“ array of unknown bound of T ”的一个左值或右值可以被转换到一个类型为“ pointer to T ”的右值。其结果是指向数组第一个元素的指针。 2. 一个非宽字符的字符串（ 2.13.4 ）可以被转换到一个类型为“ pointer to char ”的右值；一个宽字符的字符串可以被转换到一个类型为“ pointer to wchar_t ”的右值。在这两种情况中，其结果是指向数组第一个元素的指针。仅当目标类型是一个明确恰当的指针时，才考虑该转换；而当仅是一般的从左值到右值的转换时，不考虑该转换。 [ 注意：不推荐使用这个转换。参见附录 D 。 ] 出于在重载解析（ 13.3.3.1.1 ）中评估的目的，这个转换被视为一个跟有一个限定转换（ 4.4 ）的数组到指针的转换。 [ 例如：作为一个数组到指针转换， "abc" 被转换到“ pointer to const char ”；然后作为一个限定转换，转换到“ pointer to char ”。 ]

1. 函数类型 T 的一个左值可以被转换到类型“ pointer to T ”的一个右值。其结果是指向该函数的指针。（这个转换不能应用于非静态成员函数，因为一个非静态成员函数的左值是无法得到的。） 2. [ 注意：参见 13.4 ，用于重载函数的补充规则。 ]

注意两个条文的条款
1
，类型“
pointer to
T
”的右值表示该指针本身是不能修改的，但其内容可以改变。例如：

char a[10];

char *p = …;

a = p;
// a is
converted to rvalue of char*, assignment not allowed

*(a+1) = *p;
// object pointed
by a+1 is lvalue, it is OK

与下面的条文相比，这
2
个条文包含了指针类型的构建，前端必须能从其他左值转型中区分出这两种情况。因此前端为它们使用了
LVALUE_CONV
。

然后在
standard_conversion

中，如果满足在
498
行条件，需要实现【
3
】条文
4.1
“左值到右值转换”的条款
1
。这一次前端使用
RVALUE_CONV
。
LVALUE_CONV
与
RVALUE_CONV
的一个区别在于当构建
LVALUE_CONV
时，我们已经知道这个右值了（在
488
及
494
行构建的指针类型），而对于
RVALUE_CONV
，在这一点上，这个右值是未知的，在后面前端需要调用
decay_conversion

来执行真正的转换。

1. 一个非函数，非数组类型的左值（ 3.10 ）可以被转换到一个右值。如果 T 是一个未完成的类型，必须这个转换的程序就是错误的。如果该左值引用的对象不是一个类型 T 或从 T 派生类型的对象，或者该对象未初始化，必须这个转换的程序具有不确定的行为。如果 T 是非类类型，该右值的类型是 T 的非 cv 限定的版本。否则，该右值的类型是 T 。 [ 在 C++ 类中，右值可以具有 cv- 限定的类型（因为它们都是对象）。这不同于 ISO C ，在 ISO C 里，非左值不能是 cv- 限定的类型。 ] 2. 由左值表示的对象的值是右值的结果（ The value contained in the object indicated by the lvalue is the rvalue result ）。当在 sizeof （ 5.3.3 ）的操作数中发生一个左值到右值的转换，包含在被引用对象中的值是不可访问的，因为这个操作符不会对其操作数求值。

下面的函数，给定表达式
ref

，它可以判断这个表达式是否为左值。看到上面为指针类型构建的
LVALUE_CONV
，该函数判定为右值。这个函数应该被仔细研究。

211

int

212

lvalue_p

(tree ref)
in
tree.c

213

{

214

return

215

(lvalue_p_1
(ref,
/*class rvalue ok*/
1) != clk_none);

216

}

而我们要区分的左值的类型如下。

2964

typedef
enum
cp_lvalue_kind {
in
cp-tree.h

2965

clk_none = 0,
/* Things that
are not an lvalue.
*/

2966

clk_ordinary = 1, /* An ordinary lvalue.

*/

2967

clk_class = 2,
/* An rvalue of
class-type.
*/

2968

clk_bitfield = 4, /* An lvalue for a bit-field.
*/

2969

clk_packed = 8
/* An lvalue for
a packed field.
*/

2970

} cp_lvalue_kind
;

在【
3
】，条文
3.10
（左值及右值）给出如下解释。

1. 任一表达式要么是左值，要么是右值。 2. 左值指一个对象或函数。一些右值表达式——它们具有类或 cv- 限定的类类型——也指向对象（调用构造函数或返回一个引用对象的类类型的函数的表达式，而且在这样的对象上可以调用成员函数，但这些表达式不是左值）。 3. [ 注意：某些内建操作符及函数调用会产生左值。 [ 例如：如果 E 是一个指针类型的表达式，那么 *E 是一个左值的表达式，引用 E 所指向的对象或函数。另一个例子，函数 int& f(); 产生一个左值，因此调用 f() 是一个左值表达式。 ]] 4. [ 注意：某些内建操作符期望左值的操作数。 [ 例如：内建的赋值操作符都期望其左侧操作数是左值 ] 。其他内建操作符产生右值，而一些则期望右值。 [ 例如：一元及二元操作符 + 期望右值的参数，并产生右值的结果 ] 。在条文 5 对每个内建操作符的讨论说明了它是否期望左值操作数，及它是否产生左值结果 ] 。 5. 调用一个不返回引用的函数的结果是一个右值。用户定义操作符是函数，这些操作符是否期望或产生左值，由其参数及返回类型决定。 6. 保存一个由到非引用类型的转换（ cast ）引致的临时对象的表达式是一个右值（这包括使用函数记号（即，显式类型转换， 5.2.3 ）所显式创建的对象。 7. 在任何时候，一个左值出现在一个期望右值的上下文中，该左值被转换为一个右值；参见 4.1 ， 4.2 ，及 4.3 。 8. 在 8.5.3 对引用初始化，及在 12.2 对临时对象的讨论，显示了在其他重要的上下文中左值及右值的行为。 9. 类右值可以有 cv- 限定的类型；非类右值总是非 cv- 限定的类型。右值应该总是具有完成的类型或 void 类型；除了这些类型。左值还可以具有未完成的类型。 10. 为了修改一个对象，该对象的一个左值是必要的；除了类类型的右值，在特定的环境下，可以用于修改其所指对象。 [ 例如：对一个对象调用成员函数（ 9.3 ）可以修改这个对象。 ] 11. 函数不可修改，但函数的指针是可修改的。 12. 一个未完成类型的指针是可修改的。在程序中的某一点，当所指向的类型完成，该指针所指向的对象亦可修改。 13. 一个 const- 限定的表达式的指称对象不应该被修改（通过这个表达式），除非它具有类类型，并且有一个可变（ mutable ）成分，该成分可以被修改（ 7.1.5.1 ）。 14. 如果一个表达式可以被用于修改它所引用的对象，该表达式被称为可修改。一个尝试通过一个不可修改的左值或右值表达式来修改对象的程序是不合法的。 15. 如果一个程序尝试，通过以下类型以外的一个左值，来访问一个对象的存储值，其行为是未不可预测的（这个列表的意图是指出那些一个对象可能或不可能被别名（ alias ）的环境： — 该对象的动态类型（ dynamic type ）， — 该对象的动态类型的一个 cv- 限定的版本， — 该对象的动态类型所对应的有符号或无符号类型， — 该对象的动态类型的一个 cv- 限定版本所对应的有符号或无符号类型， — 一个聚合或 union 类型，在其成员中包含上述类型之一（包括，递归地，一个子聚合或被包含的（ contained ） union 的一个成员）， — 该对象的动态类型的基类类型（可能有 cv- 限定）， — 字符或无符号字符类型。

考虑下面对非静态方法的处理，因为非静态方法必须这样调用：“
a.fa();
”，其中给定的对象可能是不可取址的（例如，在语句“
A().fa();
”中，“
A()
”返回了一个右值），非静态方法被认为是右值。另外，表达式“
A().fa();
”可以修改这个对象，因此如果不要求严格的左值（参数
treat_class_rvalues_as_lvalues

为
1
），“
A()
”可被视为左值。注意
156
行的
TARGET_EXPR
，它将封装刚才提及的“
A()
”返回的临时对象（注意
161
行的注释）。

62

static
cp_lvalue_kind

63

lvalue_p_1

(tree ref,
in
tree.c

64

int treat_class_rvalues_as_lvalues)

65

{

66

cp_lvalue_kind op1_lvalue_kind = clk_none;

67

cp_lvalue_kind op2_lvalue_kind = clk_none;

68

69

if (TREE_CODE (TREE_TYPE (ref)) ==
REFERENCE_TYPE)

70

return
clk_ordinary;

71

72

if (ref == current_class_ptr

)

73

return
clk_none;

74

75

switch
(TREE_CODE (ref))

76

{

77

/* preincrements and predecrements are valid
lvals, provided

78

what they refer
to are valid lvals.
*/

79

case
PREINCREMENT_EXPR:

80

case
PREDECREMENT_EXPR:

81

case
SAVE_EXPR:

82

case
UNSAVE_EXPR:

83

case
TRY_CATCH_EXPR:

84

case
WITH_CLEANUP_EXPR:

85

case
REALPART_EXPR:

86

case
IMAGPART_EXPR:

87

return
lvalue_p_1 (TREE_OPERAND (ref, 0),

88

treat_class_rvalues_as_lvalues);

89

90

case
COMPONENT_REF:

91

op1_lvalue_kind = lvalue_p_1
(TREE_OPERAND (ref, 0),

92

treat_class_rvalues_as_lvalues);

93

/* In an
expression of the form "X.Y", the packed-ness of the

94

expression
does not depend on "X".
*/

95

op1_lvalue_kind &= ~clk_packed;

96

/* Look at the member designator.
*/

97

if (!op1_lvalue_kind

98

/* The
"field" can be a FUNCTION_DECL or an OVERLOAD in some

99

situations.
*/

100

|| TREE_CODE (TREE_OPERAND (ref, 1))
!= FIELD_DECL)

101

;

102

else if (DECL_C_BIT_FIELD (TREE_OPERAND
(ref, 1)))

103

{

104

/* Clear the
ordinary bit. If this object was a class

105

rvalue we
want to preserve that information.
*/

106

op1_lvalue_kind &= ~clk_ordinary;

107

/* The lvalue
is for a bitfield.
*/

108

op1_lvalue_kind |= clk_bitfield;

109

}

110

else if (DECL_PACKED (TREE_OPERAND (ref,
1)))

111

op1_lvalue_kind |= clk_packed;

112

113

return
op1_lvalue_kind;

114

115

case
STRING_CST:

116

return
clk_ordinary;

117

118

case
VAR_DECL:

119

if (TREE_READONLY (ref) && !
TREE_STATIC (ref)

120

&& DECL_LANG_SPECIFIC (ref)

121

&& DECL_IN_AGGR_P (ref))

122

return
clk_none;

123

case
INDIRECT_REF:

124

case
ARRAY_REF:

125

case
PARM_DECL:

126

case
RESULT_DECL:

127

if (TREE_CODE (TREE_TYPE (ref)) !=
METHOD_TYPE)

128

return
clk_ordinary;

129

break
;

130

131

/* A currently unresolved scope ref.
*/

132

case
SCOPE_REF:

133

abort ();

134

case
MAX_EXPR:

135

case
MIN_EXPR:

136

op1_lvalue_kind = lvalue_p_1
(TREE_OPERAND (ref, 0),

137

treat_class_rvalues_as_lvalues);

138

op2_lvalue_kind = lvalue_p_1
(TREE_OPERAND (ref, 1),

139

treat_class_rvalues_as_lvalues);

140

break
;

141

142

case
COND_EXPR:

143

op1_lvalue_kind = lvalue_p_1
(TREE_OPERAND (ref, 1),

144

treat_class_rvalues_as_lvalues);

145

op2_lvalue_kind = lvalue_p_1 (TREE_OPERAND
(ref, 2),

146

treat_class_rvalues_as_lvalues);

147

break
;

148

149

case
MODIFY_EXPR:

150

return
clk_ordinary;

151

152

case
COMPOUND_EXPR:

153

return
lvalue_p_1 (TREE_OPERAND (ref, 1),

154

treat_class_rvalues_as_lvalues);

155

156

case
TARGET_EXPR:

157

return
treat_class_rvalues_as_lvalues ? clk_class : clk_none;

158

159

case
CALL_EXPR:

160

case
VA_ARG_EXPR:

161

/* Any
class-valued call would be wrapped in a TARGET_EXPR.
*/

162

return
clk_none;

163

164

case
FUNCTION_DECL:

165

/* All
functions (except non-static-member functions) are

166

lvalues.
*/

167

return
(DECL_NONSTATIC_MEMBER_FUNCTION_P (ref)

168

? clk_none : clk_ordinary);

169

170

case
NON_DEPENDENT_EXPR:

171

/* We must
consider NON_DEPENDENT_EXPRs to be lvalues so that

172

things like
"&E" where "E" is an expression with a

173

non-dependent
type work. It is safe to be lenient because an

174

error will be
issued when the template is instantiated if "E"

175

is not an
lvalue.
*/

176

return
clk_ordinary;

177

178

default
:

179

break
;

180

}

181

182

/* If one operand is
not an lvalue at all, then this expression is

183

not an
lvalue.
*/

184

if (!op1_lvalue_kind || !op2_lvalue_kind)

185

return
clk_none;

186

187

/* Otherwise, it's
an lvalue, and it has all the odd properties

188

contributed by
either operand.
*/

189

op1_lvalue_kind = op1_lvalue_kind |
op2_lvalue_kind;

190

/* It's not an
ordinary lvalue if it involves either a bit-field or

191

a class
rvalue.
*/

192

if ((op1_lvalue_kind & ~clk_ordinary) !=
clk_none)

193

op1_lvalue_kind &= ~clk_ordinary;

194

return
op1_lvalue_kind;

195

}

上面的
NON_DEPENDENT_EXPR
是用于非类型依赖，但出现在模板中的表达式的占位符。看到

INDIRECT_REF
是左值（不过指针本身是右值，它是上面条款
3
所描述的情况）；而普通的变量也是左值（
118
行）；另外如果数组被引用，其引用是左值，否则该数组将被衰退为右值的指针类型。接着注意
149
行的
MODIFY_EXPR
，它毫无疑问是左值，而随后的
COMPOUND_EXPR
依赖于其第二个操作数。而对于可能包含左值操作数的表达式，
lvalue_p_1

递归入操作数。

值得注意的是，“
int& f();
”的调用表达式“
f();
”是一个左值，但是像“
f() = 5;
”这样的表达式是非法的；这个左值可以被直接使用的情况是把“
f()
”用作参数，
125
行的
PARM_DECL
覆盖了这个用法；因此不在
PARM_DECL
里的
CALL_EXPR
被视为右值。另外，
PARM_DECL
，
RESULT_DECL
，
ARRAY_REF
，
INDIRECT_REF
作为左值，其类型不能是类的非静态方法。

standard_conversion (continue)

524

if ((tcode == POINTER_TYPE ||
TYPE_PTR_TO_MEMBER_P (to))

525

&& expr && null_ptr_cst_p
(expr))

526

conv = build_conv
(STD_CONV, to, conv);

527

else if (tcode == POINTER_TYPE &&
fcode == POINTER_TYPE

528

&& TREE_CODE (TREE_TYPE (to))
== VECTOR_TYPE

529

&& TREE_CODE (TREE_TYPE (from))
== VECTOR_TYPE

530

&& ((*targetm

.vector_opaque_p) (TREE_TYPE
(to))

531

|| (*targetm

.vector_opaque_p)
(TREE_TYPE (from))))

532

conv = build_conv
(STD_CONV, to, conv);

533

else
if ((tcode == INTEGER_TYPE && fcode == POINTER_TYPE)

534

|| (tcode == POINTER_TYPE && fcode == INTEGER_TYPE))

535

{

536

/* For backwards
brain damage compatibility, allow interconversion of

537

pointers and
integers with a pedwarn.
*/

538

conv = build_conv
(STD_CONV, to, conv);

539

ICS_BAD_FLAG (conv) = 1;

540

}

541

else if (tcode == ENUMERAL_TYPE &&
fcode == INTEGER_TYPE)

542

{

543

/* For backwards
brain damage compatibility, allow interconversion of

544

enums and
integers with a pedwarn.
*/

545

conv = build_conv
(STD_CONV, to, conv);

546

ICS_BAD_FLAG (conv) = 1;

547

}

注意上面，指针与整数及整数与枚举值之间的转换，在
C++
的语言环境中，都是不良转换（不过在
C
下，仅会给出警告）。因此这些转换会被记录，并给予最低的等级。

standard_conversion (continue)

548

else if ((tcode == POINTER_TYPE &&
fcode == POINTER_TYPE)

549

|| (TYPE_PTRMEM_P (to) &&
TYPE_PTRMEM_P (from)))

550

{

551

tree to_pointee;

552

tree from_pointee;

553

554

if (tcode == POINTER_TYPE

555

&&
same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (from),

556

TREE_TYPE (to)))

557

;

558

else if (VOID_TYPE_P (TREE_TYPE (to))

559

&& !TYPE_PTRMEM_P (from)

560

&& TREE_CODE (TREE_TYPE
(from)) != FUNCTION_TYPE)

561

{

562

from = build_pointer_type

563

(cp_build_qualified_type
(void_type_node,

564

cp_type_quals (TREE_TYPE (from))));

565

conv = build_conv
(PTR_CONV, from, conv);

566

}

567

else if (TYPE_PTRMEM_P (from))

568

{

569

tree fbase = TYPE_PTRMEM_CLASS_TYPE
(from);

570

tree tbase = TYPE_PTRMEM_CLASS_TYPE (to);

571

572

if (DERIVED_FROM_P (fbase, tbase)

573

&&
(same_type_ignoring_top_level_qualifiers_p

574

(TYPE_PTRMEM_POINTED_TO_TYPE (from),

575

TYPE_PTRMEM_POINTED_TO_TYPE
(to))))

576

{

577

from = build_ptrmem_type (tbase,

578

TYPE_PTRMEM_POINTED_TO_TYPE (from));

579

conv = build_conv
(PMEM_CONV, from, conv);

580

}

581

else if (!same_type_p (fbase, tbase))

582

return
NULL;

583

}

584

else if (IS_AGGR_TYPE (TREE_TYPE (from))

585

&& IS_AGGR_TYPE (TREE_TYPE
(to))

586

/* [conv.ptr]

587

588

An rvalue of
type "pointer to cv D," where D is a

589

class type,
can be converted to an rvalue of type

590

"pointer
to cv B," where B is a base class (clause

591

_class.derived_) of D. If B is an inaccessible

592

(clause
_class.access_) or ambiguous

593

(_class.member.lookup_) base class of D, a program

594

that
necessitates this conversion is ill-formed.

*/

595

/* Therefore,
we use DERIVED_FROM_P, and not

596

ACESSIBLY_UNIQUELY_DERIVED_FROM_P,
in this test.
*/

597

&& DERIVED_FROM_P (TREE_TYPE
(to), TREE_TYPE (from)))

598

{

599

from =

600

cp_build_qualified_type (TREE_TYPE
(to),

601

cp_type_quals
(TREE_TYPE (from)));

602

from = build_pointer_type
(from);

603

conv = build_conv
(PTR_CONV, from, conv);

604

}

605

606

if (tcode == POINTER_TYPE)

607

{

608

to_pointee = TREE_TYPE (to);

609

from_pointee = TREE_TYPE (from);

610

}

611

else

612

{

613

to_pointee = TYPE_PTRMEM_POINTED_TO_TYPE
(to);

614

from_pointee =
TYPE_PTRMEM_POINTED_TO_TYPE (from);

615

}

616

617

if (same_type_p (from, to))

618

/* OK */
;

619

else if (comp_ptr_ttypes (to_pointee,
from_pointee))

620

conv = build_conv
(QUAL_CONV, to, conv);

621

else if (expr && string_conv_p (to,
expr, 0))

622

/* converting
from string constant to char *.
*/

623

conv = build_conv
(QUAL_CONV, to, conv);

624

else if (ptr_reasonably_similar
(to_pointee, from_pointee))

625

{

626

conv = build_conv
(PTR_CONV, to, conv);

627

ICS_BAD_FLAG (conv) = 1;

628

}

629

else

630

return
0;

631

632

from = to;

633

}

同样在【
3
】条文
4.10
“指针转换”中，有以下段落。并注意到在函数的
499
行把左值转换为右值，上面的
conv

保存了这个转换。

1. 一个空指针常量是一个整型常量表达式（ 5.19 ）的右值，它被评估为整形值 0 。一个空指针常量可以被转换到一个指针类型；其结果是这个类型的空指针值，并且可以与其它指向对象或指向函数的指针值区分开来。 2 个相同类型的空指针值应该是相等的。一个空指针常量到 cv- 限定类型指针的转换是单个转换，而不是一个包含指针转换再加上限定转换（ 4.4 ）的转换序列。 2. 类型“ pointer to cv T ”，其中 T 是一个对象类型，的一个右值，可以被转换到类型“ pointer to cv void ”的一个右值。其结果指向类型 T 的对象所在内存位置的开头，仿佛该对象是类型 T 作为最后派生类的对象（ most derived object (1.8) of type T ）（即，不是作为基类子对象）。 3. 类型“ pointer to cv D ”，其中 D 是一个类类型，的一个右值，可以被转换到类型“ pointer to cv B ”，其中 B 是 D 的一个基类（条文 10 ），的一个右值。如果 B 是 D 的一个不可访问（条文 11 ）或有二义性（ 10.2 ）的基类，必须这个转换的程序是非法的。转换的结果是指向派生类对象的基类子对象的指针。空指针值被转换为目标类型的空指针值。

条款
1
由上面
526
行代码实现。它是单个
STD_CONV
。而条款
2
的条件由
558 ~ 560
行的代码来测试。
584 ~ 597
行的条件则实现条款
3
。

条文
4.11
“成员指针的转换”显示如下。

1. 一个空指针常量（ 4.10 ）可以被转换到成员指针；其结果是这个类型的空成员指针值，它与其它从非空指针常量构建的成员指针区分开来。两个相同类型的空成员指针应该是相等的。从一个空指针常量到具有 cv- 限定类型的成员指针的转换是单个转换，而不是包含成员指针转换，及限定转换（ 4.4 ）的转换序列。 2. 类型“ pointer to member of B of type cv T ”，其中 B 是一个类类型，的一个右值，可以被转换到类型“ pointer to member of D of type cv T ”，其中 D 是 B 的派生类（条文 10 ），的一个右值。如果 B 是 D 的一个不可访问（条文 11 ），或有二义性（ 10.2 ）或虚拟（ 10.1 ）的基类，必须这个转换的程序是非法的。转换的结果指向相同的成员，就像转换发生前的成员指针，不过它指向基类的成员，就好像它是派生类的一个成员。该结果指向 D 实例中 B 的成员。因为结果具有类型“ pointer to member of D of type cv T ”，它可以通过一个 D 对象解引用（ dereference ）。其结果相当于 B 的成员指针被 D 中 B 的子对象解引用。空成员指针值被转换到目标类型的空成员指针值。 [ 成员指针转换的规则（从基类成员指针到派生类成员指针）看起来与指向对象指针的规则相反（从派生类指针到基类指针）（ 4.10 ，条文 10 ）。为了确保类型安全，这个转换是必要的。注意到一个成员指针不是一个对象指针或函数指针，并且这些指针的转换规则不适用于成员指针。特别的，一个成员指针不能被转换到一个 void* 。 ]

同样条款
1
被上面
526
行的代码所覆盖。而条款
2
由
567
行的代码块所处理。来到
617
行，经过上面的转换序列，现在
from

及
to

应该或者是相同的类型，或者仅是
cv-
限定符的不同；否则，意味着没有可用的转换。

下面方法指针之间的转换类似于成员指针之间的转换。注意到
fromfn

及
tofn

分别是所指向的函数；
fbase

及
tbase

是各自的隐含的
this

指针。因此能执行的转换是：类型“
pointer to method of
B of type cv T
”，其中
B
是一个类类型，的一个右值，可用被转换到类型“
pointer to the
same
method of D of type cv T
”，其中
D
是
B
的一个派生类，的一个右值。并且看到在这里“相同”的含义要比重载中更严格些。

standard_conversion (continue)

634

else if (TYPE_PTRMEMFUNC_P (to) &&
TYPE_PTRMEMFUNC_P (from))

635

{

636

tree fromfn = TREE_TYPE
(TYPE_PTRMEMFUNC_FN_TYPE (from));

637

tree tofn = TREE_TYPE
(TYPE_PTRMEMFUNC_FN_TYPE (to));

638

tree fbase = TREE_TYPE (TREE_VALUE
(TYPE_ARG_TYPES (fromfn)));

639

tree tbase = TREE_TYPE (TREE_VALUE
(TYPE_ARG_TYPES (tofn)));

640

641

if (!DERIVED_FROM_P (fbase, tbase)

642

|| !same_type_p (TREE_TYPE (fromfn),
TREE_TYPE (tofn))

643

|| !compparms (TREE_CHAIN
(TYPE_ARG_TYPES (fromfn)),

644

TREE_CHAIN (TYPE_ARG_TYPES
(tofn)))

645

|| cp_type_quals (fbase) !=
cp_type_quals (tbase))

646

return
0;

647

648

from = cp_build_qualified_type (tbase,
cp_type_quals (fbase));

649

from = build_method_type_directly

(from,

650

TREE_TYPE
(fromfn),

651

TREE_CHAIN
(TYPE_ARG_TYPES (fromfn)));

652

from = build_ptrmemfunc_type (build_pointer_type
(from));

653

conv = build_conv
(PMEM_CONV, from, conv);

654

}

【
3
】条文
4.12
“布尔型转换”对以下的转换给出了指引。

1. 算术类型，枚举类型，指针类型，或成员指针类型的一个右值可以被转换为一个布尔类型的右值。一个 0 值，空指针值，或空成员指针值被转换为 false ；其他值被转换为 true 。

不过，指针到布尔值的转换等级不如整数到布尔值的转换。

standard_conversion (continue)

655

else if (tcode == BOOLEAN_TYPE)

656

{

657

/* [conv.bool]

658

659

An rvalue of
arithmetic, enumeration, pointer, or pointer to

660

member type can
be converted to an rvalue of type bool.

*/

661

if (ARITHMETIC_TYPE_P (from)

662

||
fcode == ENUMERAL_TYPE

663

|| fcode == POINTER_TYPE

664

|| TYPE_PTR_TO_MEMBER_P (from))

665

{

666

conv = build_conv
(STD_CONV, to, conv);

667

if (fcode == POINTER_TYPE

668

|| TYPE_PTRMEM_P (from)

669

|| (TYPE_PTRMEMFUNC_P (from)

670

&& ICS_STD_RANK (conv) <
PBOOL_RANK))

671

ICS_STD_RANK (conv) = PBOOL_RANK;

672

return
conv;

673

}

674

675

return
NULL_TREE;

676

}

那么下面的代码处理由【
3
】，条文
4.5
“整型提升”，
4.6
“浮点型提升”，
4.7
“整型转换”，
4.8
“浮点型转换”，及
4.9
“浮点整型转换”所描述的转换。下面的段落是其细节。

1. 类型 char ， signed char ， unsigned char ， short int ，或 unsigned short int 的一个右值可以被转换为类型 int 的一个右值，如果 int 可以表示源类型的所有值；否则，源右值可以被转换为类型 unsigned int 的一个右值。 2. 类型 wchar_t （ 3.9.1 ）或枚举类型（ 7.2 ）的一个右值可以被转换为以下类型中第一个可以表示源类型所有值的类型的一个右值： int ， unsigned int ， long ，或 unsigned long 。 3. 一个整型位域（ 9.6 ）的右值可以被转换为类型 int 的一个右值，如果 int 可以表示该位域的所有值；否则，它可以被转换为类型 unsigned int ，如果 unsigned int 可以表示其所有值。如果位域还要大，不会对其应用整型提升。如果该位域具有枚举的类型，出于提升的目的，它亦被视为该类型的其他值。 4. 类型 bool 的一个右值可以被转换为类型 int 的一个右值， false 成为 0 而 true 成为 1 。 5. 这些转换被称为整型提升（ integral promotion ）。

1. 类型 float 的一个右值可以被转换为类型 double 的一个右值。其值不变。 2. 这个转换被称为浮点提升（ floating point promotion ）。

1. 一个整型的右值可以被转换为另一个整型的右值。一个枚举类型的右值可以被转换为一个整型的右值。 2. 如果目标类型是无符号的，其结果值是与源整数同余的（ congruent ）最小无符号整数。（模 2n ，其中 n 是用于表示该无符号类型的比特数）。 [ 注意：在一个 2 进制补码表示中，这个转换只是概念上的，位模式（ bit pattern ）没有变化（如果没有发生截断）。 ] 3. 如果目标类型是有符号的，值不会改变，如果目标类型（及位域宽度）能表示它；否则，其值取决于编译器实现。 4. 如果目标类型是 bool ，参见 4.12 。如果源类型是 bool ，值 false 被转换为 0 ，值 true 被转换为 1 。 5. 整形提升不包括在整形转换中。

1. 一个浮点类型的右值可以被转换到另一个浮点类型的右值。如果源值可以被目标类型精确表示，转换的结果就是这个精确表示。如果源值位于目标类型所能表示的 2 个相邻值之间，转换的结果依赖于编译器实现对两者的选择。否则，其行为是未定义的。 2. 浮点提升不包括在浮点转换中。

1. 一个浮点类型的右值可以被转换为一个整形的右值。该转换就是截断；即，小数部分被舍弃。如果截断后的值不能被目标类型表示，其行为是未定义的。 [ 注意：如果目标类型是 bool ，参见 4.12 。 ] 2. 一个整形或枚举类型的右值可以被转换为一个浮点类型的右值。如果可能，其结果是精确的。否则，依赖于编译器的实现，选择次高或次低的表示值。 [ 注意：如果该整数不能被该浮点类型的一个值精确表示，会发生精度丢失 ] 。如果源类型是 bool ，值 false 被转换为 0 而值 true 转换为 1 。

679
到
690
行的代码覆盖了上面所提及的所有的情形。因为
PROMO_RANK
要优于
STD_RANK
，编译器总是尽可能使用
PROMO_RANK
。

standard_conversion (continue)

677

/* We don't check
for ENUMERAL_TYPE here because there are no standard

678

conversions to
enum type.
*/

679

else if (tcode == INTEGER_TYPE || tcode ==
BOOLEAN_TYPE

680

|| tcode == REAL_TYPE)

681

{

682

if (! (INTEGRAL_CODE_P (fcode) || fcode ==
REAL_TYPE))

683

return
0;

684

conv = build_conv
(STD_CONV, to, conv);

685

686

/* Give this a
better rank if it's a promotion.
*/

687

if (same_type_p (to, type_promotes_to
(from))

688

&& ICS_STD_RANK (TREE_OPERAND
(conv, 0)) <= PROMO_RANK)

689

ICS_STD_RANK (conv) = PROMO_RANK;

690

}

691

else if (fcode == VECTOR_TYPE &&
tcode == VECTOR_TYPE

692

&& ((*targetm

.vector_opaque_p) (from)

693

|| (*targetm

.vector_opaque_p) (to)))

694

return
build_conv
(STD_CONV, to, conv);

695

else if (!(flags &
LOOKUP_CONSTRUCTOR_CALLABLE)

696

&& IS_AGGR_TYPE (to)
&& IS_AGGR_TYPE (from)

697

&& is_properly_derived_from
(from, to))

698

{

699

if (TREE_CODE (conv) == RVALUE_CONV)

700

conv = TREE_OPERAND (conv, 0);

701

conv = build_conv
(BASE_CONV, to, conv);

702

/* The
derived-to-base conversion indicates the initialization

703

of a parameter
with base type from an object of a derived

704

type. A
temporary object is created to hold the result of

705

the
conversion.
*/

706

NEED_TEMPORARY_P (conv) = 1;

707

}

708

else

709

return
0;

710

711

return
conv;

712

}

695
到
707
行的代码处理派生类到基类的转换，它由条文“隐式转换序列”的条款
6
所定义。