5.13.1.2.3.1. 案例学习：到指针的转换
5.13.1.2.3.1.1. 从类到指针
到指针的转换是很有趣的，值得一看。处理这个转换的函数是下面的 cp_convert_to_pointer 。类可以被转换到指针类型，仅当它定义了一个这样做的用户定义转换。
76 static tree
77 cp_convert_to_pointer (tree type, tree expr, bool force) in cvt.c
78 {
79 tree intype = TREE_TYPE (expr);
80 enum tree_code form;
81 tree rval;
82 if (intype == error_mark_node)
83 return error_mark_node;
84
85 if (IS_AGGR_TYPE (intype))
86 {
87 intype = complete_type (intype);
88 if (!COMPLETE_TYPE_P (intype))
89 {
90 error ("can't convert from incomplete type `%T' to `%T'",
91 intype, type);
92 return error_mark_node;
93 }
94
95 rval = build_type_conversion (type, expr);
96 if (rval)
97 {
98 if (rval == error_mark_node)
99 error ("conversion of `%E' from `%T' to `%T' is ambiguous",
100 expr, intype, type);
101 return rval;
102 }
103 }
函数 build_type_conversion ， build_user_type_conversion 的定义如下。显然它查找这个用户定义的转换操作符，并产生执行转换的代码。
995 tree
996 build_type_conversion (tree xtype, tree expr) in cvt.c
997 {
998 /* C++: check to see if we can convert this aggregate type
999 into the required type. */
1000 return build_user_type_conversion (xtype, expr, LOOKUP_NORMAL);
1001 }
2522 tree
2523 build_user_type_conversion (tree totype, tree expr, int flags) in call.c
2524 {
2525 struct z_candidate *cand
2526 = build_user_type_conversion_1 (totype, expr, flags);
2527
2528 if (cand)
2529 {
2530 if (TREE_CODE (cand->second_conv) == AMBIG_CONV)
2531 return error_mark_node;
2532 return convert_from_reference (convert_like (cand->second_conv, expr));
2533 }
2534 return NULL_TREE;
2535 }
5.13.1.2.3.1.2. 到 void* 或函数指针
那么在下面的 type 是转换的目标类型， 106 行的条件为“ void* ”或函数指针的 type 所满足。而 intype 是表达式 expr 的类型。
cp_convert_to_pointer (continue)
105 /* Handle anachronistic conversions from (::*)() to cv void* or (*)(). */
106 if (TREE_CODE (type) == POINTER_TYPE
107 && (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE
108 || VOID_TYPE_P (TREE_TYPE (type))))
109 {
110 /* Allow an implicit this pointer for pointer to member
111 functions. */
112 if (TYPE_PTRMEMFUNC_P (intype))
113 {
114 if (pedantic || warn_pmf2ptr )
115 pedwarn ("converting from `%T' to `%T'", intype, type);
116 if (TREE_CODE (expr) == PTRMEM_CST)
117 expr = build_address (PTRMEM_CST_MEMBER (expr));
118 else
119 {
120 tree decl = maybe_dummy_object (TYPE_PTRMEM_CLASS_TYPE (intype),
121 0);
122 decl = build_address (decl);
123 expr = get_member_function_from_ptrfunc (&decl, expr);
124 }
125 }
126 else if (TREE_CODE (TREE_TYPE (expr)) == METHOD_TYPE)
127 {
128 if (pedantic || warn_pmf2ptr )
129 pedwarn ("converting from `%T' to `%T'", intype, type);
130 expr = build_addr_func (expr);
131 }
132 if (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE)
133 return build_nop (type, expr);
134 intype = TREE_TYPE (expr);
135 }
如果 intype 是方法指针的类型，这个转换可能是危险的代码；因此给出警告。而如果 expr 是一个 PTRMEM_CST ——一个成员指针常量，只需要获取这个成员的地址。不过，对于 expr 是指向方法的指针的情况，要求在调用 get_member_function_from_ptrfunc 中有隐含的 this 指针实参来解析这个指针。因而需要调用 maybe_dummy_object 来构建该类型用于解析的假的实例。
1717 tree
1718 maybe_dummy_object (tree type, tree* binfop) in cp/tree.c
1719 {
1720 tree decl, context;
1721 tree binfo;
1722
1723 if (current_class_type
1724 && (binfo = lookup_base (current_class_type , type,
1725 ba_ignore | ba_quiet, NULL)))
1726 context = current_class_type ;
1727 else
1728 {
1729 /* Reference from a nested class member function. */
1730 context = type;
1731 binfo = TYPE_BINFO (type);
1732 }
1733
1734 if (binfop)
1735 *binfop = binfo;
1736
1737 if (current_class_ref && context == current_class_type
1738 /* Kludge: Make sure that current_class_type is actually
1739 correct. It might not be if we're in the middle of
1740 tsubst_default_argument. */
1741 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (current_class_ref )),
1742 current_class_type ))
1743 decl = current_class_ref ;
1744 else
1745 decl = build_dummy_object (context);
1746
1747 return decl;
1748 }
首先，为这个假的对象设立相应的上下文；如果“ this ”指针是可用的，就把它用作这个假对象；否则，通过下面的函数构建该对象的一个 NULL 指针。
1706 tree
1707 build_dummy_object (tree type) in cp/tree.c
1708 {
1709 tree decl = build1 (NOP_EXPR, build_pointer_type (type), void_zero_node);
1710 return build_indirect_ref (decl, NULL);
1711 }
5.13.1.2.3.1.3. 在类指针之间
如果源类型及目标类型都是指向类的指针，它们必须有继承关系；否则就是一个错误。而如果目标类型是指向方法的指针，把其他类型的指针转换到它是不允许的。那么对于标量指针之间，及标量指针与类指针之间的转换，只需为该转换构建 NOP_EXPR 。
这包括了【 3 】条文 5.2.10 “ Reinterpret_cast ”，条款 7 所定义的情况：
| 7. 指向一个对象的指针可用被显式地转换到一个不同类型的对象。除了转换类型为“ T1 指针类型”的一个右值到类型“ T2 指针类型”（其中 T1 及 T2 是对象类型，并且 T2 所要求的对齐不小于 T1 ），然后回到其初始类型，产生初始的指针值之外；这样的一个指针转换的结果是未定义的。 |
cp_convert_to_pointer (continue)
137 if (expr == error_mark_node)
138 return error_mark_node;
139
140 form = TREE_CODE (intype);
141
142 if (POINTER_TYPE_P (intype))
143 {
144 intype = TYPE_MAIN_VARIANT (intype);
145
146 if (TYPE_MAIN_VARIANT (type) != intype
147 && TREE_CODE (type) == POINTER_TYPE
148 && TREE_CODE (TREE_TYPE (type)) == RECORD_TYPE
149 && IS_AGGR_TYPE (TREE_TYPE (type))
150 && IS_AGGR_TYPE (TREE_TYPE (intype))
151 && TREE_CODE (TREE_TYPE (intype)) == RECORD_TYPE)
152 {
153 enum tree_code code = PLUS_EXPR;
154 tree binfo;
155 tree intype_class;
156 tree type_class;
157 bool same_p;
158
159 intype_class = TREE_TYPE (intype);
160 type_class = TREE_TYPE (type);
161
162 same_p = same_type_p (TYPE_MAIN_VARIANT (intype_class),
163 TYPE_MAIN_VARIANT (type_class));
164 binfo = NULL_TREE;
165 /* Try derived to base conversion. */
166 if (!same_p)
167 binfo = lookup_base (intype_class, type_class, ba_check, NULL);
168 if (!same_p && !binfo)
169 {
170 /* Try base to derived conversion. */
171 binfo = lookup_base (type_class, intype_class, ba_check, NULL);
172 code = MINUS_EXPR;
173 }
174 if (binfo == error_mark_node)
175 return error_mark_node;
176 if (binfo || same_p)
177 {
178 if (binfo)
179 expr = build_base_path (code, expr, binfo, 0);
180 /* Add any qualifier conversions. */
181 return build_nop (type, expr);
182 }
183 }
184
185 if (TYPE_PTRMEMFUNC_P (type))
186 {
187 error ("cannot convert `%E' from type `%T' to type `%T'",
188 expr, intype, type);
189 return error_mark_node;
190 }
191
192 return build_nop (type, expr);
193 }
5.13.1.2.3.1.4. 指向成员的指针之间
下面， TYPE_PTRMEM_P 成立，如果这是一个指向数据成员的指针。
注意到当到达这里，该语句一定通过了解析过程中的语法检查；因此 TREE_TYPE (type) 必定匹配下面的 TREE_TYPE (intype) 。在上面的例子中，该转换可以被隐式地执行；除非该转换是自虚拟基类——这只能通过 reinterpret_cast 来完成，正如【 3 】条文 5.2.10 “ Reinterpret_cast ”，条款 3 定义的：“ 由 reinterpret_cast 执行的映射是由实现定义的。 [ 注意：它可能，或可能不， 产生一个不同于原始值的表达 ] ”。 GCC 选择对于这种 自虚拟基类的 转换不做任何事。考虑下面的例子：
class C {};
class D {
public :
C dc;
};
class B: public virtual D {
public :
C bc;
};
C* func (B* b) { return &b->bc; }
int main () {
D d;
func (&d);
return 0;
}
编译器给出如下的消息（它违反了【 3 】条文 4.11 “成员指针的转换”，条款 2 ）：
test2.cpp: In function ‘int main()’:
test2.cpp:17: error: invalid conversion from ‘D*’ to ‘B*’
test2.cpp:17: error: initializing argument 1 of ‘C* func(B*)’
test2.cpp:17: error: cannot convert from base ‘D’ to derived type ‘B’ via virtual base ‘D’
前两个 error 是在 convert_like_real 的 3944 及 3946 行给出的；最后一个则是在这里。
如果 type 及 intype 没有继承关系，注意到下面在 204 及 207 行的 lookup_base 将返回 NULL （如果基类是不可访问或具二义性，将返回 error_mark_node ），这也是仅为 reinterpret_cast 所允许的情形，如下面【 3 】的条文 5.2.10 “ Reinterpret_cast ”：
| 9. 一个“指向具有类型 T1 的 X 成员的指针”的右值，可以被显式地转换到一个“指向具有类型 T2 的 Y 成员的指针”的右值，如果 T1 及 T2 都是函数类型或两者都是对象类型。空成员指针值（ 4.11 ）可以被转换到目的类型的空成员指针值。这个转换的结果是不确定的，除了以下情形以外： — 转换“成员函数指针”类型的一个右值到另外的成员函数指针类型，再转换回原始类型，产生原始的成员指针值。 — 转换 “指向具有类型 T1 的 X 成员的指针”类型的一个右值到“指向具有类型 T2 的 Y 成员的指针”的类型（其中 T2 的对齐要求不强于 T1 （ no stricter than ）），再转换回原始类型，产生原始的成员指针值。 |
看到其结果是不确定的，这就是为什么 reinterpret_cast 是一个危险的操作符，它应该被小心使用。对于 type 及 intype 不具有继承关系的情形， GCC 在 236 行为之构建了 NOP_EXPR 。并且注意到如果我们能来到这里，相应的转换表达式必定通过了语法检查。
cp_convert_to_pointer (continue)
194 else if (TYPE_PTRMEM_P (type) && TYPE_PTRMEM_P (intype))
195 {
196 tree b1;
197 tree b2;
198 tree binfo;
199 enum tree_code code = PLUS_EXPR;
200 base_kind bk;
201
202 b1 = TYPE_PTRMEM_CLASS_TYPE (type);
203 b2 = TYPE_PTRMEM_CLASS_TYPE (intype);
204 binfo = lookup_base (b1, b2, ba_check, &bk);
205 if (!binfo)
206 {
207 binfo = lookup_base (b2, b1, ba_check, &bk);
208 code = MINUS_EXPR;
209 }
210 if (binfo == error_mark_node)
211 return error_mark_node;
212
213 if (bk == bk_via_virtual)
214 {
215 if (force)
216 warning ("pointer to member cast from `%T' to `%T' is via virtual base",
217 intype, type);
218 else
219 {
220 error ("pointer to member cast from `%T' to `%T' is via virtual base",
221 intype, type);
222 return error_mark_node;
223 }
224 /* This is a reinterpret cast, whose result is unspecified.
225 We choose to do nothing. */
226 return build1 (NOP_EXPR, type, expr);
227 }
228
229 if (TREE_CODE (expr) == PTRMEM_CST)
230 expr = cplus_expand_constant (expr);
231
232 if (binfo && !integer_zerop (BINFO_OFFSET (binfo)))
233 expr = size_binop (code,
234 build_nop (sizetype, expr),
235 BINFO_OFFSET (binfo));
236 return build_nop (type, expr);
237 }
238 else if (TYPE_PTRMEMFUNC_P (type) && TYPE_PTRMEMFUNC_P (intype))
239 return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), expr, 0);
而如果这些类型具有继承关系，前端会相应地调整类实例。
5.13.1.2.3.1.5. 从成员函数指针到其它指针类型
那么下面的代码处理以下与 reinterpret_cast 相关的情形：
| 4. 一个指针可用被显式地转换到任意足够大保存它的整数类型。其映射函数是实现定义的 [ 注意：对于那些知道底层机器寻址结构的人来说，这不足为奇 ] 。 5. 一个整数类型或枚举类型的值可以被显式地转换到一个指针。一个指针转换到足够大小的一个整数（如果在实现中有这样对象的存在），然后转换回同样的指针类型，将得到其原始值；指针与整数映射的其他方面则是由实现确定的。 6. 指向一个函数的指针可用被显式地转换到指向另一个函数类型的指针。通过一个指向别的函数类型的指针（ 8.3.5 ）来调用这个函数，其行为是未定义的。除了把类型“ T1 指针”的一个右值转换到“ T2 指针”类型（其中 T1 及 T2 都是函数类型），然后转换回其原始类型，产生原始的指针值之外，这样的一个指针转换的结果是不确定的。 [ 注意：参考 4.10 ，关于更多指针转换的细节 ] 。 8. 空指针值（ 4.10 ）被转换到目的类型的空指针值。 |
下面的 type 是目的类型，而 form 应该是“ from ”的笔误。注意到成员指针不能保存在任一整数类型中，因为事实上，它包含了两个部分——对象及成员。
cp_convert_to_pointer (continue)
240 else if (TYPE_PTRMEMFUNC_P (intype))
241 {
242 if (!warn_pmf2ptr )
243 {
244 if (TREE_CODE (expr) == PTRMEM_CST)
245 return cp_convert_to_pointer (type,
246 PTRMEM_CST_MEMBER (expr),
247 force);
248 else if (TREE_CODE (expr) == OFFSET_REF)
249 {
250 tree object = TREE_OPERAND (expr, 0);
251 return get_member_function_from_ptrfunc (&object,
252 TREE_OPERAND (expr, 1));
253 }
254 }
255 error ("cannot convert `%E' from type `%T' to type `%T'",
256 expr, intype, type);
257 return error_mark_node;
258 }
259
260 if (integer_zerop (expr))
261 {
262 if (TYPE_PTRMEMFUNC_P (type))
263 return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), expr, 0);
264
265 if (TYPE_PTRMEM_P (type))
266 /* A NULL pointer-to-member is represented by -1, not by
267 zero. */
268 expr = build_int_2 (-1, -1);
269 else
270 expr = build_int_2 (0, 0);
271 TREE_TYPE (expr) = type;
272 /* Fix up the representation of -1 if appropriate. */
273 force_fit_type (expr, 0);
274 return expr;
275 }
276 else if (TYPE_PTR_TO_MEMBER_P (type) && INTEGRAL_CODE_P (form))
277 {
278 error ("invalid conversion from '%T' to '%T'", intype, type);
279 return error_mark_node;
280 }
281
282 if (INTEGRAL_CODE_P (form))
283 {
284 if (TYPE_PRECISION (intype) == POINTER_SIZE)
285 return build1 (CONVERT_EXPR, type, expr);
286 expr = cp_convert (c_common_type_for_size (POINTER_SIZE, 0), expr);
287 /* Modes may be different but sizes should be the same. */
288 if (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (expr)))
289 != GET_MODE_SIZE (TYPE_MODE (type)))
290 /* There is supposed to be some integral type
291 that is the same width as a pointer. */
292 abort ();
293 return convert_to_pointer (type, expr);
294 }
295
296 if (type_unknown_p (expr))
297 return instantiate_type (type, expr, tf_error | tf_warning);
298
299 error ("cannot convert `%E' from type `%T' to type `%T'",
300 expr, intype, type);
301 return error_mark_node;
302 }
现在回到 ocp_convert 中的过程。注意下面的 e 来自 expr ，因此 720 行的 dtype 是表达式的类型；而 code 是目的类型的节点编码。那么如果目的类型是类类型，如 729 行所示，如果源类型与目的类型具有继承关系，或者源类型定义了到目的类型的转换操作符，这个转换是可能的。
ocp_convert (continue)
705 (code == VECTOR_TYPE)
706 return fold (convert_to_vector (type, e));
707 if (code == REAL_TYPE || code == COMPLEX_TYPE)
708 {
709 if (IS_AGGR_TYPE (TREE_TYPE (e)))
710 {
711 tree rval;
712 rval = build_type_conversion (type, e);
713 if (rval)
714 return rval;
715 else
716 if (flags & LOOKUP_COMPLAIN)
717 error ("`%#T' used where a floating point value was expected",
718 TREE_TYPE (e));
719 }
720 if (code == REAL_TYPE)
710 return fold (convert_to_real (type, e));
711 else if (code == COMPLEX_TYPE)
712 return fold (convert_to_complex (type, e));
713 }
714
715 /* New C++ semantics: since assignment is now based on
716 memberwise copying, if the rhs type is derived from the
717 lhs type, then we may still do a conversion. */
718 if (IS_AGGR_TYPE_CODE (code))
719 {
720 tree dtype = TREE_TYPE (e);
721 tree ctor = NULL_TREE;
722
723 dtype = TYPE_MAIN_VARIANT (dtype);
724
725 /* Conversion between aggregate types. New C++ semantics allow
726 objects of derived type to be cast to objects of base type.
727 Old semantics only allowed this between pointers.
728
729 There may be some ambiguity between using a constructor
730 vs. using a type conversion operator when both apply. */
731
732 ctor = e;
733
734 if (abstract_virtuals_error (NULL_TREE, type))
735 return error_mark_node;
736
737 if ((flags & LOOKUP_ONLYCONVERTING)
738 && ! (IS_AGGR_TYPE (dtype) && DERIVED_FROM_P (type, dtype)))
739 /* For copy-initialization, first we create a temp of the proper type
740 with a user-defined conversion sequence, then we direct-initialize
741 the target with the temp (see [dcl.init]). */
742 ctor = build_user_type_conversion (type, ctor, flags);
743 else
744 ctor = build_special_member_call (NULL_TREE,
745 complete_ctor_identifier ,
746 build_tree_list (NULL_TREE, ctor),
747 TYPE_BINFO (type), flags);
748 if (ctor)
749 return build_cplus_new (type, ctor);
750 }
751
752 if (flags & LOOKUP_COMPLAIN)
753 error ("conversion from `%T' to non-scalar type `%T' requested",
754 TREE_TYPE (expr), type);
755 if (flags & LOOKUP_SPECULATIVELY)
756 return NULL_TREE;
757 return error_mark_node;
758 }
1386
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
