blocks|key|2310913|text|在C%2B%2B中，1.0是一个double，因此它将提高计算的精度。但是，如果这是意图的话，那么只显式地将其转换为double就更清楚了。如果这是意图的话，它在表达式中也不是一个理想的位置(top-bottom将在精度提高之前进行评估)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2310914|不过，假设可能还有其他原因，比如常数曾经是2.0，但随着时间的推移，它被微调到1.0，隐藏了这种乘法的原始原因。从你的计算结果来看，我不认为是这样的。|2310915|entityMap^0|6|3|C|6|1I|6|2K|A|0|L|3|13|3|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|X|8|@]|D|@]|E|$]]]|I|$]]

In C++, <code>1.0</code> is a <code>double</code>, so it would increase the precision of the calculations. It would be clearer to just explicitly cast to <code>double</code> if that's the intention though. It's also not in an ideal place in the expression if this is the intention (<code>top-bottom</code> will be evaluated before the increase in precision).

There could hypothetically be additional reasons for it though, like the constant used to be <code>2.0</code> but over time was fine-tuned to <code>1.0</code>, hiding the original reason for this multiplication. Judging from the calculation you're performing, I don't think this was the case.

blocks|key|230521|text|C/C%2B%2B|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|230522|当一个或多个变量top、bottom等是double类型时，1.0的乘法就没有意义了。您应该简单地删除它，因为它没有任何用途。当所有变量都是float类型时，double文本1.0的乘法强制用双精度算法计算表达式。|CODE|230523|另一方面，当所有变量都是整数时，1.0的乘法要求用浮点算法进行计算。如果没有乘法，计算将使用整数算法执行，这将产生不同的结果。|230524|我的猜测是，代码最初使用整数和1.0是必需的。在某个时间点，代码被更改为使用浮点变量，但现在的假乘法没有被删除。|230525|Delphi|230526|如果您在Delphi代码中看到这样的表达式，那么您应该简单地删除乘法。除法运算符的存在强制将表达式计算为浮点表达式。|230527|Delphi表达式的计算规则与C和C%2B%2B略有不同。在C和C%2B%2B中，单个符号用于整数除法和浮点数除法，表达式的上下文确定使用哪种除法形式。在Delphi中，/是浮点除法，div是整数除法。|230528|entityMap^0|0|5|0|8|3|C|6|K|6|U|3|1Y|5|27|6|2F|3|0|G|3|0|F|3|0|0|6|0|0|25|1|2C|3|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|X|8|@$9|Y|A|Z|B|H]|$9|10|A|11|B|H]|$9|12|A|13|B|H]|$9|14|A|15|B|H]|$9|16|A|17|B|H]|$9|18|A|19|B|H]|$9|1A|A|1B|B|H]]|D|@]|E|$]]|$1|I|3|J|5|6|7|1C|8|@$9|1D|A|1E|B|H]]|D|@]|E|$]]|$1|K|3|L|5|6|7|1F|8|@$9|1G|A|1H|B|H]]|D|@]|E|$]]|$1|M|3|N|5|6|7|1I|8|@$9|1J|A|1K|B|C]]|D|@]|E|$]]|$1|O|3|P|5|6|7|1L|8|@]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1M|8|@$9|1N|A|1O|B|H]|$9|1P|A|1Q|B|H]]|D|@]|E|$]]|$1|S|3|-4|5|6|7|1R|8|@]|D|@]|E|$]]]|T|$]]

C/C++

When one or more of the variables <code>top</code>, <code>bottom</code> etc. are of type <code>double</code> then the multiplication by <code>1.0</code> is pointless. You should simply remove it since it serves no purpose. When all of the variables are of type <code>float</code> then the multiplication by the <code>double</code> literal <code>1.0</code> forces the expression to be evaluated with double precision arithmetic.

On the other hand, when all of the variables are integers, the multiplication by <code>1.0</code> forces the calculation to be performed with floating point arithmetic. Without the multiplication the calculation would be performed with integer arithmetic which would yield a different result.

My guess is that the code originally used integers and the <code>1.0</code> was needed. At some point in time the code was changed to use floating point variables but the now spurious multiplication was not removed.

Delphi

If you saw such an expression in Delphi code then you should simply remove the multiplication. The presence of a division operator forces the expression to be evaluated as a floating point expression.

The rules for Delphi expression evaluation are a little different from C and C++. In C and C++ a single symbol, <code>/</code> is used for both integer and floating point division, with the context of the expression determined which form of division is used. In Delphi <code>/</code> is floating point division and <code>div</code> is integer division.

blocks|key|2311022|text|在C%2B%2B中，经验法则是|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2311023|如果操作涉及浮动类型，则将两个操作数转换为浮动类型(结果为浮动类型)。|blockquote|2311024|请记住，operation与operator非常相关。操作顺序由运算符优先确定。|offset|length|style|CODE|2311025|C%2B%2B中基本操作的优先级是非常自然的。数学：|2311026|*，/发生在%2B，-之前|unordered-list-item|2311027|(中的表达式，)首先发生|2311028|所以如果你有|2311029|float+f+=+1.0f+%2B+1+/+2;

//+then+`f`+will+be+`1.0f`,+because

int+++sub+=+1+/+2+++++;++//+<-+an+integer+division,+happens+first+and+gives+0
float+f+++=+1.0f+%2B+sub;++//+<-+0+because+the+division+result+was+evaluated+first|code-block|syntax|javascript|2311030|最后的结果是float类型，因为最后一个操作是一个float+%2B+int。|2311031|另一个例子，涉及带括号的表达式：|2311032|float+f+=+(1.0f+%2B+1)+/+4;

//+`f`+will+be+`0.5`+this+time.+The+braced+expressions+happens+first:

float+sub+=+1.0f+%2B+1;++//+float+%2B+int+=+float
float+f+++=+sub+/+4;+++//+float+/+int+=+float|2311033|这里需要注意的是，4到4.0f的转换在操作之前发生，就像在这个示例性的程序集中：|BOLD|2311034|//+[mnemomic]+[what]%2B+[target]
fload+1.0f,+float_register_0
fload+1,++++float_register_1
fadd++float_register_0,+float_register_1,+float_register_2+//+sub+is+in+[2]
fload+4,++++float_register_3+++++++++++++++++++++++++++++++//+4+is+in+[3]
fdiv++float_register_2,+float_register_3,+f++++++++++++++++//+[2]/[3]+->+f|2311035|记住|2311036|2311037|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Operators_in_C_and_C%252B%252B#Operator_precedence^0|0|0|4|9|E|8|W|5|0|0|0|0|1|2|1|6|1|8|1|0|0|1|7|1|0|0|0|6|5|P|B|0|0|0|9|1|B|4|P|F|0|0|0|2|0|0|Z|0^^$0|@$1|2|3|4|5|6|7|1K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1L|8|@]|9|@]|A|$]]|$1|E|3|F|5|6|7|1M|8|@$G|1N|H|1O|I|J]|$G|1P|H|1Q|I|J]]|9|@$G|1R|H|1S|1|1T]]|A|$]]|$1|K|3|L|5|6|7|1U|8|@]|9|@]|A|$]]|$1|M|3|N|5|O|7|1V|8|@$G|1W|H|1X|I|J]|$G|1Y|H|1Z|I|J]|$G|20|H|21|I|J]|$G|22|H|23|I|J]]|9|@]|A|$]]|$1|P|3|Q|5|O|7|24|8|@$G|25|H|26|I|J]|$G|27|H|28|I|J]]|9|@]|A|$]]|$1|R|3|S|5|6|7|29|8|@]|9|@]|A|$]]|$1|T|3|U|5|V|7|2A|8|@]|9|@]|A|$W|X]]|$1|Y|3|Z|5|6|7|2B|8|@$G|2C|H|2D|I|J]|$G|2E|H|2F|I|J]]|9|@]|A|$]]|$1|10|3|11|5|6|7|2G|8|@]|9|@]|A|$]]|$1|12|3|13|5|V|7|2H|8|@]|9|@]|A|$W|X]]|$1|14|3|15|5|6|7|2I|8|@$G|2J|H|2K|I|J]|$G|2L|H|2M|I|J]|$G|2N|H|2O|I|16]]|9|@]|A|$]]|$1|17|3|18|5|V|7|2P|8|@]|9|@]|A|$W|X]]|$1|19|3|1A|5|6|7|2Q|8|@$G|2R|H|2S|I|16]]|9|@]|A|$]]|$1|1B|3|C|5|D|7|2T|8|@$G|2U|H|2V|I|16]]|9|@]|A|$]]|$1|1C|3|-4|5|6|7|2W|8|@]|9|@]|A|$]]]|1D|$1E|$5|1F|1G|1H|A|$1I|1J]]]]

In C++, the rule of thumb is

<blockquote>
 If the operation involves a floating type, both operands are converted to the floating type (the result is of floating type)
</blockquote>

Keep in mind that <code>operation</code> is very related to <code>operator</code>. And the order of operations is determined by
<a href="http://en.wikipedia.org/wiki/Operators_in_C_and_C%2B%2B#Operator_precedence" rel="nofollow">operator precedence</a>.

Precedence of the basic operations in C++ is quite natural w.r.t. maths: 

<ul>
<li><code>*</code>,<code>/</code> happen before <code>+</code>,<code>-</code></li>
<li>expressions within <code>(</code>, <code>)</code> happen first</li>
</ul>

So if you have

<pre><code>float f = 1.0f + 1 / 2;

// then `f` will be `1.0f`, because

int sub = 1 / 2 ; // &lt;- an integer division, happens first and gives 0
float f = 1.0f + sub; // &lt;- 0 because the division result was evaluated first
</code></pre>

The final result is of type <code>float</code> because the last operations is a <code>float + int</code>.

Another example, involving braced expressions:

<pre><code>float f = (1.0f + 1) / 4;

// `f` will be `0.5` this time. The braced expressions happens first:

float sub = 1.0f + 1; // float + int = float
float f = sub / 4; // float / int = float
</code></pre>

Here it is important to note that the conversion of <code>4</code> to <code>4.0f</code> happens before the operation, like in this exemplary assembly:

<pre><code>// [mnemomic] [what]+ [target]
fload 1.0f, float_register_0
fload 1, float_register_1
fadd float_register_0, float_register_1, float_register_2 // sub is in [2]
fload 4, float_register_3 // 4 is in [3]
fdiv float_register_2, float_register_3, f // [2]/[3] -&gt; f
</code></pre>

<hr>

Remember

<blockquote>
 If the operation involves a floating type, both operands are converted to the floating type (the result is of floating type)
</blockquote>

I happen to come across some similar kind of programming styles mostly when there is an Float or Double operations. 

<pre><code>ratio = 1.0 * (top - bottom) / (right - left); 
</code></pre>

All variables involved are float. 
What is the significance of having <code>1.0</code> multiplied to the result? 
As per my thinking multiplying <code>1.0</code> is some extra burden.Since the result wont change. 

Or is it similar to write an condition having <code>and 1==1</code>.

P.S: There are some situations where in some variables(except ratio) are assigned to non Float/double values as a long or integer.

Programming style in Float operations

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我碰巧遇到了一些类似的编程风格，主要是当有一个浮点或双操作时。ratio = 1.0 * (top - bottom) / (right - left);  所涉及的所有变量都是浮动的。让1.0与结果相乘有什么意义？按照我的想法，乘以1.0是一些额外的burden.Since，结果不会改变。或者编写具有and  1==...

问浮点操作中的编程风格
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问浮点操作中的编程风格EN