& 与操作 两个都为1时 结果为1
0&0=0 0&1=0 1&0=0 1&1=1
总结:两位同时为1,结果才为1,否则结果为0.
与运算的用途:
1)清零
如果想将一个单元清零,即使其全部二进制位为0,只要与一个各位都为零的数值相与,结果为零。
2)取一个数的指定位
比如取数 X=1010 1110 的低4位,只需要另找一个数Y,令Y的低4位为1,其余位为0,即Y=0000
1111,然后将X与Y进行按位与运算(X&Y=0000 1110)即可得到X的指定位。
3)判断奇偶
只要根据最未位是0还是1来决定,为0就是偶数,为1就是奇数。因此可以用if ((a & 1) == 0)代替if (a % 2 ==
0)来判断a是不是偶数。
| 或操作 两个都为0时 结果为0
0|0=0 0|1=1 1|0=1 1|1=1
总结:参加运算的两个对象只要有一个为1,其值为1.
例如:3|5即 0000 0011| 0000 0101 = 0000 0111,因此,3|5的值得7。
注意:负数按补码形式参加按位或运算。
或运算的用途:
1)常用来对一个数据的某些位设置为1
比如将数 X=1010 1110 的低4位设置为1,只需要另找一个数Y,令Y的低4位为1,其余位为0,即Y=0000
1111,然后将X与Y进行按位或运算(X|Y=1010 1111)即可得到
^ 异或操作 两个相同为0 不同为1
0^0=0 0^1=1 1^0=1 1^1=0
总结:参加运算的两个对象,如果两个相应位相同为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;
异或运算的用途:
1)翻转指定位
比如将数 X=1010 1110 的低4位进行翻转,只需要另找一个数Y,令Y的低4位为1,其余位为0,即Y=0000
1111,然后将X与Y进行异或运算(X^Y=1010 0001)即可得到。
2)与0相异或值不变
例如:1010 1110 ^ 0000 0000 = 1010 1110
3)交换两个数
void Swap(int &a, int &b){
if (a != b){
a ^= b;
b ^= a;
a ^= b;
}
}
~ 取反操作 0变1 2变0
<< 左移 各二进制位全部左移若干位,高位丢弃,低位补0
>> 右移
各二进制位全部右移若干位,对于无符号数,高位补0,有符号数,
各编译器处理不同,有的符号位(算术右移),有的补0(逻辑右移)
使用 #define 定义常量 bit 3 ==>1000
a |= BIT3; ==> a = a |= BIT3;
|(或):有 1 为 1 ,将 bit 3 置位
a = 1 0001 | 1000 = 1001 a = 9
a &= ~BIT3; ==> a = a &= ~BIT3;
& (与) :有 0 为 0 ,使用 ~ 取反后将 bit 3 清零
a = 8 1000 & ~(1000) = 1000 & 0001 = 0000 a = 0
#define BIT3 (0x1 << 3)
static int a;
void set_bit(void) { a |= BIT3; }
void clear_bit(void) { a &= ~(BIT3); }
#define Min(x, y) ((x) < (y)? (x) : (y))
#define Min(x, y) ({ \
typeof(x) _min1 = (x); \
typeof(y) _min2 = (y); \
(void) (&_min1 == &_min2); \
_min1 < _min2 ? _min1 : _min2; \
})
#define Max(x, y) ({ \
typeof(x) _max1 = (x); \
typeof(y) _max2 = (y); \
(void) (&_max1 == &_max2); \
_max1 > _max2 ? _max1 : _min2; \
})
#define Min(x, y, z) ({\
typeof(x) _min1 = (x); \
typeof(y) _min2 = (y); \
typeof(z) _min3 = (z); \
(void) (&_min1 == &_min2); \
(void) (&_min1 == &_min3); \
_min1 < _min2 ? (_min1 < _min3 ? _min1 : _min3);\
(_min2 < _min3 ? _min2 : _min3); \
})
#define Max(x, y, z) ({\
typeof(x) _min1 = (x); \
typeof(y) _min2 = (y); \
typeof(z) _min3 = (z); \
(void) (&_min1 == &_min2); \
(void) (&_min1 == &_min3); \
_min1 > _min2 ? (_min1 > _min3 ? _min1 : _min3);\
(_min2 > _min3 ? _min2 : _min3); \
})
#define abs(x) ({ \
int _x = x; \
(_x < 0) ? -_x : _x;\
})
#define swap(x, y) \
do{ \
typeof(x) _x = (x); \
(x) = (y); \
(y) = (_x); \
}while(0)
#define swap(x, y) \
(((x) ^= (y)), ((y) ^= (x)), ((x) ^= (y)))
bool is_little_endian(void){
int data = 1; //使用 1 移植性更好,int 为4字节的时候 0x00000001
printf("data 0x%08x in mermory\n", data);
printf("first byte data is: 0x%08x\n", *(char *)data);
/*< 低字节放在低地址,低地址即data变量首地址,即小端序 */
if(*(char *)data == 1){
return true; // is little endian
}else{
return false; // is big endian
}
}
bool is_little_endian(void){
union endian{
int i;
char c;
};
union endian test;
test.i = 1;
//printf("data 0x%08x in memory\n", test.i);
//printf("first byte data is : 0x%08x\n", test.ch);
if(test.c == 1){
return true; // is little endian
}else{
return false;
}
}
|低字节--------------->高字节|
|------|------|------|------|
| 0x78 | 0x56 | 0x34 | 0x12 |
|------|------|------|------|
|低地址--------------->高地址|
// little |0x12|0x34|0x56|0x78|
// big |0x78|0x56|0x34|0x12|
0x12向右移了3个字节 24位
0x34向右移了1个字节 8位
0x56向左移了1个字节 8位
0x78向左移了3个自己 24位
#define L2B_32(data) (true == is_little_endian(data) ? \
(((data & 0xff000000) >> 24) | \
((data & 0x00ff0000) >> 8) | \
((data & 0x0000ff00) << 8) | \
((data & 0x000000ff) << 24)) : data)
printf("%#x\n", L2B_32(0x12345678));
0x78563412
// 位序反转 32bit 0x12345678 --> 0x87654321
#define BitSWAP_4(x) ((x)&0xf)
#define BitSWAP_8(x) ((BitSWAP_4(x) << 4) | BitSWAP_4((x) >> 4))
#define BitSWAP_16(x) ((BitSWAP_8(x) << 8) | BitSWAP_8((x) >> 8))
#define BitSWAP_32(x) ((BitSWAP_16(x) << 16) | BitSWAP_16((x) >> 16))
#define BitSWAP_64(x) ((BitSWAP_32(x) << 32) | BitSWAP_32((x) >> 32))
// 字节序反转
#define ByteSWAP_8(x) ((x)&0xff)
#define ByteSWAP_16(x) ((ByteSWAP_8(x) << 8) | ByteSWAP_8((x) >> 8))
#define ByteSWAP_32(x) ((ByteSWAP_16(x) << 16) | ByteSWAP_16((x) >> 16))
#define ByteSWAP_64(x) ((ByteSWAP_32(x) << 32) | ByteSWAP_32((x) >> 32))
// littel endian 2 big endian 32bit 0x12345678 --> 0x78563412