blocks|key|1569737|text|坦率地说，我认为所有的fff都更具可读性。至于它是一个反模式的评论，如果你真的关心所有的位都被设置/清除，我认为你可能处于这样一种情况，你无论如何都会关心变量的大小，这将需要像boost::uint16_t这样的东西，等等。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1569738|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|$]]

Frankly I think all fff's is more readable. As to the comment that its an antipattern, if you really care that all the bits are set/cleared, I would argue that you are probably in a situation where you care about the size of the variable anyway, which would call for something like boost::uint16_t, etc.

blocks|key|1569823|text|避免上述问题的一种方法是简单地这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1569824|unsigned+int+flags+=+0;
flags+=+~flags;|code-block|syntax|javascript|1569825|轻便且切中要害。|1569826|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|$]]

A way which avoids the problems mentioned is to simply do:

<pre><code>unsigned int flags = 0;
flags = ~flags;
</code></pre>

Portable and to the point.

blocks|key|1354450|text|我不确定在C%2B%2B中使用无符号整型作为标志是不是一个好主意。那么bitset之类的呢？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1354451|std::numeric_limit<unsigned+int>::max()更好，因为0xffffffff假定无符号整型是32位整数。|offset|length|style|CODE|1354452|entityMap^0|0|0|13|18|A|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@$D|L|E|M|F|G]|$D|N|E|O|F|G]]|9|@]|A|$]]|$1|H|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|I|$]]

I am not sure using an unsigned int for flags is a good idea in the first place in C++. What about bitset and the like?

<code>std::numeric_limit&lt;unsigned int&gt;::max()</code> is better because <code>0xffffffff</code> assumes that unsigned int is a 32-bit integer.

blocks|key|1354650|text|只要您将#include+<limits.h>作为您的includes之一，就应该使用|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1354651|unsigned+int+flags+=+UINT_MAX;|code-block|syntax|javascript|1354652|如果你想要更长的比特，你可以使用|1354653|unsigned+long+flags+=+ULONG_MAX;|1354654|无论如何实现有符号整数，这些值都保证将结果集的所有值位都设置为1。|1354655|entityMap^0|4|J|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|W|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|Y|8|@]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|R|$]]

As long as you have <code>#include &lt;limits.h&gt;</code> as one of your includes, you should just use 

<pre><code>unsigned int flags = UINT_MAX;
</code></pre>

If you want a long's worth of bits, you could use

<pre><code>unsigned long flags = ULONG_MAX;
</code></pre>

These values are guaranteed to have all the value bits of the result set to 1, regardless of how signed integers are implemented.

blocks|key|1569982|text|是。正如在其他答案中所提到的，-1是最可移植的；然而，它并不具有很强的语义性，并且会触发编译器警告。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1569983|要解决这些问题，请尝试这个简单的帮助器：|1569984|static+const+struct+All1s
{
++++template<typename+UnsignedType>
++++inline+operator+UnsignedType(void)+const
++++{
++++++++static_assert(std::is_unsigned<UnsignedType>::value,+"This+is+designed+only+for+unsigned+types");
++++++++return+static_cast<UnsignedType>(-1);
++++}
}+ALL_BITS_TRUE;|code-block|syntax|javascript|1569985|用法：|1569986|unsigned+a+=+ALL_BITS_TRUE;
uint8_t++b+=+ALL_BITS_TRUE;
uint16_t+c+=+ALL_BITS_TRUE;
uint32_t+d+=+ALL_BITS_TRUE;
uint64_t+e+=+ALL_BITS_TRUE;|1569987|entityMap^0|F|2|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|V|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|W|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|X|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|Y|8|@]|D|@]|E|$K|L]]|$1|Q|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|R|$]]

Yes. As mentioned in other answers, <code>-1</code> is the most portable; however, it is not very semantic and triggers compiler warnings.

To solve these issues, try this simple helper:

<pre><code>static const struct All1s
{
 template&lt;typename UnsignedType&gt;
 inline operator UnsignedType(void) const
 {
 static_assert(std::is_unsigned&lt;UnsignedType&gt;::value, "This is designed only for unsigned types");
 return static_cast&lt;UnsignedType&gt;(-1);
 }
} ALL_BITS_TRUE;
</code></pre>

Usage:

<pre><code>unsigned a = ALL_BITS_TRUE;
uint8_t b = ALL_BITS_TRUE;
uint16_t c = ALL_BITS_TRUE;
uint32_t d = ALL_BITS_TRUE;
uint64_t e = ALL_BITS_TRUE;
</code></pre>

blocks|key|1354627|text|我不会做-1的事情。这是相当不直观的(至少对我而言)。将带符号的数据赋值给无符号变量似乎违反了事物的自然顺序。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1354628|在你的情况下，我总是使用0xFFFF。(当然，对于可变大小，请使用正确数量的F。)|offset|length|style|CODE|1354629|顺便说一句，我很少在现实世界的代码中看到-1技巧。|1354630|此外，如果您真的关心uint32_t中的各个位，那么开始使用固定宽度的uint8_t、vairable和vairable类型是个好主意。|1354631|entityMap^0|0|C|6|0|0|A|8|Z|7|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@$D|P|E|Q|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|R|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|S|8|@$D|T|E|U|F|G]|$D|V|E|W|F|G]]|9|@]|A|$]]|$1|L|3|-4|5|6|7|X|8|@]|9|@]|A|$]]]|M|$]]

I would not do the -1 thing. It's rather non-intuitive (to me at least). Assigning signed data to an unsigned variable just seems to be a violation of the natural order of things.

In your situation, I always use <code>0xFFFF</code>. (Use the right number of Fs for the variable size of course.)

[BTW, I very rarely see the -1 trick done in real-world code.]

Additionally, if you really care about the individual bits in a vairable, it would be good idea to start using the fixed-width <code>uint8_t</code>, <code>uint16_t</code>, <code>uint32_t</code> types.

blocks|key|1354824|text|正如其他人提到的，-1是创建整数的正确方法，该整数将转换为所有位都设置为1的无符号类型。然而，C%2B%2B中最重要的事情是使用正确的类型。因此，您的问题的正确答案(包括您提出的问题的答案)是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1354825|std::bitset<32>+const+flags(-1);|code-block|syntax|javascript|1354826|这将始终包含您所需的确切位数。它会构建一个所有位都设置为1的std::bitset，原因与其他答案中提到的原因相同。|offset|length|style|CODE|1354827|entityMap^0|0|0|U|B|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

As others have mentioned, -1 is the correct way to create an integer that will convert to an unsigned type with all bits set to 1. However, the most important thing in C++ is using correct types. Therefore, the correct answer to your problem (which includes the answer to the question you asked) is this:

<pre><code>std::bitset&lt;32&gt; const flags(-1);
</code></pre>

This will always contain the exact amount of bits you need. It constructs a <code>std::bitset</code> with all bits set to 1 for the same reasons mentioned in other answers.

blocks|key|1569574|text|它当然是安全的，因为-1将总是设置所有可用位，但我更喜欢~0。-1对于unsigned+int来说意义不大。0xFF...不是很好，因为它取决于文字的宽度。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1569575|entityMap^0|Z|C|1I|4|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|M|8|@]|D|@]|E|$]]]|G|$]]

It is certainly safe, as -1 will always have all available bits set, but I like ~0 better. -1 just doesn't make much sense for an <code>unsigned int</code>. <code>0xFF</code>... is not good because it depends on the width of the type.

blocks|key|1354532|text|实战:是的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1354533|理论上:不是。|1354534|-1+=0xFFFFFFFFF(或您的平台上int的任何大小)只有在二的补码算术中才为真。在实践中，它是可行的，但也有一些遗留的机器(IBM大型机等)。你得到的是一个实际的符号位，而不是2的补码表示。您提出的~0解决方案应该适用于任何地方。|1354535|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|$]]

Practically: Yes

Theoretically: No.

-1 = 0xFFFFFFFF (or whatever size an int is on your platform) is only true with two's complement arithmetic. In practice, it will work, but there are legacy machines out there (IBM mainframes, etc.) where you've got an actual sign bit rather than a two's complement representation. Your proposed ~0 solution should work everywhere.

blocks|key|1354780|text|我说：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1354781|int+x;
memset(&x,+0xFF,+sizeof(int));|code-block|syntax|javascript|1354782|这将始终为您提供所需的结果。|1354783|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|$]]

I say:

<pre><code>int x;
memset(&amp;x, 0xFF, sizeof(int));
</code></pre>

This will always give you the desired result.

blocks|key|1570041|text|一种让意思变得更明显但又避免重复输入的方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1570042|const+auto+flags+=+static_cast<unsigned+int>(-1);|code-block|syntax|javascript|1570043|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|$]]

A way to make the meaning bit more obvious and yet to avoid repeating the type:

<pre><code>const auto flags = static_cast&lt;unsigned int&gt;(-1);
</code></pre>

blocks|key|1354734|text|是的，显示的表示是非常正确的，因为如果我们以相反的方式来做，u将需要一个运算符来反转所有的位，但在这种情况下，如果我们考虑机器中整数的大小，那么逻辑是相当简单的|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1354735|例如，在大多数机器中，一个整数是2字节=+16位，它能容纳的最大值是2%5E16-1=65535+2%5E16=65536|1354736|0%2565536=0+-1%2565536=65535，对应于1111...1，并且所有的位都设置为1(如果我们考虑残基类别mod+65536)，因此它非常简单。|1354737|我猜|1354738|不，如果你考虑这个概念，它非常适合无符号整数，而且它实际上是有效的。|1354739|只需检查以下程序片段|1354740|int+main()+{|1354741|unsigned+int+a=2;

cout<<(unsigned+int)pow(double(a),double(sizeof(a)*8));

unsigned+int+b=-1;

cout<<"\n"<<b;

getchar();

return+0;|code-block|syntax|javascript|1354742|}|1354743|B=+4294967295的答案，其中for是4字节整数的-1%252%5E32|1354744|因此，它对无符号整数是完全有效的|1354745|如有任何差异，plzz报告|1354746|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|13|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|14|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|15|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|16|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|17|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|18|8|@]|9|@]|A|$]]|$1|N|3|O|5|P|7|19|8|@]|9|@]|A|$Q|R]]|$1|S|3|T|5|6|7|1A|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1B|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1C|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|1D|8|@]|9|@]|A|$]]|$1|10|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]]|11|$]]

yes the representation shown is very much correct as if we do it the other way round u will require an operator to reverse all the bits but in this case the logic is quite straightforward if we consider the size of the integers in the machine

for instance in most machines an integer is 2 bytes = 16 bits maximum value it can hold is 2^16-1=65535 2^16=65536

0%65536=0
-1%65536=65535 which corressponds to 1111.............1 and all the bits are set to 1 (if we consider residue classes mod 65536)
hence it is much straight forward.

I guess

no if u consider this notion it is perfectly dine for unsigned ints and it actually works out

just check the following program fragment

int main()
{

<pre><code>unsigned int a=2;

cout&lt;&lt;(unsigned int)pow(double(a),double(sizeof(a)*8));

unsigned int b=-1;

cout&lt;&lt;"\n"&lt;&lt;b;

getchar();

return 0;
</code></pre>

}

answer for b = 4294967295 whcih is -1%2^32 on 4 byte integers

hence it is perfectly valid for unsigned integers

in case of any discrepancies plzz report

I've seen this pattern used a lot in C &amp; C++.

<pre><code>unsigned int flags = -1; // all bits are true
</code></pre>

Is this a good portable way to accomplish this? Or is using <code>0xffffffff</code> or <code>~0</code> better?

Is it safe to use -1 to set all bits to true?

我看到这个模式在C& C++中用得很多。unsigned int flags = -1;  // all bits are true这是一种很好的可移植的实现方式吗？还是使用0xffffffff或~0更好？

问使用-1将所有位设置为真是否安全？
EN

回答 12

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用-1将所有位设置为真是否安全？EN

回答 12

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用-1将所有位设置为真是否安全？
EN