C语言初阶之操作符

一、操作符分类

  • 算术操作符   + - * / %
  • 移位操作符   << >>
  • 位操作符    & | ^
  • 赋值操作符   = += -= *= /=
  • 单目操作符   ! sizeof + - ~ & *
  • 关系操作符   > < >= <= == !=
  • 逻辑操作符   && ||
  • 条件操作符   ? :
  • 逗号表达式   ,
  • 下标引用、函数调用和结构成员   [] () . ->

二、算数操作符

+    -   *   /   %
  • /   除法
  1. 整数除法(除号两端都是整数)
  2. 浮点数除法(除号两端只要有一个小数就执行小数除法)
  •  %   取模操作符的两个操作数必须是整数
  • 除了 % 操作符之外,其他的几个操作符可以作用于整数和浮点数。
  • 对于 / 操作符如果两个操作数都为整数,执行整数除法。而只要有浮点数执行的就是浮点数除法。

三、移位操作符

<< 左移操作符
>> 右移操作符
    
注:移位操作符的操作数只能是整数。

移动的是补码二进制

1)左移

左边抛弃、右边补0

C语言初阶之操作符_第1张图片

2)右移

  1. 逻辑移位 左边用0填充,右边丢弃
  2. 算术移位 左边用原该值的符号位填充,右边丢弃

C语言初阶之操作符_第2张图片

C语言初阶之操作符_第3张图片

C语言初阶之操作符_第4张图片

一般编译器采用算数右移

C语言初阶之操作符_第5张图片

a移位赋值给b,但a本身不变。

四、位操作符

位操作符有:

& //按位与
| //按位或
^ //按位异或
//注:他们的操作数必须是整数。

& //按位与 - 只有两个数的二进制同时为1,结果才为1,否则为0。(负数按补码形式参加按位与运算)
| //按位或 - 参加运算的两个数只要两个数中的一个为1,结果就为1。
^ //按位异或 - 对应二进制位相同为0,相异为1

//方法2:
#include 
int main()
{
	int num = -1;
	int i = 0;
	int count = 0;//计数
	for (i = 0; i < 32; i++)
	{
		if (num & (1 << i))
			count++;
	}
	printf("二进制中1的个数 = %d\n", count);
	return 0;
}
//思考还能不能更加优化,这里必须循环32次的。
//方法3:
#include 
int main()
{
	int num = -1;
	int i = 0;
	int count = 0;//计数
	while (num)
	{
		count++;
		num = num & (num - 1);
	}
	printf("二进制中1的个数 = %d\n", count);
	return 0;
}
//这种方式是不是很好?达到了优化的效果,但是难以想到

num 的值为 -1 时,程序会计算 -1 的二进制表示中包含的1的个数。

-1 的二进制表示为 1111 1111(根据补码表示法),其中共有8个1。程序会使用 Brian Kernighan's 算法来计算这个值。

首先,初始化 count 为 0。

进入循环,第一次迭代:

  • num 的值为 -1,二进制表示为 1111 1111。
  • 执行 num = num & (num - 1),即 -1 = -1 & (-1 - 1),得到 -1 = -1 & -2
  • -2 的二进制表示为 1111 1110。
  • num 的新值为 -2
  • count 的值增加1,变为 1。

进入下一次迭代:

  • num 的值为 -2,二进制表示为 1111 1110。
  • 执行 num = num & (num - 1),即 -2 = -2 & (-2 - 1),得到 -2 = -2 & -3
  • -3 的二进制表示为 1111 1101。
  • num 的新值为 -3
  • count 的值增加1,变为 2。

继续迭代,每次迭代都会消除一个1,直到 num 变为0。

五、赋值操作符

赋值操作符可以连续使用,比如:

int a = 10;
int x = 0;
int y = 20;
a = x = y + 1;//连续赋值
//x = y+1;
//a = x;

复合赋值符

+=
-=
*=
/=
%=
>>=
<<=
&=
|=
^=

六、单目操作符

1)单目操作符介绍

!           逻辑反操作
-           负值
+           正值
&           取地址
sizeof      操作数的类型长度(以字节为单位)
~           对一个数的二进制按位取反
--          前置、后置--
++          前置、后置++
*           间接访问操作符(解引用操作符)
(类型)       强制类型转换

2)取地址与解引用

int main() {
	int a = 10;
	//pa是指针变量
	int* pa = &a;

	*pa = 20;  //解引操作符(间接访问操作符)- 通用pa中存放的地址,找到指向的空间(内容)
	int c = *pa;

	return 0;
}

3)sizeof和数组

        sizeof不是函数,是操作符,计算的是类型创建变量的大小,单位是字节。

#include 
void test1(int arr[])
{
	printf("%d\n", sizeof(arr));//(2)
}
void test2(char ch[])
{
	printf("%d\n", sizeof(ch));//(4)
}
int main()
{
	int arr[10] = { 0 };
	char ch[10] = { 0 };
	printf("%d\n", sizeof(arr));//(1)
	printf("%d\n", sizeof(ch));//(3)
	test1(arr);
	test2(ch);
	return 0;
}

C语言初阶之操作符_第6张图片

传递数组名实质是传递数组首地址。

七、关系操作符

>
>=
<
<=
!=   用于测试“不相等”
==      用于测试“相等”

对比整型浮点型,不能比较字符串

八、逻辑操作符

&&     逻辑与
||     逻辑或

区分逻辑与和按位与 区分逻辑或和按位或,如果结果是真用1表示,是假用0表示。

1&2----->0
1&&2---->1
1|2----->3
1||2---->1

C语言初阶之操作符_第7张图片

a++为后置++,a运算时为0,为假,不继续进行后面的&&运算。
或者运算 || 左边为真,不进行后面的运算。

九、条件操作符

exp1 ? exp2 : exp3  //三目操作符
 真     执行  不执行
 假    不执行  执行

十、逗号表达式

exp1, exp2, exp3, …expN
  • 逗号表达式,就是用逗号隔开的多个表达式。
  • 逗号表达式,从左向右依次执行。整个表达式的结果是最后一个表达式的结果。
//代码1
int a = 1;
int b = 2;
int c = (a>b, a=b+10, a, b=a+1);//逗号表达式
c是多少? c=13

十一、下标引用、函数调用和结构成员

1)[ ] 下标引用操作符

        操作数:一个数组名 + 一个索引值

 int arr[10];//创建数组
 arr[9] = 10;//实用下标引用操作符。
 [ ]的两个操作数是arr和9。

2)( ) 函数调用操作符

        接受一个或者多个操作数:第一个操作数是函数名,剩余的操作数就是传递给函数的参数。

#include 
void test1()
{
	printf("hehe\n");
}
void test2(const char* str)
{
	printf("%s\n", str);
}
int main()
{
	test1();            //实用()作为函数调用操作符。
	test2("hello bit.");//实用()作为函数调用操作符。
	return 0;
}

3)访问一个结构的成员

  •  结构体.成员名
  • ->   结构体指针->成员名
#include 
struct Stu{
	char name[10];
	int age;
	char sex[5];
	double score;
};
void set_age1(struct Stu stu){
	stu.age = 18;
}
void set_age2(struct Stu* pStu){
	pStu->age = 18;//结构成员访问
}
void Print(struct Stu* p) {
	printf("%s %d %s %lf", (*p).name, (*p).age, (*p).sex, (*p).score);
	printf("%s %d %s %lf", p->name, p->age, p->sex, p->score);//结构体指针->成员名
}
int main(){
	struct Stu stu;
	struct Stu* pStu = &stu;//结构成员访问

	stu.age = 20;//结构成员访问
	set_age1(stu);

	pStu->age = 20;//结构成员访问
	set_age2(pStu);

	printf("%s %d %s %lf", stu.name, stu.age, stu.sex, stu.score);
	return 0;
}

十二、表达式求值

  • 表达式求值的顺序一部分是由操作符的优先级和结合性决定。
  • 同样,有些表达式的操作数在求值的过程中可能需要转换为其他类型。

1)隐式类型转换

C的整型算术运算总是至少以缺省整型类型的精度来进行的。

为了获得这个精度,表达式中的字符(char)和短整型(short)操作数在使用之前被转换为普通整型,这种转换称为整型提升

  • 表达式的整型运算要在CPU的相应运算器件内执行,CPU内整型运算器(ALU)的操作数的字节长度 一般就是int的字节长度,同时也是CPU的通用寄存器的长度。
  • 因此,即使两个char类型的相加,在CPU执行时实际上也要先转换为CPU内整型操作数的标准长度
  • 通用CPU(general-purpose CPU)是难以直接实现两个8比特字节直接相加运算(虽然机器指令 中可能有这种字节相加指令)。所以,表达式中各种长度可能小于int长度的整型值,都必须先转换为int或unsigned int,然后才能送入CPU去执行运算。
int main() {
	char c1 = 5;
	//00000000000000000000000000000101,存不下,截断
	//00000101 - c1
	char c2 = 127;
	//00000000000000000000000001111111,存不下,截断
	//01111111 - c2
	char c3 = c1 + c2;
	//补回,整型提升
	//00000000000000000000000000000101
	//00000000000000000000000001111111
	//00000000000000000000000010000100,存不下,截断
	//10000100 - c3
	//%d,十进制形式打印有符号的整数
	//11111111111111111111111110000100 - 提升,高位补1 - 补码
	//100000000000000000000000011111100 --> -124
	printf("%d\n", c3);
	return 0;
}

整形提升是按照变量的数据类型的符号位来提升的。

//负数的整形提升
char c1 = -1;
变量c1的二进制位(补码)中只有8个比特位:
1111111
因为 char 为有符号的 char
所以整形提升的时候,高位补充符号位,即为1
提升之后的结果是:
11111111111111111111111111111111

//正数的整形提升
char c2 = 1;
变量c2的二进制位(补码)中只有8个比特位:
00000001
因为 char 为有符号的 char
所以整形提升的时候,高位补充符号位,即为0
提升之后的结果是:
00000000000000000000000000000001

//无符号整形提升,高位补0

 实例1中的a,b要进行整形提升,但是c不需要整形提升 

//实例1
int main()
{
	char a = 0xb6;
	short b = 0xb600;
	int c = 0xb6000000;
	if (a == 0xb6)
		printf("a");
	if (b == 0xb600)
		printf("b");
	if (c == 0xb6000000)
		printf("c");
	return 0;
}

        a,b整形提升之后,变成了负数,所以表达式 a==0xb6 , b==0xb600 的结果是假,但是c不发生整形提升,则表 达式 c==0xb6000000 的结果是真.

//实例2
int main()
{
	char c = 1;
	printf("%u\n", sizeof(c));
	printf("%u\n", sizeof(+c));
	printf("%u\n", sizeof(-c));
	return 0;
}

 实例2中的,c只要参与表达式运算,就会发生整形提升,表达式 +c ,就会发生提升,所以 sizeof(+c) 是4个字节。

表达式 -c 也会发生整形提升,所以 sizeof(-c) 是4个字节,但是 sizeof(c) ,就是1个字节。

2)算术转换

        如果某个操作符的各个操作数属于不同的类型,那么除非其中一个操作数的转换为另一个操作数的类 型,否则操作就无法进行。下面的层次体系称为寻常算术转换

long double
double
float
unsigned long int
long int
unsigned int
int

        如果某个操作数的类型在上面这个列表中排名较低,那么首先要转换为另外一个操作数的类型后执行运 算。

但是算术转换要合理,要不然会有一些潜在的问题。

float f = 3.14;
int num = f;//隐式转换,会有精度丢失

3)操作符属性

复杂表达式的求值有三个影响的因素。

  1. 操作符的优先级
  2. 操作符的结合性
  3. 是否控制求值顺序

两个相邻的操作符先执行哪个?取决于他们的优先级。如果两者的优先级相同,取决于他们的结合性。

操作符优先级

操作符 描述 用法示例 结果类型 结合性 是否控制求值顺序
() 聚组 (表达式) 与表达式同 N/A
() 函数调用 rexp(rexp,...,rexp) rexp L-R
[ ] 下标引用 rexp[rexp] lexp L-R
. 访问结构成员 lexp.member_name lexp L-R
-> 访问结构指针成员 rexp->member_name lexp L-R
++ 后缀自增 lexp++ rexp L-R
-- 后缀自减 lexp-- rexp L-R
! 逻辑反 !rexp rexp R-L
~ 按位取反 ~rexp rexp R-L
+ 单目,表示正值 +rexp rexp R-L
- 单目,表示负值 -rexp rexp R-L
++ 前缀自增 ++rexp rexp R-L
-- 前缀自减 --rexp rexp R-L
* 间接访问 *rexp lexp R-L
& 取地址 &rexp rexp R-L
sizeof 取其长度,以字节表示 sizeof rexp sizeof(类型) rexp R-L
(类型) 类型转换 (类型) rexp rexp R-L
* 乘法 rexp * rexp rexp L-R
/ 除法 rexp / rexp rexp L-R
% 整数取余 rexp % rexp rexp L-R
+ 加法 rexp + rexp rexp L-R
- 减法 rexp - rexp rexp L-R
<< 左移位 rexp << rexp rexp L-R
>> 右移位 rexp >> rexp rexp L-R
> 大于 rexp > rexp rexp L-R
>= 大于等于 rexp >= rexp rexp L-R
< 小于 rexp < rexp rexp L-R
<= 小于等于 rexp <= rexp rexp L-R
== 等于 rexp == rexp rexp L-R
!= 不等于 rexp != rexp rexp L-R
& 位与 rexp & rexp rexp L-R
^ 位异或 rexp ^ rexp rexp L-R
| 位或 rexp | rexp rexp L-R
&& 逻辑与 rexp && rexp rexp L-R
|| 逻辑或 rexp || rexp rexp L-R
? : 条件操作符 rexp ? rexp : rexp rexp N/A
= 赋值 lexp = rexp rexp R-L
+= 以...加 lexp += rexp rexp R-L
-= 以...减 lexp -= rexp rexp R-L
*= 以...乘 lexp *= rexp rexp R-L
/= 以...除 lexp /= rexp rexp R-L
%= 以...取模 lexp %= rexp rexp R-L
<<= 以...左移 lexp <<= rexp rexp R-L
>>= 以...右移 lexp >>= rexp rexp R-L
&= 以...与 lexp &= rexp rexp R-L
^= 以...异或 lexp ^= rexp rexp R-L
|= 以...或 lexp |= rexp rexp R-L
逗号 rexp rexp L-R

总结:

        我们写出的表达式如果不能通过操作符的属性确定唯一的计算路径,那这个表达式就是存在问题的。

你可能感兴趣的:(C语言,c语言,开发语言)