java中的位移运算 - 编程当前位置:& &&&java中的位移运算java中的位移运算&&网友分享于：&&浏览：27次java中的移位运算
一 基本概念
所有的整数类型以二进制数字位的变化及其宽度来表示。例如，byte 型值42的二进制代码是 ，其中每个位置在此代表2的次方，在最右边的位以20开始。向左下一个位置将是21，或2，依次向左是22，或4，然后是8，16，32等等，依此类推。因此42在其位置1，3，5的值为1（从右边以0开始数）；这样42是21+23+25的和，也即是2+8+32 。
所有的整数类型（除了char 类型之外）都是有符号的整数。这意味着他们既能表示正数，又能表示负数。Java 使用大家知道的2的补码（two's complement ）这种编码来表示负数，也就是通过将与其对应的正数的二进制代码取反（即将1变成0，将0变成1），然后对其结果加1。例如，-42就是通过将42的二进制代码的各个位取反，即对 取反得到 ，然后再加1，得到 ，即-42 。要对一个负数解码，首先对其所有的位取反，然后加1。例如-42，或 取反后为 ，或41，然后加1，这样就得到了42。
如果考虑到零的交叉（zero crossing ）问题，你就容易理解Java （以及其他绝大多数语言）这样用2的补码的原因。假定byte 类型的值零用 代表。它的补码是仅仅将它的每一位取反，即生成 ，它代表负零。但问题是负零在整数数学中是无效的。为了解决负零的问题，在使用2的补码代表负数的值时，对其值加1。即负零 加1后为 。但这样使1位太靠左而不适合返回到byte 类型的值，因此人们规定，-0和0的表示方法一样，-1的解码为 。尽管我们在这个例子使用了byte 类型的值，但同样的基本的原则也适用于所有Java 的整数类型。
因为Java 使用2的补码来存储负数，并且因为Java 中的所有整数都是有符号的，这样应用位运算符可以容易地达到意想不到的结果。例如，不管你如何打算，Java 用高位来代表负数。为避免这个讨厌的意外，请记住不管高位的顺序如何，它决定一个整数的符号。二 位逻辑运算符位逻辑运算符有“与”（AND）、“或”（OR）、“异或（XOR ）”、“非（NOT）”，分别用“&”、“|”、“^”、“~”表示，4-3 表显示了每个位逻辑运算的结果。在继续讨论之前，请记住位运算符应用于每个运算数内的每个单独的位。表4-3 位逻辑运算符的结果 A 0 1 0 1 B 0 0 1 1 A | B 0 1 1 1 A & B 0 0 0 1 A ^ B 0 1 1 0 ~A 1 0 1 0
按位非（NOT）
按位非也叫做补，一元运算符NOT“~”是对其运算数的每一位取反。例如，数字42，它的二进制代码为：
经过按位非运算成为
按位与（AND）
按位与运算符“&”，如果两个运算数都是1，则结果为1。其他情况下，结果均为零。看下面的例子：
按位或（OR）
按位或运算符“|”，任何一个运算数为1，则结果为1。如下面的例子所示：
按位异或（XOR）
按位异或运算符“^”，只有在两个比较的位不同时其结果是 1。否则，结果是零。下面的例子显示了“^”运算符的效果。这个例子也表明了XOR 运算符的一个有用的属性。注意第二个运算数有数字1的位，42对应二进制代码的对应位是如何被转换的。第二个运算数有数字0的位，第一个运算数对应位的数字不变。当对某些类型进行位运算时，你将会看到这个属性的用处。
位逻辑运算符的应用
下面的例子说明了位逻辑运算符：
// Demonstrate the bitwise logical operators.class BitLogic {public static void main(String args[]) {
String binary[] = {"0000", "0001", "0010", "0011", "0100", "0101", "0110", "0111", "1000", "1001", "1010", "1011", "1100", "1101", "1110", "1111"
};int a = 3; // 0 + 2 + 1 or 0011 in binaryint b = 6; // 4 + 2 + 0 or 0110 in binaryint c = a |int d = a & int e = a ^ int f = (~a & b) | (a & ~b);int g = ~a & 0x0f;
System.out.println(" a = " + binary[a]);System.out.println(" b = " + binary[b]);System.out.println(" a|b = " + binary[c]);System.out.println(" a&b = " + binary[d]);System.out.println(" a^b = " + binary[e]);System.out.println("~a&b|a&~b = " + binary[f]);System.out.println(" ~a = " + binary[g]);
在本例中，变量a与b对应位的组合代表了二进制数所有的 4 种组合模式：0-0，0-1，1-0 ，和1-1 。“|”运算符和“&”运算符分别对变量a与b各个对应位的运算得到了变量c和变量d的值。对变量e和f的赋值说明了“^”运算符的功能。字符串数组binary 代表了0到15 对应的二进制的值。在本例中，数组各元素的排列顺序显示了变量对应值的二进制代码。数组之所以这样构造是因为变量的值n对应的二进制代码可以被正确的存储在数组对应元素binary[n] 中。例如变量a的值为3，则它的二进制代码对应地存储在数组元素binary[3] 中。~a的值与数字0x0f （对应二进制为 ）进行按位与运算的目的是减小~a的值，保证变量g的结果小于16。因此该程序的运行结果可以用数组binary 对应的元素来表示。该程序的输出如下：
a = 0011 b = 0110 a|b = 0111 a&b = 0010 a^b = 0101 ~a&b|a&~b = 0101 ~a = 1100 三 左移运算符左移运算符&&使指定值的所有位都左移规定的次数。它的通用格式如下所示：
value && num这里，num 指定要移位值value 移动的位数。也就是，左移运算符&&使指定值的所有位都左移num位。每左移一个位，高阶位都被移出（并且丢弃），并用0填充右边。这意味着当左移的运算数是int 类型时，每移动1位它的第31位就要被移出并且丢弃；当左移的运算数是long 类型时，每移动1位它的第63位就要被移出并且丢弃。
在对byte 和short类型的值进行移位运算时，你必须小心。因为你知道Java 在对表达式求值时，将自动把这些类型扩大为 int 型，而且，表达式的值也是int 型。对byte 和short类型的值进行移位运算的结果是int 型，而且如果左移不超过31位，原来对应各位的值也不会丢弃。但是，如果你对一个负的byte 或者short类型的值进行移位运算，它被扩大为int 型后，它的符号也被扩展。这样，整数值结果的高位就会被1填充。因此，为了得到正确的结果，你就要舍弃得到结果的高位。这样做的最简单办法是将结果转换为byte 型。下面的程序说明了这一点：
// Left shifting a byte value.class ByteShift {
public static void main(String args[]) {byte a = 64,
i = a && 2;b = (byte) (a && 2);
System.out.println("Original value of a: " + a);System.out.println("i and b: " + i + " " + b);}}
该程序产生的输出下所示：
Original value of a: 64i and b: 256 0
因变量a在赋值表达式中，故被扩大为int 型，64（ ）被左移两次生成值256 （ ）被赋给变量i。然而，经过左移后，变量b中惟一的1被移出，低位全部成了0，因此b的值也变成了0。
既然每次左移都可以使原来的操作数翻倍，程序员们经常使用这个办法来进行快速的2 的乘法。但是你要小心，如果你将1移进高阶位（31或63位），那么该值将变为负值。下面的程序说明了这一点：
// Left shifting as a quick way to multiply by 2.class MultByTwo {
public static void main(String args[]) {int num = 0xFFFFFFE;
for(i=0; i&4; i++) {num = num && 1; System.out.println(num);
}}这里，num 指定要移位值value 移动的位数。也就是，左移运算符&&使指定值的所有位都左移num位。每左移一个位，高阶位都被移出（并且丢弃），并用0填充右边。这意味着当左移的运算数是int 类型时，每移动1位它的第31位就要被移出并且丢弃；当左移的运算数是long 类型时，每移动1位它的第63位就要被移出并且丢弃。
在对byte 和short类型的值进行移位运算时，你必须小心。因为你知道Java 在对表达式求值时，将自动把这些类型扩大为 int 型，而且，表达式的值也是int 型。对byte 和short类型的值进行移位运算的结果是int 型，而且如果左移不超过31位，原来对应各位的值也不会丢弃。但是，如果你对一个负的byte 或者short类型的值进行移位运算，它被扩大为int 型后，它的符号也被扩展。这样，整数值结果的高位就会被1填充。因此，为了得到正确的结果，你就要舍弃得到结果的高位。这样做的最简单办法是将结果转换为byte 型。下面的程序说明了这一点：
// Left shifting a byte value.class ByteShift {
public static void main(String args[]) {byte a = 64,
i = a && 2;b = (byte) (a && 2);
System.out.println("Original value of a: " + a);System.out.println("i and b: " + i + " " + b);}}
该程序产生的输出下所示：
Original value of a: 64i and b: 256 0
因变量a在赋值表达式中，故被扩大为int 型，64（ ）被左移两次生成值256 （ ）被赋给变量i。然而，经过左移后，变量b中惟一的1被移出，低位全部成了0，因此b的值也变成了0。
既然每次左移都可以使原来的操作数翻倍，程序员们经常使用这个办法来进行快速的2 的乘法。但是你要小心，如果你将1移进高阶位（31或63位），那么该值将变为负值。下面的程序说明了这一点：
// Left shifting as a quick way to multiply by 2.class MultByTwo {
public static void main(String args[]) {int num = 0xFFFFFFE;
for(i=0; i&4; i++) {num = num && 1; System.out.println(num);
该程序的输出如下所示：
初值经过仔细选择，以便在左移 4 位后，它会产生-32。正如你看到的，当1被移进31 位时，数字被解释为负值。四 右移运算符右移运算符&&使指定值的所有位都右移规定的次数。它的通用格式如下所示：
value && num
这里，num 指定要移位值value 移动的位数。也就是，右移运算符&&使指定值的所有位都右移num位。下面的程序片段将值32右移2次，将结果8赋给变量a:
int a = 32;a = a && 2; // a now contains 8
当值中的某些位被“移出”时，这些位的值将丢弃。例如，下面的程序片段将35右移2 次，它的2个低位被移出丢弃，也将结果8赋给变量a:
int a = 35; a = a && 2; // a still contains 8
用二进制表示该过程可以更清楚地看到程序的运行过程：
将值每右移一次，就相当于将该值除以2并且舍弃了余数。你可以利用这个特点将一个整数进行快速的2的除法。当然，你一定要确保你不会将该数原有的任何一位移出。
右移时，被移走的最高位（最左边的位）由原来最高位的数字补充。例如，如果要移走的值为负数，每一次右移都在左边补1，如果要移走的值为正数，每一次右移都在左边补0，这叫做符号位扩展（保留符号位）（sign extension ），在进行右移操作时用来保持负数的符号。例如，–8 && 1 是–4，用二进制表示如下：
一个要注意的有趣问题是，由于符号位扩展（保留符号位）每次都会在高位补1，因此-1右移的结果总是–1。有时你不希望在右移时保留符号。例如，下面的例子将一个byte 型的值转换为用十六进制表示。注意右移后的值与0x0f进行按位与运算，这样可以舍弃任何的符号位扩展，以便得到的值可以作为定义数组的下标，从而得到对应数组元素代表的十六进制字符。
// Masking sign extension.class HexByte {static public void main(String args[]) {
char hex[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f''
};byte b = (byte) 0xf1;
System.out.println("b = 0x" + hex[(b && 4) & 0x0f] + hex[b & 0x0f]);}}
该程序的输出如下：
b = 0xf1 五 无符号右移正如上面刚刚看到的，每一次右移，&&运算符总是自动地用它的先前最高位的内容补它的最高位。这样做保留了原值的符号。但有时这并不是我们想要的。例如，如果你进行移位操作的运算数不是数字值，你就不希望进行符号位扩展（保留符号位）。当你处理像素值或图形时，这种情况是相当普遍的。在这种情况下，不管运算数的初值是什么，你希望移位后总是在高位（最左边）补0。这就是人们所说的无符号移动（unsigned shift ）。这时你可以使用Java 的无符号右移运算符&&& ，它总是在左边补0。
下面的程序段说明了无符号右移运算符&&& 。在本例中，变量a被赋值为-1，用二进制表示就是32位全是1。这个值然后被无符号右移24位，当然它忽略了符号位扩展，在它的左边总是补0。这样得到的值255被赋给变量a。
int a = -1; a = a &&& 24;
下面用二进制形式进一步说明该操作：
int型-1的二进制代码&&& 24 无符号右移24位00
int型255的二进制代码
由于无符号右移运算符&&& 只是对32位和64位的值有意义，所以它并不像你想象的那样有用。因为你要记住，在表达式中过小的值总是被自动扩大为int 型。这意味着符号位扩展和移动总是发生在32位而不是8位或16位。这样，对第7位以0开始的byte 型的值进行无符号移动是不可能的，因为在实际移动运算时，是对扩大后的32位值进行操作。下面的例子说明了这一点：
// Unsigned shifting a byte value.class ByteUShift {static public void main(String args[]) {int b = 2;int c = 3;
a |= 4;b &&= 1; c &&= 1; a ^=System.out.println("a = " + a);System.out.println("b = " + b);System.out.println("c = " + c);
该程序的输出如下所示：
a = 3 b = 1 c = 6
12345678910
12345678910
12345678910 上一篇：下一篇：文章评论相关解决方案 12345678910 Copyright & &&版权所有&、^、！和|操作符称为逻辑操作符，用逻辑操作符把运算对象连接起来符合C#语法的式子称为逻辑表达式。逻辑 操作符&!&和&^&只作用于其后的操作数，故称为一元操作符。而&&&&、&||&、&&&和&|&为二元操作符，这4个操作 符用于表达式，产生一个true或false逻辑值。如果 x 为 true，则不计算 y（因为不论 y 为何值，&或&操作的结果都为 true）。这被称作为&短路&计算。&&如果 x 为 false，则不计算 y（因为不论 y 为何值，&与&操作的结果都为 false）。这被称作为&短路&计算。|当且仅当两个操作数均为 false 时，结果才为 false。&当且仅当两个操作数均为 true 时，结果才为 true。^当且仅当只有一个操作数为 true 时，结果才为 true。~运算符对操作数执行按位求补运算，其效果相当于反转每一位。定义　　异或（xor）是一个数学运算符。它应用于逻辑运算。异或符号为&^&。 其运算法则为a异或b=a'b或ab'（a'为非a）。 　　真异或假的结果是真，假异或真的结果也是真，真异或真的结果是假，假异或假的结果是假。就是说两个值不相同，则异或结果为真。反之，为假。 不同为1,相同为0,如1001异或1010等于0011. 　　异或也叫半加运算，其运算法则相当于不带进位的二进制加法：二进制下用1表示真，0表示假，则异或的运算法则为：0异或0=0，1异或0=1，0异或1=1，1异或1=0，这些法则与加法是相同的，只是不带进位。异或运算法则　　1. a ^ b = b ^ a 　　2. a ^ b ^ c = a ^ (b ^ c) = (a ^ b) ^ 　　3. d = a ^ b ^ c 可以推出 a = d ^ b ^ c. 　　4. a ^ b ^ a = b. 　　x是二进制数0101 　　y是二进制数1011 　　则结果为x^y=1110 　　0^0=0 　　0^1=1 　　1^0=1 　　1^1=0 　　只有在两个比较的位不同时其结果是1，否则结果为0 　　即&相同为0，不同为1&！ 　　输入运算符输入结果1^011^100^000^11异或逻辑　　异或逻辑的逻辑符号如图2所示，其真值表如图1所示。异或逻辑的关系是：当AB不同时，输出P=1；当AB相同时，输出P=0。&&&是异或运算符号，异或逻辑也是与或非逻辑的组合，其逻辑表达式为： 　　P=A&B0&0=0 　0&1=11&0=1 　　1&1=0作用　　在计算机中普遍运用，异或(xor)的逻辑符号^ (Shift + 6)或一个圆圈里面增加一个+（&）或者&.形象表示为： 　　真^假=真 　　&&&&& 假^真=真 　　假^假=假 　　真^真=假 　　或者为： 　　True ^ False = True 　　False ^ True = True 　　False ^ False = False 　　True ^ True = False 　　部分计算机语言用1表示真，用0表示假，所以两个字节按位异或如下: 　　 　　异或 　　 　　= 　　　　 　　异或 　　 　　= 　　&==================================================================分割线1、位逻辑非运算位逻辑非运算是单目的，只有一个运算对象。位逻辑非运算按位对运算对象的值进行非运算，即：如果某一位等于0，就将其转变为1；如果某一位等于1，就将其转变为0。比如，对二进制的进行位逻辑非运算，结果等于，用十进制表示就是：~145等于110；对二进制的进行位逻辑非运算，结果等于。用十进制表示就是~85等于176。&2、位逻辑与运算位逻辑与运算将两个运算对象按位进行与运算。与运算的规则：1与1等于1，1与0等于0。比如：（二进制）&等于（二进制）。&3、位逻辑或运算位逻辑或运算将两个运算对象按位进行或运算。或运算的规则是：1或1等1，1或0等于1，0或0等于0。比如（二进制）| （二进制）等于（二进制）。&4、位逻辑异或运算位逻辑异或运算将两个运算对象按位进行异或运算。异或运算的规则是：1异或1等于0，1异或0等于1，0异或0等于0。即：相同得0，相异得1。比如：（二进制）^（二进制）等于（二进制）。&5、位左移运算位左移运算将整个数按位左移若干位，左移后空出的部分0。比如：8位的byte型变量byte a=0x65(即二进制的),将其左移3位：a&&3的结果是0x27(即二进制的)。&6、位右移运算&位右移运算将整个数按位右移若干位，右移后空出的部分填0。比如：8位的byte型变量Byte a=0x65(既（二进制的）)将其右移3位：a&&3的结果是0x0c(二进制)。&在进行位与、或、异或运算时，如果两个运算对象的类型一致，则运算结果的类型就是运算对象的类型。比如对两个int变量a和b做与运算，运算结果的类型还是int型。如果两个运算对象的类型不一致，则C#要对不一致的类型进行类型转换，变成一致的类型，然后进行运算。类型转换的规则同算术运算中整型量的转换则一致。由位运算符连接整型量而成的表达式就是位运算表达式。&&(详解2)一、&按位与&运算符(&)&&& 1、运算规则&&&& 参加运算的两个数据，按二进位进行&与&运算，如果两个相应的二进位都为1，则该位的结果值为1，否则为0，即：&&& 0&0=0，0&1=0，1&0=0，1&1=1.&& 2、用途&&&& (1)清零&&&&&&& 运算对象：原来的数中为1的位，新数中相应位为0。&&& （2）取一个数中某些指定位。&&&&&& 如想要取一个整数a（占2个字节）的低（高）字节，只需将a与八进制的377（177400）按位与即可。&&& （3）保留某一个数的某一位。&&&&&&& 与一个数进行&运算，此数在该位取1。&&& 3、例如：9&5可写算式如下： 的二进制补码)&的二进制补码)　的二进制补码)可见9&5=1。　　按位与运算通常用来对某些位清0或保留某些位。例如把a 的高八位清 0 ， 保留低八位， 可作 a&255 运算 ( 255 的二进制数为1111)。main(){int a=9,b=5,c;c=a&b;printf("a=%d\nb=%d\nc=%d\n",a,b,c);}二、 按位或运算符(|)&& 1、运算规则&&&& 参加运算的两个数据，按二进位进行&或&运算，如果两个相应的二进位都为0，则该位的结果值为0，否则为1，即：&&& 0|0=0，0|1=1，1|0=1，1|1=1。&& 2、用途&&&& 对一个数据的某些位定值为1。3.例如：9|5可写算式如下： 00101 (十进制为13)可见9|5=13main(){int a=9,b=5,c;c=a|b;printf("a=%d\nb=%d\nc=%d\n",a,b,c);}　三、&异或&运算符(^)&& 也称XOR运算符。&& 1、运算规则&&&& 若参加运算的两个二进位同号，则结果为0（假）；异号则为1（真），即：&&& 0^0=0，0^1=1，1^0=1，1^1=0.&& 2、用途&&&& (1)使特定位翻转&&&&&&& 假设有，想使其低4位翻转，可以将它与进行^运算。&&& （2）与0相^，保留原值&&& （3）交换两个值，不用临时变量&&&&&&& 假如a=3,b=4。想将a和b的值互换，可以用以下赋值语句实现：&&&&&&& a=a^b; b=b^a;&&&& a=a^b;　3、例如9^5可写成算式如下： 00 (十进制为12)main(){int a=9;a=a^15;printf("a=%d\n",a);}四、&取反&运算符(～)&& 1、运算规则&& ~是一个单目（元）运算符，用来对一个二进制数按位取反，即将0变1，1变0。&& 2、用途&&& 使一个整数a的最低位为0,可以用：a=a&~1;　3、例如～9的运算为： ~(1001)结果为：0110五、 左移运算符(&&)&& 1、运算规则&& 用来将一个数的各二进位全部左移若干位，右补0，高位左移后溢出，舍弃不起作用。&& 2、用途&&& 左移一位相当于乘以23、例如：设 a=15，a&&2　表示把右移为(十进制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&0c=(p&0xff00)&&8;printf("a=%d\nb=%d\nc=%d\nd=%d\n",a,b,c,d);}&&&六、 右移运算符(&&)&& 1、运算规则&& 用来将一个数的各二进位全部右移若干位，移到右端的低位被舍弃，对无符号数，高位补0；&&& 对有符号数，左边移入0（&逻辑右移&）或1（&算术右移&）&& 2、用途&&& 右移一位相当于除以2&&&&七、位运算赋值运算符&&&& 位运算符与赋值运算符可以组成复合赋值运算符,如：&&&& &=,|=,&&=,&&=,^=　八、不同长度的数据进行位运算&&& 如果两个数据长度不同，进行位运算时（如：a&b,而a为long型，b为int型），系统会将二者按右端对齐。如果b为正数，则左侧16位补满0，若b为负数，左端应补满1，如果b为无符号整数型，则左端填满0。位域有些信息在存储时，并不需要占用一个完整的字节， 而只需占几个或一个二进制位。例如在存放一个开关量时，只有0和1 两种状态， 用一位二进位即可。为了节省存储空间，并使处理简便，Ｃ语言又提供了一种数据结构，称为&位域&或&位段&。所谓&位域&是把一个字节中的二进位划分为几个不同的区域， 并说明每个区域的位数。每个域有一个域名，允许在程序中按域名进行操作。 这样就可以把几个不同的对象用一个字节的二进制位域来表示。一、位域的定义和位域变量的说明位域定义与结构定义相仿，其形式为：&struct 位域结构名&{ 位域列表 };其中位域列表的形式为： 类型说明符 位域名：位域长度例如：&struct bs{int a:8;int b:2;int c:6;};位域变量的说明与结构变量说明的方式相同。 可采用先定义后说明，同时定义说明或者直接说明这三种方式。例如：&struct bs{int a:8;int b:2;int c:6;}说明data为bs变量，共占两个字节。其中位域a占8位，位域b占2位，位域c占6位。对于位域的定义尚有以下几点说明：1、一个位域必须存储在同一个字节中，不能跨两个字节。如一个字节所剩空间不够存放另一位域时，应从下一单元起存放该位域。也可以有意使某位域从下一单元开始。例如：&struct bs{unsigned a:4unsigned :0 /*空域*/unsigned b:4 /*从下一单元开始存放*/unsigned c:4}在这个位域定义中，a占第一字节的4位，后4位填0表示不使用，b从第二字节开始，占用4位，c占用4位。2、由于位域不允许跨两个字节，因此位域的长度不能大于一个字节的长度，也就是说不能超过8位二进位。3、位域可以无位域名，这时它只用来作填充或调整位置。无名的位域是不能使用的。例如：&struct k{int a:1int :2 /*该2位不能使用*/int b:3int c:2};从以上分析可以看出，位域在本质上就是一种结构类型， 不过其成员是按二进位分配的。二、位域的使用位域的使用和结构成员的使用相同，其一般形式为： 位域变量名&位域名 位域允许用各种格式输出。main(){struct bs{unsigned a:1;unsigned b:3;unsigned c:4;} bit,*bit.a=1;bit.b=7;bit.c=15;printf("%d,%d,%d\n",bit.a,bit.b,bit.c);pbit=&pbit-&a=0;pbit-&b&=3;pbit-&c|=1;printf("%d,%d,%d\n",pbit-&a,pbit-&b,pbit-&c);}上例程序中定义了位域结构bs，三个位域为a,b,c。说明了bs类型的变量bit和指向bs类型的指针变量pbit。这表示位域也是可以使用指针的。程序的9、10、11三行分别给三个位域赋值。( 应注意赋值不能超过该位域的允许范围)程序第12行以整型量格式输出三个域的内容。第13行把位域变量bit的地址送给指针变量pbit。第14行用指针方式给位域a重新赋值，赋为0。第15行使用了复合的位运算符"&="， 该行相当于： pbit-&b=pbit-&b&3位域b中原有值为7，与3作按位与运算的结果为3(111&011=011,十进制值为3)。同样，程序第16行中使用了复合位运算"|="， 相当于： pbit-&c=pbit-&c|1其结果为15。程序第17行用指针方式输出了这三个域的值。类型定义符ｔｙｐｅｄｅｆＣ语言不仅提供了丰富的数据类型，而且还允许由用户自己定义类型说明符，也就是说允许由用户为数据类型取&别名&。 类型定义符typedef即可用来完成此功能。例如，有整型量a,b,其说明如下： int aa,b; 其中int是整型变量的类型说明符。int的完整写法为integer，为了增加程序的可读性，可把整型说明符用typedef定义为： typedef int INTEGER 这以后就可用INTEGER来代替int作整型变量的类型说明了。 例如： INTEGER a,b;它等效于： int a,b; 用typedef定义数组、指针、结构等类型将带来很大的方便，不仅使程序书写简单而且使意义更为明确，因而增强了可读性。例如：typedef char NAME[20]; 表示NAME是字符数组类型，数组长度为20。然后可用NAME 说明变量，如： NAME a1,a2,s1,s2;完全等效于： char a1[20],a2[20],s1[20],s2[20]又如：&typedef struct stu{ char name[20];} STU;定义STU表示stu的结构类型，然后可用STU来说明结构变量： STU body1,body2;typedef定义的一般形式为： typedef 原类型名 新类型名 其中原类型名中含有定义部分，新类型名一般用大写表示， 以便于区别。在有时也可用宏定义来代替typedef的功能，但是宏定义是由预处理完成的，而typedef则是在编译时完成的，后者更为灵活方便。例子:例如有中种颜色选择,1代表红,2代表蓝,4带表黑,8带表白1=2=4=8=如果你选择了2和4(既红和黑)则1()或2()或4()=7()如果提供7给你，你怎么知道选择了1和2和4呢?答案是:7跟四个数1,2,4,8分别做或结果还是7,则说明某个被选择了如：7或2=7,所以1被选择了&& 7或8=15,不等于7哦,所以8没被选择了&& ,这样应该知道用途了吧具体的位运算方式如下：&运算名称意义运算对象类型&运算结果类型&对象数&实例&~位逻辑非运算&整型或字符型整型&1&~a&&&位逻辑与运算整型或字符型&整型&2&a&b&|&位逻辑或运算整型或字符型整型&2&a|b^&位逻辑异或运算&整型或字符型&整型&1&^a&&&&位左移运算&整型或字符型&整型&2&a&&4&&&&位又移运算&整型或字符型&整型&2&a&&2
、 、 、 、 、