C语言操作符总结

C语言操作符分类：

---

---

算术操作符

+ - * / %
1. 除了%操作符之外，其他的几个操作符可以用作于整数和浮点数。
2. .对于/操作符，如果两个操作符都为整数，执行整数除法，而只要有浮点数执行的就是浮点数的除法。
3. %操作符的两个操作数必须为整数，返回的是整除后的余数。

#include <stdio.h>
int main()
{
    int a = 10;
    int b = 4;
    int c = a%b;//2
    printf("%d\n",c);
    return 0;
}

---

移位操作符

<<左移操作符
>>右移操作符

左移操作符移位规则：左边丢弃，右边补0（$\color{#DC143C}{左移一位相当于乘以2}$）

#include <stdio.h>
int main()
{
    int a = 10;  //00000000 00000000 00000000 00001010
    int b = a<<1;//00000000 00000000 00000000 00010100
    printf("a = %d,b = %d\n",a,b);//a = 10,b = 20
    return 0;
}

右移操作符移位规则：

1. 逻辑移位—右边丢弃，左边补0
2. 算数移位—左边丢弃，左边补符号位（$\color{#DC143C}{右移一位相当于除以2}$）

#include <stdio.h>
int main()
{
    int a = 10;  //00000000 00000000 00000000 00001010
    int b = a>>1;//00000000 00000000 00000000 00000101
    printf("a = %d,b = %d\n",a,b);//a = 10,b = 5
    return 0;
}

注意：左移右移操作符并不会改变变量本身的值，要想改变可以将左移右移后的值重新赋给变量本身。

#include <stdio.h>
int main()
{
    int a = 10;
    a = a>>1;
    printf("a = %d\n",a );//a = 5
    return 0;
}

来一道题练习一下：写一个函数求一个整数存储在内存中的二进制中1的个数。（函数返回1的个数）

int count_binary(num)
{
    int i = 0;
    int count = 0;
    for(i=0; i<32; i++)
    {
        if(((num>>i)&1)==1)//num右移i位和1相与，若值为1，则二进制中有1
            count++;
    }
    return count;
}

---

位操作符

& 按位与
| 按位或
^ 按位异或

按位与&：

&	1	0
1	1	0
0	0	0

按位或 |：

&	1	0
1	1	1
0	1	0

按位异或 ^：

&	1	0
1	0	1
0	1	0

注意：操作数必须为整数。

上面的题目还可以这样解：
（写一个函数求一个整数存储在内存中的二进制中1的个数）

int count_binary1(num)
{
    int count = 0;
    while(num)
    {
        num=num&(num-1);
        count++;
    }
    return count;
}

---

赋值操作符

= 可以给变量重新赋值
复合操作符
+= -= *= /= %= >>= <<= &= |= ^=
举个栗子：a = a+2等价于a += 2

---

单目操作符

操作符	功能
！	逻辑反操作
-	负值
+	正值
&	取地址
sizeof()	操作数的类型长度（以字节为单位）
~	对一个数的二进制按位取反
–	前置、后置–
++	前置、后置++
*	间接访问操作符（解引用操作符）
(类型)	强制类型转换

这里重点介绍以下几个操作符的一些用法：

& 取地址

#include <stdio.h>
int main()
{
    int arr[10]={0};
    printf("%p\n",&arr);//数组的地址     ①
    printf("%p\n",arr);//数组首元素的地址   ②
    printf("%p\n",&arr+1);//比①的值多40个字节
    printf("%p\n",arr+1);//比②的值多4个字节
    return 0;
}

sizeof() 求字节

#include <stdio.h>
int main()
{
    int arr[10] = {0};
    short s = 3;
    int a = 10;
    printf("%d\n",sizeof(arr));//40
    printf("%d\n",sizeof(int [10]));//40
    printf("%d\n",sizeof(s=a+4));//2
    printf("%d\n",s);//3
    printf("%d\n",a);//10
    return 0;
}

注：sizeof()可以求变量（类型）所占空间的大小

++和–运算符

#include <stdio.h>
int main()
{
    //前置++和--
    int a =10;
    int b = 0;
    int c = 0;
    b = ++a;//先对a进行自增，然后使用a，表达式的值就是a自增之后的值，因此b = 11;
    c = --a;//先对a进行自减，然后使用a，表达式的值就是a自减之后的值，因此b = 10;
    return 0;
}

#include <stdio.h>
int main()
{
    //后置++和--
    int a =10;
    int b = 0;
    int c = 0;
    b = a++;//先对a使用，再增加，因此b=10,a=11;
    c = a--;//先对a使用，再自减，因此c=11,a=10;
    return 0;
}

---

关系操作符

> >= < <= != ==
注意：在编程中，注意==和=不要写错

---

逻辑操作符

&& 逻辑与

| | 逻辑或

注意：区分逻辑与和按位与（逻辑或和按位或）

#include <stdio.h>
int main()
{
    int a = 0;
    int b = 0;
    a = 1&2;
    b = 1&&2;
    printf("a = %d,b = %d\n",a,b);//a = 0,b = 1
    a = 1|2;
    b = 1||2;
    printf("a = %d,b = %d\n",a,b);//a = 3,b = 1
    return 0;
}

这里介绍一道经典的例题：

#include <stdio.h>
int main()
{
    int i=0, a=0, b=2, c=3, d=4;
    i=a++&&++b&&d++;
    printf("a = %d, b = %d, c = %d, d = %d",a,b,c,d);
    return 0;
}

结果为a = 1, b = 2, c = 3, d = 4；
逻辑与的工作原理为：&&操作符的左操作数总是首先进行求值，如果它的值为真，然后就紧接着对右操作数进行求值；如果左操作数的值为假，那么右操作数将不再进行求值，因为整个表达式的值肯定为假，右操作数已经无关紧要。
在这道题中，a先使用再自增，a=0为假，后面的式子不进行计算，所以只有a加了1，别的都不变。

再来一道类似的：

#include <stdio.h>
int main()
{
    int i=0, a=0, b=2, c=3, d=4;
    i=a++||++b||d++;
    printf("a = %d, b = %d, c = %d, d = %d",a,b,c,d);
    return 0;
}

结果为a = 1, b = 3, c = 3, d = 4；
同样，逻辑或首先对左操作数进行求值，如果值为真，右操作数将不再求值，因为整个表达式的值此时已经确定。
在这道题中，a先使用再自增，a=0为假，继续求值，b先自增再再使用，b=3为真，后面的式子不再进行计算。

---

条件操作符

exp1 ? exp2 : exp3

如果表达式1判断为真，则执行表达式2，否则执行表达式3

举个栗子：

int max = a>b ? a : b;//找两个数中的较大值（若a>b,则max = a，否则max = b）

---

逗号引用操作符

exp1 ， exp2 ， exp3， …expN

逗号表达式就是用逗号隔开的多个表达式；从左向右依次执行，整个表达式的结果是最后一个表达式的结果。

#include <stdio.h>
int main()
{
    int a = 1;
    int b = 2;
    int c =(a>b, a=b+10, b=a+1);
    printf("%d\n",c);
    return 0;
}

结果为13；

---

下标引用、函数调用和结构成员

1.[ ] 下标引用

操作数：一个数组名+一个索引值

int arr[10];//创建数组
arr[9] = 10;//使用下标引用操作符
//[]的操作数是arr和9

2.( ) 函数调用操作符

接受一个或多个操作数：第一个操作数是函数名，剩余的操作数就是传递给函数的参数

3.访问一个结构体成员

. 结构体.函数名

-> 结构体指针->成员名
如果s是个结构体变量，那么s.a就访问s中名为a的成员。当你拥有一个指向结构体的指针而不是结构本身，且欲访问它的成员时，就需要用->操作符而不是.操作符

举个栗子：（.访问结构体成员）

#include <stdio.h>
#include <string.h>
struct Stu
{
    char name[20];
    int age;
    char sex[5];

};
int main()
{
    struct Stu s;
    strcpy(s.name,"丁一");
    printf("%s\n",s.name);
    s.age = 20;
    printf("%d\n",s.age);
    strcpy(s.sex,"男");
    printf("%s\n",s.sex);
    return 0;
}

（->访问结构体成员）

#include <stdio.h>
#include <string.h>
struct Stu
{
    char name[20];
    int age;
    char sex[5];

};
int main()
{
    struct Stu s;
    struct Stu *ps=&s;
    strcpy(ps->name,"丁一");//strcpy((*ps).name,"丁一");
    printf("%s\n",ps->name);
    ps->age = 20;//(*ps).age=20;
    printf("%d\n",ps->age);
    strcpy(ps->sex,"男");//strcpy((*ps).sex,"男");
    printf("%s\n",ps->sex);

    return 0;
}

---

END