blocks|key|1545344|text|if条件中的数字取决于您想要对结果做什么。在IEEE+754中，使用的是(几乎？)所有C实现除以0是可以的:得到正无穷大或负无穷大。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1545345|如果您的目标是避免%2B/-无限，那么if条件中的数字将取决于分子。当分子为1时，您可以使用DBL_MIN或来自math.h的FLT_MIN。|1545346|如果您的目标是在除后避免大量的数字，那么您可以进行除法，然后检查除后fabs(number)是否大于某个值，然后根据需要采取任何行动。|1545347|你的问题没有一个正确的答案。|1545348|entityMap^0|0|2|0|H|2|18|7|1I|6|1P|7|0|Y|C|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|Z|8|@$9|10|A|11|B|C]]|D|@]|E|$]]|$1|J|3|K|5|6|7|12|8|@]|D|@]|E|$]]|$1|L|3|-4|5|6|7|13|8|@]|D|@]|E|$]]]|M|$]]

The number in the <code>if</code> condition depends on what you want to do with the result. In IEEE 754, which is used by (almost?) all C implementations, dividing by 0 is OK: you get positive or negative infinity.

If your goal is to avoid +/- Infinity, then the number in the <code>if</code> condition will depend upon the numerator. When the numerator is 1, you can use <code>DBL_MIN</code> or <code>FLT_MIN</code> from <code>math.h</code>.

If your goal is to avoid huge numbers after the division, you can do the division and then check if <code>fabs(number)</code> is bigger than certain value after the division, and then take whatever action as needed.

There is no single correct answer to your question.

blocks|key|4166987|text|只需使用：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4166988|if(number+>+0)
++++number+=+1/number;|code-block|syntax|javascript|4166989|注意>和>=之间的区别。如果是number+>+0，那么肯定不是0。|offset|length|style|CODE|4166990|如果数字可以是负数，也可以使用：|4166991|if(number+!=+0)
++++number+=+1/number;|4166992|注意，正如其他人在注释中提到的那样，检查number不是0并不会阻止您的结果成为Inf或-Inf。|4166993|entityMap^0|0|0|2|1|4|2|F|A|W|1|0|0|0|K|6|S|1|14|3|18|4|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@$I|X|J|Y|K|L]|$I|Z|J|10|K|L]|$I|11|J|12|K|L]|$I|13|J|14|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|15|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|16|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|17|8|@$I|18|J|19|K|L]|$I|1A|J|1B|K|L]|$I|1C|J|1D|K|L]|$I|1E|J|1F|K|L]]|9|@]|A|$]]|$1|S|3|-4|5|6|7|1G|8|@]|9|@]|A|$]]]|T|$]]

Just use:

<pre><code>if(number &gt; 0)
 number = 1/number;
</code></pre>

Note the difference between <code>&gt;</code> and <code>&gt;=</code>. If <code>number &gt; 0</code>, then it definitely is not <code>0</code>.

If number can be negative you can also use:

<pre><code>if(number != 0)
 number = 1/number;
</code></pre>

Note that, as others have mentioned in the comments, checking that <code>number</code> is not <code>0</code> will not prevent your result from being <code>Inf</code> or <code>-Inf</code>.

blocks|key|4167020|text|您可以简单地检查：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4167021|if+(number+>+0)++|code-block|syntax|javascript|4167022|我不明白你为什么需要下限。|4167023|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

You can simply check: 

<pre><code>if (number &gt; 0) 
</code></pre>

I can't understand why you need the lower limit.

blocks|key|1545363|text|对于数字类型，T+std::numeric_limits提供您需要的任何东西。例如，您可以这样做，以确保min_invertible之上的任何内容都具有有限的倒数：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1545364|float+max_float+=+std::numeric_limits<float>::max();+
float+min_float+=+std::numeric_limits<float>::min();+//+or+denorm_min()
float+min_invertible+=+(max_float*min_float+>+1.0f+)?+min_float+:+1.0f/max_float;|code-block|syntax|javascript|1545365|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

For numeric type T std::numeric_limits gives you anything you need. For example you could do this to make sure that anything above min_invertible has finite reciprocal:

<pre><code>float max_float = std::numeric_limits&lt;float&gt;::max(); 
float min_float = std::numeric_limits&lt;float&gt;::min(); // or denorm_min()
float min_invertible = (max_float*min_float &gt; 1.0f )? min_float : 1.0f/max_float;
</code></pre>

blocks|key|407155|text|你不能体面地检查前面。DBL_MAX+/+0.5实际上是一个除以零；结果是从任何其他除法得到的无穷大等于(几乎)为零。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|407156|有一个简单的解决方案:只需检查结果。std::isinf(result)将告诉您结果是否溢出，而IEEE754告诉您，除法在其他情况下不能产生无穷大。(嗯，除了INF/x以外，。这并不是真正产生无穷大，而只是保持它。)|407157|entityMap^0|B|D|0|I|I|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|P|8|@]|D|@]|E|$]]]|I|$]]

You can't decently check up front. <code>DBL_MAX / 0.5</code> effectively is a division by zero; the result is the same infinity you'd get from any other division by (almost) zero.

There is a simple solution: just check the result. <code>std::isinf(result)</code> will tell you whether the result overflowed, and IEEE754 tells you that division cannot produce infinity in other cases. (Well, except for INF/x,. That's not really producing infinity but merely preserving it.)

blocks|key|407200|text|通过溢出或下溢产生无益结果的风险取决于分子和分母。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|407201|考虑到这一点的安全检查是：|407202|if+(den+==+0.0+%7C%7C+log2(num)+-+log2(den)+>=+log2(FLT_MAX))
++++/*+expect+overflow+*/+;
else
++++return+num+/+den;|code-block|syntax|javascript|407203|但是你可能想要在log2(FLT_MAX)上刮一小部分毛，这样就能为以后的算术和总结留出回旋的空间。|offset|length|style|CODE|407204|您可以对frexp做类似的操作，这也适用于负值：|407205|int+max;
int+n,+d;

frexp(FLT_MAX,+&max);

frexp(num,+&n);
frexp(den,+&d);

if+(den+==+0.0+%7C%7C+n+-+d+>+max)
++++/*+might+overflow+*/+;
else
++++return+num+/+den;|407206|这就避免了计算对数的工作，如果编译器能够找到一种合适的方法，那么计算对数的效率可能会更高，但它并不是那么精确。|407207|entityMap^0|0|0|0|8|D|0|4|5|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|Z|8|@$K|10|L|11|M|N]]|9|@]|A|$]]|$1|O|3|P|5|6|7|12|8|@$K|13|L|14|M|N]]|9|@]|A|$]]|$1|Q|3|R|5|F|7|15|8|@]|9|@]|A|$G|H]]|$1|S|3|T|5|6|7|16|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|17|8|@]|9|@]|A|$]]]|V|$]]

Your risk of producing an unhelpful result through overflow or underflow depends on both numerator and denominator.

A safety check which takes that into consideration is:

<pre><code>if (den == 0.0 || log2(num) - log2(den) &gt;= log2(FLT_MAX))
 /* expect overflow */ ;
else
 return num / den;
</code></pre>

but you might want to shave a small amount off <code>log2(FLT_MAX)</code> to leave wiggle-room for subsequent arithmetic and round-off.

You can do something similar with <code>frexp</code>, which would work for negative values as well:

<pre><code>int max;
int n, d;

frexp(FLT_MAX, &amp;max);

frexp(num, &amp;n);
frexp(den, &amp;d);

if (den == 0.0 || n - d &gt; max)
 /* might overflow */ ;
else
 return num / den;
</code></pre>

This avoids the work of computing the logarithm, which might be more efficient if the compiler can find a suitable way of doing it, but it's not as accurate.

blocks|key|1545314|text|对于IEEE+32位浮动，最小可能大于0的值是2%5E-149.|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1545315|如果使用的是IEEE+64位，最小的可能值是2%5E-1074.|1545316|也就是说，(x+>+0)可能是更好的测试。|1545317|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

With IEEE 32-bit floats, the smallest possible value greater than 0 is 2^-149.

If you're using IEEE 64-bit, the smallest possible value is 2^-1074.

That said, (x > 0) is probably the better test.

I want to avoid dividing by zero so I have an <code>if</code> statement: 

<pre><code>float number;
//........
if (number &gt; 0.000000000000001) 
 number = 1/number;
</code></pre>

How small of a value can I safely use in place of <code>0.000000000000001</code>?

How close to division by zero can I get?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我想避免除以零，所以我有一个if语句：float number;//........if (number > 0.000000000000001)   number = 1/number;我可以安全地使用多小的值来代替0.000000000000001

问除以零我能得到多近？
EN

回答 7

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问除以零我能得到多近？EN

回答 7

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问除以零我能得到多近？
EN