Some 宏定义

& 与操作  两个都为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