尝试将char所有位设为1时结果异常，求问题原因分析

Great question! Let's break down exactly what's going on here and why you're not getting the all-ones value you expect.

First, let's clarify: an 8-bit char with all bits set to 1 should be 11111111 (hex 0xFF). But your results—11000111 (0xC7) when starting from 00000000, and 11001111 (0xCF) when starting from 00000110—clearly show only partial bits are being set to 1, with some bits even changing based on the original value of foo.

Here are the most likely causes:

1. You're using an incorrect mask or broken bitwise logic #

Looking at your output values, the pattern tells us your code isn't setting all bits to 1. Instead:

• The top two bits (bits 7 and 6) are always 11
• Bits 5 and 4 are always 00
• Only bit 3 changes based on the original foo value

This suggests you might have a typo in your mask or a flawed bitwise operation. For example, if you accidentally wrote something like:

foo |= 0xC7 | (foo << 1);

This would produce exactly your results:

• When foo is 0, foo << 1 is 0, so you get 0xC7 (11000111)
• When foo is 0x06 (00000110), foo << 1 is 0x0C (00001100), and 0xC7 | 0x0C gives 0xCF (11001111)

This kind of incorrect logic makes your result depend on the original foo instead of forcing all bits to 1.

2. Confusion between signed and unsigned char assignment #

If you're trying to set all bits to 1, the correct approach depends on whether your char is signed or unsigned:

• For unsigned char: Just assign foo = 0xFF; directly (this is the literal all-ones value)
• For signed char: Assign foo = -1;—in two's complement, -1 is represented as 11111111 for 8-bit values

If you tried to assign 0xFF to a signed char, the memory will still hold 11111111, but printing it with %d will show -1 instead of 255—which might make you think it's wrong, but your binary output doesn't match this scenario, so this is probably not your issue.

3. Unexpected truncation from integer promotion #

In C/C++, char values are promoted to int when used in bitwise operations. For example, ~0 is a 32-bit int with all bits set (0xFFFFFFFF), and assigning this to a char will truncate it to 8 bits (0xFF, all ones)—which is correct. But if you add extra operations (like shifting before truncation), you might accidentally clear or modify bits.

How to fix it #

To reliably set all bits of a char to 1, use one of these simple, guaranteed methods:

// Method 1: Direct assignment (works for both signed and unsigned)
char foo = (char)0xFF;

// Method 2: Bitwise OR with full mask (sets all bits to 1 regardless of original value)
foo |= 0xFF;

// Method 3: For signed char only, use -1 (two's complement all-ones)
char foo = -1;

Double-check your code for typos in mask values (like writing 0xC7 instead of 0xFF) or incorrect bitwise logic—this is almost certainly the root cause of your unexpected results.

内容的提问来源于stack exchange，提问作者Alexander Andrews