算术运算符

+ - * / %

除了%操作符，其余几个操作符都是既适用于浮点类型有适用于整数类型。

当/操作符的两个操作数都是整数时，它执行整除运算，在其他情况下则执行浮点数除法，整除运算的任意操作符为负值，运算结果又编译器定义。整数类型进行 "/" 运算商也是整数，截断小数部分

%为取模操作符，它接受两个整型操作数，把左操作数除以右操作数，它的返回值是余数而不是商

应尽量避免让负数参与/ 和 %运算，结果肯能是不确定的

#include 
  
   

void div(unsigned int i, unsigned int j)
{
        if (i == ((i/j)*j))
        {
                printf ("%u is divisible by %u\n", i, j);
        }
}
void div_mod(unsigned int i, unsigned j)
{
        if (i == (((i/j)*j) + i%j))
        {
                printf ("%u is divisible by %u\n", i, j);
        }
}
int main()
{
        div(100, 10);
        div(100, 11);
        div_mod(100, 10);
        div_mod(100, 11);
}

  

100 is divisible by 10
100 is divisible by 10
100 is divisible by 11

逻辑操作符

&& || !

使用&&或||连接的表达式从左到右求值，已知结果则立即停止。

注意！与~操作符的区别：！是逻辑取反，~是按位取反

#include 
  
   

int main()
{
        int a;
        int i;

        for (a=0, i=0; a<=1&&!i++; a++)
        {
                a++;
        }

        printf("a = %d x = %d\n", a, i);
}

  

a = 2 x = 1

位操作符

& | ^ ~ << >>
&可用于屏蔽(mask off)位，|可用于设置(turn on)位

value = value & ~(1<

value = value | 1<

~操作符可用于定义机器字长全F

<< 左移n位，等效于 *2^n(不溢出情况下)

>> 右移n位，等效于/ 2^n

左移右移两个操作数必须都是整型类型

右移位操作存在一个左移位操作不曾面临的问题：从左边移入新位时，可以选择两种方案：

一种是逻辑移位，左边移入的位用0填充；

另一种是算术移位，左边移入的位有原先该值的符号位决定，符号位为1则移入的位均为1，符号位为0则移入的位均为0，这样能够保证原数的正负形式不变。

算术左移和逻辑左移是相同的，它们只在右移时不同，而且只有当操作数是负值时才不一样。

注：标准说明无符号类型值的执行的所有移位操作都是逻辑移位，但对于有符号值，到底是采用逻辑移位还是算术移位取决于编译器。因此，一个程序如果使用了有符号数的右移位操作，它就是不可移植的。

&在特定情况下可以代替%进行取余运算

除数为2^n时取余可用&代替，且效率更高

以下为判断整除的例子

除数任意

BOOL_T IsDivisible_A(IN UINT uiX, IN UINT uiY)
{
    BOOL_T bDiv = BOOL_FALSE;

    if (0 == (uiX%uiY))
    {
        bDiv = BOOL_TRUE;
    }

    return bDiv;   
}
BOOL_T IsDivisible_B(IN UINT uiX, IN UINT uiY)
{
    BOOL_T bDiv = BOOL_FALSE;

    if (uiX == ((uiX/uiY)*uiY))
    {
        bDiv = BOOL_TRUE;
    }

    return bDiv;   
}

BOOL_T IsDivisible_8_A(IN UINT uiX)
{
    BOOL_T bDiv = BOOL_FALSE;

    if (0 == (uiX&0x7U))
    {
        bDiv = BOOL_TRUE;
    }

    return bDiv;   
}
BOOL_T IsDivisible_8_B(IN UINT uiX)
{
    BOOL_T bDiv = BOOL_FALSE;

    if (uiX == ((uiX>> 3UL)<<3UL))
    {
        bDiv = BOOL_TRUE;
    }

    return bDiv;   
}

#include 
  
   

#define Conversion_4Byte(x ,y) \
        y =     \
        ((x & 0xFF000000U) >> 24)| \
        ((x & 0x00FF0000U) >> 8) | \
        ((x & 0xFF00U)  << 8)  | \
        ((x & 0xFFU)    << 24)
int main()
{
        unsigned int x = 0xAABBCCDD;
        unsigned int y = 0;

        Conversion_4Byte(x, y);

        printf("%#X \n%#X\n", x, y);

}

  

0XAABBCCDD
0XDDCCBBAA

位运算符常见用法

#define BIT_SET(f, b)   ((f) |= (b))
#define BIT_RESET(f, b) ((f) &= ~(b))
#define BIT_TEST(f, b)  (((f)&(b)) != 0)
#define BIT_MATCH(f, b) (((f)&(b)) == (b))

typedef enum tagEvent
{
    EVENT_X = 0,
    EVENT_Y,
    EVENT_Z
}

#define EVENT_MASK(enEvt)   ((UINT)(1UL << (ULONG)(UINT)(enEvt)))

#define EVENT_ON(uiCur, enEvt)   (BIT_SET(uiCur, EVENT_MASK(enEvt)))
#define EVENT_OFF(uiCur, enEvt)  (BIT_RESET(uiCur, EVENT_MASK(enEvt)))
#define EVENT_TEST(uiCur, enEvt) (BIT_TEST(uiCur, EVENT_MASK(enEvt)))

#define BIT_SET(f, b)   ((f) |= (b))
#define BIT_RESET(f, b) ((f) &= ~(b))
#define BIT_TEST(f, b)  (((f)&(b)) != 0)
#define BIT_MATCH(f, b) (((f)&(b)) == (b))

#define STATUS_X    0x01U
#define STATUS_Y    0x02U
#define STATUS_Z    0x04U

#define STATUS_ALL  (STATUS_X | STATUS_Y | STATUS_Z)

#define STATUS_ISVALID(uiStatus)    (BIT_TEST(uiStatus, STATUS_ALL) && \
                                     !BIT_TEST(uiStatus, ~STATUS_ALL))

转换

类型 后缀

int

unsigned int u/U

long l/L

unsigned long ul/UL

long long ll

unsigned long long ull/ULL

为常量写适当的后缀，可增加代码可读性，也能预防由于转换引起的微妙问题

#include 
  
   

int main()
{
        printf("the default size %d\n", sizeof(0));
        printf("the postfix U size %d\n", sizeof(0U));
        printf("the postfix L size %d\n", sizeof(0L));
        printf("the postfix UL size %d\n", sizeof(0UL));
        printf("the postfix LL size %d\n", sizeof(0LL));
        printf("the postfix ULL size %d\n", sizeof(0ULL));
}

  

the default size 4
the postfix U size 4
the postfix L size 4
the postfix UL size 4
the postfix LL size 8
the postfix ULL size 8