❶ c语言中的位运算子中‘按位取反’是怎么运算的
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
❷ c语言中如何提取二进制数中的某一位
下面是三种方式：
①通过模2除2（%2、/2）的方法
num%2——取出二进制的最后一位
num/2——右移去掉二进制的最后一位
通过while循环，依次取出二进制的最后一位数字判断是否为1，若为1则count++，while（num）只有当num变为0时循环结束。
问题：在测试-1出现bug，-1的二进制中应该有32个1，输出却为0。我们将-1带入代码中发现-1%2=0，count不增，然后-1/2=0，循环结束，故输出count的值为0。
解决方案：将变量num的数据类型改为unsigned int （无符号整型），此时表示的是正的整型的最大值，所以当num=-1时，表示二进制为32个1的正数，通过循环可以输出正确的个数。
②通过右移操作符（>>）、按位与操作符（&）实现
Example：当num=10(1010)，通过右移操作num>>i，二进制向右移动i位。
//i=0，num>>0，右移0位，此时（1010）&（0001）=0
//i=1，num>>1，右移1位，此时（0101）&（0001）=1，count++
//i=2，num>>2，右移2位，此时（0010）&（0001）=0
//i=3，num>>3，右移3位，此时（0001）&（0001）=1，count++
……
因为二进制共32位，所以循环要执行32次后结束，得到count为2。
缺点：不够高效，必须循环32次。
③通过按位与操作符（&）巧妙运算实现
Example: 当num=15时，
1//num&(num-1)=(1111)&(1110)=(1110)
2//num&(num-1)=(1110)&(1101)=(1100)
3//num&(num-1)=(1100)&(1011)=(1000)
4//num&(num-1)=(1000)&(0111)=0 ，循环停止。共执行4次while循环。
(2)c语言中1110怎么算扩展阅读
一、指定的某一位数置1
宏 #define setbit(x,y) x|=(1<<y)
二、指定的某一位数置0
宏 #define clrbit(x,y) x&=~(1<<y)
三、指定的某一位数取反
宏 #define reversebit(x,y) x^=(1<<y)
四、获取的某一位的值
宏 #define getbit(x,y) ((x) >> (y)&1)
❸ c语言位运算符的用法
c语言位运算符的用法1
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(){
int a=9,b=5,c;
c=a&b;
printf("a=%d/nb=%d/nc=%d/n",a,b,c);
}
2. 按位或运算
按位或运算符“|”是双目运算符。其功能是参与运算的两数各对应的二进位相或。只要对应的二个二进位有一个为1时，结果位就为1。参与运算的两个数均以补码出现。
例如：9|5可写算式如下： 00001001|00000101
00001101 (十进制为13)可见9|5=13
main(){
int a=9,b=5,c;
c=a|b;
printf("a=%d/nb=%d/nc=%d/n",a,b,c);
}
3. 按位异或运算
按位异或运算符“^”是双目运算符。其功能是参与运算的两数各对应的二进位相异或，当两对应的二进位相异时，结果为1。参与运算数仍以补码出现，例如9^5可写成算式如下： 00001001^00000101 00001100 (十进制为12)。
main(){
int a=9;
a=a^15;
printf("a=%d/n",a);
}
4. 求反运算
求反运算符～为单目运算符，具有右结合性。 其功能是对参与运算的数的各二进位按位求反。例如～9的运算为： ~(0000000000001001)结果为：1111111111110110。
5. 左移运算
左移运算符“<<”是双目运算符。其功能把“<< ”左边的运算数的各二进位全部左移若干位，由“<<”右边的数指定移动的位数，高位丢弃，低位补0。例如： a<<4 指把a的各二进位向左移动4位。如a=00000011(十进制3)，左移4位后为00110000(十进制48)。
6. 右移运算
右移运算符“>>”是双目运算符。其功能是把“>> ”左边的运算数的`各二进位全部右移若干位，“>>”右边的数指定移动的位数。
例如：设 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/tb=%d/n",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/nb=%d/nc=%d/nd=%d/n",a,b,c,d);
}
c语言位运算符的用法2
C语言位运算。所谓位运算，就是对一个比特(Bit)位进行操作。比特(Bit)是一个电子元器件，8个比特构成一个字节(Byte)，它已经是粒度最小的可操作单元了。
C语言提供了六种位运算符：
按位与运算(&)
一个比特(Bit)位只有 0 和 1 两个取值，只有参与&运算的两个位都为 1 时，结果才为 1，否则为 0。例如1&1为 1，0&0为 0，1&0也为 0，这和逻辑运算符&&非常类似。
C语言中不能直接使用二进制，&两边的操作数可以是十进制、八进制、十六进制，它们在内存中最终都是以二进制形式存储，&就是对这些内存中的二进制位进行运算。其他的位运算符也是相同的道理。
例如，9 & 5可以转换成如下的运算：
0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 (9 在内存中的存储)
& 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101 (5 在内存中的存储)
-----------------------------------------------------------------------------------
0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0001 (1 在内存中的存储)
也就是说，按位与运算会对参与运算的两个数的所有二进制位进行&运算，9 & 5的结果为 1。
又如，-9 & 5可以转换成如下的运算：
1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 (-9 在内存中的存储)
& 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101 (5 在内存中的存储)
-----------------------------------------------------------------------------------
0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101 (5 在内存中的存储)
-9 & 5的结果是 5。
关于正数和负数在内存中的存储形式，我们已在教程《整数在内存中是如何存储的》中进行了讲解。
再强调一遍，&是根据内存中的二进制位进行运算的，而不是数据的二进制形式;其他位运算符也一样。以-9&5为例，-9 的在内存中的存储和 -9 的二进制形式截然不同：
1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 (-9 在内存中的存储)
-0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 (-9 的二进制形式，前面多余的 0 可以抹掉)
按位与运算通常用来对某些位清 0，或者保留某些位。例如要把 n 的高 16 位清 0 ，保留低 16 位，可以进行n & 0XFFFF运算(0XFFFF 在内存中的存储形式为 0000 0000 -- 0000 0000 -- 1111 1111 -- 1111 1111)。
【实例】对上面的分析进行检验。
00001. #include
00002.
00003. int main(){
00004. int n = 0X8FA6002D;
00005. printf("%d, %d, %X ", 9 & 5, -9 & 5, n & 0XFFFF);
00006. return 0;
00007. }
运行结果：
1, 5, 2D
按位或运算(|)
参与|运算的两个二进制位有一个为 1 时，结果就为 1，两个都为 0 时结果才为 0。例如1|1为1，0|0为0，1|0为1，这和逻辑运算中的||非常类似。
例如，9 | 5可以转换成如下的运算：
0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 (9 在内存中的存储)
| 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101 (5 在内存中的存储)
-----------------------------------------------------------------------------------
0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1101 (13 在内存中的存储)
9 | 5的结果为 13。
又如，-9 | 5可以转换成如下的运算：
1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 (-9 在内存中的存储)
| 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101 (5 在内存中的存储)
-----------------------------------------------------------------------------------
1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 (-9 在内存中的存储)
-9 | 5的结果是 -9。
按位或运算可以用来将某些位置 1，或者保留某些位。例如要把 n 的高 16 位置 1，保留低 16 位，可以进行n | 0XFFFF0000运算(0XFFFF0000 在内存中的存储形式为 1111 1111 -- 1111 1111 -- 0000 0000 -- 0000 0000)。
【实例】对上面的分析进行校验。
00001. #include
00002.
00003. int main(){
00004. int n = 0X2D;
00005. printf("%d, %d, %X ", 9 | 5, -9 | 5, n | 0XFFFF0000);
00006. return 0;
00007. }
运行结果：
13, -9, FFFF002D
按位异或运算(^)
参与^运算两个二进制位不同时，结果为 1，相同时结果为 0。例如0^1为1，0^0为0，1^1为0。
例如，9 ^ 5可以转换成如下的运算：
0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 (9 在内存中的存储)
^ 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101 (5 在内存中的存储)
-----------------------------------------------------------------------------------
0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1100 (12 在内存中的存储)
9 ^ 5的结果为 12。
又如，-9 ^ 5可以转换成如下的运算：
1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 (-9 在内存中的存储)
^ 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101 (5 在内存中的存储)
-----------------------------------------------------------------------------------
1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0010 (-14 在内存中的存储)
-9 ^ 5的结果是 -14。
按位异或运算可以用来将某些二进制位反转。例如要把 n 的高 16 位反转，保留低 16 位，可以进行n ^ 0XFFFF0000运算(0XFFFF0000 在内存中的存储形式为 1111 1111 -- 1111 1111 -- 0000 0000 -- 0000 0000)。
【实例】对上面的分析进行校验。
00001. #include
00002.
00003. int main(){
00004. unsigned n = 0X0A07002D;
00005. printf("%d, %d, %X ", 9 ^ 5, -9 ^ 5, n ^ 0XFFFF0000);
00006. return 0;
00007. }
运行结果：
12, -14, F5F8002D
取反运算(~)
取反运算符~为单目运算符，右结合性，作用是对参与运算的二进制位取反。例如~1为0，~0为1，这和逻辑运算中的!非常类似。。
例如，~9可以转换为如下的运算：
~ 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 (9 在内存中的存储)
-----------------------------------------------------------------------------------
1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0110 (-10 在内存中的存储)
所以~9的结果为 -10。
例如，~-9可以转换为如下的运算：
~ 1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 (-9 在内存中的存储)
-----------------------------------------------------------------------------------
0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1000 (9 在内存中的存储)
所以~-9的结果为 8。
【实例】对上面的分析进行校验。
00001. #include
00002.
00003. int main(){
00004. printf("%d, %d ", ~9, ~-9 );
00005. return 0;
00006. }
运行结果：
-10, 8
左移运算(<<)
左移运算符<<用来把操作数的各个二进制位全部左移若干位，高位丢弃，低位补0。
例如，9<<3可以转换为如下的运算：
<< 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 (9 在内存中的存储)
-----------------------------------------------------------------------------------
0000 0000 -- 0000 0000 -- 0000 0000 -- 0100 1000 (72 在内存中的存储)
所以9<<3的结果为 72。
又如，(-9)<<3可以转换为如下的运算：
<< 1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 (-9 在内存中的存储)
-----------------------------------------------------------------------------------
1111 1111 -- 1111 1111 -- 1111 1111 -- 1011 1000 (-72 在内存中的存储)
所以(-9)<<3的结果为 -72
如果数据较小，被丢弃的高位不包含 1，那么左移 n 位相当于乘以 2 的 n 次方。
【实例】对上面的结果进行校验。
00001. #include
00002.
00003. int main(){
00004. printf("%d, %d ", 9<<3, (-9)<<3 );
00005. return 0;
00006. }
运行结果：
72, -72
右移运算(>>)
右移运算符>>用来把操作数的各个二进制位全部右移若干位，低位丢弃，高位补 0 或 1。如果数据的最高位是 0，那么就补 0;如果最高位是 1，那么就补 1。
例如，9>>3可以转换为如下的运算：
>> 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 (9 在内存中的存储)
-----------------------------------------------------------------------------------
0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0001 (1 在内存中的存储)
所以9>>3的结果为 1。
又如，(-9)>>3可以转换为如下的运算：
>> 1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 (-9 在内存中的存储)
-----------------------------------------------------------------------------------
1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 1110 (-2 在内存中的存储)
所以(-9)>>3的结果为 -2
如果被丢弃的低位不包含 1，那么右移 n 位相当于除以 2 的 n 次方(但被移除的位中经常会包含 1)。
【实例】对上面的结果进行校验。
00001. #include
00002.
00003. int main(){
00004. printf("%d, %d ", 9>>3, (-9)>>3 );
00005. return 0;
00006. }
运行结果：
1, -2
c语言位运算符的用法3
一、位运算符
在计算机中，数据都是以二进制数形式存放的，位运算就是指对存储单元中二进制位的运算。C语言提供6种位运算符。
二、位运算
位运算符 & |~<< >> ∧ 按优先级从高到低排列的顺序是：
位运算符中求反运算“~“优先级最高，而左移和右移相同，居于第二，接下来的顺序是按位与 “&“、按位异或 “∧“和按位或 “|“。顺序为~ << >> & ∧ | 。
例1：左移运算符“<<”是双目运算符。其功能把“<< ”左边的运算数的各二进位全部左移若干位，由“<<”右边的数指定移动的位数，高位丢弃，低位补0。
例如：
a<<4
指把a的各二进位向左移动4位。如a=00000011(十进制3)，左移4位后为00110000(十进制48)。
例2：右移运算符“>>”是双目运算符。其功能是把“>> ”左边的运算数的各二进位全部右移若干位，“>>”右边的数指定移动的位数。
例如：
设 a=15，
a>>2
表示把000001111右移为00000011(十进制3)。
应该说明的是，对于有符号数，在右移时，符号位将随同移动。当为正数时，最高位补0，而为负数时，符号位为1，最高位是补0或是补1 取决于编译系统的规定。
例3：设二进制数a是00101101 ，若通过异或运算a∧b 使a的高4位取反，低4位不变，则二进制数b是。
解析：异或运算常用来使特定位翻转，只要使需翻转的位与1进行异或操作就可以了，因为原数中值为1的位与1进行异或运算得0 ，原数中值为0的位与1进行异或运算结果得1。而与0进行异或的位将保持原值。异或运算还可用来交换两个值，不用临时变量。
如 int a=3 , b=4;，想将a与b的值互换，可用如下语句实现：
a=a∧b;
b=b∧a;
a=a∧b;
所以本题的答案为： 11110000 。
❹ C语言中八进制和十六进制怎么表示以及原码，反码
比如十进制的17，
八进制表示为：021 前面加0
十六进制表示为：0x11 前面加0x或者0X
原码是用二进制表示如果是8bit原码则为 0001 0001
反码为二进制的相反，0变为1,1变为0，则反码为1110 1110
❺ c语言中按位取反-1怎么算
c语言中-1的绝对值是1，二进制00000001，取反为11111110，-1为11111111，取反是00000000。
1、所有正整数的按位取反是其本身+1的负数；
2、所有负整数的按位取反是其本身+1的绝对值；
3、零的按位取反是-1（0在数学界既不是正数也不是负数）；
0的原码：
取反：
最高位是1所以是负数，求其原始数据，方法是
再次取反加1（符号位不变）
取反：
加
所以是-1
(5)c语言中1110怎么算扩展阅读
C语言按位与运算符(&)
按位与运算将两个运算分量的对应位按位遵照以下规则进行计算：
0&0=0,0&1=0,1&0=0,1&1=1。
即同为1的位，结果为1，否则结果为0。
例如，设3的内部表示为
00000011
5的内部表示为
00000101
则3&5的结果为
00000001
按位与运算有两种典型用法，一是取一个位串信息的某几位，如以下代码截取x的最低7位：x&0177。二是让某变量保留某几位，其余位置0，如以下代码让x只保留最低6位：x=x&077。以上用法都先要设计好一个常数，该常数只有需要的位是1，不需要的位是0。用它与指定的位串信息按位与。
❻ C语言 位运算
###位运算的逻辑：
1：（位与）运算符（&）：双目操作符，当两个位进行相与时，只有两者都为“1”时结果才为“1”（即：全真为真，一假为假），运算规则如下：
左运算量 右运算量 &运算结果
0 & 0 = 0
0 & 1 = 0
1 & 0 = 州明 0
1 & 1 = 1
运算：
例：
#include <stdio.h>
int main(int argc,char *crgv[]){
unsigned char x=0156, y=0xaf, z;
z=x&y;
printf("%d",z)
}
结果为：0x2e
运算过程：态燃0156（8进制）==0000 0110 1110（2进制）；
进行 &（位与运算）
0xaf(16进制) ==0000 1010 1111（2进制）；
结果：0000 0010 1110（2进制）==0x2e（十六进制）；
2：位或运算符（|）：
双目操作符，当两个 位 进行相或时，两者中只要有一方为“1”，结果就为“1”（即：一真为真，两假为假），运算规则如下：
左运算量 右运算量 （|） 运算结果
0 | 0 = 0
1 | 1 = 1
0 | 1 = 1
1 | 1 = 1
例：
#include <stdio.h>
int main(int argv,char *argc[]){
unsigned char x=027,y=0x75;
z=x|y;
}
运行过程：
027（8进制）=0001 0111(2进制)
进行 |（位或运算）
0x75(16进制)=0111 0101(2进制)
结果：0111 0111（2进制）=0x77(16进制)
3.异或运算（^）:
当两个位进行异或时，只要两者相同，结果为“0”，否者结果为“1”，（即：同假异真）运算规则如下：
左运算量 右运算量 （^） 运算结果
0 ^ 0 = 0
1 ^ 1 帆迹虚 = 0
0 ^ 1 = 1
1 ^ 0 = 1
例：
#include
int main(int argv,char *argc[]){
unsigned(无符号) char x=25,y=0263,z;
z=x^y;
printf("%d\n",z);
}
运算过程：
25（十进制)=0001 1001(二进制)
运算 ^（异或运算）
0263（8进制）=1011 0011（二进制）
结果：1010 1010（二进制）=0252（8进制）
4：移位操作符（“<<” 或 ">>"）：位移位运算的一般形式：<运算量><运算符><表达式>；
<运算量>必须为整型结果数值：
<运算符>为左移位（<<）或 右移位（>>）运算；
<表达式>也必须为整型结果数值；
移位操作就是把一个数值左移或右移若干位；假如左移n位，原来值最左边的n位数被丢掉，右边n卫补“0” ；右移操作就是和左移操作移动方向相反；
符号位的处理方法：
(1):逻辑移位，不考虑符号问题，原数值右移n位后，左边空出的n歌位置，用0填充；
（2）：算术移位，原来值进行了右移操作后，需要保证符号位不变，因此，右移n位后，左边空出的n个位置，用原数值的符号位填充。原来若是负数，则符号位为“1”，填充的位也是“1”；原来若是正数，则符号位为“0”，填充的位也是“0”，这样保证移位后的数据与原数正负相同；
例：“1000 1001”将其右移两位，逻辑移位的结果为“0010 0010”，算术移位为：“1110 0010”；
将其左移两位，逻辑移位和算术移位的结果为：“0010 0100”；
（3）***补充：特定位清零（由“1”变成“0”）用 位与 操作；特定位变“1”（由“0”变成“1”）用 位或操作；
例：
a、请把0xd5的第2位进行清零操作
0xd5=1101 0101=>1101 0001
1111 1011
~0000 0100
=0000 0001<<2
~(0x01<<2)&0xd5
b、请把0xed的第3位进行清零操作
0xed=1110 1101=>1110 0101
1111 0111
~
0000 1000
= 0000 0001<<3
~(0x01<<3)&0xed
c、请把0x7d的第2-4位进行清零
0x7d=0111 1101=>0110 0001
1110 0011
~
0001 1100
=
0000 0111<<2
~(0x07)&0x7d
d、请把0x7d的第2位和第3位进行清零
0x7d=0111 1101=>0111 0001
1111 0011
~
0000 1100
0000 0011<<2
~(0x03<<2)&0x7d
e、请把0xc7的第4位进行置1
0xc7=1100 0111=>1101 0111
0001 0000
=0000 0001<<4
=~(0x01<<4)|0xc7
f、请把0x87的第3位进行置1
0x87=1000 0111=>1000 1111
0000 1000
~(0x01<<3)|0x87
g、请把0xc7的第3—5位置1
0xc7=1100 0111=>1111 1111
0011 1000
0000 0111<<3
~(0x07<<3)|0x87