零基础自学C语言|操作符详解

饺子之欣喜

于 2023-11-23 18:00:00 发布

阅读量53

点赞数 5

分类专栏： C语言零基础文章标签： c语言开发语言

本文链接：https://blog.csdn.net/Dumpling527/article/details/134552503

版权

C语言同时被 2 个专栏收录

22 篇文章 1 订阅

订阅专栏

零基础

22 篇文章 0 订阅

订阅专栏

一、操作符的分类

1.算数操作符：+、-、*、/、%

2.移位操作符：>>、<<

3.位操作符：&、|、^

4.赋值操作符：=、+=、-=、*=、/=、%=、<<=、>>=、&=、|=、^=

5.单目操作符：!、++、--、&、*、+、-、~、sizeof、(类型)

6.关系操作符：>、>=、<、<=、==、!=

7.逻辑操作符：&&、||、

8.条件操作符：?、:

9.逗号表达式：,

10.下标引用：[]

11.函数调用：()

12.结构成员访问：.、->

二、二进制和进制转换

其实我们经常能听到2进制、8进制、10进制、16进制这样的讲法，那是什么意思呢？其实2进制、8进制、10进制、16进制是数值的不同表示形式而已。

比如：数值15的各种进制的表示形式：

15的2进制：1111

15的8进制：173

15的10进制：154 15的16进制：F

我们重点介绍一下二进制：

首先我们还是得从10进制讲起，其实10进制是我们生活中经常使用的，我们已经形成了很多尝试：

10进制中满10进1
10进制的数字每一位都是0~9的数字组成

其实二进制也是一样的：

2进制中满2进1
2进制的数字每一位都是0~1的数字组成

那么1101 就是二进制的数字了。

（1）二进制转十进制

其实10进制的123表示的值是一百二十三，为什么是这个值呢？其实10进制的每一位是权重的，10进制的数字从右向左是个位、十位、百位…，分别每一位的权重是 $10^{0}$ 、 $10^1$ 、 $10^2$ ...

如下图：

2进制和10进制是类似的，只不过2进制的每一位的权重，从右向左是： $2^0$ 、 $2^1$ 、 $2^2$ ...如果是2进制的1101，该怎么理解呢？

（2）十进制转二进制数字

（3）二进制转八进制

8进制的数字每一位是0~7的，0~7的数字，各自写成2进制，最多有3个2进制位就足够了，比如7的二进制是111，所以在2进制转8进制数的时候，从2进制序列中右边低位开始向左每3个2进制位会换算一个8进制位，剩余不够3个2进制位的直接换算。

如：2进制的01101011，换成8进制：0153,0开头的数字，会被当做8进制。

（4）二进制转十六进制

16进制的数字每一位是0~9,a~f的，0~9,a ~f的数字，各自写成2进制，最多有4个2进制位就足够了。

比如：f的二进制是1111，所以在2进制转16进制数的时候，从2进制序列中右边低位开始向左每4个2进制位会换算一个16进制位，剩余不够4个二进制位的直接换算。

如：2进制的01101011，换成16进制：0x6b,16进制表示的时候前面加0x

三、源码、反码、补码

整数的2进制表示方法有三种，即原码、反码和补码
有符号整数的三种表示方法均有符号位和数值位两部分，2进制序列中，最高位的1位是被当做符号位，剩余的都是数值位。
符号位都是用0表示"正"，用1表示"负"。
正整数的原、反、补码都相同。
负整数的三种表示方法各不相同。

原码：直接将数值按照正负数的形式翻译成二进制得到的就是原码。
反码：将原码的符号位不变，其他位依次按位取反就可以得到反码。
补码：反码＋1就得到补码。

反码得到原码也是可以使用：取反，+1的操作。
对于整形来说：数据存放内存中其实存放的是补码。

为什么呢？

在计算机系统中，数值一律用补码来表示和存储。原因在于，使用补码，可以将符号位和数值域统一处理；同时，加法和减法也可以统一处理 (CPU只有加法器）此外，补码与原码相互转换，其运算过程是相同的，不需要额外的硬件电路。

四、移位操作符

<< 左移操作符
>> 右移操作符

注：移位操作符的操作数只能是整数。

（1）左移操作符

移位规则：左边抛弃、右边补0

int main()
{
	int num = 10;
	int n = num << 1;
	printf("%d\n", num);
	printf("%d\n", n);
	return 0;
}

（2）右移操作符

移位规则：首先右移运算分两种：
1.逻辑右移：左边用0填充，右边丢弃
2.算术右移：左边用原该值的符号位填充，右边丢弃

int main()
{
	int num = 10;
	int n = num >> 1;
	printf("%d\n", num);
	printf("%d\n", n);
	return 0;
}

ps：对于移位运算符，不要移动负数位，这个是标准未定义的。

例如：

int main()
{
	int num = 10;
	int n = num >> -1;//这是错误的
	printf("%d\n", num);
	printf("%d\n", n);
	return 0;
}

五、位操作符&、|、^、~、

注：他们的操作数必须是整数

&：按位与

|：按位或

^：按位异或

~：按位取反

直接上代码：

int main()
{
	int num1 = -3;
	int num2 = 5;
	printf("%d\n", num1 & num2);
	printf("%d\n", num1 | num2);
	printf("%d\n", num1 ^ num2);
	printf("%d\n", ~0);
	return 0;
}

这些操作符都是将左右两边的整数的二进制补码进行比较

按位与的结果为两边同时为1时取1，其他情况取0：

//000000000000000000000000000000101(5)
//111111111111111111111111111111101(-3)
//000000000000000000000000000000101(5&(-3))

按位或是两边同时取0时取0，其他情况取1：

//000000000000000000000000000000101(5)
//111111111111111111111111111111101(-3)
//111111111111111111111111111111101(5|(-3))

按位异或是两边相同时取0，其他情况取1：

//000000000000000000000000000000101(5)
//111111111111111111111111111111101(-3)
//111111111111111111111111111111000(5^(-3))

按位取反是遇到1时取0，遇到0时取1：

//00000000000000000000000000000000(0)
//11111111111111111111111111111111(~0)

一道变态的面试题：

不能创建临时变量实现两个数的交换。

在学习这道题的写法前，我们要知道两个公式：
a^0=a

a^a=0

然后我们就可以看懂代码了：

int main()
{

	int a = 10;
	int b = 20;
	a = a ^ b;
	b = a ^ b;//b == a ^ b ^ b == a ^ 0 == a
	a = a ^ b;//a == a ^ b ^ a == a ^ a ^ b == 0 ^ b == b
}

练习1：求一个整数储存在内存中二进制1的个数

方法1：

int main()
{
	int num = 10;
	int count = 0;
	while (num)
	{
		if (num % 2 == 1)
		{
			count++;
		}
		num /= 2;
	}
	printf("%d\n", count);
	return 0;
}

方法2：

int main()
{
	int num = 10;
	int count = 0;
	for (int i = 0; i < 32; i++)
	{
		if (num & (1 << i))
		{
			count++;
		}
	}
	printf("%d\n", count);
	return 0;
}

方法3：

int main()
{
	int num = 10;
	int count = 0;
	while (num)
	{
		count++;
		num = num & (num - 1);
	}
	printf("%d\n", count);
	return 0;
}

这种方式很好，但是非常难想到。

练习2：二进制位置0或者置1

编写代码将13二进制序列的第5位修改为1，然后再改回0

参考代码：

int main()
{
	int a = 13;
	a = a | (1 << 4);
	printf("%d\n", a);
	a = a & ~(1 << 4);
	printf("%d\n", a);
	return 0;
}

六、单目操作符

单目操作符的特点是只有一个操作数，在单目操作符中只有＆和＊没有介绍，这2个操作符，我们放在学习指针的时候学习。

七、逗号表达式

逗号表达式，就是用逗号隔开的多个表达式。

逗号表达式，从左向右依次执行。整个表达式的结果是最后一个表达式的结果。

int main()
{
	int a = 1;
	int b = 2;
	int c = (a > b, a = b + 10, b = a + 1);
	printf("%d", c);
	return 0;
}

结果是13。

a = get_val();
count_val(a);
while (a > 0) {
	//业务处理
	a = get_val();
	count_val(a);
}

这段代码可以改写成：

while (a = get_val(), count_val(a), a > 0) {
	//业务处理
}

这样更加简便。

八、结构成员访问操作符

（1）结构体的介绍

C语言已经提供了内置类型，如：char、short、int、long、float、double等，但是只有这些内置类型还是不够的，假设我想描述学生，描述一本书，这时单一的内置类型是不行的。描述一个学生需要名字、年龄、学号、身高、体重等；描述一本书需要作者、出版社、定价等。C语言为了解决这个问题，增加了结构体这种自定义的数据类型，让程序员可以自己创造适合的类型。

结构是一些值的集合，这些值称为成员变量。结构的每个成员可以是不同类型的变量，如：
标量、数组、指针，甚至是其他结构体。

（2）结构体的声明

例如，我要描述一个学生：

struct Stu
{
	char name[20];
	int age;
	char sex[5];
	char id[20];//学号
};

（3）结构体的变量定义和初始化

变量的定义：

struct Point
{
	int x;
	int y;
}P1;
//或者：
struct point p2;

变量的初始化：

struct Stu
{
	char name[15];
	int age;
};

struct Stu s1 = { "hehe",20 };
struct Stu s2 = {.age=20,.name="lisi"};

变量的嵌套初始化：

struct a
{
	struct Point;
	int b;
};

struct a a1 = { {2,3},4 };

（4）结构成员访问操作符

结构体成员的直接访问是通过点操作符（.) 访问的。点操作符接受两个操作数。如下所示：

#include <stdio.h>
struct Point
{
	int x;
	int y;
}p = { 1,2 };
int main()
{
	printf("x: %d y: %d\n", p.x, p.y);
	return 0;
}

使用方式：结构体变量.成员名

九、操作符的属性：优先级，结合性

C语言的操作符有2个重要的属性：优先级、结合性，这两个属性决定了表达式求值的计算顺序

（1）优先级

优先级指的是，如果一个表达式包含多个运算符，哪个运算符应该优先执行。各种运算符的优先级是不一样的。

上面示例中，表达式3+4*5里面既有加法运算符(+)，又有乘法运算符 (*)。由于乘法的优先级高于加法，所以会先计算4*5，而不是先计算3+4。

（2）结合性

如果两个运算符优先级相同，优先级没办法确定先计算哪个了，这时候就看结合性了，则根据运算符是左结合，还是右结合，决定执行顺序。大部分运算符是左结合（从左到右执行），少数运算符是右结合（从右到左执行），比如赋值运算符（=)。

上面示例中，＊和／的优先级相同，它们都是左结合运算符，所以从左到右执行，先计算5*6,再计算6/2。

运算符的优先级顺序很多，下面是部分运算符的优先级顺序（按照优先级从高到低排列），建议大概记住这些操作符的优先级就行，其他操作符在使用的时候查看下面表格就可以了。

圆括号：（()）
自增运算符（++)，自减运算符（--)
单目运算符（＋和﹣)
乘法（*)，除法（/)
加法（+)，减法（-)
关系运算符（<、＞等）
赋值运算符（=)

由于圆括号的优先级最高，可以使用它改变其他运算符的优先级。

C语言运算符优先级和结合性https://zh.cppreference.com/w/c/language/operator_precedence

十、表达式求值

（1）整型提升

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

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

整型提升的意义：
表达式的整型运算要在CPU的相应运算器件内执行，CPU内整型运算器（ALU）的操作数的字节长度一般就是int的字节长度，同时也是CPU的通用寄存器的长度。
因此，即使两个char类型的相加，在CPU执行时实际上也要先转换为CPU内整型操作数的标准长度。
通用CPU (general-purpose CPU) 是难以直接实现两个8比特字节直接相加运算（虽然机器指令中可能有这种字节相加指令）。所以，表达式中各种长度可能小于int长度的整型值，都必须先转换为int或unsigned int，然后才能送入CPU去执行运算。

int main()
{
	char a = 60;
	char b = 10;
	char c = 0;
	c = a + b;
	return 0;
}

a和b的值被提升为普通整型，然后再执行加法运算。加法运算完成之后，结果将被截断，然后储存在c中。
如何进行整体提升呢？
1．有符号整数提升是按照变量的数据类型的符号位来提升的2，无符号整数提升，高位补0

负数的整形提升：

int main()
{	
	char c1 = -1;
	//变量c1的二进制位（补码）中只有8个比特位：1111111
	//因为 char 为有符号的 char
	//所以整形提升的时候，高位补充符号位，即为1
	//提升之后的结果是：
	//11111111111111111111111111111111
}

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

（2）算数转换

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

1 long double
2 double
3 float
4 unsigned long int
5 long int
6 unsigned int
7 int

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

（3）问题解析

问题表达式1：

a*b + c*d + e*f

表达式1在计算的时候，由于＊比＋的优先级高，只能保证，＊的计算是比＋早，但是优先级并不能决定第三个＊比第一个＋早执行。

所以表达式的计算机顺序就可能是：

a*b

c*d

a*b + c*d

e*f

a*b + c*d + e*f

或者：

a*b

c*d

e*f

a*b + c*d

a*b + c*d + e*f

问题表达式2：

c + --c;

同上，操作符的优先级能决定自减 -- 的运算在 + 的运算的前面，但是我们并没有办法得知，操作符的左操作数的获取在右操作数之前还是之后求值，所以结果是不可预测的，是有歧义的。

问题表达式3：

int main()
{
	int i = 10;
	i = i-- - --i * (i = -3) * i++ + ++i;
	printf("i = %d\n", i);
	return 0;
}

这是在不同的编译器下这个代码的结果：

出自：《C和指针》

问题表达式4：

int fun()
{
	static int count = 1;
	return ++count;
}
int main()
{
	int answer;
	answer = fun() - fun() * fun();
	printf("%d\n", answer);//输出多少？
	return 0;
}

这个代码有没有实际的问题？有问题！虽然在大多数的编译器上求得结果都是相同的。

这是因为函数的调用先后顺序无法通过操作符的优先级确定，所以是有问题的。

总结：

即使有了操作符的优先级和结合性，我们写出的表达式依然有可能不能通过操作符的属性确定唯一的计算路径，那这个表达式就是存在潜在风险的，建议不要写出特别负责的表达式。

饺子之欣喜

关注

5
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
零基础自学C语言|操作符详解

C语言已经提供了内置类型，如：char、short、int、long、float、double等，但是只有这些内置类型还是不够的，假设我想描述学生，描述一本书，这时单一的内置类型是不行的。描述一个学生需要名字、年龄、学号、身高、体重等；描述一本书需要作者、出版社、定价等。C语言为了解决这个问题，增加了结构体这种自定义的数据类型，让程序员可以自己创造适合的类型。结构是一些值的集合，这些值称为成员变量。结构的每个成员可以是不同类型的变量，如：标量、数组、指针，甚至是其他结构体。int x;
复制链接

扫一扫