blocks|key|3352566|text|为什么不使用long来存储结果呢？然后，您可以应用such+as+this+one技术来检测溢出|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3352567|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/199333/best-way-to-detect-integer-overflow-in-c-c/199354#199354^0|P|G|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

Why not use long to store the result? You can then apply techniques <a href="https://stackoverflow.com/questions/199333/best-way-to-detect-integer-overflow-in-c-c/199354#199354">such as this one</a> to detect the overflow

blocks|key|1036002|text|如果您可以访问更大的数据类型，则可以执行以下操作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1036003|int32_t+hash,+seed;
int64_t+temporary;

temporary+=+hash+*+seed+%2B+string[i];
hash+=+(+temporary+>>+32+)+%5E+(+temporary+&+0xFFFFFFFF+);|code-block|syntax|javascript|1036004|否则，您将不得不手动将散列和种子相乘为两个值，使用overflow添加stringi，然后将这两个值相加%5E。|1036005|哈希是隐式有损的，因此，除非有特定的原因需要它们，如匹配现有算法，否则就让溢出的比特消失，这应该是可以的。|1036006|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

If you have access to a larger data type, you can do something like this:

<pre><code>int32_t hash, seed;
int64_t temporary;

temporary = hash * seed + string[i];
hash = ( temporary &gt;&gt; 32 ) ^ ( temporary &amp; 0xFFFFFFFF );
</code></pre>

Otherwise you will have to manually multiply the hash and seed into two values, add string[i] with overflow, then ^ the two values.

Hashes are implicitly lossy, so it should be fine to just let the overflow bits go unless there is a specific reason you need them, like matching an existing algorithm.

blocks|key|1120182|text|像这样的散列函数应该会溢出。你必须声明"hash“没有签名。如果你真的需要一个int而不是简单的使用hash+&+0x7fffffff。查看Fowler-Noll-Vo+algorithm，你会在那里找到源代码的链接。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1120183|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Fowler-Noll-Vo_hash_function^0|1Y|O|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

Hash functions like this one are supposed to overflow. You have to declare "hash" unsigned. If you really need an int than simply use hash &amp; 0x7fffffff. Review the <a href="http://en.wikipedia.org/wiki/Fowler-Noll-Vo_hash_function" rel="nofollow noreferrer">Fowler-Noll-Vo algorithm</a>, you'll find links to source code there.

blocks|key|1036077|text|您的问题有许多可能的解释，正如评论所指出的，您可能需要澄清。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1036078|然而，唯一合理的解释是，您希望将散列值限制在指定的范围内。假设如此，那么如果范围是0到HASH_TABLE_SIZE+-+1，那么：|1036079|hash+=+(hash+*+seed+%2B+string[i])+%25+HASH_TABLE_SIZE+;|code-block|syntax|javascript|1036080|或者，如果表大小是2的幂，则使用掩码：|1036081|#define+HASH_TABLE_SIZE+(0x01<<8)++//+2%5E8+(256)+table
#define+HASH_MODULO_MASK+(HASH_TABLE_SIZE+-+1)
...
hash+=+(hash+*+seed+%2B+string[i])+&+HASH_MODULO_MASK+;|1036082|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

There are a number of possible interpretations of your question, and as noted by the comments, you may need to clarify. 

The only sensible interpretation however is that you want to restrict the hash value to a specified range. Assuming that, then if the range were 0 to HASH_TABLE_SIZE - 1, then:

<pre><code>hash = (hash * seed + string[i]) % HASH_TABLE_SIZE ;
</code></pre>

or if the table size is a power of two, use a mask:

<pre><code>#define HASH_TABLE_SIZE (0x01&lt;&lt;8) // 2^8 (256) table
#define HASH_MODULO_MASK (HASH_TABLE_SIZE - 1)
...
hash = (hash * seed + string[i]) &amp; HASH_MODULO_MASK ;
</code></pre>

I'm working on a hash function which gets a string as input.

Right now I'm doing a loop and inside the hash (an int variable) is being multiplied by a value and then the ASCII code for the current character is added to the mix.

<pre><code>hash = hash * seed + string[i]
</code></pre>

But sometimes, if the string is big enough there is an integer overflow there, what can I do to avoid it while maintaining the same hash structure? Maybe a bit operation included inside the loop?

Efective way to avoid integer overflow when multiplying?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我正在研究一个哈希函数，它将一个字符串作为输入。现在，我正在做一个循环，在hash (一个int变量)中乘以一个值，然后将当前字符的ASCII代码添加到混合中。hash = hash * seed + string[i]但有时，如果字符串足够大，有一个整数溢出，我可以做什么来避免它，同时保持相同的哈希结构？也许在循环中...

问乘法时避免整数溢出的有效方法？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问乘法时避免整数溢出的有效方法？EN