单片机函数中GPIOX-CRL&=0XFF00FFFFF怎么计算，还有图中圈中部分麻烦给解释下！谢

位运算符的运算规则如下:&: 在C语言中有两种意思，一种是取地址符，是单目运算符；另一种是位运算符，表示“按位与”，是双目运算符。|: 是位运算符，表示“按位或”。资料扩展1、符号 & 和 | 这两个运算符都是二进制的按位操作符。&: 二进制“与”(都为1时，结果是1，否则是0。)，比如:1010 & 1011 = 1010，1010 & 1000 = 1000。|: 二进制“或”(有1时，结果是1，都是0时，结果为0。)，比如:1010 | 1011 = 1011，1010 | 1000 = 1010。2、位运算符将数字视为二进制值，并按位进行相应运算，运算完成后再重新转换为数字。例如:表达式10&15表示(1010 & 1111)，它将返回表示1010的值10。因为真真得真，或者是11得1，同位全是1结果也是1。表达式10|15表示(1010 | 1111),它将返回表示1111的值15。假假得假。全零得零。3、C语言中的符号分为10类:算术运算符、关系运算符、逻辑运算符、位操作运算符、赋值运算符、条件运算符、逗号运算符、指针运算符、求字节数运算符和特殊运算符。4、位操作运算符:参与运算的量，按二进制位进行运算。包括位与(&)、位或(|)、位非(~)、位异或(^)、左移(<<)、右移(>>)六种。

参加运算的两个数据，按二进制位进行“与”运算。 运算规则：0&0=0; 0&1=0; 1&0=0; 1&1=1; 即：两位同时为“1”，结果才为“1”，否则为0 例如：3&5 即 0000 0011& 0000 0101 = 00000001 因此，3&5的值得1。 另，负数按补码形式参加按位与运算。 “与运算”的特殊用途： 方法：找一个数，对应X要取的位，该数的对应位为1，其余位为零，此数与X进行“与运算”可以得到X中的指定位。 参加运算的两个对象，按二进制位进行“或”运算。 运算规则：0|0=0； 0|1=1； 1|0=1； 1|1=1； 即 ：参加运算的两个对象只要有一个为1，其值为1。 例如:3|5　即 00000011 | 0000 0101 = 00000111 因此，3|5的值得7。 另，负数按补码形式参加按位或运算。 “或运算”特殊作用： （1）常用来对一个数据的某些位置1。 方法：找到一个数，对应X要置1的位，该数的对应位为1，其余位为零。此数与X相或可使X中的某些位置1。 例：将X=10100000的低4位置1 ，用X | 0000 1111 = 1010 1111即可得到。 参加运算的两个数据，按二进制位进行“异或”运算。 运算规则：0^0=0； 0^1=1； 1^0=1； 1^1=0； 即：参加运算的两个对象，如果两个相应位为“异”（值不同），则该位结果为1，否则为0。 “异或运算”的特殊作用： （1）使特定位翻转找一个数，对应X要翻转的各位，该数的对应位为1，其余位为零，此数与X对应位异或即可。 例：X=10101110，使X低4位翻转，用X ^0000 1111 = 1010 0001即可得到。 （2）与0相异或，保留原值 ，X ^ 00000000 = 1010 1110。 下面重点说一下按位异或,异或其实就是不进位加法,如1+1=0，,0+0=0,1+0=1。 异或的几条性质: 1、交换律 2、结合律（即(a b) c == a (b c)） 3、对于任何数x，都有x x=0，x 0=x 4、自反性: a b b=a^0=a; 异或运算最常见于多项式除法，不过它最重要的性质还是自反性：A XOR B XOR B = A，即对给定的数A，用同样的运算因子（B）作两次异或运算后仍得到A本身。这是一个神奇的性质，利用这个性质，可以获得许多有趣的应用。 例如，所有的程序教科书都会向初学者指出，要交换两个变量的值，必须要引入一个中间变量。但如果使用异或，就可以节约一个变量的存储空间： 设有A,B两个变量，存储的值分别为a，b，则以下三行表达式将互换他们的值 表达式 （值） ： a=a^b; b=b^a; a=a^b; 1-1000放在含有1001个元素的数组中，只有唯一的一个元素值重复，其它均只出现 一次。每个数组元素只能访问一次，设计一个算法，将它找出来；不用辅助存储空 间，能否设计一个算法实现？ 解法一、显然已经有人提出了一个比较精彩的解法，将所有数加起来，减去1+2+...+1000的和。 这个算法已经足够完美了，相信出题者的标准答案也就是这个算法，唯一的问题是，如果数列过大，则可能会导致溢出。 解法二、异或就没有这个问题，并且性能更好。 将所有的数全部异或，得到的结果与1 2 3 ... 1000的结果进行异或，得到的结果就是重复数。 应用举例2(综合&和^):(题目链接: http://gdutcode.sinaapp.com/problem.php?cid=1051&pid=7 ) 一系列数中,除两个数外其他数字都出现过两次,求这两个数字,并且按照从小到大的顺序输出.例如 2 2 1 1 3 4.最后输出的就是3 和4 这个题就是首先在输入的时候一直异或,就可以把这两个数异或的乘积找出来,就比如上例中x=3^4; 然后找一个变量tmp来分开这两个数.按位与的话可以发现会分开这两个数分别存在num1和num2中.然后就有结果了. 将一个运算对象的各二进制位全部左移若干位（左边的二进制位丢弃，右边补0）。 例：a = a<< 2将a的二进制位左移2位，右补0， 左移1位后a = a *2; 若左移时舍弃的高位不包含1，则每左移一位，相当于该数乘以2。 将一个数的各二进制位全部右移若干位，正数左补0，负数左补1，右边丢弃。 操作数每右移一位，相当于该数除以2。 例如：a = a>> 2 将a的二进制位右移2位， 左补0 or 补1得看被移数是正还是负。 位运算符与赋值运算符结合，组成新的复合赋值运算符，它们是： 运算规则：和前面讲的复合赋值运算符的运算规则相似。 不同长度的数据进行位运算 如果两个不同长度的数据进行位运算时，系统会将二者按右端对齐，然后进行位运算。 以“与”运算为例说明如下：我们知道在C语言中long型占4个字节，int型占2个字节，如果一个long型数据与一个int型数据进行“与”运算，右端对齐后，左边不足的位依下面三种情况补足， （1）如果整型数据为正数，左边补16个0。 （2）如果整型数据为负数，左边补16个1。 （3）如果整形数据为无符号数，左边也补16个0。 如：long a=123;int b=1;计算a& b。 如：long a=123;int b=-1;计算a& b。 如：long a=123;unsigned intb=1;计算a & b。

首先，^是异或，不是或，异或是指位不同则为1。-3^2：-0011 ^ 0010(以四位为例，实际一般是32位，和机器有关) 负数要用补码（除符号位外取反加1）计算，即 1011 取反加1 ： 1101(-3补码)， 1101 ^ 0010得 1111(补码),转原码，减1取反，即1110再取反，1001所以结果为 -1；而 3^-2，实际上是 0011^1110(-2,1010的补码) ，得1101（结果补码）,减1取反，得1011(原码)，-3；-3^-2，即 1101^1110,得0011，即3，而 3^2，即0011^0010，得，0001，即1；~表示取反，3为0011，~3就是1100，2为0010，~2就是1101, ~3^~2，即 1100^1101，得0001，即1。扩展资料：位运算就是二进制数值按照位运算符&(与)，|（或）,~（取反）,^（异或）,>>（左移）,<<（右移）对二进制数值进行运算，我们知道 程序中的所有数在计算机内存中都是以二进制的形式储存的。位运算说穿了，就是直接对整数在内存中的二进制位进行操作。比如，and运算本来是一个逻辑运算符，但整数与整数之间也可以进行and运算。举个例子，6的二进制是110，11的二进制是1011，那么6 and 11的结果就是2，它是二进制对应位进行逻辑运算的结果（0表示False，1表示True，空位都当0处理）。参考资料来源：百度百科-位运算

位运算是指按二进制进行的运算。在系统软件中，常常需要处理二进制位的问题。C语言提供了6个位操作运算符。这些运算符只能用于整型操作数，即只能用于带符号或无符号的char,short,int与long类型。C语言提供的位运算符列表：运算符含义描述&按位与如果两个相应的二进制位都为1，则该位的结果值为1，否则为0|按位或两个相应的二进制位中只要有一个为1，该位的结果值为1^按位异或若参加运算的两个二进制位值相同则为0，否则为1~取反~是一元运算符，用来对一个二进制数按位取反，即将0变1，将1变0<<左移用来将一个数的各二进制位全部左移N位，右补0>>右移将一个数的各二进制位右移N位，移到右端的低位被舍弃，对于无符号数，高位补01、“按位与”运算符（&）按位与是指：参加运算的两个数据，按二进制位进行“与”运算。如果两个相应的二进制位都为1，则该位的结果值为1；否则为0。这里的1可以理解为逻辑中的true,0可以理解为逻辑中的false。按位与其实与逻辑上“与”的运算规则一致。逻辑上的“与”，要求运算数全真，结果才为真。若，true,B=true,则A∩B=true例如：3&53的二进制编码是11(2)。（为了区分十进制和其他进制，本文规定，凡是非十进制的数据均在数据后面加上括号，括号中注明其进制，二进制则标记为2）内存储存数据的基本单位是字节（Byte），一个字节由8个位（bit)所组成。位是用以描述电脑数据量的最小单位。二进制系统中，每个0或1就是一个位。将11（2）补足成一个字节，则是00000011（2）。5的二进制编码是101（2），将其补足成一个字节，则是00000101（2）按位与运算：00000011(2)&00000101(2)&00000001(2)由此可知3&5=1c语言代码：#includemain(){inta=3;intb=5;printf("%d",a&b);}按位与的用途：（1）清零若想对一个存储单元清零，即使其全部二进制位为0，只要找一个二进制数，其中各个位符合一下条件：原来的数中为1的位，新数中相应位为0。然后使二者进行&运算，即可达到清零目的。例：原数为43，即00101011（2），另找一个数，设它为148，即10010100（2），将两者按位与运算：00101011（2）&10010100（2）00000000（2）c语言源代码：#includemain(){inta=43;intb=148;printf("%d",a&b);}（2）取一个数中某些指定位若有一个整数a(2byte),想要取其中的低字节，只需要将a与8个1按位与即可。a0010110010101100b0000000011111111c0000000010101100（3）保留指定位：与一个数进行“按位与”运算，此数在该位取1.例如：有一数84，即01010100（2），想把其中从左边算起的第3，4，5，7，8位保留下来，运算如下：01010100(2)&00111011(2)00010000(2)即：a=84,b=59c=a&b=16c语言源代码：#includemain(){inta=84;intb=59;printf("%d",a&b);}

计算两个数x，y相与的结果。代码写作x&y先将x与y分别写成二进制bit形式~~例如计算10&3010二进制为101030为11110然后从低位开始，每个bit分别作与运算~~其中bit的与运算，除了1&1=1外，其余组合结果均为0故10&30=01010，即1010。。。

C语言中按位或，与，非是怎么用的，怎么运算？ 按位或规则： 1｜1=1 1｜0=1 0｜1=1 0｜0=0 按位与规则： 1&1=1 1&0=0 0&1=0 0&0=0 非运算规则： ~1=0 ~0=1 对每一个二进位制位进行相应的运算。 c语言中>>=运算子是怎么用的？能举例最好 首先，">>"是一个运算子，叫做右移运算子，与之对应的有"<<"左移运算子。 其次，">>="或是"<<="与"+="，"-="，"*="，"/="等等这些运算子作用是相同的。 通常可以使用位移运算子做快速的"*2"或"/2"运算 比如： int a=32; printf("%d",(a>>=3)); 右移3位，就相当于32/2/2/2=4 如果改为左移， int a=16; printf("%d",(a<<=2)); 左移2位，就相当于16*2*2=64 在C语言中指数运算怎么用 C语言中指标运算要用pow()函式，例如2的4次方要写成这样：pow(2,4);^在C语言中是一个位操作符，作用是按位异或。注意，pow()函式要包含math.h档案 c语言中for语句是怎么用的 for是C语言中的一个关键字，主要用来控制回圈语句的执行。下面举例说明for语句的使用方法：int i;for(i=0; i i=0是初始化部分；i{printf(＂HelloWorld＂);} 上面的for语句就是控制输出3次HelloWorldfor回圈是开界的。它的一般形式为： for（； ； ) 语句； 初始化总是一个赋值语句， 它用来给回圈控制变数赋初值； 条件表示式是一个关系表示式， 它决定什么时候退出回圈； 增量定义回圈控制变数每回圈一次后 按什么方式变化。这三个部分之间用＂；＂分开。 例如： for(i=1; i10时， 结束回圈。for的回圈顺序你如果了解的话就会理解i++的作用了 我系统的说下吧 for（表示式1；表示式2；表示式3）{ 回圈内容； } for的流程如下 当进入for回圈的时候，首先执行表示式1（就是你上边的i=1的部分） 然后执行表示式2（就是你上边的i<8的部分）判断是否满足条件 满足条件进入回圈体，执行回圈体内容，当回圈结束后执行表示式3（也就是你写的i++），然后再执行表示式2，判断是否还满足条件，这时i经过了表示式3后值已经变成了2.所以还是满足表示式2的条件。这样一直下去直到不满足的时候回圈就结束了 回圈如for (i=o;i<5;i++)printf(＂ ＂); i初始值为0.i小于5时执行以下的语句。执行后就进行i++（也就是把i自身+1）。for()回圈，最常用的回圈 语法结构： for(语句1;语句2;语句3){ 回圈体 } 语句1：初值表示式，用于在回圈开始前为回圈变数赋初值 语句2：回圈控制逻辑表示式，它控制回圈执行的条件，决定回圈的次数 语句3：回圈控制变数修改表示式，它使for回圈趋向结束 回圈体：需要重复执行的语句 例程： #include<stdio.h> int main(){ for(int i=0;i<5;i++){ printf("%d ",i); } return 0; } 语句1: int i=0; （仅进入回圈体时执行，同一个回圈周期仅执行一次） 语句2：i<10; 判断语句，当条件成立时执行回圈体 （当程式进入回圈时，i=0,此时紧接着执行语句2，发现语句2成立，那么程式开始执行回圈体） 语句3：i++; （第一次回圈体执行完成后，程式自动执行语句3，执行语句3后自动再去判断语句2是否成立，如果成立则再执行回圈体，以此类推） 回圈体：printf(“%d ”,i); 程式解释：回圈输出变数i的值 最终输出结果 0 1 2 3 4“”这是注释符，注释符后面的内容是对程式的解释或者说明，不是程式体的一部分 如果有大块资料作为引数传递的时候，采用的方案往往是指标，for(int i=0; i<10; ++i){ printf("你好"); 输出你好10次} 在C语言中，运算子 是什么意思是怎么用的 运算子就是执行运算的符号。 和数学里面的加减乘除类似用法。 比如A+B 这里的+ 就是运算子。 分为单目 双目 三目三种。^的意思是异或，就是二进位制的按位计算，相异为1，否则为0； 举个例子： 140^60 = (0x10001100) ^ (0x00111100) = 0x10110000 = 176 C语言中逗号运算子怎么用? 逗号运算子( , )是C语言运算子中优先顺序最低的一种运算子，结合顺序是从左至右，用来顺序求值（最后一个逗号后面表示式的值作为整个表示式的值）。 根据你的例子，首先声明了三个变数a,s,d；接着给s赋值为2，d赋值为3；接着要计算给a赋的值：根据运算子的优先顺序，先算小括号里的s+2=4，接着算d+4=7，然后才是逗号运算子，取7，最后和小括号外面的12想加得19，即a=19。

一、位运算符C语言提供了六种位运算符：& 按位与| 按位或^ 按位异或~ 取反<< 左移>> 右移1. 按位与运算 按位与运算符"&"是双目运算符。其功能是参与运算的两数各对应的二进位相与。只有对应的两个二进位均为1时，结果位才为1 ，否则为0。参与运算的数以补码方式出现。例如：9&5可写算式如下： 00001001 (9的二进制补码)&00000101 (5的二进制补码) 00000001 (1的二进制补码)可见9&5=1。 按位与运算通常用来对某些位清0或保留某些位。例如把a 的高八位清 0 ， 保留低八位， 可作 a&255 运算 ( 255 的二进制数为0000000011111111)。main(){int a=9,b=5,c;c=a&b;printf("a=%d b=%d c=%d ",a,b,c);}2. 按位或运算 按位或运算符“|”是双目运算符。其功能是参与运算的两数各对应的二进位相或。只要对应的二个二进位有一个为1时，结果位就为1。参与运算的两个数均以补码出现。例如：9|5可写算式如下： 00001001|0000010100001101 (十进制为13)可见9|5=13main(){int a=9,b=5,c;c=a|b;printf("a=%d b=%d c=%d ",a,b,c);}3. 按位异或运算 按位异或运算符“^”是双目运算符。其功能是参与运算的两数各对应的二进位相异或，当两对应的二进位相异时，结果为1。参与运算数仍以补码出现，例如9^5可写成算式如下： 00001001^00000101 00001100 (十进制为12)main(){int a=9;a=a^15;printf("a=%d ",a);}4. 求反运算 求反运算符～为单目运算符，具有右结合性。 其功能是对参与运算的数的各二进位按位求反。例如～9的运算为： ~(0000000000001001)结果为：11111111111101105. 左移运算 左移运算符“<<”是双目运算符。其功能把“<< ”左边的运算数的各二进位全部左移若干位，由“<<”右边的数指定移动的位数，高位丢弃，低位补0。例如： a<>”是双目运算符。其功能是把“>> ”左边的运算数的各二进位全部右移若干位，“>>”右边的数指定移动的位数。 例如：设 a=15，a>>2 表示把000001111右移为00000011(十进制3)。 应该说明的是，对于有符号数，在右移时，符号位将随同移动。当为正数时， 最高位补0，而为负数时，符号位为1，最高位是补0或是补1 取决于编译系统的规定。Turbo C和很多系统规定为补1。main(){unsigned a,b;printf("input a number: ");scanf("%d",&a);b=a>>5;b=b&15;printf("a=%d b=%d ",a,b);}请再看一例!main(){char a="a",b="b";int p,c,d;p=a;p=(p<<8)|b;d=p&0xff;c=(p&0xff00)>>8;printf("a=%d b=%d c=%d d=%d ",a,b,c,d);}

u2002u2002u2002u2002在十进制加法运算中，因为我们的加法满足 满十进一 的规则，所以这种运算方式将会导致 进位 [1] ，从而导致了这样的一种结果： u2002u2002u2002u2002在十进制的 四则运算 [2] 里，每一位低位 [3] 都可能因为四则运算而影响到下一位高位 [4] 。 u2002u2002u2002u2002而在我们的位运算中，以下4种位运算方式都没有 进位 规则。 u2002u2002u2002u2002此外，还要提到两种特殊的位运算 进位 和 退位 ，看一下这两种情况下的运算结果： u2002u2002u2002u2002当然还有 无限位数 下运算，参考如下： u2002u2002u2002u2002看完这2种情况可能有人会说：这不是已经影响到了每一位上的数？甚至前后位还发生了“数据的丢失”！ u2002u2002u2002u2002确切的说：不管是有限位数下还是无限位数下，进位和退位的运算都影响到了其它位。但特别要强调的是：位运算是“对每一位进行独立运算”， 进位 和 退位 也是如此： u2002u2002u2002u2002通过尝试，我们可以发现二进制的加法和十进制的加法其实都有着共通的地方，也就是“满n进位”，即：满2进1，满10进1。我们列几个式子计算一下就清楚了： 待进位 的二进制计算可以观察到如下图表般的规律： 结果位 的二进制运算则有如下规律: u200bu2002u2002u2002规律有了，那么我们开始开始尝试使用位运算完成加法计算： u200bu2002u2002u2002到步骤4时，问题来了。我们需要一些例子分析一下会有什么结果： u200bu2002u2002u2002这里我们发现应该让1100和0001进行重复步骤的加算，因为1100和0001是2个全新的数，并没有让它们相加组合： u200bu2002u2002u2002回头完善步骤： u200bu2002u2002u2002至此，通过位运算完成加法计算已经说明完毕。我们可以发现位运算的作用真的就只是“在做标记”而已，是名副其实的“按位运算”。 u2002u2002u2002至于减法涉及到了一些特别的技巧，乘法除法其实按本文理解了位运算的本质后也并不会很难用位运算去实现它，所以就不再提及了，读者可以自行尝试，或者搜索其它作者的相关文章。 本文所提及的口头术语的解释：

按位与运算符"&"是双目运算符。 其功能是参与运算的两数各对应的二进位相与。只有对应的两个二进位均为1时， 结果位才为1， 否则为0。比如 9&16 =0000 1001&0001 0000=0000 00000010 0111&0000 1111=0000 0111

逐位相“与”、逐位相“或”与：有一个为0则为0，否则为1；即1与1=1，1与0、0与1、0与0都=0。或：至少有一个为1则为1，否则为0；即1或1、1或0、0或1都=1，0或0=0.按位相或和相与,没有进位。 相或运算:在给定的逻辑变量中,只要有一个为1,两个二进制数相或的结果就为1。只有两者都为0时，两个二进制数相或的结果为1。二进制的逐位相与是 编程语言中常用二进制的逐位相与是&判断两个表达式的真假性，只有两个表达式同时为真才为真，有一个为假则为假，具有短路性质。用&表示将两个二进制的数逐位相与，结果是相与之后的结果。部分编程语言还用&放在变量前表示引用赋值，比如PHP。

+法的优先级比左移高，先算2+1=3再算b左移3位b=10转成二进制就是1010，左移两位就是1010000，转成10进制是80。（这里还有简便算法，左移3位就是乘以2^3，也能得到80）最后是赋值，a=80，所以a的值是80.

i的值是八进制的0122，即二进制的0000000001010010j的值是十六进制的0xa4，即二进制的0000000010100100<<的优先级高于&的优先级，所以i&j<<2等价于：i&(j<<2)即0000000001010010&(0000000010100100<<2)0000000010100100<<2，是左移两位，变成0000001010010000i&(j<<2)就是0000000001010010&0000001010010000&是按位与，对应位都是1，结果是1，否则为0结果是：00000000000010000，即十进制的16，所以结果是16

&是二进制“与”运算，参加运算的两个数的二进制按位进行运算，运算的规律是：0&0=00&1=01&0=01&1=1对于参加运算的数要换算为二进制进行运算，例如3&2的结果是2，过程如下：3&2=0111&0010=0010=2

与运算的运算规则：与运算是计算机中一种基本的逻辑运算方式，符号表示为“&”，按二进制位进行与运算，运算规则为，0&0=0；0&1=0；1&0=0；1&1=1，即：两位同时为“1”，结果才为“1”，否则为“0”。负数按补码形式参加按位与运算。扩展资料：“与运算”的特殊用途：（1）清零：如果想将一个单元清零，即，使其全部二进制位为0，只要与一个各位都为零的数值相与，结果为零。（2）取一个数中的指定位：确定一个数，对应X要取的位，该数的对应位为1，其余位为零，此数与X进行“与运算”可以得到X中的指定位。

C语言提供了表12—1所列出的6种位运算符以及表12-2所列出的5种扩展运算符。表12-1运算符含义优先级~按位求反高<<左移低>>右移&按位与^按位异或|按位或表12-2扩展运算符表达式等价的表达式<<=a<<=2a=a<<2>>=b>>=1b=b>>1&=a&=ba=a&b^=a^=ba=a^b|=a|=ba=a|b【说明】位运算符中，只有“反求”（~）是单目运算符，即要求运算符两侧各有一个运算量，其余均为双目运算符。运算的运算对象只能是整形或字符型数据，不能是其他类型的数据，在VC6.0中整形数据占4个字节，字符型数据占1个字节。参与运算时，操作数都必须首先转换成二进制形式，然后再执行相应的按位运算。各双目运算符与赋值运算符结合可以组成扩展的赋值运算符，见表12-2.12.2位运算符详解12.2.1按位与运算按位与运算“&”的运算格式：操作数1&操作数2【说明】其中“操作数1”和操作数“2”必须是整型或字符型数据。按位与运算规则是：当参加运算的2个二进制数的对应位都为1，则该位的结果为1，否则为0，即0&0=0，0&1=0，1&0=0，1&1=1。【例如】4&5的运算如下：00000100（4）（&）00000101（5）00000100（4）因此，4&5的值为4。可以利用按位与运算来实现一些特定的功能，下面介绍几种常见的功能。清零如果想将一个数的全部二进制置为零，只要找一个二进制数，其中个个位要符合以下条件：原来的数中为1的位，新数中相应的位为0。然后使二者进行按位与运算即可达到清零的目的。【例如】原有数为171，其二进制形式为10101011，另找一个数，设它为00010100，它符合以上条件，即在原数为1的位置上，它的位值均为0。将两个数进行&运算：10101011（&）0001010000000000当然也可以不用00010100这个数而用其他数（如01000100）也可以，只要符合上述条件即可。任何一个数与“0”按位于之后的结果为0。娶一个数中某些指定位【例如】有一个两字节的短整型数x，想要取其中的低字节，只要将x与八进制数（377）8按位于即可。如图12-1所示，经过运算“z=x&y”后z只保留x的低字节，高字节为0.x0010110010101100y0000000011111111z0000000010101100图12-1取x的低八位数x0010110010101100y1111111100000000Z0010110000000000图12-2取x的高8位如果想取两个字节中的高字节，如图12-2所示只需进行运算z=x&（177400）8。保留一个数的某些位要想将哪一位保留下来，就与一个数进行&运算，此数在该位取1。【例如】有一数01110100，想把其中左面第1、3、5位保留下来，可以这样运算：01110100（十进制数116）（&）10101010（十进制数170）00100000（十进制数32）

位运算符C提供了六种位运算运算符;这些运算符可能只允许整型操作数，即char、short、int和long，无论signed或者unsigned。&按位AND|按位OR^按位异或<<左移>>右移~求反(一元运算)按位与操作&通常用于掩去某些位，比如n=n&0177;使得n中除了低7位的各位为0。按位或操作|用于打开某些位:x=x|SET_ON;使得x的某些SET_ON与相对的位变为1。按位异或操作^使得当两个操作数的某位不一样时置该位为1，相同时置0。应该区分位操作符&、|与逻辑操作符&&、||，后者从左到右的评价一个真值。比如，如果x为1、y为2，那么x&y为0，而x&&y为1。移位运算符<<和>>将左侧的操作数左移或者右移右操作数给定的数目，右操作数必须非负。因此x<<2将x的值向左移动两位，用0填充空位;这相当于乘4。右移一个无符号数会用0进行填充。右移一个带符号数在某些机器上会用符号位进行填充(“算数移位”)而在其他机器上会用0进行填充(“逻辑移位”)。单目运算符~对一个整数求反;即将每一个1的位变为0，或者相反。比如x=x&~077将x的后六位置0。注意x&~077的值取决于字长，因此比如如果假设x是16位数那么就是x&0177700。这种简易型式并不会造成额外开销，因为~077是一个常数表达式，可以在编译阶段被计算。作为一个使用位操作的实例，考虑函数getbits(x,p,n)。它返回以p位置开始的n位x值。我们假设0位在最右边，n和p是正数。例如，getbits(x,4,3)返回右面的4、3、2位。/*getbits:返回从位置p开始的n位*/unsignedgetbits(unsignedx,intp,intn){return(x>>(p+1-n))&~(~0<<n);}表达式x>>(p+1-n)将需要的域移动到字的右侧。~0是全1;将其左移n为并在最右侧填入0;用~使得最右侧n个1成为掩码。

具体不知道怎么定义的但是所谓位与，即为按位做与运算。就是每一位两个数字做与运算，因为在计算机世界里，只有0和1两个数字。于是有：1与1----------等于10与1----------等于0。

首先，^是异或，不是或，异或是指位不同则为1-3^2：-0011 ^ 0010(我以四位为例，实际一般是32位，和机器有关) 负数要用补码（除符号位外取反加1）计算，即 1011 取反加1 ： 1101(-3补码)， 1101 ^ 0010得 1111(补码),转原码，减1取反，即1110再取反，1001所以结果为 -1而 3^-2，实际上是 0011^1110(-2,1010的补码) ，得1101（结果补码）,减1取反，得1011(原码)，-3-3^-2，即 1101^1110,得0011，即3，而 3^2，即0011^0010，得，0001，即1~表示取反，3为0011，~3就是1100，2为0010，~2就是1101, ~3^~2，即 1100^1101,得0001，即1.

我只能部分回答你的问题：　　单说【与】，它是逻辑代数中的概念，是一种【逻辑运算】。另外，还有【或】运算、【非】运算。能够进行逻辑运算的，都得是【逻辑变量（或常量）】——即：取值范围为｛FALSE，TRUE｝的量。　　【逻辑与】——＆＆，其实就是上面的【与】的全称；【逻辑或】——｜｜，就是【或】的全称。所以，逻辑与和逻辑或也是【逻辑变量】间的一种运算——至少是可以转化为逻辑变量的量。　　我不知道你的问题属于哪个领域，但在计算机语言中，一般将数值为0的量视为：FALSE；数值非零的量视作：TRUE。逻辑与和逻辑或都有自己的运算规则，一般是通过真值表来定义的。　　你的例子中，a、b均不为零，应都视作：TRUE；那么，逻辑运算的结果就是：　　　　a＆＆b＝TRUE＆＆TRUE＝TRUE；　　　　a｜｜b＝TRUE｜｜TRUE＝TRUE；　　【按位与】——＆、【按位或】——｜，是对逻辑与、逻辑或的一种扩充。首先，你得明白什么叫做【位】。　　【位】——即【bit】——也即【比特】，是计算机中存储数据的最小单位。【位】上的取值，只能是｛0，1｝中的值。你的例子中的各种变量，就是以【位】的形式给出的。如：　　　　a＝4′b0101；　　它表示：a是一个4【位】的变量，各个位的取值分别为：0、1、0、1。　　因为【位】的取值只能是｛0，1｝，所以可以很自然地将其对应为｛FALSE，TRUE｝。这样一来，两个【位】之间，就可以进行【逻辑运算】了。　　而按位与（按位或），就是指：将两个【位】数相同的变量，的每一【位】，对应进行逻辑与（逻辑或）运算，将结果保存为另一个具有同样【位】数的变量。所以，逻辑与、逻辑或，是按位与、按位或的基础。对于本题：　　　　a＆b＝4′b｛（0＆＆0），（1＆＆0），（0＆＆1），（1＆＆1）｝　　　　　　　＝4′b｛0，0，0，1｝　　　　　　　＝4′b0001　　　　a｜b＝4′b｛（0｜｜0），（1｜｜0），（0｜｜1），（1｜｜1）｝　　　　　　　＝4′b｛0，1，1，1｝　　　　　　　＝4′b0111　　　　　　至于【约简与】，我也不懂，帮不了你了。　　我们是用从左到右的一排数字来表示一个数的。在十进制数中，从左到右各个数位分别为：……千位、百位、十位、个位，每位所表示的数值，越来越小。因此，左边的数位称作高位，右边的称作低位。对于二进制数的位——又称比特，就自然相应地称作：高比特位、低比特位。　　因此，所谓“4个高比特位”，就是指变量左边的4位上的数字。因为是对【位】进行处理，自然就要用到【按位与（或）】运算了。根据【逻辑与（或）】的性质：　　任何数，和TRUE（即：1）进行【与】运算，结果都为这个数本身；　　任何数，和FALSE（即：0）进行【与】运算，结果都为FALSE（即：0）；　　任何数，和TRUE（即：1）进行【或】运算，结果都为TURE（即：1）；　　任何数，和FALSE（即：0）进行【或】运算，结果都为这个数本身；再看看a、b的取值情况，不难看出：只有在进行【与】运算时，才能保住a的高四位。所以答案就是：A。

&是按位与运算，把a和b的二进制数按位与的结果赋给d//以下来自百度百科在c语言里，&代表取地址或者逻辑与运算取变量的地址：&变量名，这将获得该变量的地址。//这是这里的用法进行逻辑与运算，格式是：变量1&变量2，进行计算时，将会把类型提升为int。

c语言中的位运算子中‘按位取反"是怎么运算的 位运算中的按位取反操作，使用的运算子为~， 其计算原则为： 按照运算元的二进位制值，逐位计算，如果原始值为0，则结果该位上为1， 否则结果该位上为0。 比如char型别的0x78按位取反 ~0x78 =~B0111 1000转为二进位制值。 =B1000 0111按位取反。 =0x87 按位取反，顾名思义，就是把每一位取反，0变成1，1变成0 c语言中的位运算子中‘按位取反"是怎么运算的，什么是负数的反码，请各位帮我解释一下！ 0001 取反 1110 符号位为1，取反+1为 1010 转化成10进制为 -2 正数的原码,补码,反码都相同,都等于它本身 负数的补码是:符号位为1,其余各位求反,末位加1 反码是:符号位为1,其余各位求反,但末位不加1 也就是说,反码末位加上1就是补码 1100110011 原 1011001100 反 除符号位，按位取反 1011001101 补 除符号位，按位取反再加1 正数的原反补是一样的 在计算机中，资料是以补码的形式储存的: 在n位的机器数中，最高位为符号位，该位为零表示为正，为1表示为负； 其余n-1位为数值位，各位的值可为0或1。 当真值为正时:原码、反码、补码数值位完全相同； 当真值为负时: 原码的数值位保持原样， 反码的数值位是原码数值位的各位取反， 补码则是反码的最低位加一。 注意符号位不变。 如:若机器数是16位: 十进位制数 17 的原码、反码与补码均为： 0000000000010001 十进位制数-17 的原码、反码与补码分别为：1000000000010001、1111111111101110、1111111111101111 c语言之中的位运算子是怎么运算的呢？ 所谓位，就是指将一个或两个数转换成二进位制按每一位进行运算 &位与 运算规则 0 & 0 = 0 0 & 1 = 0 1 & 0 = 0 1 & 1 = 1 |位或 运算规则 0 | 0 = 0 0 | 1 = 1 1 | 0 = 1 1 | 1 = 1 ^异或 运算规则 0 ^ 0 = 0 0 ^ 1 = 1 1 ^ 0 = 1 1 ^ 1 = 0 ~取反 运算规则 将0变1 将1变0 <<左移 运算规则 左移n位，相当于给一个十进位制数乘以2的n次方 >>右移 运算规则 右移n位，相当于给一个十进位制数除以2的n次方 前三个是两个二进位制数之间的运算 后三个是一个二进位制数自身的运算 C语言中的位运算子 0x 表示16进位制 0***表示8进位制 10进位制你会吧？ 0x1 = 16进位制的1 0x10 = 16进位制的16 c语言中的位运算的运算子号是什么？？？ & 按位与 | 按位或 ^ 按位异或 ~ 取反 << 左移 >> 右移 按位运算子是怎么运算的？ 1、按位运算子是把两个运算元分别转换成二进位制数，如果两个二进位制数长度不一样，在短的左边补0，补到一样的长度，然后对两个二进位制数按对应的位进行运算。 2、示例按位与： 11101010 00011111 ------------ 00001010 C语言 位运算子 你全错了 a=00000011 b=00000011 | 00001000 =00001011 c=b<<1=00010110,即十进位制的22 位运算子是怎样运算的 位运算子 按 数值 的 2进位制资料 位对位地 运算，没有进位，也没有向高位借1的方法。 例如: 十进位制 81 | 225 运算 ( 16进位制： 0x50 | 0xe1) 按位或： 0101 0000 | 1110 0001 = 1111 0001 81 & 225 运算 ( 16进位制： 0x50 & 0xe1) 按位与： 0101 0000 & 1110 0001 = 0100 0000

现只讨论正整数，给你举个例子你就明白了：比如说是十进制的5&9操作过程如下：先将5,9转换二进制5=101（二进制）,9=1001（二进制），然后与位数多那个补齐也就说5=0101（二进制）5 01019 1001---------------1 0001 过程是左起第一位0&1得0，第二位1&0得0，第三位0&0得0,1&1得1，所以得到结果为0001；十进制也是1；同理按位或，异或同理可得希望你满意

C语言的运算符主要用于构成表达式，同一个符号在不同的表达式中，其作用并不一致。下面按计算的优先顺序，分别说明不同作用的表达式。需要特别指出，在C语言标准中，并没有结合性的说法。 相同优先级运算符，从左至右依次运算。注意后缀运算优先级高于前缀。因此++i++应解释为++(i++)。而与或非的运算优先级都不一样，因此a && b || b && c解释为(a && b) || (b && c)合理使用优先级可以极大简化表达式。基本表达式 1级基本表达式（Primary expressions），主要是用于运算符之间，做为运算数。标识，常量，字符串文字量，优先级提升表达式最优先执行。优先级提升表达式是指圆括号包围的表达式，如“( expression )”后缀表达式 2极postfix-expression [ expression ]，数组下标运算。postfix-expression ( argument-expression-list)，函数调用，括号内的参数可选。postfix-expression . identifier，成员访问，postfix-expression -> identifier，成员访问，->号之前应为指针。postfix-expression ++，后缀自增postfix-expression --，后缀自减( type-name ) { initializer-list }( type-name ) { initializer-list , } 复合初始化，C99后新增。例如 int* a = (int[]) { 1, 2, 3 };//等价于 int unamed[] = {1, 2, 3}; //unamed表示一个不可见的变量名。 int* a = unamed; 单目/一元运算 3级++ unary-expression 前缀自增-- unary-expression 前缀自减unary-operator cast-expression 单目转型表式式， 包括 取地址& ，提领 * ， 正号+ ，负号- 位反~ 逻辑否!。sizeof unary-expression 求类型长度，对表达式求类型长度sizeof ( type-name ) 求类型长度强制类型表达式 4级( type-name ) cast-expression，强制表达式成为type-name指定的类型。乘法表达式 5级“ * ” 乘法运算符；“ / ”除法运算符；“ % ” 取余运算符。加法运算符 6级“ + ”加法运算符；“ - ”减法运算符。移位运算符 7级<< 左移运算符；>> 右移运算符。关系运算符 8级<、<=、>、>=关系运算符。相等运算符 9级“ == ”等于运算符；“ != ”不等于运算符。位与运算符 10级“ & ”按位与运算符位异或运算符 11级“ ∧ ”按位异或运算符（Bitwise exclusive OR operator）。位或运算符 12 级“ | ”按位或运算符（Bitwise inclusive OR operator）。　　逻辑与运算符 13级“&&”逻辑与运算符。逻辑或运算符 14 级“ || ”逻辑或运算符。三元条件运算符 15级? :条件运算符。赋值运算符 16 级=、 +=、 -=、 *=、 /=、 %=、 &=、 ^=、 |=、 <<=、 >>=赋值运算符。逗号运算符 17级“，”逗号运算符。[pre]C 语言中，逗号（,）也可以是运算符，称为逗号运算符（Comma Operator）。逗号运算符可以把两个以上（包含两个）的表达式连接成一个表达式，称为逗号表达式。其一般形式为：　　子表达式1, 子表达式2, ..., 子表达式n　　例如：　　a + b, c = b, c++　　逗号运算符的优先级是所有运算符中级别最低的，通常配合 for 循环使用。逗号表达式最右边的子表达式的值即为逗号表达式的值。上例中，c++ 的值（c 自增之前的值）即为该表达式的值。　　逗号运算符保证左边的子表达式运算结束后才进行右边的子表达式的运算。也就是说，逗号运算符是一个序列点，其左边所有副作用都结束后，才对其右边的子表达式进行运算。因此，上例中，c 得到 b 的值后，才进行自增运算。优先级：C语言中，运算符的运算优先级共分为15 级。1 级最高，15 级最低。 在表达式中，优先级较高的先于优先级较低的进行运算。而在一个运算量两侧的运算符 优先级相同时，则按运算符的结合性所规定的结合方向处理。结合性：C语言中各运算符的结合性分为两种，即左结合性(自左至右)和右结合性(自右至左)。例如算术运算符的结合性是自左至右，即先左后右。如有表达式x-y+z 则y 应先与“-”号结合，执行x-y 运算，然后再执行+z 的运算。这种自左至右的结合 方向就称为“左结合性”。而自右至左的结合方向称为“右结合性”。最典型的右结合 性运算符是赋值运算符。如x=y=z,由于“=”的右结合性，应先执行y=z 再执行x=(y=z)运算。C语言运算符中有不少为右结合性，应注意区别，以避免理解错误。优先级从上到下依次递减，最上面具有最高的优先级，逗号操作符具有最低的优先级。所有的优先级中，只有三个优先级是从右至左结合的，它们是单目运算符、条件运算符、赋值运算符。其它的都是从左至右结合。具有最高优先级的其实并不算是真正的运算符，它们算是一类特殊的操作。()是与函数相关，[]与数组相关，而－>及.是取结构成员。其次是单目运算符，所有的单目运算符具有相同的优先级，因此在我认为的 真正的运算符中它们具有最高的优先级，又由于它们都是从右至左结合的，因此*p++与*(p++)等效是毫无疑问的。另外在C语言里，没有前置后置之分，因为++ -- 是右结合所以右侧优先运算，表现为 "操作数后置优先级比较高" 的假象，前置和后置的区分是因为运算符重载而后加入C++的接下来是算术运算符，*、/、%的优先级当然比+、－高了。移位运算符紧随其后。其次的关系运算符中，< <= > >=要比 == !=高一个级别，不大好理解。所有的逻辑操作符都具有不同的优先级（单目运算符除外，！和~）逻辑位操作符的"与"比"或"高，而"异或"则在它们之间。跟在其后的&&比||高。接下来的是条件运算符，赋值运算符及逗号运算符。在C语言中，只有4个运算符规定了运算方向，它们是&&、| |、条件运算符及赋值运算符。&&、| |都是先计算左边表达式的值，当左边表达式的值能确定整个表达式的值时，就不再计算右边表达式的值。如 a = 0 && b; &&运算符的左边位0，则右边表达式b就不再判断。在条件运算符中。如a?b:c；先判断a的值，再根据a的值对b或c之中的一个进行求值。赋值表达式则规定先对右边的表达式求值，因此使 a = b = c = 6;成为可能。口诀注释优先级等级口诀圆方括号、箭头一句号， 自增自减非反负、针强地址长度，乘除，加减，再移位，小等大等、等等不等，八位与，七位异，六位或，五与，四或，三疑，二赋，一真逗。其中“，”号为一个等级分段。优先级等级注释“圆方括号、箭头一句号”指的是第15级的运算符。其中圆方括号很明显“（）、[]”，箭头 指的是指向结构体成员运算符“->”，句号 指的是结构体成员运算符“.” ；“自增自减非反负、针强地址长度”指的是第14级的运算符。其中 非 指的是逻辑运算符“!”，反 指的是按位取反运算符“~”，负 指的是负号运算符“－”，针 指的是指针运算符“*”，强 指的是强制类型转换运算符，地址 指的是地址运算符“&”，长度 指的是长度运算符“sizeof ”；“乘除，加减，再移位”移位指的是左移运算符“<<”和右移运算符“>>”，其中除法还包括了 取余运算符“%”；“小等大等、等等不等” 指的是第10级到第9级的运算符：<、<=、>和>=，等等指的是等于运算符==，不等指的是不等于运算符!=“八位与，七位异，六位或”其中 八位与 指的是第8级的 按位与 运算符“&”，七位异 指的是第7级的按位异或运算符“^”，六位或 指的是第6级的按位或运算符“|”；“五与，四或”指的是第5级、第4级的逻辑与运算符“&&”和逻辑或运算符“||”；“三疑，二赋，一真逗”指的是第3级到第1级的运算符。其中，三疑指的是条件运算符“？：” （三有双重含义：即指优先级别是三，它的运算符类型也是三目，疑也取“?”之意），二赋 指的是赋值运算符=、+=、-=、*=、/=、%=、>>=、<<=、&=、^=和|= ，一真逗 指的是第1级的“，”运算符，真字只是为了语句需要罢了。由于C语言的运算符优先级与C++的不完全一样(主要是增加了几个运算符)，所以这个口诀不能完全实用于C++.但是应该能够兼容，大家可以比较一下他们的区别应该就能够很快掌握C++的优先级的！应用举例1、赋值运算符：a=5;a=b=0;第一个赋值语句把5赋给变量a；第二个赋值语句的意思是把0同时赋值给两个变量。这是因为赋值语句是从右向左运算的，也就是说从右端开始计算，先b=0，然后a=b。2、复合赋值运算符：a=1;a+=3;上面第二个赋值语句等价于a=a+3;即a=4。3、算术运算符：Area=Height*Width;num=num1+num2/num3-num4;第一个赋值语句Height和Width相乘结果赋给变量Area；第二个赋值语句先完成num2与num3的整除运算，然后与num1相加，再减去num4，结果赋给num。运算符运算顺序先算乘除再算加减。单目正和单目负最先运算。4、逻辑运算符：a=1,b=1;a||b-1;因为a=1为真值，所以不管b-1是不是真值，总的表达式一定为真值，这时后面的表达式就不会再计算了。5、关系运算符：if(a>0)...如果a>0，则执行if语句中的内容，否则退出。6、条件运算符：a=(b>0)?b:-b;当b>0时，a=b；当b不大于0时，a=-b；其实上面的意思就是把b的绝对值赋值给a。7、逗号运算符：b=2,c=7,d=5;a=(++b,c--,d+3);有三个表达式，用逗号分开，所以最终的值应该是最后一个表达式的值，也就是d+3=8，所以a=8。8、位逻辑运算符包括：1。&位与符 2。|位或符 3。^位异或符 4。~位取反符　　以操作数12为例。位运算符将数字12视为1100。位运算符将操作数视为位而不是数值。数值　　可以是任意进制的：十进制、八进制或十六进制。位运算符则将操作数转化为二进制，并相应地返回1或0。　　位运算符将数字视为二进制值，并按位进行相应运算，运算完成后再重新转换为数字。例如：　　表达式10&15表示(1010 & 1111)，它将返回表示1010的值10。因为真真得真，或者是11得1，同位全是1结果也是1　　表达式10|15表示(1010 | 1111),它将返回表示1111的值15。假假得假。全零得零。　　表达式10^15表示(1010 ^ 1111), 它将返回表示0101的值5。此时是同性相斥，相同的就为假。　　表达式~10表示(~1010)，它将返回表示0101的值 -11。此号好理解，按位取反。

按位与的运算规则：1&1=1；1&0=0；0&1=0；0&0=0。按位与运算按位与运算符“＆”是双目运算符。其功能是参与运算的两数各对应的二进位相与。只要对应的二个二进位都为1时，结果位就为1。参与运算的两个数均以补码出现。扩展资料1、按位运算符是把两个操作数分别转换成二进制数，如果两个二进制数长度不一样，在短的左边补0，补到一样的长度，然后对两个二进制数按对应的位进行运算。2、按位与的示例1110101000011111------------000010103、字符串的按位与运算：int len=strlen(str1); //假定str1与str2长度相等，若不相同，再根据要求调整代码。char str="";for(int i=0;i<len&&i<50;i++)str="0"+((str1-"0")&(str2-"0"))参考资料来源：百度百科-按位与

按位与的运算规则：1&1=1；1&0=0；0&1=0；0&0=0。按位与运算按位与运算符“＆”是双目运算符。其功能是参与运算的两数各对应的二进位相与。只要对应的二个二进位都为1时，结果位就为1。参与运算的两个数均以补码出现。扩展资料1、按位运算符是把两个操作数分别转换成二进制数，如果两个二进制数长度不一样，在短的左边补0，补到一样的长度，然后对两个二进制数按对应的位进行运算。2、按位与的示例1110101000011111------------000010103、字符串的按位与运算：int len=strlen(str1); //假定str1与str2长度相等，若不相同，再根据要求调整代码。char str="";for(int i=0;i<len&&i<50;i++)str="0"+((str1-"0")&(str2-"0"))参考资料来源：百度百科-按位与

按位与的运算规则：1&1=1；1&0=0；0&1=0；0&0=0。按位与运算按位与运算符“＆”是双目运算符。其功能是参与运算的两数各对应的二进位相与。只要对应的二个二进位都为1时，结果位就为1。参与运算的两个数均以补码出现。扩展资料1、按位运算符是把两个操作数分别转换成二进制数，如果两个二进制数长度不一样，在短的左边补0，补到一样的长度，然后对两个二进制数按对应的位进行运算。2、按位与的示例1110101000011111------------000010103、字符串的按位与运算：int len=strlen(str1); //假定str1与str2长度相等，若不相同，再根据要求调整代码。char str="";for(int i=0;i<len&&i<50;i++)str="0"+((str1-"0")&(str2-"0"))参考资料来源：百度百科-按位与

anl就是与啊。比如A=0101B，R1=1001B.ANL A,R1 结果A为0001BORL就是或运算。比如A=0101B，R1=1001B.ANL A,R1 结果A为1101

位运算是指按二进制进行的运算。在系统软件中，常常需要处理二进制位的问题。C语言提供了6个位操作运算符。这些运算符只能用于整型操作数，即只能用于带符号或无符号的char,short,int与long类型。C语言提供的位运算符列表：运算符含义描述&按位与如果两个相应的二进制位都为1，则该位的结果值为1，否则为0|按位或两个相应的二进制位中只要有一个为1，该位的结果值为1^按位异或若参加运算的两个二进制位值相同则为0，否则为1~取反~是一元运算符，用来对一个二进制数按位取反，即将0变1，将1变0<<左移用来将一个数的各二进制位全部左移N位，右补0>>右移将一个数的各二进制位右移N位，移到右端的低位被舍弃，对于无符号数，高位补01、“按位与”运算符（&）按位与是指：参加运算的两个数据，按二进制位进行“与”运算。如果两个相应的二进制位都为1，则该位的结果值为1；否则为0。这里的1可以理解为逻辑中的true,0可以理解为逻辑中的false。按位与其实与逻辑上“与”的运算规则一致。逻辑上的“与”，要求运算数全真，结果才为真。若，true,B=true,则A∩B=true例如：3&53的二进制编码是11(2)。（为了区分十进制和其他进制，本文规定，凡是非十进制的数据均在数据后面加上括号，括号中注明其进制，二进制则标记为2）内存储存数据的基本单位是字节（Byte），一个字节由8个位（bit)所组成。位是用以描述电脑数据量的最小单位。二进制系统中，每个0或1就是一个位。将11（2）补足成一个字节，则是00000011（2）。5的二进制编码是101（2），将其补足成一个字节，则是00000101（2）按位与运算：00000011(2)&00000101(2)&00000001(2)由此可知3&5=1c语言代码：#include<stdio.h>main(){inta=3;intb=5;printf("%d",a&b);}按位与的用途：（1）清零若想对一个存储单元清零，即使其全部二进制位为0，只要找一个二进制数，其中各个位符合一下条件：原来的数中为1的位，新数中相应位为0。然后使二者进行&运算，即可达到清零目的。例：原数为43，即00101011（2），另找一个数，设它为148，即10010100（2），将两者按位与运算：00101011（2）&10010100（2）00000000（2）c语言源代码：#include<stdio.h>main(){inta=43;intb=148;printf("%d",a&b);}（2）取一个数中某些指定位若有一个整数a(2byte),想要取其中的低字节，只需要将a与8个1按位与即可。a0010110010101100b0000000011111111c0000000010101100（3）保留指定位：与一个数进行“按位与”运算，此数在该位取1.例如：有一数84，即01010100（2），想把其中从左边算起的第3，4，5，7，8位保留下来，运算如下：01010100(2)&00111011(2)00010000(2)即：a=84,b=59c=a&b=16c语言源代码：#include<stdio.h>main(){inta=84;intb=59;printf("%d",a&b);}

位运算在很多系统程序中常要求在位(bit)一级进行运算或处理。C语言提供了位运算的功能，这使得C语言也能像汇编语言一样用来编写系统程序。一、位运算符C语言提供了六种位运算符：&按位与|按位或^按位异或~取反<<左移>>右移1.按位与运算按位与运算符"&"是双目运算符。其功能是参与运算的两数各对应的二进位相与。只有对应的两个二进位均为1时，结果位才为1，否则为0。参与运算的数以补码方式出现。例如：9&5可写算式如下：00001001(9的二进制补码)&00000101(5的二进制补码)00000001(1的二进制补码)可见9&5=1。按位与运算通常用来对某些位清0或保留某些位。例如把a的高八位清0，保留低八位，可作a&255运算(255的二进制数为0000000011111111)。main(){inta=9,b=5,c;c=a&b;printf("a=%d b=%d c=%d ",a,b,c);}2.按位或运算按位或运算符“|”是双目运算符。其功能是参与运算的两数各对应的二进位相或。只要对应的二个二进位有一个为1时，结果位就为1。参与运算的两个数均以补码出现。例如：9|5可写算式如下：00001001|0000010100001101(十进制为13)可见9|5=13main(){inta=9,b=5,c;c=a|b;printf("a=%d b=%d c=%d ",a,b,c);}3.按位异或运算按位异或运算符“^”是双目运算符。其功能是参与运算的两数各对应的二进位相异或，当两对应的二进位相异时，结果为1。参与运算数仍以补码出现，例如9^5可写成算式如下：00001001^0000010100001100(十进制为12)main(){inta=9;a=a^15;printf("a=%d ",a);}4.求反运算求反运算符～为单目运算符，具有右结合性。其功能是对参与运算的数的各二进位按位求反。例如～9的运算为：~(0000000000001001)结果为：11111111111101105.左移运算左移运算符“<<”是双目运算符。其功能把“<<”左边的运算数的各二进位全部左移若干位，由“<<”右边的数指定移动的位数，高位丢弃，低位补0。例如：a<<4指把a的各二进位向左移动4位。如a=00000011(十进制3)，左移4位后为00110000(十进制48)。6.右移运算右移运算符“>>”是双目运算符。其功能是把“>>”左边的运算数的各二进位全部右移若干位，“>>”右边的数指定移动的位数。例如：设a=15，a>>2表示把000001111右移为00000011(十进制3)。应该说明的是，对于有符号数，在右移时，符号位将随同移动。当为正数时，最高位补0，而为负数时，符号位为1，最高位是补0或是补1取决于编译系统的规定。TurboC和很多系统规定为补1。main(){unsigneda,b;printf("inputanumber:");scanf("%d",&a);b=a>>5;b=b&15;printf("a=%d b=%d ",a,b);}请再看一例!main(){chara="a",b="b";intp,c,d;p=a;p=(p<<8)|b;d=p&0xff;c=(p&0xff00)>>8;printf("a=%d b=%d c=%d d=%d ",a,b,c,d);}

首先,二进制与运算规则:1&1=1 1&0=0 0&0=0 二进制或运算规则:1|1=1 1|0=1 0|0=0再：二进制与十进制转换：不能打2的n次方，只好以例子讲解： 1111 1111＝128*1+64*1+32*1+16*1+8*1+4*1+2*1+1*1 0000 0000＝128*0+64*0+32*0+16*0+8*0+4*0+2*0+1*015＝二进制： （0000 1111）127＝二进制：（1111 1111）按位与自然就是（0000 1111）＝15128＝二进制：（0001 0000 0000）127＝二进制：（0000 1111 1111） （高位用0补齐）按位或 就是（0001 1111 1111）＝255回答补充：二进制“与”运算规则:1&1=1 1&0=0 0&0=0 二进制“或”运算规则:1|1=1 1|0=1 0|0=0 按位与就是从高到低，逐位进行"与"运算所以从高到低，15&127:15＝二进制： （0000 1111）127＝二进制：（1111 1111） ↓↓↓↓↓↓ 0000 1111 注意： “与”运算规则:1&1=1 1&0=0 0&0=0

6=0000 01102=0000 0010按位与，就是将这两个数字对应的位逐一进行与运算。结果得0000 0010=2。

按位与运算符 "&" 是双目运算符。其功能是参与运算的两数各对应的二进位相与。只有对应的两个二进位均为1时，结果位才为1 ，否则为0。参与运算的数以补码方式出现。 9&5 = 1 可写算式如下： 00001001 (9的二进制补码) 00000101 (5的二进制补码) 00000001 (1的二进制补码) 00001001 & 00000101 = 00000001 a. 清零 s 特定位 (mask中特定位置0，其它位为1， s = s&mask ) b. 取某数 s 中指定位 (mask中特定位置1，其它位为0， s = s&mask ) 按位或运算符 “|” 是双目运算符。其功能是参与运算的两数各对应的二进位相或。只要对应的二个二进位有一个为1时，结果位就为1。参与运算的两个数均以补码出现。 9|5 = 13 可写算式如下： 00001001|00000101 = 00001101(十进制为13) 对 s 特定位置1(mask中特定位置1，其它位为0， s=s|mask ) 按位异或运算符 “^” 是双目运算符。其功能是参与运算的两数各对应的二进位相异或，当两对应的二进位相异时，结果为1。参与运算数仍以补码出现。 9^5 = 12 可写成算式如下： 00001001^00000101 = 00001100 (十进制为12) a. 使 s 特定位的值取反 (mask中特定位置1，其它位为0， s=s^mask ) b. 不引入第三变量，交换两个变量的值 (设 a=a1,b=b1 ) 求反运算符 ～ 为单目运算符，具有右结合性。 其功能是对参与运算的数的各二进位按位求反。 例如～9的运算为： ~(0000000000001001) = 1111111111110110 左移运算符 “<<” 是双目运算符。其功能把“<< ”左边的运算数的各二进位全部左移若干位，由“<<”右边的数指定移动的位数， 高位丢弃，低位补0。 相当于其值乘以几个2。 例如： a<<4 指把a的各二进位向左移动4位。即a*2*2*2*2,a乘以4个2 右移运算符 “>>” 是双目运算符。其功能是把“>> ”左边的运算数的各二进位全部右移若干位，“>>”右边的数指定移动的位数。相当于其值除以几个2,并只取整数。 例如： 对于左边移出的空位，如果是正数则空位补0，若为负数，可能补0或补1，这取决于所用的计算机系统。移入0的叫逻辑右移，移入1的叫算术右移，Turbo C采用逻辑右移。 再看一例:

1&2是0位运算&就是把二进制的每一位做与运算，两个都是1结果就是1，否则就是01是01，2是10，所以与出来的结果就是00.

250（10）=11111010（2)5(10)=101(2)11111010&&101就是11111010 101每一位上同为1的为1所以答案为0

250（10）=11111010（2) 5(10)=101(2) 11111010&&101就是 11111010 101 每一位上同为1的为1 所以答案为0

将十进制数字转化成二进制，再分别按位与（或）与：1 1相与为1 、 0与任何数字相与为0或：1 1相或为1 、1与任何数字相或为1

6<<2是六的二进制向左移两位6 的二进制表示是110左移两位是11000后面补6>>2右移两位110右移两位是1 把后面的10拿掉了,剩下1

c语言位运算符包括 位逻辑运算符 和 移位运算符。位逻辑运算符：&按位与，|按位或，^按位异或，~取反移位运算符：<<左移，>>右移-----------------------------------------------------------------------&按位与运算符：二进制中运算,0&0=0,0&1=0,1&0=0,1&1=1，相当于布尔型的与运算|按位或运算符：二进制中运算，0|0=0,0|1=1,1|0=1,1|1=1，相当于布尔型的或运算^按位异或运算符：二进制中运算，0^0=0,0^1=1,1^0=1,1^1=0，0与0位异或等于0,1与1位异或等于0,1和0异或等于1~取反运算符，二进制中运算：~1=0,~0=1，非1等于0（非真得假）非0等于1（非假得真）。<<左移运算符：运算规则：把"<<"左边的运算数的各二进制位全部左移若干位，移动的位数由"<<"右边的数指定，高位丢弃，地位补0。可以实现乘法运算，二进制0000011<<2得二进制00001100.>>右移运算符：运算规则：把">>"左边的运算数的各二进制位全部右移若干位，移动的位数由">>"右边的数指定。有符号的数右移时符号也随着右移；是正数的话在最高位补0，是负数的话，符号位为1，最高位补0还是补1决取于计算机系统的规定。移入0的称为"逻辑右移"，移入1的称为“算术左移”。很多系统规定为补1，即“算术右移”。右移运算可以实现除法的功能，右移1位相当于该数除以2，右移n位相当于该数除以2的n次方。-------------------------------------------------------------------------运算符 优先级 运算符类型& 8 双目| 10 双目^ 9 双目~ 2 单目<< 5 双目>> 5 双目---------------------------------------------------------------------------

没有 只有"非" 和 "异或" 存在反运算

都是转换成01来计算如逻辑与，a&b，就是先把13和8转换成二进制，然后做加法，相同位上有1取1，没1取0，最后得到新的二进制，再将该二进制数转换为十进制移位就是往左边移动或右边移动，超出字节数的丢掉，不足的补0

按位与运算 按位与运算符"&"是双目运算符。其功能是参与运算的两数各对应的二进位相与。只有对应的两个二进位均为1时，结果位才为1 ，否则为0。参与运算的数以补码方式出现。例如：9&5可写算式如下： 00001001 (9的二进制补码)&00000101 (5的二进制补码) 00000001 (1的二进制补码)可见9&5=1。按位与运算通常用来对某些位清0或保留某些位。例如把a 的高八位清 0 ， 保留低八位， 可作 a&255 运算 ( 255 的二进制数为0000000011111111)。应用：a. 清零特定位 (mask中特定位置0，其它位为1，s=s&mask)b. 取某数中指定位 (mask中特定位置1，其它位为0，s=s&mask)

在进入本章的大型示例之前，还要先学习一组运算符，它们看起来类似于前面介绍的逻辑运算符，但实际上与逻辑运算符完全不同。这些运算符称为按位运算符，因为它们操作的是整数值中的位。按位运算符有6个，如表3-5所示。表3-5 按位运算符运 算 符 说 明& 按位与运算符| 按位或运算符^ 按位异或(EOR)运算符~ 按位非运算符，也称为1的补位运算符<< 按位左移运算符>> 按位右移运算符这些运算符都只能用于整数类型。~运算符是一元运算符，只处理一个操作数，其他都是二元运算符。按位与运算符&合并操作数的对应位，如果两个位都是1，结果位就是1，否则，结果位就是0。假定声明了如下变量：int x = 13;int y = 6;int z = x&y; /* AND the bits of x and y */在执行第三条语句后，z的值是4(二进制为100)，因为x和y的对应位的合并过程如下：x 0 0 0 0 1 1 0 1y 0 0 0 0 0 1 1 0x&y 0 0 0 0 0 1 0 0显然，变量的位数要比这里显示的多，但其他位都是0。变量x和y的对应位都是1的情况只有从右数的第三位，所以只有这一位的按位与结果为1。警告：千万不要混淆按位运算符和逻辑运算符。表达式x & y生成的结果完全不同于x && y。如果对应位中有一个或两个位是1，按位或运算符|就生成1，否则就生成0。下面看一个例子。如果在一个语句中合并相同的值：int z = x|y; /* OR the bits of x and y */结果如下：x 0 0 0 0 1 1 0 1y 0 0 0 0 0 1 1 0x|y 0 0 0 0 1 1 1 1z存储的值是15(二进制的1111)。如果两个位是不同的，按位异或运算符^就生成1，否则就生成0。再使用相同的初始值，语句：int z = x^y; /*Exclusive OR the bits of x and y */会使z包含值11(二进制的1011)，因为位的合并如下：x 0 0 0 0 1 1 0 1y 0 0 0 0 0 1 1 0x^y 0 0 0 0 1 0 1 1一元运算符~会翻转其操作数的位，将1变成0，0变成1。如果把这个运算符应用于值为13的变量x，并编写如下语句：int z = ~x; /* Store 1"s complement of x */z的值就是14，位的设置如下：x 0 0 0 0 1 1 0 1~x 1 1 1 1 0 0 1 0在负整数的2的补码中，值1111 0010是14。如果不熟悉2的补码形式，可以参阅附录A。移位运算符会把左操作数的位移动右操作数指定的位数。使用下面的语句可以指定左移位操作：int value = 12;int shiftcount = 3; /* Number of positions to be shifted */int result = value << shiftcount; /* Shift left shiftcount positions */变量result的值是96，其二进制为0000 1100。现在把其中的位向左移动3位，在右边补入0，所以value << shiftcount的二进制值是0110 0000。右移位运算符会向右移位，但它比左移位复杂一些。对于不带符号的数值，向右移位时，会在左边的空位中填充0。下面用一个例子来说明。假定声明一个变量：unsigned int value = 65372U;在两字节的变量中，这个值的二进制形式为：1111 1111 0101 1100假定现在执行如下语句：unsigned int result = value >> 2; /* Shift right two bits */value中的位向右移动两位，在左边补入0，得到的值存储在result中。在二进制中，其值为0，在十进制中，其值为16 343。0011 1111 1101 0111对于带符号的负值，其最左一位是1，则移位的结果取决于系统。在大多数情况下，符号位会扩散，所以向右移位时补入的是1，但在一些系统上，补入的是0。下面看看这对结果有什么影响。假定用下面的语句定义一个变量：int new_value = -164;其位模式与前面使用的无符号值相同，这是该值的2的补码：1111 1111 0101 1100执行如下语句：int new_result = new_value >> 2; /* Shift right two bits */这行语句将new_value的值向右移动两位，结果存储在new_result中。在通常情况下，如果扩散符号位，在向右移位时将1插入左边的空位，new_result的值就是：1111 1111 1101 0111其十进制值是–41，这是我们希望的结果，因为–164/4的结果应是–41。但在一些计算机上，如果不扩散符号位，new_result的值就是：0011 1111 1101 0111在本例中向右移动两位，会把值–164变成+16 343，这是一个意想不到的结果。3.3.1 按位运算符的op=用法所有的二元按位运算符都可以在op=形式的赋值语句中使用，但~运算符例外，它是一元运算符。如第2章所述，如下形式的语句：lhs op= rhs;等价于：lhs = lhs op (rhs);这说明，如果编写如下语句：value <<= 4;其作用是将整数变量value的内容向右移动4位。该语句与下面的代码等效：value = value << 4;其他二元运算符也可以这样使用。例如，可以编写如下语句：value &= 0xFF;其中value是一个整数变量，这个语句等价于：value = value & 0xFF;其作用是使最右边的8位保持不变，其他的位都设置为0。3.3.2 使用按位运算符从学术的角度来看，按位运算符很有趣，但它们用于什么场合？它们不用于日常的编程工作，但在一些领域非常有效。按位与&、按位或|运算符的一个主要用途是测试并设置整数变量中的各个位。此时可以使用各个位存储涉及二选一的数据。例如，可以使用一个整数变量存储一个人的几个特性。在一个位中存储这个人是男性还是女性，使用3个位指定这个人是否会说法语、德语或意大利语。再使用另一个位记录这个人的薪水是否多于$50 000。在这4个位中，都记录了一组数据。下面看看这是如何实现的。只有两个位都是1，结果才是1，此时可以使用&运算符选择整数变量的一个部分，甚至可以选择其中的一个位。首先定义一个值，它一般称为掩码，用于选择需要的位。在掩码中，希望保持不变的位置上包含1，希望舍弃的位置上包含0。接着对这个掩码与要从中选择位的值执行按位与操作。下面看一个例子。下面的语句定义了掩码：unsigned int male = 0x1; /* Mask selecting first (rightmost) bit */unsigned int french = 0x2; /* Mask selecting second bit */unsigned int german = 0x4; /* Mask selecting third bit */unsigned int italian = 0x8; /* Mask selecting fourth bit */unsigned int payBracket = 0x10; /* Mask selecting fifth bit */在每条语句中，1位表示该条件是true。这些二进制掩码都选择一个位，所以可以定义一个unsigned int变量personal_data来存储一个人的5项信息。如果第一位是1，这个人就是男性，如果是0，这个人就是女性。如果第二位是1，这个人就说法语，如果是0，这个人就不说法语，数据值右边的5位都是这样。因此，可以给一个说德语的人测试变量personal_data，如下面的语句所示：if(personal_data & german)/* Do something because they speak German */如果personal_data对应掩码german的位是1，表达式personalData & german的值就不是0(true)，否则就是0。当然，也可以通过逻辑运算符合并多个使用掩码的表达式，选择各个位。下面的语句测试某个人是否是女性，是说法语还是说意大利语：if(!(personal_data & male) && ((personal_data & french) ||(personal_data & italian)))/* We have a French or Italian speaking female */可以看出，测试单个位或位的组合是很简单的。另一个需要理解的操作是如何设置各个位。此时可以使用按位或(OR)运算符。按位或运算符与测试位的掩码一起使用，就可以设置变量中的各个位。如果要设置变量personal_data，记录某个说法语的人，就可以使用下面的语句：personal_data |= french; /* Set second bit to 1 */上面的语句与如下语句等效：personal_data = personal_data|french; /* Set second bit to 1 */personal_data中从右数的第二位设置为1，其他位都不变。利用|运算符的工作方式，可以在一条语句中设置多个位：personal_data |= french|german|male;这条语句设置的位记录了一个说法语和德语的男子。如果变量personal_data以前曾记录这个人也说意大利语，则这一位仍会设置为1，所以OR运算符是相加的。如果某个位已经设置为1，它仍会设置为1。如何重置一个位？假定要将男性位设置为女性，这需要将一个位重置为0，此时应使用!运算符和按位与(AND)运算符：personal_data &= !male; /* Reset male to female */这是可行的，因为!male将表示男性的位设置为0，其他位仍设置为1。因此，对应于男性的位设置为0，0与任何值的与操作都是0，其他位保持不变。如果另一个位是1，则1&1仍是1。如果另一个位是0，则0&1仍是0。使用位的例子记录了个人数据的特定项。如果要使用Windows应用程序编程接口(API)编写PC程序，就会经常使用各个位来记录各种Windows参数的状态，在这种情况下，按位运算符非常有用。试试看：使用按位运算符下面在一个略微不同的例子中使用一些按位运算符，但规则与前面相同。这个例子说明了如何使用掩码从变量中选择多个位。我们要编写的程序将在变量中设置一个值，再使用按位运算符翻转十六进制数字的顺序。下面是代码：/* Program 3.10 Exercising bitwise operators */#include <stdio.h>int main(void){unsigned int original = 0xABC;unsigned int result = 0;unsigned int mask = 0xF; /* Rightmost four bits */printf(" original = %X", original);/* Insert first digit in result */result |= original&mask; /* Put right 4 bits from original in result *//* Get second digit */original >>= 4; /* Shift original right four positions */result <<= 4; /* Make room for next digit */result |= original&mask; /* Put right 4 bits from original in result *//* Get third digit */original >>= 4; /* Shift original right four positions */result <<= 4; /* Make room for next digit */result |= original&mask; /* Put right 4 bits from original in result */printf(" result = %X ", result);return 0;}输出如下：original = ABC result = CBA代码的说明这个程序使用了前面探讨的掩码概念。original中最右边的十六进制数是通过表达式original & mask将original和mask的值执行按位与操作而获得的。这会把其他十六进制数设置为0。因为mask的值的二进制形式为：0000 0000 0000 1111可以看出，只有右边的4位没有改变。在original中，这4位都是1，在执行按位与操作的结果中，这4位仍是1，其他位都是0。这是因为0与任何值执行按位与操作，结果都是0。选择了右边的4位后，用下面的语句存储结果：result |= original&mask; /* Put right 4 bits from original in result */result的内容与右边表达式生成的十六进制数进行或操作。为了获得original中的第二位，需要把它移动到第一个数字所在的位置。为此将original向右移动4位：original >>= 4; /* Shift original right four positions */第一个数字被移出，且被舍弃。为了给original的下一个数字腾出空间，下面的语句将result的内容向左移动4位：result <<= 4; /* Make room for next digit */现在要在result中插入original中的第二个数字，而当前这个数字在第一个数字的位置上，使用下面的语句：result |= original&mask; /* Put right 4 bits from original in result */要得到第三个数字，重复上述过程。显然，可以对任意多个数字重复这个过程。

答案是9符号^是异或的意思，也就是两个操作位，如果是不同的，则计算结果是1符号<<是左位移的意思，按位移动c=a^b<<2 的计算顺序是先计算b<<2，即2<<2得8然后计算 a^8 = 1^8 = (2进制)0001^(2进制)1000 = (2进制)1001 = 9

我们都知道，数据在计算机里是以二进制形式表示的。在实际问题中，常常 也有一些数据对象的情况比较简单，只需要一个或几个二进制位就能够编码表示。如果在一个软件系统中这种数据对象非常多，用一个基本数据类型表示，对计算机 资源是一种浪费。另一方面，许多系统程序需要对二进制位表示的数据直接操作，例如许多计算机硬件设备的状态信息通常是用二进制位串形式表示的，如果要对硬 件设备进行操作，也要送出一个二进制位串的方式发出命令。由于C语言的主要设计目的是面向复杂的系统程序设计，所以它特别提供了对二进制位的操作功能，称 为位运算。 　　位运算应用于整型数据，即把整型数据看成是固定的二进制序列，然后对这些二进制序列进行按位运算。与其它 高级语言相比，位运算是Ｃ语言的特点之一。但是由于位运算的应用涉及更深入和更广泛的内容，初学者不必细究，在实际应用中可逐步体会其优越性。这部分内容 相对比较独立，读者可根据实际需要选择学习。本书仅对位运算及其应用作简要的介绍。3.5.1 位运算符　　因为一个二进制位只能取值为0或者1，所以位运算就是从具有0或者1值的运算对象出发，计算出具有0或者1 值的结果。Ｃ语言提供了6种基本位运算功能：位否定、位与、位或、位异或、位左移和位右移。其中除位否定是单目运算外，其余5种均为双目运算，6个位运算 符分为4个优先级别，参见表3-9。表3-9 逻辑运算符运算符 含义 运算对象个数 结合方向 优先级~ 按位求反 单目运算符 自右向左 1<< 按位左移 双目运算符 自左向右 2>> 按位右移 双目运算符 自左向右 2& 按位与 双目运算符 自左向右 3 | 按位或 双目运算符 自左向右 4^ 按位异或 双目运算符 自左向右 5说明：① 位运算的优先级是：~→<<、>>→&→|→^。② 位运算的运算对象只能是整型(int)或字符型(char)的数据。③ 位运算是对运算量的每一个二进制位分别进行操作。3.5.2 按位逻辑运算　　按位逻辑运算包括：位与、位或、位异或和位否定等四种运算。为了帮助读者理解，我们设a和b都是16位二进制整数，它们的值分别是： a: 1010,1001,0101,0111 b: 0110,0000,1111,1011 为了便于阅读，a和b中每４位用一个逗号分开。以下介绍对于a和b的位与、位或、位异或和位否定等按位逻辑运算。　　1.按位与运算 (&) 按位与是对两个运算量相应的位进行逻辑与，"&"的运算规则与逻辑与"&&"相同。 按位与表达式：c=a&b a: 1010,1001,0101,0111 & b: 0110,0000,1111,1011 c: 0010,0000,0101,0011　　2.按位或运算（|） 按位或是对两个运算量相应的位进行逻辑或操作，其运算规则与逻辑或"||"相同。 按位或表达式：c=a|b a: 1010,1001,0101,0111 | b: 0110,0000,1111,1011 c: 1110,1001,1111,1111　　3.按位异或运算（^） 按位异或运算的规则是：两个运算量的相应位相同，则结果为０，相异则结果为１。 即： 0^0=0 0^1=1 1^0=1 1^1=0 按位异或表达式：c=a^b a: 1010,1001,0101,0111 ^ b: 0110,0000,1111,1011 c: 1100,1001,1010,1100 可见，异或运算的含义是：两个相应位的值相异，则结果为１，相同则为０。　　4.按位求反运算符（~） 按位求反运算运算规则是将二进制表示的运算对象按位取反，即将１变为0，将0变为１。 按位异或表达式：c=~a ~ a: 1010,1001,0101,0111 c: 0101,0110,1010,1000　　5.按位逻辑运算的应用例3-8：设 int x=7，求y=~x y=~x=~7=~(0000,0000,0000,0111)=1111,1111,1111,1000=-8 可见，对x的值(7)按位求反结果恰为-8的补码表示，其原因是计算机中有： 整数求负＝整数求补＝按位求反＋１　 所以：按位求反＝整数求负－１。 请注意求反运算与单目减和逻辑非运算的区别： y=-x; 　结果为：y=-7， y=!x; 结果为：y=0。　　例3-9：用按位与运算屏蔽特定位（将指定位清为０）。 设 n=051652（八进制数），计算m=n&0177，则：m=052。 n: 0,101,001,110,101,010 & 0177: 0,000,000,001,111,111 m: 0,000,000,000,101,010 经过位与运算，将ｎ前９位屏蔽掉，即截取ｎ的后７位。　　例3-10：用按位与运算保留特定位。 要想将一个变量ｎ的特定位保留下来，只要设一个数，使该数的某些位为１，这些位是与要保留的ｎ的特定位相对应的位，再将ｎ与该数按位与。 设 n=011050（为八进制数。对应的二进制为：0,001,001,000,101,000），要将ｎ的右起第2、4、6、8、10位保留下来，只要 n=n&01252，则有： n: 0,001,001,000,101,000 & 01252: 0,000,001,010,101,010 n: 0,000,001,000,101,000　（n=01050） 注意，按位与的"&"功能与取地址运算的"&"不同，尽管两者采用了相同的符号。　　例3-11：用按位或运算将指定的位置为１。 设：x=061，y=016，则z=a|b为： x: 0000，0000，0011，0001 | y: 0000，0000，0000，1110 z: 0000，0000，0011，1111 即将x或y中为１的位的相应位置成１，其结果是z中的后６位为１。　　例3-12：用按位异或运算将某个量的特定位翻转。 要将变量ｎ的特定位翻转，即原来为１的变0，为0的变１，只要设一个数，使该数的某些位为１，这些位是与ｎ中要翻转的相对应的位，然后将ｎ与该数进行按位异或运算。 设：a=015，要将后四位翻转，只要a=a^017，则： a: 0000，0000，0011，1101 ^ 017: 0000，0000，0011，1111 a: 0000，0000，0000，00103.5.3 移位运算　　C语言提供了两个移位运算：左移和右移，它们是把整数作为二进制位序列，求出把这个序列左移若干位或者右移 若干位所得到的序列。左移和右移都是双目运算，运算符左边的运算对象是被左移或右移的数据，而运算符右边的运算对象是指明移动的位数。数据左移或右移后空 出来的位置补0。 左移、右移运算表达式的一般形式为：x << n 或 x >> n其中x为移位运算对象，是要被移位的量；n是要移动的位数。左移运算的规则是将x的二进制位全部向左移动n位，将左边移出的高位舍弃，右边空出的位补０。右移是将x的各二进制位全部向右移动n位，将右边移出的低 位舍弃，左边高位空出要根据原来量符号位的情况进行补充，对无符号数则补０；对有符号数，若为正数则补０，若为负数则补１。　　例如，设a=7，则：b=a<<2　 即：b=0000,0111<<2=0001,1100=28c=a>>2 　即：c=0000,0111>>2=0000,0001=1左移的一个特殊用途是将整数值乘以2的幂，例如：左移运算表达式1<<4的计算结果是16，右移可以用于将整数值除乘2的幂。3.5.4 位运算赋值运算符　　位运算符与赋值运算符可以组成以下5种位运算赋值运算符：&=、 |=、 >>=、 <<=、 ^=由这些位运算赋值运算符可以构成位运算赋值表达式。例如：x&=y 相当于：x=x&yx<<=2 相当于：x=x<<2x>>=3 相当于：x=x>>3x^=5 相当于：x=x^5

第一、C语言中异或运算符为^,顾名思义就是不同为1，相同为0；具体就是0^0等于0,1^1等于0,0^1等于1，1^0等于1；第二、异或运算的用途：First:可以是使一个数中的某些特定位进行翻转；例如对整数10100001（即整数161在进行位运算过程中，是以补码的形式操作的）中的第1位和第3位进行翻转（最低位【即权值最小，即最右侧】），用00000111与其做异或运算即可；Second：可以实现两个值的交换，而不需要借助temp,如 int a=12,b=161; a=a^b;b=b^a;a=a^b;进行操作后，a=161,b=12;Third:a=a^b^b;进行这波操作后a还是原来的a;第三、谢谢各位看官，初来乍到，多多支持（点赞）

c语言，位符合赋值运算子， <<=,>>=,&=,^=!=, 分别什么含义啊？ 1.= 赋值运算子 变数=表示式 如：a=3；将a的值赋为3 2./= 除后赋值 变数/=表示式 如：a/=3;即a=a/3 3.*= 乘后赋值 变数*=表示式 如：a*=3;即a=a*3 4.%= 取模后赋值 变数%=表示式 如：a%=3;即a=a%3 5.+= 加后赋值 变数+=表示式 如：a+=3;即a=a+3 6.-= 减后赋值 变数-=表示式 如：a-=3;即a=a-3 7.<<= 左移后赋值 变数<<=表示式 左移就是将《左边的数的二进位制各位全部左移若干位，《右边的数指定移动位数，高位丢弃，低位补0， 移几位就相当于乘以2的几次方 8.>>= 右移后赋值 变数>>=表示式 右移运算子是用来将一个数的各二进位制位右移若干位，移动的位数由右运算元指定（右运算元必须是非负值），移到右端的低位被舍弃，对于无符号数，高位补0。对于有符号数，某些机器将对左边空出的部分用符号位填补（即“算术移位”），而另一些机器则对左边空出的部分用0填补（即“逻辑移位”）。注意：对无符号数,右移时左边高位移入0；对于有符号的值,如果原来符号位为0(该数为正),则左边也是移入0。如果符号位原来为1(即负数),则左边移入0还是1,要取决于所用的计算机系统。有的系统移入0,有的 系统移入1。移入0的称为“逻辑移位”,即简单移位；移入1的称为“算术移位”。 9.&= 按位与后赋值 变数&=表示式 按位与是指：参加运算的两个资料，按二进位制位进行“与”运算。如果两个相应的二进位制位都为1，则该位的结果值为1；否则为0。这里的1可以理解为逻辑中的true,0可以理解为逻辑中的false。按位与其实与逻辑上“与”的运算规则一致。逻辑上的“与”，要求运算数全真，结果才为真。若，A=true,B=true,则A∩B=true 10. ^= 按位异或后赋值 变数^=表示式 参与运算的两个量按照对应的位进行异或运算，且 0^0→0, 0^1→1, 1^0→1, 1^1→0 此外，一个数与0异或仍保持不变，即a^0=a 一个数与自己异或结果为0，即a^a=0 11.|= 按位或后赋值 变数|=表示式 参与运算的两个量按照对应位进行或运算，且 0|0→0, 0|1→1, 1|0→1, 1|1→1 这些位运算都是与二进位制码有关的，所以多弄弄也就会了 C语言中复合赋值运算子 ：<<= , >>= ,&= ,^= , |= 分别表示什么啊 ？ 请高手指点 运算子= 这种组合是赋值语句的一种简写形式,例如: a+=b其实就是a=a+b,只不过你说的是逻辑运算子,道理是一样的. <<是左移,>>是右移,&是与,|是或,^是异或,都是针对2进位制运算的. C语言中算术运算子和赋值运算子哪个优先顺序高？ 算术运算子高！ 表示式优先顺序()(小括号) [](阵列下标) .(结构成员) ->(指标型结构成员)↑最高!(逻辑非) .(位取反) -(负号) ++(加1) --(减1) &(变数地址) │*(指标所指内容) type(函式说明) sizeof(长度计算) │*(乘) /(除) %(取模) │+(加) -(减) │<<(位左移) >>(位右移) │<(小于) <=(小于等于) >(大于) >=(大于等于) │==(等于) !=(不等于) │&(位与) │^(位异或) │|(位或) │&&(逻辑与) │||(逻辑或) │?:(?表示式) │= += -=(联合操作) │,(逗号运算子) │最低 1. .的优先顺序高于*。->操作符用于消除这个问题。 *p.f变成了*(p.f)而不是(*p).f2. []高于*，于是int *ap[]中的ap变成了元素为int指标的阵列。3. 函式()高于*，因此，int *fp()不再是函式指标了，而是一个函式，返回int *。4. 逗号运算子在所有运算子中优先顺序最低，所以，i = 1, 2就成了(i = 1), 2而不是i = (1, 2)。 逗号运算子的值是最右边运算元的值，逗号运算子结合性从左至右，因此又称为顺序求值运算子。5. 在表示式中如果有布林操作、算术运算、位操作等混合计算，始终应该在适当的地方加上括号。 x = f() + g() * h(); 乘法先于加法执行，但是g()和h()的呼叫可能以任何顺序出现。同样，f()可能在乘法之前呼叫，也可能在乘法之后呼叫。 优先顺序和结合性规则告诉你哪些符号组成一个意群，大部分这样的意群内部如何进行计算的次序是未定义的。有些操作符，如&&和||等，其运算元的计算顺序是确定的，它们使用短路原则。 C语言中记住两个优先顺序就够了：乘法和除法先于加法和减法，在涉及其他操作符时一律加上括号。结合性用于在几个操作符具有相同的优先顺序时确定先执行哪一个。每个操作符拥有某一级别的优先顺序，同时也拥有左结合性或者右结合性。 所有的赋值符（包括复合赋值符）都具有右结合性（从右到左执行），因此可以使用连等的赋值形式。唯一的三目运算子?:也是具有右结合性的。 所有优先顺序相同的操作符，它们的结合性也相同，这是必须如此的。在函式呼叫中，各个引数的计算顺序是不确定的 附录C C语言运算子优先顺序和结合性 优先顺序 运算子 含义 运算型别 结合性 1 （ ） [ ] -> , 圆括号 下标运算子 指向结构体成员运算子 结构体成员运算子 单目 自左向右 2 ! ~ ++ -- (型别关键字) + - * & sizeof 逻辑非运算子 按位取反运算子 自增、自尖运算子 强制型别转换 正、负号运算子 指标运算子 地址运算子 长度运算子 单目 自右向左 3 * / % 乘、除、求余运算子 双目 自左向右 4 + - 加、减运算子 双目 自左向右 5 << >> 左移运算子 右移运算子 双目 自左向右 6 < <= > >= 小于、大于、小于等于、大于等于 关系 自左向右 7 = = ！= 等于、不等于 关系 自左向右 8 & 按位与运算子 位运算 自左向右 9 ^ 按位异或运算子 位运算 自左向右 10 | 按位或运算子 位运算 自左向右 11 && 逻辑与运算子 位运算 自左向右 12 || 逻辑或运算子 位运算 自左向右 13 ? : 条件运算子 三目 自右向左 14 = += -= *= /= %= << = >>= &= ^= |= 赋值运算子 双目 自右向左 15 , 逗号运算 顺序 自左向右 C语言中的算术自反赋值运算子怎么运算? 算术自反赋值运算子有加赋值（+=、双目中缀）、减赋值（-=、双目中缀）、乘赋值（＊=、双目中缀）、除赋值（/=、双目中缀）、模赋值（％=、双目运算）。前一个运算物件必须是变数，后一个运算物件是表示式。运算规则是先计算右边表示式的值，再和左边变数进行相应的运算，然后将结果赋予左边的变数。例如说 x += b; 其运算就是 x = x + b ; x -= b; 其运算就是 x = x - b ; x *= b; 其运算就是 x = x * b ; x /= b; 其运算就是 x = x / b ; x %= b; 其运算就是 x = x % b ; 说白了就是那种型别运算的简写。。。。。 c语言 复合赋值运算子的问题，请指教！ 第一步：a=a/(a-6)，a的值传递给第二步进行下一步计算 第二步：a=a*a，a的值传递给第三步进行下一步计算 第三步：a=a+a，a的最终结果在这里 记住两句话： 1、=赋值号，自右向左进行； 2、a+=1相当于a=a+1。这个a/=a-6先把a-6看成一个数，a/=1不就是a=a/1嘛； 我新手，c语言关系运算符和赋值运算子，哪个优先顺序高？比如a=b>c怎么理解？ 下面的是优先顺序排序上面的高下面的低，左右高低有描述。 () [] -> . left to right ! ~ ++ -- + - * (type) sizeof right to left * / % left to right + - left to right << >> left to right < <= > >= left to right == != left to right & left to right ^ left to right | left to right && left to right || left to right ?: right to left = += -= *= /= %= &= ^= |= <<= >>= right to left , left to right ======================== a=b>c 相当于 a = (b> c) 在c语言中，逻辑运算子和赋值运算子那个更优先计算呢？ 逻辑运算子 C语言中算术运算子、关系运算符、逻辑运算子、赋值运算子等运算子的优先顺序 求大神帮忙 解析： (1) 记住加减乘除就可以了 (2) 其它的，直接加括号 (3) 应付考试：多做练习题 (4) 职场程式猿：直接加括号

按位与和逻辑与的区别如下：①代表含义不同按位与运用二进制进行计算，逻辑与比较符号两边的真假输出逻辑值。②运算法则不同按位与对所有的表达式都要判断，逻辑与运算符第一个表达式不成立的话，后面的表达式不运算，直接返回。③输出不同按位与&输出运算结果为不同的数值，逻辑与 && 输出逻辑值true或者 false。例如： 按位与1&2=0；逻辑与1&&2=true（一般用数字1代指ture）。扩展资料按位与运算符“&”是双目运算符。其功能是参与运算的两数各对应的二进位相与。只有对应的两个二进位都为1时，结果位才为1。参与运算的两个数均以补码出现。按位与规则1&1=11&0=00&1=00&0=0逻辑与，符号为“&&”，只有两个操作数都是真，结果才是真。 逻辑与操作属于短路操作，既如果第一个操作数能够决定结果，那么就不会对第二个操作数求值。对于逻辑与操作而言，如果第一个操作数是假，则无论第二个操作数是什么值，结果都不可能是真，相当于短路了右边。逻辑与规则1&&1=11&&0=00&&1=00&&0=0参考资料来源：百度百科-按位与参考资料来源：百度百科-逻辑与

按位运算符的作用就是直接对整数在内存中的二进制位进行操作。将一个地址和一个10H进行按位，具体要看在哪一种程序语言中，以及使用哪一种类型的按位运算符。按位与运算符"&"是双目运算符。其功能是参与运算的两数各对应的二进位相与。只有对应的两个二进位均为1时，结果位才为1 ，否则为0。参与运算的数以补码方式出现。例如：9&5可写算式如下： 00001001 (9的二进制补码)&00000101 (5的二进制补码) 00000001 (1的二进制补码)可见9&5=1。按位与运算通常用来对某些位清0或保留某些位。例如把a 的高八位清 0 ， 保留低八位， 可作 a&255 运算 ( 255 的二进制数为0000000011111111)。扩展资料：C语言中，按位运算符的运算优先级共分为15 级。1 级最高，15 级最低。在表达式中，优先级较高的先于优先级较低的进行运算。而在一个运算量两侧的按位运算符优先级相同时，则按运算符的结合性所规定的结合方向处理。“ & ”按位与运算符属于十级，优先级较低。按位运算符中的树状数组是一个查询和修改复杂度都为log(n)的数据结构。主要用于查询任意两位之间的所有元素之和，但是每次只能修改一个元素的值；经过简单修改可以在log(n)的复杂度下进行范围修改，但是这时只能查询其中一个元素的值(如果加入多个辅助数组则可以实现区间修改与区间查询)。参考资料来源：百度百科—位运算

有符号数的运算u2f45法u2f00.有符号数的加减法1、符号数与u2f46符号数的u2f08为规定性：u2f00个数，是有符号数还是u2f46符号数都是u2f08为规定的。进u2f8fu2f06进制运算时u2f64u2f46符号数或是补码运算时，结果都是正确的。10000100＋00001110若规定为u2f46符号数，即 132＋146＝146D 。若规定为符号数，则为-124+14＝-110，u2f7d［-110］补＝10010010。解释：10000100是 -124的补码，0001110是14的补码，在机器中运算后得出的结果是[-110]的补码。机器中的有符号数的运算u2f00般就是补码的运算。2、补码加减法运算计算机中，当确定为符号数运算时，符号数u2f00律u2f64补码表u2f70，运算时符号位和数字位u2f00起参加运算。同样，运算结果也u2f64补码表u2f70。1）两符号数相加公式：[X+Y]补 （MOD2）=[X]补＋[Y]补 //MOD2即 mod 2^n，即丢弃符号位的进位（因为符号位参与运算是补码运算的特点）2）两符号数相减公式：[X-Y]补 （MOD2）= [X]补+[-Y]补3.例u2f26：求3CH-90H。u2fb8先3CH=0011 1100，90H=1001 0000（1）当为有符号数时，显然这两个数是某两个数的补码。（具体是哪两个数X Y, 需要u2f83u2f30计算）。运算结果也是补码，是X-Y的补码 [X-Y]补。机器只运算到这u2f00步。[X-Y]补 就是运算结果，溢出 进位等标志位也都是这个补码运算过程的结果，由硬件ALU运算。X-Y并不是机器的运算结果，由[X-Y]补求X-Y是在计算机组成原理中由程序员或者编译器完成的u2f2f作，对于编译器来说运算结果才是X-Y，编译器属于软件，不属于硬件机器。根据微机中有符号数（补码）的减法公式，[x]补（输u2f0a）-[Y]补（输u2f0a）=[x]补+[-Y]补（求补操作结果）=[X-Y]补（微机运算结果） ，求[-Y]补是关键。[x]补=0011 1100，[Y]补=1001 0000，[-Y]补=[Y]补的 求补=0110 1111（取反）+1（加u2f00）=0111 0000 //不是[Y]补的补码！！更不存在什么 -[Y]补 的补码（不存在-[Y]补这种写法）解释求补操作：u2f46论-[Y]补的符号位是0还是1。正数也可以有求补操作，只是得到的数不叫补码，就是为了把减法转换成加法。求补操作 就是取余（求补）（补码是u2f08规定的，但是求补是数学定义）。证明[-Y]补=对-[Y]补 求补操作：[0]补=[-x]补+[X]补 。[-x]补和[X]补不是正数和负数的关系！！u2f7d是互补关系，算数相反，不是逻辑相反。另外仔细想u2f00下，我们学补码是为了什么？以前是为了求u2f00个原码的补码是什么，因为计算机组成原理中 从编译器到微机 从微机到编译器 需要原码变成补码 补码变成原码，但是在微机原理中，就不需要这u2f00部分了，u2f7d是需要求补操作了。计算机组成原理中，是由y原码求出来的[-y]补，u2f7d微机原理中是 对[y]补 求反操作出来的[-y]补，计算过程都不u2f00样。计算机组成原理中的过程可以理解 但是不是微机真正的运算过程，这u2f00次学习的微机原理的补码的加减法才是真的硬件的运算过程！另外，补充u2f00点，X=[X]补 的补码，由补码求原码时不u2f64按照由原码求补码的逆过程（补码为1000 0000时例外！）。《微机原理与接u2f1d技术》中写道：“由加法器的原理图，加法器的u2f45式控制Mu2f64于控制加减法，当M=0时进u2f8fS=A+B操作，当M=1时进u2f8fS=A-B操作。当M=1（减法）时，各个异或门对B的各位进u2f8f求反，并将1作为初试进位加u2f0a结果，也就是执u2f8f对B的求反加1，即求补操作。” 也就是说！u2f46论B是有符号数还是u2f46符号数，u2f46论符号位是0还是1，只要M=1，就统统对B执u2f8f求补操作所以，求补操作可以对符号位是0的数执u2f8f！所以，[X-Y]补=0011 1100-1001 0000=0011 1100+0111 0000=ACH（2）补码最u2f24好处就是不管是有符号数还是u2f46符号数都可以u2f64同u2f00套加减法。系统对有符号数和u2f46符号数的加减法都采u2f64u2f00样的策略。u2f46符号加减法不存在溢出问题，只是将进位或借位存储在CF中。机器不知道你进u2f8f的运算是否有符号，如果你进u2f8f的是有符号运算，你需要查看OF，否则不需要。所以，溢出不溢出，是由程序员判断的，机器不知道。不管是有符号数还是u2f46符号数，微机都是按补码运算，u2f84于是进位还是溢出不仅要看进位标志位，还要看溢出标志位。只不过在做u2f46符号数运算时程序员不考虑溢出标志位，只考虑进位标志位u2f7d已。u2f50如0111+1101，你说它是u2f46符号数7+13呢，还是有符号数7-3呢？对微机u2f7du2f94这是u2f00回事！所以，微机中，u2f46符号数时和有符号数时的运算结果u2f00定是u2f00样的。（3）注意这道题和《计算机组成原理》学补码加减运算时的题u2f6c的区别。例u2f26：X=+0101，Y=-1010，求X-Y。题u2f6c给的X Y，是原码， 所以已经默认是有符号数，也有判断是否溢出，所以默认的计算过程也是指机器运算过程。原码在机器中 均是以补码保存和运算的，[x]补-[Y]补=[x]补+[-Y]补=[X-Y]补，只u2f64到了[x]补+[-Y]补=[X-Y]补属于类型：已知X Y，所以先求[X]补， [-Y]补 ，便求得[X-Y]补。然后求X-Y。也就是说，上u2f00题已知的是[X]补 [Y]补，（机器的）运算结果是[X-Y]补。中间过程没必要求出X Y是什么数。本题已知的是X Y，先得出机器的运算结果[X-Y]补，在做编译器的u2f2f作由[X-Y]补 求出X-Y。u2f06者求[-Y]补的u2f45法不u2f00样：前者是对[Y]补 求补操作 求得的，后者是由-Y求得。可以说，后u2faf例u2f26是编译器和微机共同u2f2f作的过程，前u2faf例u2f26只关系微机运算。￥5.9百度文库VIP限时优惠现在开通,立享6亿+VIP内容立即获取有符号数的运算方法有符号数的运算u2f45法u2f00.有符号数的加减法1、符号数与u2f46符号数的u2f08为规定性：u2f00个数，是有符号数还是u2f46符号数都是u2f08为规定的。进u2f8fu2f06进制运算时u2f64u2f46符号数或是补码运算时，结果都是正确的。10000100＋00001110若规定为u2f46符号数，即 132＋146＝146D 。若规定为符号数，则为-124+14＝-110，u2f7d［-110］补＝10010010。解释：10000100是 -124的补码，0001110是14的补码，在机器中运算后得出的结果是[-110]的补码。机器中的有符号数的运算u2f00般就是补码的运算。

C语言中 移位 和 按位 和 +-*/ 的优先顺序是怎么样的 下面是C语言中所使用的运算子的优先顺序和结合性： 优先顺序 运算子 结合性 (最高) () [] -> . 自左向右 ! ~ ++ -- + - * & sizeof 自右向左 * / % 自左向右 + - 自左向右 << >> 自左向右 < <= > >= 自左向右 == != 自左向右 & 自左向右 ^ 自左向右 | 自左向右 && 自左向右 || 自左向右 ?: 自右向左 = += -= *= /= %= &= ^= |= <<= >>= 自右向左 (最低) , 自左向右 还有指标运算子、sizeof运算子、阵列运算子[]等等 一、赋值运算子 赋值语句的作用是把某个常量或变数或表示式的值赋值给另一个变数。符号为‘="。这里并不是等于的意思，只是赋值，等于用‘=="表示。 注意：赋值语句左边的变数在程式的其他地方必须要宣告。 得已赋值的变数我们称为左值，因为它们出现在赋值语句的左边；产生值的表示式我们称为右值，因为她它们出现在赋值语句的右边。常数只能作为右值。 例如： count=5; total1=total2=0; 第一个赋值语句大家都能理解。 第二个赋值语句的意思是把0同时赋值给两个变数。这是因为赋值语句是从右向左运算的，也就是说从右端开始计算。这样它先total2=0;然后total1=total2;那么我们这样行不行呢？ (total1=total2)=0; 这样是不可以的，因为先要算括号里面的，这时total1=total2是一个表示式，而赋值语句的左边是不允许表示式存在的。 二、算术运算子 在C语言中有两个单目和五个双目运算子。 符号 功能 + 单目正 - 单目负 * 乘法 / 除法 % 取模 + 加法 - 减法 下面是一些赋值语句的例子， 在赋值运算子右侧的表示式中就使用了上面的算术运算子： Area=Height*Width; num=num1+num2/num3-num4; 运算子也有个运算顺序问题，先算乘除再算加减。单目正和单目负最先运算。 取模运算子(%)用于计算两个整数相除所得的余数。例如： a=7%4; 最终a的结果是3，因为7%4的余数是3。 那么有人要问了，我要想求它们的商怎么办呢？ b=7/4; 这样b就是它们的商了，应该是1。 也许有人就不明白了，7/4应该是1.75，怎么会是1呢？这里需要说明的是，当两个整数相除时，所得到的结果仍然是整数，没有小数部分。要想也得到小数部分，可以这样写7.0/4或者7/4.0，也即把其中一个数变为非整数。 那么怎样由一个实数得到它的整数部分呢？这就需要用强制型别转换了。例如： a=(int) (7.0/4); 因为7.0/4的值为1.75，如果在前面加上(int)就表示把结果强制转换成整型，这就得到了1。那么思考一下a=(float) (7/4);最终a的结果是多少？ 单目减运算子相当于取相反值，若是正值就变为负值，若是负数就变为正值。 单目加运算子没有意义，纯粹是和单目减构成一对用的。 三、逻辑运算子 逻辑运算子是根据表示式的值来返回真值或是假值。其实在C语言中没有所谓的真值和假值，只是认为非0为真值，0为假值。 符号 功能 && 逻辑与 || 逻辑或 ! 逻辑非 例如： 5!3; 0||-2&&5; !4; 当表示式进行&&运算时，只要有一个为假，总的表示式就为假，只有当所有都为真时，总的式子才为真。当表示式进行||运算时，只要有一个为真，总的值就为真，只有当所有的都为假时，总的式子才为假。逻辑非(!)运算是把相应的变数资料转换为相应的真/假值。若原先为假，则逻辑非以后为真，若原先为真，则逻辑非以后为假。 还有一点很重要，当一个逻辑表示式的后一部分的取值不会影响整个表示式的值时，后一部分就不会进行运算了。例如： a=2,b=1; a||b-1; 因为a=2，为真值，所以不管b-1是不是真值，总的表示式一定为真值，这时后面的表示式就不会再计算了。 四、关系运算符 关系运算符是对两个表示式进行比较，返回一个真/假值。 符号 功能 > 大于 < 小于 >= 大于等于 <= 小于等于 == 等于 != 不等于 这些运算子大家都能明白，主要问题就是等于==和赋值=的区别了。 一些刚开始学习C语言的人总是对这两个运算子弄不明白，经常在一些简单问题上出错，自己检查时还找不出来。看下面的程式码： if(Amount=123) …… 很多新人都理解为如果Amount等于123，就怎么样。其实这行程式码的意思是先赋值Amount=123，然后判断这个表示式是不是真值，因为结果为 123，是真值，那么就做后面的。如果想让当Amount等于123才执行时，应该if(Amount==123) …… 五、自增自减运算子 这是一类特殊的运算子，自增运算子++和自减运算子--对变数的操作结果是增加1和减少1。例如： --Couter; Couter--; ++Amount; Amount++; 看这些例子里，运算子在前面还是在后面对本身的影响都是一样的，都是加1或者减1，但是当把他们作为其他表示式的一部分，两者就有区别了。运算子放在变数前面，那么在运算之前，变数先完成自增或自减运算；如果运算子放在后面，那么自增自减运算是在变数参加表示式的运算后再运算。这样讲可能不太清楚，看下面的例子： num1=4; num2=8; a=++num1; b=num2++; a =++num1;这总的来看是一个赋值，把++num1的值赋给a，因为自增运算子在变数的前面，所以num1先自增加1变为5，然后赋值给a，最终a也为5。b=num2++;这是把num2++的值赋给b，因为自增运算子在变数的后面，所以先把num2赋值给b，b应该为8，然后num2自增加1变为 9。 那么如果出现这样的情况我们怎么处理呢？ c=num1+++num2; 到底是c=(num1++)+num2;还是c=num1+(++num2);这要根据编译器来决定，不同的编译器可能有不同的结果。所以我们在以后的程式设计当中，应该尽量避免出现上面复杂的情况。 六、复合赋值运算子 在赋值运算子当中，还有一类C/C++独有的复合赋值运算子。它们实际上是一种缩写形式，使得对变数的改变更为简洁。 Total=Total+3; 乍一看这行程式码，似乎有问题，这是不可能成立的。其实还是老样子，"="是赋值不是等于。它的意思是本身的值加3，然后在赋值给本身。为了简化，上面的程式码也可以写成： Total+=3; 复合赋值运算子有下列这些： 符号 功能 += 加法赋值 -= 减法赋值 *= 乘法赋值 /= 除法赋值 %= 模运算赋值 <<= 左移赋值 >>= 右移赋值 &= 位逻辑与赋值 |= 位逻辑或赋值 ^= 位逻辑异或赋值 上面的十个复合赋值运算子中，后面五个我们到以后位运算时再说明。 那么看了上面的复合赋值运算子，有人就会问，到底Total=Total+3;与Total+=3;有没有区别？答案是有的，对于A=A+1，表示式A被计算了两次，对于复合运算子A+=1，表示式A仅计算了一次。一般的来说，这种区别对于程式的执行没有多大影响，但是当表示式作为函式的返回值时，函式就被呼叫了两次(以后再说明)，而且如果使用普通的赋值运算子，也会加大程式的开销，使效率降低。 七、条件运算子 条件运算子(?:)是C语言中唯一的一个三目运算子，它是对第一个表示式作真/假检测，然后根据结果返回两外两个表示式中的一个。 <表示式1>?<表示式2>:<表示式3> 在运算中，首先对第一个表示式进行检验，如果为真，则返回表示式2的值；如果为假，则返回表示式3的值。 例如： a=(b>0)?b:-b; 当b>0时，a=b；当b不大于0时，a=-b；这就是条件表示式。其实上面的意思就是把b的绝对值赋值给a。 八、逗号运算子 在C语言中，多个表示式可以用逗号分开，其中用逗号分开的表示式的值分别结算，但整个表示式的值是最后一个表示式的值。 假设b=2,c=7,d=5, a1=(++b,c--,d+3); a2=++b,c--,d+3; 对于第一行程式码，有三个表示式，用逗号分开，所以最终的值应该是最后一个表示式的值，也就是d+3，为8，所以a=8。对于第二行程式码，那么也是有三个表示式，这时的三个表示式为a2=++b、c--、d+3,(这是因为赋值运算子比逗号运算子优先顺序高)所以最终表示式的值虽然也为8，但a2=3。 还有其他的如位逻辑运算子，位移运算子等等，我们等到讲位运算时再说明。 九、优先顺序和结合性 从上面的逗号运算子那个例子可以看出，这些运算子计算时都有一定的顺序，就好象先要算乘除后算加减一样。优先顺序和结合性是运算子两个重要的特性，结合性又称为计算顺序，它决定组成表示式的各个部分是否参与计算以及什么时候计算。 c语言中加减乘除的优先顺序是怎么样的? 优先顺序是，从左到右，左边的操作符先做，右边的操作符后做；对于一个算式中的所有操作符，要先做乘除，后做加碱。 C语言中前++和—>的优先顺序 ->的优先顺序高于++（字首） C语言中&&和||谁的优先顺序大 printf("%d",1||1&&0); 输出1 C语言中，&和<<的优先顺序谁高？ 先左移，后按位与。 byte & (1<< i) C语言中*与&的优先顺序 *优先于&. 实际上, 在真的写程式时, 请不要使用预设优先顺序, 应当使用括号. 其目的不是为了确保运算正确性, 而是为了清楚明白的表示, 这一行在做什么. 这是一个好习惯, 用来让程式更加清晰, 便于日后维护; 节省记忆运算优先顺序, 只是顺便. c语言中()和!哪个优先顺序高 当然是（）运算等级高啦:slyar./blog/c-operator-priority.参考下很全面的 C语言中“%”和“/”哪一个优先顺序高？ 优先顺序一样，按照自左向右计算，“(int)(2.5+7)%2/4”的结果是0，(int)(2.5+7)是将7+2.5后强制转化为整形，就是9，9%2=1，1/4=0，所以结果为0 在C语言中，&& 和||的优先顺序哪个高？ ，逗号运算在c语言中是最后的。&& || 是同级，看哪个在前就先算哪个。不过要注意的是&& ||都有不完全运送。对于&&运送则从左到右进行判断，如果左边为0，则右边不再计算，整个&&运算就是0.||运算也是从左到右，如果有左边为1则右边也不在计算，直接输出1. ++a||++b&&++c这个就可以先判断++a||++b，这里呢，根据上述所说的进行判断，如果1则继续判断&&，如果0则直接输出0，不做最后的++c C语言中的+和〉哪个优先顺序高 优先顺序 + 高于 > 高于 == 高于 && 高于 ||