- 算术操作符
- 移位操作符
- 位操作符
- 逻辑操作符
- 赋值操作符
- 复合赋值操作符
- 单目操作符
- 三目操作符
- 关系操作符
- 下标引用、函数调用、结构成员
- 逗号运算符
- 算术操作符
除号"/"
使用“/"时,结果只有当有一方为浮点型,才执行浮点型算法,计算结果不受数据类型影响
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;
}