我经常希望能够像这样在 c 中做某些事情：
val1 &= 0b00001111; //clear high nibble
val2 |= 0b01000000; //set bit 7
val3 &= ~0b00010000; //clear bit 5
这种语法似乎是C语言中非常有用的补充，我想不出任何缺点，而且在位操作比较常见的低级语言中，它似乎是一件很自然的事情。
编辑：我看到了其他一些很好的替代方案，但当存在更复杂的掩码时，它们都会崩溃。例如，如果reg是控制微控制器上I/O引脚的寄存器，并且我想同时将2、3和7号引脚设置为高电平，我可以写reg = 0x46;，但我需要花费10秒钟思考它（并且每次阅读这些代码之后的一两天里，我可能还需要再花费10秒钟），或者我可以写reg = (1 << 1) | (1 << 2) | (1 << 6);，但我个人认为这比只需编写`reg = 0b01000110;' 要不清晰得多。尽管我同意这种方法无法很好地扩展到8位或16位架构以外。不过我从来没有需要制作32位掩码。
由于缺乏先例和实用性不足，添加二进制常量的提议被拒绝。
虽然它不在标准C中，但是GCC作为扩展支持它，前缀为0b或0B：
i = 0b101010;
详见 此处。
这就是促使十六进制成为... 十六进制。 "... 十六进制表示法的主要用途是作为计算机和数字电子设备中二进制编码值的人类友好表示..."。它将如下所示：
val1 |= 0xF;
val2 &= 0x40;
val3 |= ~0x10;
十六进制:
稍微练习一下，转换十六进制和二进制之间的转换就会变得非常自然。试着手写出你的转换结果，不要使用在线的二/十六进制转换器--这样几天后它就会变得自然而然（并且更快）。
另外: 即使二进制文字不是C标准，如果你使用GCC编译，也可以使用二进制文字，它们应该以'0b'或'0B'为前缀。有关更多信息，请参见 此处 的官方文档。示例：
int b1 = 0b1001; // => 9
int b2 = 0B1001; // => 9
你提供的所有例子都可以更清晰地表达：
val1 &= (1 << 4) - 1; //clear high nibble
val2 |= (1 << 6); //set bit 6
val3 &=~(1 << 3); //clear bit 3
（我已经擅自修改了注释，让它们从零开始计数，就像自然界本来就是这样的。）
您的编译器将折叠这些常量，因此以这种方式编写它们不会带来性能损失。并且，这比0b...版本更容易阅读。
(1 << 4) - 1真的等同于0xF吗？也许不是。 - Abraham Sanchez我认为易读性是首要考虑因素。虽然低级，但阅读和维护你的代码的是人类，而不是机器。
如果你错误地输入了0b1000000000000000000000000000000（0x40000000），而实际上你想要输入的是0b10000000000000000000000000000000（0x80000000），那么这是否容易让你发现呢？
我建议在C语言中使用C宏来避免编译器警告或其他问题。我使用Ox（就像“Ohio”）代替0x。
#define Ob00000001 1
#define Ob10000000 (1 << (8-1))
#define Ob00001111 15
#define Ob11110000_8 (Ob00001111 << (8 - 4))
#define Ob11110000_16 (Ob00001111 << (16 - 4))
#define Ob11110000_32 (((uint32_t) Ob00001111) << (32 - 4))
#define Ob11110000_64 (((uint64_t) Ob00001111) << (64 - 4))
#define Ox0F Ob00001111
#define OxF0 Ob11110000_8
#define OxF000 Ob11110000_16
#define OxF0000000 Ob11110000_32
#define OxF000000000000000 Ob11110000_64
int main() {
#define Ob00001110 14
// bitwise operations work
if (Ob00001110 == (Ob00001111 & ~Ob00000001)) {
printf("true\n");
}
}
/* binmacro.h */
#define BX_0000 0
#define BX_0001 1
#define BX_0010 2
#define BX_0011 3
#define BX_0100 4
#define BX_0101 5
#define BX_0110 6
#define BX_0111 7
#define BX_1000 8
#define BX_1001 9
#define BX_1010 A
#define BX_1011 B
#define BX_1100 C
#define BX_1101 D
#define BX_1110 E
#define BX_1111 F
#define BIN_A(x) BX_ ## x
#define BIN_B(x,y) 0x ## x ## y
#define BIN_C(x,y) BIN_B(x,y)
#define BIN_B4(x,y,z,t) 0x ## x ## y ## z ## t
#define BIN_C4(x,y,z,t) BIN_B4(x,y,z,t)
#define BIN(x,y) BIN_C(BIN_A(x),BIN_A(y))
#define BIN4(x,y,z,t) BIN_C4(BIN_A(x),BIN_A(y),BIN_A(z),BIN_A(t))
/*---- test ... ---*/
BIN(1101,0100)
BIN4(1101,0010,1100,0101)
预处理成...
$ cpp binmacro.h
0xD4
0xD2C5
二进制在控制器上设置特定输出时最有用。我使用的是一种技术上非法但始终有效的黑客方法。如果您只需要打开一个LED，使用整个int甚至char都会冒犯每个人的感官。不要忘记，对于这些东西，我们可能并不谈论编译复杂性的极致。因此，为了个体可读性和群体控制，我使用位域：
struct DEMAND
{
unsigned int dOil : 1; // oil on
unsigned int dAir : 1; // air on
unsigned int dHeat : 1; // heater on
unsigned int dMtr1 : 1; // motor 1 on
unsigned int dMtr2 : 1; // motor 2 on
unsigned int dPad1 : 10;// spare demand o/p's
unsigned int dRunCycle: 1; // GO !!!!
unsigned int dPad2 : 15;// spare o/p's
unsigned int dPowerOn: 1; // Power on
}DemandBF;
当单独使用时，它们很容易处理，或者为了更彻底的控制，它们可以被视为无符号整数，而对K&R不予理会：
void *bitfPt = &DemandBF;
unsigned int *GroupOuts = (unsigned int *)bitfPt;
DemandBF.dAir = 1; // Clearly describes what's turning on
DemandBF.dPowerOn = 1;
*GroupOuts ^= 0x04; // toggle the heater
*GroupOuts = 0; // kill it all
这对我总是有效的，可能不太可移植，但实际上谁会像这样移植它呢？试一试吧。
自从C++14标准中包含了二进制字面量，就像您建议的那样：
二进制字面量是字符序列0b或字符序列0B，后跟一个或多个二进制数字（0、1）
int b = 0b101010;
自C++11以来，还有一种声明自定义字面量的方法。二进制字面量最初未被纳入标准的原因已不再重要。
#define B00000000 0#define B00000001 1#define B00000010 2#define B00000011 3...#define B10100100 0xA4... 可能需要强制类型转换为unsigned char。 - pmg0是一个八进制常量。 - chqrlie