算术操作符
+ - * / %
1.除了%之外，其他的几个操作符可以作用于整数与浮点数。
2.%的两个操作数必须为整数。
移位操作符
右移操作符：>> （有÷2的效果）
1.算术右移：右边丢弃，左边补原符号位
2.逻辑右移：右边丢弃，左边补0
int main()
{
int a = 16;
//>> -- 右移操作符
//移动的是二进制位
//00000000000000000000000000010000
int b = a >> 1;
printf("%d", b);
return 0;
}
int main()
{
int a = -1;
//整数的二进制表示有：原码，反码，补码
//存储到内存中的是补码
//10000000000000000000000000000001 -- 原码
//11111111111111111111111111111110 -- 反码
//11111111111111111111111111111111 -- 补码
int b = a >> 1;
printf("%d", b);
return 0;
}左移操作符：<< （有×2的效果）
左边丢弃，右边补0
注：对于移位操作符，不要移动负数位，这个是标准未定义的。且只能作用于整数
位操作符
1. & 按位与
规则：
1&1=1
1&0=0
0&1=0
0&0=0
int main()
{
//& - 按2进制位与
int a = 3;
int b = 5;
int c = a & b;
//000000000000000000000000000000011 有一个是0就是0，两个都为1才是1
//000000000000000000000000000000101
//000000000000000000000000000000101
printf("%d", c);
return 0;
}
2. | 按位或
规则：
1|1=1
1|0=1
0|1=1
0|0=0
int main()
{
//| - 按2进制位或
int a = 3;
int b = 5;
int c = a | b;
//000000000000000000000000000000011 有一个是1就是1，两个都为0才是0
//000000000000000000000000000000101
//000000000000000000000000000000111
printf("%d\n", c);
return 0;^ 按位异或
规则：
1^1=0
1^0=1
0^1=1
0|0=0
int main()
{
//^ - 按2进制位异或
int a = 3;
int b = 5;
int c = a ^ b;
//000000000000000000000000000000011 相同为0，相异为1
//000000000000000000000000000000101
//000000000000000000000000000000110
printf("%d\n", c);
return 0;
}
例：交换两个int变量的值，不能使用第三个变量。即a=3，b=5，交换后a=5，b=3
法一
int main()
{
int a = 3;
int b = 5;
a = a + b;
b = a - b;
a = a - b;
printf("a=%d b=%d\n", a, b);
return 0;
}法二：
int main()
{
int a = 3;
int b = 5;
a = a ^ b;
b = a ^ b;
a = a ^ b;
printf("a=%d b=%d", a, b);
return 0;
}赋值操作符
=
复合赋值操作
复合赋值运算符有下列这些：
+= 加法赋值
-= 减法赋值
*= 乘法赋值
/= 除法赋值
%= 模运算赋值
<<= 左移赋值
>>= 右移赋值
&= 位逻辑与赋值
|= 位逻辑或赋值
^= 位逻辑异或赋值
单目操作符
a+b ：+双目操作符
单目操作符：只有一个操作数
！ 逻辑反操作
- 负值
+ 正值
& 取地址
sizeof 操作数的类型长度
~ 对一个数的二进制按位取反
-- 前置、后置--
++ 前置、后置++
* 间接访问操作符（解引用操作符）
（类型） 强制类型转换
例：sizeof
int main()
{
int a = 10;
char c = 'r';
char* p = &c;
int arr[10] = { 0 };
//sizeof计算变量所占内存空间的大小，单位是字节
printf("%d\n", sizeof(a));//4
printf("%d\n", sizeof(c));//1
printf("%d\n", sizeof(p));//4
printf("%d\n", sizeof(arr));//40
return 0;
}
int main()
{
short s = 0;
int a = 10;
printf("%d\n", sizeof(s = a + 5));//short只能存两个字节
printf("%d\n", s);//sizeof括号内的表达式不参与运算
return 0;
}例 ：~
int main()
{
int a = 0;
//~按二进制位取反
//000000000000000000000000
//111111111111111111111111 -- 补码
//111111111111111111111110 -- 反码
//100000000000000000000001 -- 原码
printf("%d\n", ~a);
return 0;
}关系操作符
| 运算符 | 名称 | 示例 | 功能 | 缩写 |
| < | 小于 | a | a小于b时返回真；否则返回假 | LT |
| <= | a | a小于等于b时返回真；否则返回假 | LE | |
| > | 大于 | a>b | a大于b时返回真；否则返回假 | GT |
| >= | a>=b | a大于等于b时返回真；否则返回假 | GE | |
| == | 等于 | a==b | a等于b时返回真；否则返回假 | EQ |
| != | 不等于 | a!=b | a不等于b时返回真；否则返回假 | NE |
逻辑操作符
&& 逻辑与：两个表达式必须都为 true(非0)，整个表达式才为 true
|| 逻辑或：必须有一个或两个表达式为 true，才能使整个表达式为 true。
！ 逻辑非：使一个表达式从 true 变成了 false，或者从 false 变成了 true
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\n d=%d\n", a, b, c, d);
//a=1,b=2,c=3,d=4
return 0;
}
int main()
{
int i = 0, a = 1 ,b = 2, c = 3, d = 4;
i = a++ && ++b && d++;
printf(" a=%d\n b=%d\n c=%d\n d=%d\n", a, b, c, d);
//a=2,b=3,c=3,d=5
return 0;
}int main()
{
int i = 0, a = 1 ,b = 2, c = 3, d = 4;
i = a++ || ++b || d++;
printf(" a=%d\n b=%d\n c=%d\n d=%d\n", a, b, c, d);
//a=2,b=2,c=3,d=4
return 0;
}或者关系：左边为真，右边就不用计算
并且关系：左边为假，右边就不用计算了
注：&& (逻辑与) 优先级高于||（逻辑或）
条件操作符
exp1? exp2 ：exp3
(若exp1为真，则exp2要计算，否则exp3要计算)
int main()
{
int a = 0;
int b = 0;
if (a > 5)
b = 3;
else
b = -3;
b = (a > 5 ? 3 : -3);
return 0;
}int main()
{
int a = 10;
int b = 20;
int max = 0;
if (a > b)
max = a;
else
max = b;
max = (a > b ? a : b);
return 0;
}逗号表达式
， 优先级别最低，它将两个及其以上的式子联接起来，从左往右逐个计算表达式，整个表达式的值为最后一个表达式的值。
下标引用，函数调用和结构成员
1.[ ]下标引用操作符
操作数：一个数组名+一个索引值
2.（）
调用函数时的（）就是函数调用操作符
3.访问一个结构的成员
. 操作符，用来访问结构的成员
struct Stu
{
char name[20];
int age;
char id[20];
};
int main()
{
int a = 10;
//使用struct Stu这个类型创建了一个学生对象s1，并初始化
struct Stu s1 = { "张三",20, "202101029"};
printf("%s\n", s1.name);
printf("%d\n", s1.age);
printf("%s\n", s1.id);
return 0;
}—>
struct Stu
{
char name[20];
int age;
char id[20];
};
int main()
{
int a = 10;
//使用struct Stu这个类型创建了一个学生对象s1，并初始化
struct Stu s1 = { "张三",20, "202101029"};
struct Stu* ps = &s1;
printf("%s\n", ps->name);
printf("%d\n", ps->age);
//结构体指针—>成员名
return 0;
}
表达式求值
隐式类型的转换
C的整型算术运算总是至少已缺省整型类型的精度来进行。为了获得这种精度，表达式中的字符和短整型操作数在使用前辈转换为普通整型，这种转换被称为整型提升。整型算术运算要在计算机cpu内的整型运算器中进行。而整型运算器的操作数字节长度是整形int的字节长度。所以在整型计算时，要将所有数据提升至整形int的字节长度32位，即4字节。但即使是两个char类型的相加，在CPU执行时实际上也要先转换为CPU内整形操作数的标准长度。
int main()
{
char a = 3;
//00000000000000000000000000000011
//00000011 -- a
char b = 127;
//00000000000000000000000001111111
//01111111 -- b
//a和b如何相加
//00000000000000000000000000000011
//00000000000000000000000001111111
//00000000000000000000000010000010
//放到char中，只存八个比特位
//10000010 --c
// 发生整型提升
//11111111111111111111111110000010 -- 补码
//11111111111111111111111110000001 -- 反码
//00000000000000000000000001111110 -- 原码
//-126
char c = a + b;
printf("%d\n", c);
return 0;
}正数的整型提升：
char c1 = 1;
'变量c1的二进制位（补码）中只有八个比特位：00000001
因为char 为有符号的char
所以整型提升的时候，高位补充符号位，即0
整型提升后的结果为：
00000000000000000000000000000001
负数的整型提升：
char c2= -1;
'变量c2的二进制位（补码）中只有八个比特位：11111111
因为char 为有符号的char
所以整型提升的时候，高位补充符号位，即1
整型提升后的结果为：
00000000000000000000000011111111
无符号的整形提升，高位补0
算术转换
int main()
{
printf("%u\n", sizeof(long double));//8
printf("%u\n", sizeof(double));//8
printf("%u\n", sizeof(float));//4
printf("%u\n", sizeof(unsigned long int));//4
printf("%u\n", sizeof(long int));//4
printf("%u\n", sizeof(unsigned int));//4
printf("%u\n", sizeof(int));//4
return 0;
}操作符的属性
优先级
第一级：圆括号【（）】、下标运算符【[]】、分量运算符的指向结构体成员运算符【->】、结构体成员运算符【.】。
第二级：逻辑非运算符【!】、按位取反运算符【~】、自增自减运算符【++ --】、负号运算符【-】、类型转换运算符【(类型)】、指针运算符和取地址运算符【*和&】、长度运算符【sizeof】。
第三级：乘法运算符【*】、除法运算符【/】、取余运算符【%】。
第四级：加法运算符【+】、减法运算符【-】。
第五级：左移动运算符【<<】、右移动运算符【>>】。
第六级：关系运算符【< > <= >= 】。
第七级：等于运算符【==】、不等于运算符【!=】。
第八级：按位与运算符【&】。
第九级：按位异或运算符【^】。
第十级：按位或运算符【|】。
第十一级：逻辑与运算符【&&】。
第十二级：逻辑或运算符【||】。
第十三级：条件运算符【?:】。
第十四级：赋值运算符【= += -= *= /= %= >>= <<.= &= |= ^=】。
第十五级：逗号运算符【,】。
1852
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
