操作符目录
一.操作符
指令系统的每一条指令都有一个操作符，它表示该指令应进行什么性质的操作。不同的指令用操作符这个字段的不同编码来表示，每一种编码代表一种指令。
1.语义
每个操作符都有自己的语义，具体取决于它所操作的类型。
2.优先级
每个操作符都有优先级。
3.结合性
每个操作符都有结合性。操作符的结合性定义了操作符对操作数执行操作的顺序，例如：右结合性表示该操作符对其操作数从右向左执行操作。
1.1分类
1.算术操作符
2.移位操作符
3.位操作符
4.赋值操作符
5.单目操作符
6.关系操作符
7.逻辑操作符
8.条件操作符
9.逗号表达式
10.下标引用、函数调用和结构成员
二、操作符详解
1、算术操作符
+：加法操作符
-：减法操作符
*：乘法操作符 /：除法操作符
%：取模操作符(即取余数)
除了 % 操作符之外，其他的几个操作符可以作用于整数和浮点数。
1.1除法操作符
1.对于 / 操作符如果两个操作数都为整数，执行整数除法。
int main ()
{
int a = 5;
int b = 2;
int c = a / b;
printf("%d\n", c);
double d = a / b;
printf("%lf\n", d);
float e = a / b;
printf("%f\n", e);
return 0;
}
可以看到，如果对于两个整数进行除法操作，无论输出类型为什么，结果都是按照整数输出。
2.而只要有浮点数执行的就是浮点数除法。
int main()
{
int a = 5 / 2;
float b = 5 / 2;
float c = 5.0 / 2;
double d = 5 / 2.0;
printf("%d\n", a);
printf("%f\n", b);
printf("%f\n", c);
printf("%lf\n", d);
return 0;
}
若想输出浮点数，除号两端至少一侧为浮点数。
1.2取模操作符
% 操作符的两个操作数必须为整数。返回的是整除之后的余数。（负数也可取余，加上负号即可）
int main()
{
int a = 5%2;
int b = 99 % 10;
printf("%d\n", a);
printf("%d\n", b);
return 0;
}
2、移位操作符
左移操作符<<
右移操作符>>
注：移位操作符的操作数只能是整数，都是对二进制数进行移位操作。
而且移位对于原来的数没有影响
2.1整数二进制表示
1.原码：
原码表示法在数值前面增加了一位符号位（即最高位为符号位）。正数该位为0，负数该位为1（0有两种表示：+0和-0），其余位表示数值的大小。
2.反码：
反码通常是用来由原码求补码或者由补码求原码的过渡码。反码跟原码是正数时，一样；负数时，反码就是原码符号位除外，其他位按位取反。
3.补码：
正数的补码与其原码相同；负数的补码是在其反码的末位加1。
计算机中都是存储的补码。
2.1.2正数
正数的原码、反码、补码都是一样的。
2.1.2负数
负数的反码就是原码符号位除外，其他位按位取反。
负数的补码是在其反码的末位加1。
2.2左移操作符
将二进制位向左移动，左侧丢弃，右侧补0。
2.2.1正数左移
int main()
{
int a = 5; //00000000000000000000000000000101
int b = a << 2;//00000000000000000000000000010100
printf("%d\n", a);
printf("%d\n", b);
return 0;
}
2.2.2负数左移
因为存储的是补码，故先计算出补码（正数因为都一样，没计算）。
int main()
{
int a = -5; //10000000000000000000000000000101-原码
//11111111111111111111111111111010-反码
//11111111111111111111111111111011-补码
int b = a << 2;//11111111111111111111111111101100-补码
//11111111111111111111111111101011-反码
//10000000000000000000000000010100-原码（-20）
printf("%d\n", a);
printf("%d\n", b);
return 0;
}
对于左移，当移一位时，会产生*2的效果。（读者可以自行验证）
2.3右移操作符
2.3.1算术移位
右边丢弃，左边补原符号位
（一般都为算术移位）
int main()
{
int a = 5; //00000000000000000000000000000101
int b = a >> 2;//00000000000000000000000000000001
printf("%d\n", a);
printf("%d\n", b);
int c = -5; //10000000000000000000000000000101-原码
//11111111111111111111111111111010-反码
//11111111111111111111111111111011-补码
int d = c >> 2;//11111111111111111111111111111110-补码
//11111111111111111111111111111101-反码
//10000000000000000000000000000010-原码（-2）
printf("%d\n", c);
printf("%d\n", d);
return 0;
}
2.3.1逻辑移位
右边丢弃，左边补0
int main()
{
int a = 5; //00000000000000000000000000000101
int b = a >> 2;//00000000000000000000000000000001
printf("%d\n", a);
printf("%d\n", b);
int c = -5; //10000000000000000000000000000101-原码
//11111111111111111111111111111010-反码
//11111111111111111111111111111011-补码
int d = c >> 2;//00111111111111111111111111111110-补码
//00111111111111111111111111111110-反码
//00111111111111111111111111111110-原码
//（1,073,741,822）
printf("%d\n", c);
printf("%d\n", d);
return 0;
}
3、位操作符
& ：按位与
| ：按位或
^ ：按位异或
注：他们的操作数必须是整数，同样都是对于二进制位操作。
3.1按位与
只要有0就输出0，全1才输出1。
int main()
{
int a = 5; //00000000000000000000000000000101
int b = 7; //00000000000000000000000000000111
int c = a & b;//00000000000000000000000000000101（5）
printf("%d\n", c);//%d打印一个有符号的整数
int e = -5; //10000000000000000000000000000101-原码
//11111111111111111111111111111010-反码
//11111111111111111111111111111011-补码
int f = 7; //00000000000000000000000000000111
int g = e& f;//00000000000000000000000000000011（3）
printf("%d\n", g);
return 0;
}
3.2按位或
只要有1就输出1，全0才输出0。
int main()
{
int a = 5; //00000000000000000000000000000101
int b = 7; //00000000000000000000000000000111
int c = a | b;//00000000000000000000000000000111（7）
printf("%d\n", c);//%d打印一个有符号的整数
int e = -5; //10000000000000000000000000000101-原码
//11111111111111111111111111111010-反码
//11111111111111111111111111111011-补码
int f = 7; //00000000000000000000000000000111
int g = e | f;//11111111111111111111111111111111-补码
//11111111111111111111111111111110-反码
//10000000000000000000000000000001-原码（-1）
printf("%d\n", g);
return 0;
}
3.3按位异或
不同才输出1，相同输出0。
int main()
{
int a = 5; //00000000000000000000000000000101
int b = 7; //00000000000000000000000000000111
int c = a ^ b;//00000000000000000000000000000010（2）
printf("%d\n", c);//%d打印一个有符号的整数
int e = -5; //10000000000000000000000000000101-原码
//11111111111111111111111111111010-反码
//11111111111111111111111111111011-补码
int f = 7; //00000000000000000000000000000111
int g = e ^ f;//11111111111111111111111111111100-补码
//11111111111111111111111111111011-反码
//10000000000000000000000000000100-原码（-4）
printf("%d\n", g);
return 0;
}
3.3.1特殊用法
不能创建临时变量（第三个变量），实现两个数的交换
int main()
{
int a = 10;
int b = 20;
a = a ^ b;
b = a ^ b;//b=(a^b)^b=a^b^b=a^(b^b)=a^0=a
a = a ^ b;//a=a^b^a=a^a^b=b
printf("a = %d b = %d\n", a, b);
return 0;
}
总结：异或具有结合律和交换律，任何数c^0=c，任何数与自己异或为0。
4、赋值操作符
即给变量赋值。
加：+=
减：-=
乘：*=
除：/=
模：%=
右移：>>=
左移：<<=
与：&=
或：|=
异或：^=
均可写成赋值形式
int main()
{
int a = 3;
int b = 4;
a = a + 1;//a+=1
b = b - 2;//b-=2
a = a * 3;//a*=3
b = b / 4;//b/=4
a = a % 5;//a%=5
b = b >> 6;//b>>=6
a = a << 7;//a<<=7
b = b & 8;//b&=8
a = a | 9;//a|=9
b = b ^ 10;//b^=10
return 0;
}
对于连续赋值，读取从右向左。如下：
5、单目操作符
单目操作符：只有一个操作数
逻辑反操作 ！
负值 -
正值 +
取地址 &
操作数的类型长度（以字节为单位）sizeof
对一个数的二进制按位取反 ~
前置-- 、后置–
前置++ 、后置++
间接访问操作符(解引用操作符) *——（指针）
强制类型转换 (类型)
int main()
{
int a = 5;//00000000000000000000000000000101
//~a=11111111111111111111111111111010-补码
//11111111111111111111111111111001-反码
//10000000000000000000000000000110-原码
int num=(int)pow(10,3);
//pow输出为double类型，前加（int）强制为int类型
int a = (int)3.14;//输出3
int b = ++a;//先a=a+1,后b=a
int c = a++;//先c=a,后a=a+1
int d = --a;//先a=a-1,后d=a
int e = a--;//先e = a,后a = a - 1
printf("!8=%d\n", !8);//!取反，非零为真，取反为0
printf("!0=%d\n", !0);//0为假，取反为1
printf("~a=%d\n", ~a);
printf("&a=%p\n", &a);
printf("b=%d c=%d d=%d e=%d\n",b,c,d,e);
return 0;
}
5.1关于sizeof
求变量（或类型）所占空间的大小，单位是字节。
void test1(int arr[])
{
printf("%d\n", sizeof(arr));//4或8（计算机为32位时为4；64位时为8）
}
void test2(char ch[])
{
printf("%d\n", sizeof(ch));//4或8（计算机为32位时为4；64位时为8）
}
int main()
{
int arr[10] = {0};
char ch[10] = {0};
printf("%d\n", sizeof(arr));//40字节
printf("%d\n", sizeof(ch));//40字节
test1(arr);
test2(ch);
return 0;
}
5.2综合应用
将一个数的某一位改变为1或0，其余位不变。
int main()
{
int a = 13;
//00000000000000000000000000001101---位数从0开始数
int b = a | (1 << 4);
//00000000000000000000000000011101(29)---第四位变为1
int c = b &( ~(1 << 4));
//00000000000000000000000000001101(13)---第四位变为0
printf("%d\n",b);
printf("%d\n",c);
return 0;
}
6、关系操作符
大于>
大于等于>=
小于<
小于等于<=
!= 用于测试“不相等”
== 用于测试“相等”，与赋值=区分
注意：在编程的过程中== 和=不小心写错，导致错误。
7、逻辑操作符
&& 逻辑与 ：判断时需要条件全部满足
|| 逻辑或：判断时仅需要条件满足其一即可
int main()
{
int i = 0,a=0,b=2,c =3,d=4;
i = a++ && ++b && d++;
printf("a = %d\n b = %d\n c = %d\nd = %d\n", a, b, c, d);
return 0;
}
i = a++ && ++b && d++;
首先a++：a=0,a=a+1=1,因为0与任何数与都为0；故之后的不再计算。
int main()
{
int i = 0, a = 1, b = 2, c = 3, d = 4;
i = a++ && ++b && d++;
printf("a = %d\nb = %d\nc = %d\nd = %d\n", a, b, c, d);
return 0;
}
i = a++ && ++b && d++;
首先a++：a=1,a=a+1=2; ++b：b=b+1=3; d++：d=4,d=d+1=5要全部计算。
7.1实例-判读年份是不是闰年
//写一个函数判断一年是不是闰年
//普通闰年：公历年份是4的倍数，且不是100的倍数的，为闰年（如2004年、2020年等就是闰年）。
//世纪闰年：公历年份是整百数的，必须是400的倍数才是闰年（如1900年不是闰年，2000年是闰年）。
int test(x)
{
if ((x% 4 == 0&&x%100!=0)||(x%400==0))
return 1;
else
return 0;
}
int main()
{
int year = 0;
scanf("%d", &year);
if (test(year))
printf("%d是闰年\n", year);
else
printf("%d不是闰年\n", year);
return 0;
}
8、条件操作符
exp1 ? exp2 : exp3
int main()
{
int a = 3;
int b = 9;
int max = a > b ? a: b;
int min= a < b ? a : b;
printf("max=%d\nmin=%d", max, min);
return 0;
}
9、逗号表达式
exp1, exp2, exp3, …expN
逗号表达式，就是用逗号隔开的多个表达式。
逗号表达式，从左向右依次执行。整个表达式的结果是最后一个表达式的结果。
int main()
{
int a = 1;
int b = 2;
int c = (a > b, a = b + 10, a, b = a + 1);
printf("%d",c);
return 0;
}
判断性语句无用，看赋值语句。
a=b+10=12,最右侧b=a+1=13,c=b。
也可简化代码：
a = get_val();
count_val(a);
while (a > 0)
{
a = get_val();
count_val(a);
//业务办理
}
//如果使用逗号表达式，改写：
while (a = get_val(), count_val(a), a>0)
{
//业务处理
}
10、下标引用、函数调用和结构成员
10.1下标引用
[ ] 下标引用操作符
操作数：一个数组名 + 一个索引值
int arr[10];//创建数组
arr[5] = 10;//实用下标引用操作符。
// [ ]的两个操作数是arr和5。
10.2函数调用
( ) 函数调用操作符
接受一个或者多个操作数：第一个操作数是函数名，剩余的操作数就是传递给函数的参数。
int add(int a,int b)
{
return a+b;
}
int main ()
{
int a=3;
int b=4;
int ret=add(a,b);//实用（）作为函数调用操作符。
printf ("%d\n",ret);
return 0;
}
10.3结构体
访问一个结构的成员
. ——结构体.成员名
-> ——结构体指针->成员名
struct student //结构体类型的说明与定义分开-声明
{
char name[10];//名字
int age; //年龄
float score; //分数
char sex; //性别
};
void set_student(struct student* pb)
{
第一种用.
//strcpy((*pb).name, "Liu");
//(*pb).age = 18;
//(*pb).score = 99;
//(*pb).sex = 'm';
//第二种用->
strcpy(pb->name, "Liu");
pb->age = 18;
pb->score = 99;
pb->sex = 'm';
}
void print_student(struct student* pb)//也可不用指针
{
printf("名字：%s 年龄：%d 分数：%.2f 性别：%c\n", pb->name, pb->age, pb->score, pb->sex);
}
int main()
{
struct student a = { "Li",20,79,'f' }; //直接定义
printf("名字：%s 年龄：%d 分数：%.2f 性别：%c\n",a.name,a.age, a.score, a.sex);
struct student b = { 0 }; //在线定义
set_student(&b);
print_student(&b);
return 0;
}
11、表达式求值
表达式求值的顺序一部分是由操作符的优先级和结合性决定。 见11.3
同样，有些表达式的操作数在求值的过程中可能需要转换为其他类型。
11.1隐式类型转换
C的整型算术运算总是至少以缺省（默认）整型类型的精度来进行的。
为了获得这个精度，表达式中的字符和短整型操作数在使用之前被转换为普通整型，这种转换称为整型提升。
整型提升的意义：
表达式的整型运算要在CPU的相应运算器件内执行，CPU内整型运算器(ALU)的操作数的字节长度一般就是int的字节长度，同时也是CPU的通用寄存器的长度。
因此，即使两个char类型的相加，在CPU执行时实际上也要先转换为CPU内整型操作数的标准长 度。
通用CPU（general-purpose CPU）是难以直接实现两个8比特字节直接相加运算（虽然机器指令中可能有这种字节相加指令）。所以，表达式中各种长度可能小于int长度的整型值，都必须先转 换为int或unsigned int，然后才能送入CPU去执行运算。
总结来说就是，系统默认进行整型运算，如果你想要运算的两个数的长度小于整型，需要先进行长度提升（整型提升），转换成整型后方可计算。
//负数的整形提升
char c1 = -1;
变量c1的二进制位(补码)中只有8个比特位：//char类型大小为一个字节，即8个比特位
1111111
因为 char 为有符号的 char
所以整形提升的时候，高位补充符号位，即为1
提升之后的结果是：
11111111111111111111111111111111 //变成int类型，4个字节，即32个比特位
//正数的整形提升
char c2 = 1;
变量c2的二进制位(补码)中只有8个比特位：
00000001
因为 char 为有符号的 char
所以整形提升的时候，高位补充符号位，即为0
提升之后的结果是：
00000000000000000000000000000001
//无符号整形提升，高位补0
11.1.1例一
int main()
{
char a = 0xb6;//1011 0110（182）-一个字节
//11111111 11111111 11111111 10110110-整型提升（符号位为1）-补码
//11111111 11111111 11111111 10110101-反码
//10000000 00000000 00000000 01001010-原码（-74）
short b = 0xb600;//1011 0110 0000 0000（46592）-两个字节
//11111111 11111111 10110110 00000000-整型提升（符号位为1）-补码
//11111111 11111111 10110101 11111111-反码
//10000000 00000000 01001010 00000000-原码（18944）
int c = 0xb6000000;
if (a == 0xb6)
printf("a");
if (b == 0xb600)
printf("b");
if (c == 0xb6000000)
printf("c");//输出
return 0;
}
实例一中的a,b要进行整形提升,但是c不需要整形提升 a,b整形提升之后,变成了负数,所以表达式 前两个判断的结果是假,但是c不发生整形提升,则表 达式 c==0xb6000000 的结果是真.
所程序输出的结果是:c
11.1.2例二
int main()
{
char c = 1;
printf("%u\n", sizeof(c));//%u打印整型
printf("%u\n", sizeof(+c));//整型提升
printf("%u\n", sizeof(-c));//整型提升
return 0;
}
实例二中的,c只要参与表达式运算,就会发生整形提升；
表达式 +c ,就会发生提升,所以 sizeof(+c) 是4个字 节.；
表达式 -c也会发生整形提升,所以 sizeof(-c) 是4个字节；
但是 sizeof（c） ,就是1个字节.
11.2算术转换
如果某个操作符的各个操作数属于不同的类型，那么除非其中一个操作数的转换为另一个操作数的类型，否则操作就无法进行。下面的层次体系称为寻常算术转换。
long double
double
float
unsigned long int
long int
unsigned int
int
如果某个操作数的类型在上面这个列表中排名较低，那么首先要转换为另外一个操作数的类型后执行运算。
//全局变量，静态变量都是放在静态区，不初始化时，默认为0
//局部变量，不初始化，默认是随机值
int i;//0
int main()
{
i--;//-1
//sizeof操作符计算返回值的结果是size_t类型，是无符号整型
if (i > sizeof(i)) //-1的无符号整型是32个1 > 4
//int i是整型，先进行算术转换，转换成无符号整型进行比较
{
printf(">\n");//输出>
}
else
{
printf("<\n");
}
return 0;
}
11.3操作符的属性
复杂表达式的求值有三个影响的因素。
- 操作符的优先级
- 操作符的结合性
- 是否控制求值顺序。
两个相邻的操作符先执行哪个？
取决于他们的优先级。如果两者的优先级相同，取决于他们的结合性。
下面给出了详细的操作符的优先级表格，从上至下优先级依次递减（越靠近上面，操作符的优先级越高）。
其中：N/A表示无结合性，控制求值顺序指顺序对运算有无影响。
如：逻辑与和逻辑或会控制求值顺序，这是因为：
如果逻辑与左边操作数是假，那么右边不用看了；
同样如果逻辑或左边操作数是真，那么右边也不用看了。（详情可见7、逻辑操作符）
11.4一些问题表达式
虽然根据优先级和结合性可以判断表达式的具体运算顺序，但仍不可随意书写表达式，同样会存在一些问题表达式：
//表达式的求值部分由操作符的优先级决定。
//表达式1
a*b + c*d + e*f
注释：上述代码在计算的时候，由于*比+的优先级高，只能保证，乘法的计算是比加法+早，但是优先级并不能决定第三个乘法比第一个加法+早执行，会存在多种计算顺序。（而对于有相互影响的表达式，此时不知道该如果运算）
int fun()
{
static int count = 1;
return ++count;
}
int main()
{
int answer;
answer = fun() - fun() * fun();
printf( "%d\n", answer);//输出多少？
return 0;
}
注释：上述代码中，函数每调用一次后再调用结果都不同，只知道*优先级高于-，但先调用哪个fun（）不知。
573
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
