blocks|key|6040548|text|结果类型将为unsigned+int+test+here。无符号表达式将被强制转换为smallValue+*+value，因此此表达式为(unsigned)-1+*+500。但是，如果你用-Wsign-conversion+-+compiler编译这段代码，它会告诉你你做了坏事。link|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|6040549|entityMap|0|LINK|mutability|MUTABLE|url|http://liveworkspace.org/code/1uymEV%25241|1|http://liveworkspace.org/code/1uymEV%25243^0|6|C|16|I|1W|I|2M|H|J|9|0|3W|4|1|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]|$9|S|A|T|B|C]|$9|U|A|V|B|C]|$9|W|A|X|B|C]]|D|@$9|Y|A|Z|1|10]|$9|11|A|12|1|13]]|E|$]]|$1|F|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]|N|$5|I|J|K|E|$L|O]]]]

result type will be <code>unsigned int</code> <a href="http://liveworkspace.org/code/1uymEV%241" rel="nofollow">test here</a>. <code>smallValue * value</code> <code>smallValue</code> will be casted to unsigned, so this expression is <code>(unsigned)-1 * 500</code>. However, if you compile this code with <code>-Wsign-conversion</code> - compiler tells you, that you do bad things. <a href="http://liveworkspace.org/code/1uymEV%243" rel="nofollow">link</a>

blocks|key|563963|text|把'auto‘变成一个带符号的类型，这样就没问题了：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|563964|long+test+=+smallValue+*+value+*+anotherSmallValue;|code-block|syntax|javascript|563965|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|$]]

Make 'auto' into a signed type and you will be fine:

<pre><code>long test = smallValue * value * anotherSmallValue;
</code></pre>

blocks|key|6040735|text|您将只使用前两个变量(smallValue+*+value)获得相同的结果。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|6040736|首先，对这两个值应用整体提升：int8_t变为int，而unsigned+int保持原样。|6040737|然后应用C%2B%2B11+5/9中的以下规则来确定结果类型：|6040738|6040739|否则，如果具有无符号整数类型的操作数的秩大于或等于另一个操作数的类型的秩，则带符号整数类型的操作数应转换为具有无符号整数类型的操作数的类型。|blockquote|BOLD|6040740|6040741|6040742|因此，必须使用模算术将-1转换为unsigned+int，并给出一个较大的正数。乘以500会溢出(同样使用模算术)，得到一个不同的大数字。|6040743|entityMap^0|B|I|0|F|6|N|3|S|C|0|0|0|12|V|0|0|0|B|2|G|C|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|C]|$9|10|A|11|B|C]|$9|12|A|13|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|14|8|@]|D|@]|E|$]]|$1|J|3|-4|5|6|7|15|8|@]|D|@]|E|$]]|$1|K|3|L|5|M|7|16|8|@$9|17|A|18|B|N]]|D|@]|E|$]]|$1|O|3|-4|5|6|7|19|8|@]|D|@]|E|$]]|$1|P|3|-4|5|6|7|1A|8|@]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1B|8|@$9|1C|A|1D|B|C]|$9|1E|A|1F|B|C]]|D|@]|E|$]]|$1|S|3|-4|5|6|7|1G|8|@]|D|@]|E|$]]]|T|$]]

You will get the same result with just the first two variables (<code>smallValue * value</code>).

First, integral promotions are applied to both values: <code>int8_t</code> becomes <code>int</code>, and <code>unsigned int</code> remains as it is.

Then this rule from C++11 5/9 is applied to determine the result type:

<blockquote>
 Otherwise, if the operand that has unsigned integer type has rank greater than or equal to the
 rank of the type of the other operand, the operand with signed integer type shall be converted to
 the type of the operand with unsigned integer type.
</blockquote>

So <code>-1</code> must be converted to <code>unsigned int</code> using modular arithmetic, giving a large positive number. Multiplying by 500 will overflow (again using modular arithmetic), giving a different large number.

blocks|key|2688296|text|操作混合类型总是容易出现这样的错误。我建议您使用单一类型进行算术运算|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2688297|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Operating with mixed types is always prone to such errors. I advise you to use a single type for arithmetic operations

blocks|key|1104909|text|当编译器看到smallValue+*+value时，它必须在给定输入数据类型signed+(8位)和unsigned+int+(通常是16位或32位)的情况下决定结果的数据类型。C%2B%2B的规则规定，在这种情况下，结果将是无符号的。因此，smallValue+*+value的值不能像您预期的那样为-500；相反，值-500被解释为正数。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1104910|此外，您在这里将一个8位值乘以一个通常为16位或32位的值。此场景中的C%2B%2B规则规定，较小的存储值将首先转换为与较大的存储值相同的大小；因此，在这种情况下，smallValue+*+value的结果将确实足够大，以存储大量的幅度500。|1104911|继续乘以无符号数量anotherSmallValue+(=1)会得到另一个具有相同值的unsigned。|1104912|因为您使用的是auto，所以返回类型被推断为unsigned。|1104913|通过简单地转换回signed+(例如，通过将值test定义为int，而不是auto+)，通常会将整个操作的结果转换回signed值，而不会在内部更改位；这将正确地显示-500，正如您所预期的那样；然而，正如其他发帖者所指出的，这在理论上是相当危险的，因为它在技术上不能保证工作，尽管它通常会以这种方式在当今的编译器中工作。|1104914|entityMap^0|6|I|12|6|1E|C|39|I|43|4|4C|4|0|26|I|36|3|0|9|H|17|8|0|7|4|M|8|0|8|6|N|4|U|3|11|4|1M|6|2B|4|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]|$9|S|A|T|B|C]|$9|U|A|V|B|C]|$9|W|A|X|B|C]|$9|Y|A|Z|B|C]|$9|10|A|11|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|12|8|@$9|13|A|14|B|C]|$9|15|A|16|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|17|8|@$9|18|A|19|B|C]|$9|1A|A|1B|B|C]]|D|@]|E|$]]|$1|J|3|K|5|6|7|1C|8|@$9|1D|A|1E|B|C]|$9|1F|A|1G|B|C]]|D|@]|E|$]]|$1|L|3|M|5|6|7|1H|8|@$9|1I|A|1J|B|C]|$9|1K|A|1L|B|C]|$9|1M|A|1N|B|C]|$9|1O|A|1P|B|C]|$9|1Q|A|1R|B|C]|$9|1S|A|1T|B|C]]|D|@]|E|$]]|$1|N|3|-4|5|6|7|1U|8|@]|D|@]|E|$]]]|O|$]]

When the compiler sees <code>smallValue * value</code>, it must decide what the data type of the result is going to be, given the input data types <code>signed</code> (8 bits) and <code>unsigned int</code> (usually, either 16 or 32 bits). The rules of C++ state that in this situation, the result will be unsigned. Therefore, the value of <code>smallValue * value</code> cannot be <code>-500</code>, as you are expecting; instead, the value <code>-500</code> is interpreted as a POSITIVE number.

Furthermore, you are here multiplying an 8-bit value by a value that is typically either 16- or 32-bit. The rules of C++ in this scenario state that the smaller-storage value will first be cast to the same size as the larger; so in this case the result of <code>smallValue * value</code> will indeed be large enough to store a number of magnitude <code>500</code>.

Proceeding to multiply by the unsigned quantity <code>anotherSmallValue</code> (=1) results in another <code>unsigned</code> with the same value.

Because you are using <code>auto</code>, the return type is therefore deduced to be <code>unsigned</code>.

Simply by casting back to a <code>signed</code> (by, for example, defining the value <code>test</code> as an <code>int</code>, rather than an <code>auto</code>, will in turn typically cast the result of the entire operation back to a <code>signed</code> value, without changing the bits internally; this will then properly display <code>-500</code>, as you expect; however, as other posters have noted, this is rather dangerous in theory because it's not techincally guaranteed to work, although it usually will work this way with today's compilers.

For the following code I get an overflow but sadly I cannot seem to understand why.

<pre><code>std::int8_t smallValue = -1;
unsigned int value = 500;
std::uint8_t anotherSmallValue = 1;

auto test = smallValue * value * anotherSmallValue;
</code></pre>

Afterwards <code>test</code> is a quite large value.

Could someone explain, what happens here?

Weird integer overflow logic

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

对于下面的代码，我得到了一个溢出，但不幸的是，我似乎不能理解为什么。std::int8_t smallValue         = -1;unsigned int value             = 500;std::uint8_t anotherSmallValue = 1;auto test = smallV...

问奇怪的整数溢出逻辑
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问奇怪的整数溢出逻辑EN