- 算术操作符
- 移位操作符
- 位操作符
- 逻辑操作符
- 赋值操作符
- 复合赋值操作符
- 单目操作符
- 三目操作符
- 关系操作符
- 下标引用、函数调用、结构成员
- 逗号运算符
- 算术操作符
除号"/"
使用“/"时，结果只有当有一方为浮点型，才执行浮点型算法，计算结果不受数据类型影响
int main()
{
int a = 5 / 2;
double b = 5 / 2;
double c = 5 / 2.0;
double d = 5.0 / 2;
printf("%d\n", a);//打印结果2
printf("%f\n", b);//打印结果2.000000
printf("%lf\n", c);//打印结果2.500000
printf("%lf\n", d);//打印结果2.500000
return 0;
}百分号"%"
“%”对除数取余数，两边必须都是整数
int main()
{
int a = 9 % 2;
printf("%d\n", a);//打印结果为1
return 0;
}加号“+” 减号“-” 乘号“*”
这些运算符号和平时运算一样
- 移位操作符
<< 左移操作符：左边丢弃，右边补0
int main()
{
int a = 3, b ;
//00000000000000000000000000000011
b = a << 3;
//0000000000000000000000000011000
printf("%d\n", b);
}00000000000000000000000000000011
00000000000000000000000000000011000
丢弃 新增
补充一下原码，反码，补码的知识点
整数在内存中的存储方式：以补码存储。正数原码、反码、补码一致，负数原码、反码、补码不一致（只用于负数）
原码：根据数值直接写出的二进制序列
反码：原码符号不变，其他位按位取反
补码：反码+1
>> 右移操作符：1.算术右移：右边丢弃，左边补原符号位
2.逻辑右移：右边丢弃，左边补0
算术右移：右边丢弃，左边补原符号位
int main()
{
int a = -5, b;
//10000000000000000000000000000101(原码）
//11111111111111111111111111111010（反码）
//11111111111111111111111111111011(补码）
b = a >> 2;
//11111111111111111111111111111110（补码）
//11111111111111111111111111111101（反码）
//10000000000000000000000000000010（原码）
printf("%d\n", b);//打印结果为-2
}11111111111111111111111111111011
1111111111111111111111111111111011
补位 丢弃
逻辑右移：右边丢弃，左边补0
int main()
{
int a = -5, b;
//10000000000000000000000000000101(原码）
//11111111111111111111111111111010（反码）
//11111111111111111111111111111011(补码）
b = a >> 2;
//00111111111111111111111111111110（补码）
//00111111111111111111111111111101（反码）
//01000000000000000000000000000010（原码）
printf("%d\n", b);
}11111111111111111111111111111011
0011111111111111111111111111111011
补位 丢弃
- 逻辑运算符
逻辑与“&&”：逻辑与两边有一边为假，整个表达式为假（假为0）
int c=a && b (如果a=0，b就可以忽略）
int main()
{
int a = 0;
int b = 2;
int c = 3;
int d = a && b && c;
printf("%d\n", d);//打印结果为0
return 0;
}逻辑与“||”：逻辑或两边有一边为真，令一边不管为真还是假，整个表达式为真（真为1）
int c=a || b (如果a=1，b就可以忽略）
int main()
{
int a = 1;
int b = 0;
int c = 3;
int d = a || b || c;
printf("%d\n", d);//打印结果为1
return 0;
}- 位操作符
按位与 “&”：两个位都是1时，结果才为.
int main()
{
int a = 3;
int b = 5;
int c;
c = a & b;
//00000000000000000000000000000011(a)
//00000000000000000000000000000101(b)
//00000000000000000000000000000001(c)
printf("%d\n", c);//打印结果为1
}按位或“|“：两个位有一个为0，结果就为0.
int main()
{
int a = 3;
int b = 5;
int c;
c = a | b;
//00000000000000000000000000000011(a)
//00000000000000000000000000000101(b)
//00000000000000000000000000000111(c)
printf("%d\n", c);//打印结果为7
}按位异或”^”:相异为1，相同为0.
int main()
{
int a = 3;
int b = 5;
int c;
c = a | b;
//00000000000000000000000000000011(a)
//00000000000000000000000000000101(b)
//00000000000000000000000000000110(c)
printf("%d\n", c);//打印结果为6
}插入一个经典例题
在不用第三个变量的情况下将两个变量的值进行交换
int main()
{
int a = 3;
//00000000000000000000000000000011
int b = 5;
//00000000000000000000000000000101
printf("a=%d b=%d\n", a, b);//打印结果 a=3,b=5
a = a ^ b;
//00000000000000000000000000000110
b = a ^ b;
//00000000000000000000000000000011
a = a ^ b;
//00000000000000000000000000000101
printf("a=%d b=%d\n", a, b);//打印结果 a=5,b=3
return 0;
}- 赋值操作符
“=”赋值操作符没什么可讲，注意不要与等号“==”弄混了
- 复合赋值操作符
“+=” “-=” “*=” “/=” “%=””<<=" ">>=" "&=" "|=" "^="等等
int main()
{
int a = 2;
a += 2;//等效为a=a+2;
printf("%d\n", a);//打印结果a=4
return 0;
}- 单目操作符
逻辑非“！”：非0为真，其他为假
int main()
{
int a = !0;
int b = !(-1);
printf("a=%d b=%d\n", a, b);//打印结果：a=1,b=0
return 0;
}负号 “-”
取地址操作符 “&”和解引用操作符“*”
struct human
{
char sex[5];
char name[10];
int age;
};
int main()
{
//将自定义类型里的信息放入结构体a中
struct human a = { "man","wsc",24};
struct human* pa = &a;//&a是结构体a的地址，指针pa指向a的地址
printf("性别:%s\n", (*pa).sex);//解引用*pa=struct human a
printf("姓名:%s\n", (*pa).name);
printf("年龄:%d\n", (*pa).age);
}按位取反“~”（按二进制补码取反）
int main()
{
int a = 3;
//00000000000000000000000000000011(原码)
int b;
b = ~a;
//11111111111111111111111111111100(补码）
//11111111111111111111111111111011(反码）
//10000000000000000000000000000100(原码）
printf("b=%d\n", b);//打印输出原码
}强制转换类型“（）“：一般用于整形提升与类型转换
整形提升按变量数据类型符号位进行提升（有符号位）
负数的整形提升
char=-1;
原码：10000001
补码：11111111
整形提升时高位补符号位：11111111111111111111111111111111
正数的整形提升
char=1;
00000001
整形提升时高位补符号位：00000000000000000000000000000001
高位补0（无符号位）
//整形提升,将char类型提升为int类型
int main()
{
int a = 3;
char b = 'c';//字符'c'的ASCII值为98
int sum;
sum =(int)(a + b);
printf("sum=%d\n", sum);//打印结果为102
return 0;
}为什么会发生隐式整形提升
表达式的整形运算在CPU中的相应运算器件内执行，而CPU的整形运算器（ALU）的操作字节长度一般为int的字节长度，这也是CPU通用寄存器的长度。
通用CPU难以实现两个小于int长度的n个字节直接相加运算，所以，表达式中各种长度可能小于int长度的整形值，都要先转换为int或者unsigned int ，再送入CPU进行运算。
//隐式整形提升
int main()
{
char a = 4;//char 类型为一个字节，8bit
//00000100
char b = 127;
//01111111
char c = a + b;//参与运算就要将char类型提升为int类型
//00000000000000000000000000000100(a)
//00000000000000000000000001111111(b)
//00000000000000000000000010000011(没转化为char类型前的c)
//100000011(c)最高位为符号位
printf("%d\n", c);//打印结果为-125
//11111111111111111111111110000011(打印结果的二进制）
return 0;
}sizeof 操作符
sizeof是操作符，不是函数。
sizeof计算变量或类型创作变量的内存大小，与存放的数据无关
int main()
{
int a = 4;
int b = 3;
char c = 'a';
int arr[5] = { 0 };
printf("%d\n", sizeof(a));//打印结果为4
printf("%d\n", sizeof(b));//打印结果为4
printf("%d\n", sizeof(c));//打印结果为1
printf("%d\n", sizeof(arr));//打印结果为20
printf("%d\n", sizeof(arr[0]));//打印结果为4
return 0;
}“++” “--”操作符（从右往左运算）
int main()
{
int a = 2;
int b = 3;
int c = a++;//先把a的值赋给c，在运行a++
int d = ++a;//a先自己加1，在将加1后的值赋给d
a++;//等效于a=a+1
b--;//等效于b=b-1
printf("a=%d b=%d c=%d d=%d", a, b,c,d);//打印结果a=5，b=2,c=2,d=4
return 0;
}- 三目操作符
（条件）？（结果为真）：（结果为假）：三目操作符也是条件操作符
int main()
{
int a = 3;
int b = 7;
printf("max=%d\n", a > b ? a : b);//打印结果为7
}- 关系操作符
“==” “<=" ">=" ”>" "<" "!="等
- 下标引用[] 函数调用() 结构成员“->“ ” .”
下标引用[]:一般引用数组从下标0开始（数组名+下标数）
int main()
{
int arr[5] = { 3,4,6,2,7 };
printf("%d\n", arr[2]);//打印结果为6
return 0;
}函数调用():括号内存放需要传递的参数
int ADD(int x, int y)
{
int sum = x + y;
return sum;
}
int main()
{
int a = 1;
int b = 2;
int sum=ADD(a, b);
printf("%d\n", sum);//打印结果为3
return 0;
}结构成员：->（结构体指针->成员名）
//创建一个自定义类型
struct human
{
char sex[5];
char name[10];
int age;
};
int main()
{
//将自定义类型里的信息放入结构体a中
struct human a = { "man","wsc",24};
struct human* pa = &a;//&a是结构体a的地址，指针pa指向a的地址
printf("性别:%s\n", pa->sex);//指针pa指向struct human a的地址，直接取地址内的值
printf("姓名:%s\n", pa->name);//结构体指针->成员
printf("年龄:%d\n", pa->age);
}结构体成员：.（结构体.成员名）
//创建一个自定义类型
struct human
{
char sex[5];
char name[10];
int age;
};
int main()
{
//将自定义类型里的信息放入结构体a中
struct human a = { "man","wsc",24};
struct human* pa = &a;//&a是结构体a的地址，指针pa指向a的地址
printf("性别:%s\n", a.sex);//结构体.成员
printf("姓名:%s\n", a.name);
printf("年龄:%d\n", a.age);
}- 逗号运算符
","逗号运算符一般只要计算最右边那位就行
int main()
{
int a = 3;
int b = 4;
int c = 5;
int d = (a > b, a + b, a + c);
printf("%d\n", d);//打印结果为8
return 0;
}
6632
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
