目录
操作符分类:
1.算数操作符
+ - * / %
1.
除了
%
操作符之外,其他的几个操作符可以作用于整数和浮点数。
2.
对于
/
操作符如果两个操作数都为整数,执行整数除法。而只要有浮点数执行的就是浮点数除法。
3.
%
操作符的两个操作数必须为整数。返回的是整除之后的余数。
2.移位操作符
位移操作符处理的是内存中的二进制序列
数据在内存中储存的是二进制补码
对于正数而言 , 源码,反码,补码相同
对于负数而言 , 反码 为源码符号位不变,其他位按位取反,
补码 为反码 + 1
符号位为最高的一位,1为负,0为正
<<
左移操作符
>>
右移操作符
ps
操作符处理的类型只能是整形变量。
2.1左移操作符
使用规则:左边丢弃,右边补0
n<<1
![](https://i-blog.csdnimg.cn/blog_migrate/7bf0fb17cbc9581d730ab5f33ef670bd.png)
ps 因为操作的是n的二进制序列,n 在没有被赋值的情况下并没有变化。
3.2右移操作符
a.算数右移 右边丢弃,左边按符号位补齐
b.逻辑右移 右边丢弃,左边补0
![](https://i-blog.csdnimg.cn/blog_migrate/cf843c59ffdb3f1f5c6c213f00599913.png)
a.算数右移
n>>1
![](https://i-blog.csdnimg.cn/blog_migrate/fb401a1275929d8f4ded84d9ce71497f.png)
打印到屏幕上的应该是源码,而不是反码!!!
b.逻辑右移
注意:对于移位操作符,不要移动负数位,这是标准为定义的
int n=4;
n>>-1; X 标准未定义
3.位操作符
&
//
按位与
|
//
按位或
^
//
按位异或
注:他们的操作数必须是整数。
位操作符处理的也是内存中的二进制补码
& 两个位同时为1时才为1
| 两个位同时为0时才为0
^ 相同为0,相异为1
举栗子
//交换两个数字的值
int main()
{
int a = 2;
int b = 5;
printf("交换前:a=%d b=%d\n", a, b);
a = a ^ b;
b = a ^ b;//a^b ^b
a = a ^ b;//a^ a^b
printf("交换后:a=%d b=%d\n", a, b);
return 0;
}
注意: a^a=0 0^a=a
//求一个整数存储在内存中的二进制中1的个数。
#include <stdio.h>
int main()
{
int num = -1;
int i = 0;
int count = 0;//计数
while (num)
{
count++;
num = num & (num - 1);// & 同时为1时才为1
//减1 是二进制位的运算
}
printf("二进制中1的个数 = %d\n", count);
return 0;
}
-1在内存中的二进制补码为
11111111111111111111111111111111
4.赋值操作符
int a;
a=5;//把5赋值给a
复合赋值符
+=
-=
*=
/=
%=
>>=
<<=
&=
|=
^=
这些运算符都可以写成复合的效果
5.单目操作符
类别
!
逻辑反操作
-
负值
+
正值
&
取地址
sizeof
操作数的类型长度(以字节为单位)
~
对一个数的二进制按位取反
--
前置、后置
--
++
前置、后置
++
*
间接访问操作符
(
解引用操作符
)
(
类型
)
强制类型转换
! 逻辑反操作
#include<stdio.h>
int main()
{
int a = 0;
if (a)
printf("666\n");
else
printf("wot\n");
if (!a)
printf("???\n");
return 0;
}
可见 若a为真则 !a 为假,反之亦然
sizeof
操作数的类型长度(以字节为单位)
#include<stdio.h>
int main()
{
int a = 12;
printf("%d\n", sizeof(a));
printf("%d\n", sizeof(int));
printf("%d\n", sizeof a);//这样写行不行?
return 0;
}
由此可见sizeof为操作符而非函数
printf
(
"%d\n"
,
sizeof
int
);
//
这样写行不行?
答案是不行的
数组与sizeof
数组名代表首元素地址,但是有两种情况是特例
1.sizeof(arr)//计算的是整个数组的大小单位是字节
2.&arr//求的是整个数组的地址
#include <stdio.h>
void test1(int arr[])
{
printf("%d\n", sizeof(arr));//?
}
void test2(char ch[])
{
printf("%d\n", sizeof(ch));//?
}
int main()
{
int arr[10] = { 0 };
char ch[10] = { 0 };
printf("%d\n", sizeof(arr));//?
printf("%d\n", sizeof(ch));//?
test1(arr);
test2(ch);
return 0;
}
输出的结果是??
#include <stdio.h>
void test1(int arr[])//传递的是首元素地址
{
printf("%d\n", sizeof(arr));//4
}
void test2(char ch[])//传递的是首元素地址
{
printf("%d\n", sizeof(ch));//1
}
int main()
{
int arr[10] = { 0 };//int 4个字节
char ch[10] = { 0 };//char 1个字节
printf("%d\n", sizeof(arr));//40
4*10=40
printf("%d\n", sizeof(ch));//10
1*10=10
test1(arr);
test2(ch);
return 0;
}
++
和
--
运算符
前置++ 和 --
先加减后使用
后置++ 和--
先使用后加减
//前置++ 和 --
#include <stdio.h>
int main()
{
int a = 10;
int x = ++a;
//先对a进行自增,然后对使用a,也就是表达式的值是a自增之后的值。x为11。
int y = --a;
//先对a进行自减,然后对使用a,也就是表达式的值是a自减之后的值。y为10;
return 0; }
//后置++和--
#include <stdio.h>
int main()
{
int a = 10;
int x = a++;
//先对a先使用,再增加,这样x的值是10;之后a变成11;
int y = a--;
//先对a先使用,再自减,这样y的值是11;之后a变成10;
return 0; }
6.关系操作符
>
>=
<
<=
!=
用于测试
“
不相等
”
==
用于测试
“
相等
”
警告:
在编程的过程中
==
和
=
不小心写错,导致错误
所以用 5==a 代替 a==5
7.逻辑操作符
&&
逻辑与
||
逻辑或
a&&b
a,b 同时为真则为真,若a为假则为假,且表达式b 不再参与运算
a||b
a,b,中同时为假则为假,若a为真,则表达式b不参与运算
举个栗子
#include <stdio.h>
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; }
输出结果为 1 2 3 4
原因:上方下划线
8.条件(三目)操作符
exp1?exp2:exp3
之前博文提及
9. 逗号表达式
exp1, exp2, exp3, …expN
逗号表达式,就是用逗号隔开的多个表达式。
逗号表达式,从左向右依次执行。整个表达式的结果是最后一个表达式的结果。
#include<stdio.h>
int main()
{
int a = 1;
int b = 2;
int c = (a > b, a = b + 10, a, b = a + 1);
printf("%d\n", c);
return 0;
}
从左到右依次计算 a=12 b=13 根据逗号表达式可知c =13
10. 下标引用、函数调用和结构成员
下标引用操作符 [ ]
操作数:一个数组名
+
一个索引值
int
arr
[
10
];
//
创建数组
arr
[
9
]
=
10
;
//
实用下标引用操作符。
[ ]
的两个操作数是
arr
和
9
。
( ) 函数调用操作符
接受一个或者多个操作数:第一个操作数是函数名,剩余的操作数就是传递给函数的参数
#include<stdio.h>
int Add(int x, int y)
{
int z = x + y;
return z;
}
int main()
{
int a = 2, c = 3;
int sum = Add(a,c);//函数调用操作符
printf("%d\n", sum);
return 0;
}
访问一个结构的成员
.
结构体
.
成员名
->
结构体指针
->
成员名
#include<stdio.h>
struct stu
{
char name[10];
int age ;
}s;
int main()
{
struct stu s = { "张三",10 };
printf("%s %d\n", s.name, s.age);
return 0;
}
#include<stdio.h>
struct stu
{
char name[10];
int age ;
};
int main()
{
struct stu s = { "张三",10 };
struct stu* sp = &s;
printf("%s %d\n", sp->name,sp->age );
return 0;
}
11表达式求值
表达式求值的顺序一部分是由操作符的优先级和结合性决定。
同样,有些表达式的操作数在求值的过程中可能需要转换为其他类型。
11.1
隐式类型转换
C
的整型算术运算总是至少以缺省整型类型的精度来进行的。
为了获得这个精度,表达式中的字符和短整型操作数在使用之前被转换为普通整型,这种转换称为
整型
提升
。
整型提升的意义
:
表达式的整型运算要在
CPU
的相应运算器件内执行,
CPU
内整型运算器
(ALU)
的操作数的字节长度
一般就是
int
的字节长度,同时也是
CPU
的通用寄存器的长度。
因此,即使两个
char
类型的相加,在
CPU
执行时实际上也要先转换为
CPU
内整型操作数的标准长
度。
通用
CPU
(
general-purpose CPU
)是难以直接实现两个
8
比特字节直接相加运算(虽然机器指令
中可能有这种字节相加指令)。所以,表达式中各种长度可能小于
int
长度的整型值,都必须先转
换为
int
或
unsigned int
,然后才能送入
CPU
去执行运算。
char a,b,c;
a=b+c;
b和c的值被提升为普通整型,然后再执行加法运算。
加法运算完成之后,结果将被截断,然后再存储于a中。
如何进行整体提升呢?
整形提升是按照变量的数据类型的符号位来提升的
//
负数的整形提升
char
c1
= -
1
;
变量
c1
的二进制位
(
补码
)
中只有
8
个比特位:
1111111
因为
char
为有符号的
char
所以整形提升的时候,高位补充符号位,即为
1
提升之后的结果是:
11111111111111111111111111111111
//
正数的整形提升
char
c2
=
1
;
变量
c2
的二进制位
(
补码
)
中只有
8
个比特位:
00000001
因为
char
为有符号的
char
所以整形提升的时候,高位补充符号位,即为
0
提升之后的结果是:
00000000000000000000000000000001
//
无符号整形提升,高位补
0
举个栗子
int main()
{
char c = 1;
printf("%u\n", sizeof(c));
printf("%u\n", sizeof(+c));
printf("%u\n", sizeof(-c));
return 0; }
结果为1,4,4
sizeof计算的是表达式的大小,只要c参与运算就会发生整型提升,sizeof虽然不会计算表达式,但要知道表达式的类型
11.2算数转化
如果某个操作符的各个操作数属于不同的类型,那么除非其中一个操作数的转换为另一个操作数的类 型,否则操作就无法进行。下面的层次体系称为寻常算术转换
。
long double
double
float
unsigned long int
long int
unsigned int
int
如果某个操作数的类型在上面这个列表中排名较低,那么首先要转换为另外一个操作数的类型后执行运算。
注意
float
f
=
3.14
;
int
num
=
f
;
//
隐式转换,会有精度丢失
11.3
操作符的属性
复杂表达式的求值有三个影响的因素。
1.
操作符的优先级
2.
操作符的结合性
3.
是否控制求值顺序。
两个相邻的操作符先执行哪个?取决于他们的优先级。如果两者的优先级相同,取决于他们的结合性。
从上到下依次递减
问题表达式
//
表达式的求值部分由操作符的优先级决定。
a
*
b
+
c
*
d
+
e
*
f
注释:代码
在计算的时候,由于
*
比
+
的优先级高,只能保证,
*
的计算是比
+
早,但是优先级并不
能决定第三个
*
比第一个
+
早执行。
所以会出现歧义
我们写出的表达式如果不能通过操作符的属性确定唯一的计算路径,那这个表达式就是存在问题
的。