我有点困惑隐式类型转换。给定以下程序
float x = 4.23423451; double y = 4.23423451; float z = 101.9876; float res1 = x * z; float res2 = y * z; std :: cout<< res1& res2< res1<< &<< res2<< std :: endl; std :: cout<< 相等< （res1 == res2）< std :: endl;输出为
res1& res2 431.839& 431.839 equality 1我的问题是对于任何值
在
res2 = y * z;
变量y是否类型转换为float或变量
请参阅我的意见。
z 的中间表达式将扩展为 double ，因此 y * z 将是一个 double 表达式。然后，隐式变窄转换将其转换为 float ，以存储在 res2 中。这同样缩小适用于 res1 。
许多二进制运算符期望操作数算术或枚举类型以类似的方式导致转换和产生结果类型。目的是产生一个共同的类型，这也是结果的类型。这种模式称为通常的算术转换，定义如下：
...
- 否则，如果任一操作数 double ，则另一个将转换为 double 。
- 否则，如果任一操作数 float ，另一个将转换为 float 。
...
b $ b
但是，这不能保证平等。
> res1 不一定等同于 res2 - 它高度依赖于 float 和 double 。这两个文本可能甚至不相等 - 4.23423451f 甚至不需要等同于 4.23423451 。您不能确定 static_cast< double>（static_cast< float>（4.23423451））将等于 4.23423451 。
请参阅§ 5.17¶ 3作业和复合赋值运算符[expr.ass] p>
如果左操作数不是类类型，则表达式被隐式转换（第4条）为左操作数的cv非限定类型。
§ 4个标准转换[conv] 说明如下：
标准转换是具有内置含义的隐式转换。第4节列举了全部这样的转换。 标准转换序列是以下列顺序的标准转换序列：
...
- 以下集合中的零个或一个转换：积分促销，浮点提升，积分转换，浮点转换，浮点积分转换，指针转换，指向成员转换的指针，
详情请参阅 4.6浮点宣传[conv.fpprom] ，
...和 4.8浮点转换[conv.double] ，
浮点类型的prvalue可以转换为另一个浮点类型的prvalue。如果源值可以在目标类型中精确表示，则转换的结果是精确表示。如果源值在两个相邻的目标值之间，则转换的结果是这些值中的任一个的实现定义的选择。
允许作为浮点促销的转化被排除在浮点数转换集合之外。
这里的问题是我们有多种情况，我们的转换不是促销而是缩小到潜在的更低精度类型（ double 到 float ）。
基本上，任何时候你转换 double 到 float ，你可能会失去精度。 / p>
I am bit confused about implicit type conversion. Given the following program
float x = 4.23423451; double y = 4.23423451; float z = 101.9876; float res1 = x * z; float res2 = y * z; std::cout << "res1 & res2 " << res1 << " & " << res2 << std::endl; std::cout << "equality " << (res1 == res2) << std::endl;The output was
res1 & res2 431.839 & 431.839 equality 1My question is "Will the equality be always true for any value of x, y & z (x = y) and also for any compiler?"
In
res2 = y * z;
Will the variable "y" be type-casted to float or variable "z" be type-casted to double?
解决方案See my comments.
This is well-defined. The intermediate expression for z will undergo widening into double, so y * z will be a double expression. An implicit narrowing conversion will then convert it to float for storing in res2. This same narrowing applies to res1.
This is reflected by §5¶9 Expressions [expr] of the C++11 standard.
Many binary operators that expect operands of arithmetic or enumeration type cause conversions and yield result types in a similar way. The purpose is to yield a common type, which is also the type of the result. This pattern is called the usual arithmetic conversions, which are defined as follows:
...
- Otherwise, if either operand is double, the other shall be converted to double.
- Otherwise, if either operand is float, the other shall be converted to float.
...
This, however, does not sure that the equality will hold.
That being said, res1 need not necessarily be equivalent to res2 -- it is highly dependent on the precision of float and double in the environment. The two literals could potentially not even be equal -- 4.23423451f not need even be equivalent to 4.23423451. You can not be sure that static_cast<double>(static_cast<float>(4.23423451)) will be equal to 4.23423451.
See §5.17¶3 Assignment and compound assignment operators [expr.ass].
If the left operand is not of class type, the expression is implicitly converted (Clause 4) to the cv-unqualified type of the left operand.
§4 Standard conversions [conv] states as follows:
Standard conversions are implicit conversions with built-in meaning. Clause 4 enumerates the full set of such conversions. A standard conversion sequence is a sequence of standard conversions in the following order:
...
- Zero or one conversion from the following set: integral promotions, floating point promotion, integral conversions, floating point conversions, floating-integral conversions, pointer conversions, pointer to member conversions, and boolean conversions.
As elaborated in §4.6 Floating point promotion [conv.fpprom],
... and §4.8 Floating point conversions [conv.double],
A prvalue of floating point type can be converted to a prvalue of another floating point type. If the source value can be exactly represented in the destination type, the result of the conversion is that exact representation. If the source value is between two adjacent destination values, the result of the conversion is an implementation-defined choice of either of those values. Otherwise, the behavior is undefined.
The conversions allowed as floating point promotions are excluded from the set of floating point conversions.
The problem here is that we have multiple cases where our conversion is not promotion, but rather narrowing to a potentially lower-precision type (double to float).
Essentially, any time you convert double to float, you may potentially lose precision.
更多推荐
C ++：隐式类型转换
发布评论