视频加载失败

C语言初阶 03:常见操作符与表达式求值

4564 字
23 分钟
C语言初阶 03:常见操作符与表达式求值

代码块包含可运行实现、局部片段、输出、故意出错的示例与思考题;它们是独立示例,请结合上下文阅读,不能将整章拼成一个程序。

阅读前先核对#

  • 有符号溢出、除零、同一标量对象上未排序的多次修改属于未定义行为,不能给出固定运行结果。优先级与结合性决定分组,不规定所有子表达式的实际求值顺序。

本章目标#

  1. 学习使用常见的操作符,在代码中熟练使用

  2. 掌握操作符的属性和表达式求值

  3. 了解表达式求值过程中的类型转换

  4. 能够识别一些问题表达式,尽量避免写出问题表达式

有了常量和变量的知识,如果要完成一些运算,还得掌握常见的操作符,下面是C语言中提供的操作符。

操作符也被叫做:运算符,是不同的翻译,意思是一样的。

算术操作符 + 、- 、* 、/ 、%移位操作符 << >>位操作符 & | ^赋值操作符 = 、+= 、 、

课件代码 03-001 · PDF 第 1 页

*=

课件代码 03-002 · PDF 第 1 页

/= 、%=

课件代码 03-003 · PDF 第 1 页

%=

课件代码 03-004 · PDF 第 1 页

>>= 、&= 、|= 、^=

课件代码 03-005 · PDF 第 1 页

&= 、|= 、^=

课件代码 03-006 · PDF 第 1 页

~ 、sizeof、(类型)

单目操作符 !、++、—、&、*、关系操作符 > 、>= 、< 、<= 、

课件代码 03-007 · PDF 第 1 页

!=

逻辑操作符 && 、||条件操作符 ? :

逗号表达式 ,下标引用 []函数调用 ()结构成员访问 . 、->这个章节,主要介绍一些常用的操作符~

1. 算术操作符#

在C语言的操作符中有一组操作符叫:算术操作符。分别是: + - * / % ,这些操作符都是双目操作符。

1.1 + 和 -#

  • 和 - 用来完成加法和减法。

  • 和 - 都是有2个操作数的,位于操作符两端的就是它们的操作数,这种操作符也叫双目操作符。

课件代码 03-008 · PDF 第 2 页

#include <stdio.h>
int main()
{
int x = 4 + 22;
int y = 61 - 23;
printf("%d\n", x);
printf("%d\n", y);
return 0;
}

1.2 *#

运算符 * 用来完成乘法。

课件代码 03-009 · PDF 第 2 页

#include <stdio.h>
int main()
{
int num = 5;
printf("%d\n", num * num); // 输出 25
return 0;
}

1.3 /#

运算符 / 用来完成除法。

除号的两端如果是整数,执行的是整数除法,得到的结果也是整数。

课件代码 03-010 · PDF 第 2,3 页

#include <stdio.h>
int main()
{
float x = 6 / 4;
int y = 6 / 4;
printf("%f\n", x); // 输出 1.000000
printf("%d\n", y); // 输出 1
return 0;
}

上面示例中,尽管变量 x 的类型是 float (浮点数),但是 6 / 4 得到的结果是 1.0 ,而不是1.5 。原因就在于 C 语言里面的整数除法是整除,只会返回整数部分,丢弃小数部分。

如果希望得到浮点数的结果,两个运算数必须至少有一个浮点数,这时 C 语言就会进行浮点数除法。

课件代码 03-011 · PDF 第 3 页

#include <stdio.h>
int main()
{
float x = 6.0 / 4; // 或者写成 6 / 4.0
printf("%f\n", x); // 输出 1.500000
return 0;
}

上面示例中, 6.0 / 4 表示进行浮点数除法,得到的结果就是 1.5 。

再看一个例子:

课件代码 03-012 · PDF 第 3 页

#include <stdio.h>
int main()
{
int score = 5;
score = (score / 20) * 100;
printf("%f\n", score);
return 0;
}

上面的代码,你可能觉得经过运算, score 会等于 25 ,但是实际上 score 等于 0 。这是因为score / 20 是整除,会得到一个整数值 0 ,所以乘以 100 后得到的也是 0 。

为了得到预想的结果,可以将除数 20 改成 20.0 ,让整除变成浮点数除法。

课件代码 03-013 · PDF 第 4 页

#include <stdio.h>
int main()
{
int score = 5;
score = (score / 20.0) * 100;
printf("%f\n", score);
return 0;
}

1.4 %#

运算符 % 表示求模(余)运算,即返回两个整数相除的余值。这个运算符只能用于整数,不能用于浮点数。

课件代码 03-014 · PDF 第 4 页

#include <stdio.h>
int main()
{
int x = 6 % 4; // 2
return 0;
}

负数求模的规则是,结果的正负号由第一个运算数的正负号决定。

课件代码 03-015 · PDF 第 4 页

#include <stdio.h>
int main()
{
printf("%d\n", 11 % -5); // 1
printf("%d\n",-11 % -5); // -1
printf("%d\n",-11 % 5); // -1
return 0;
}

上面示例中,第一个运算数的正负号( 11 或 -11 )决定了结果的正负号。

练习1:计算正整数的最后一位

课件代码 03-016 · PDF 第 5 页

#include <stdio.h>
int main()
{
int num = 123;
printf("%d\n", num % 10);
return 0;
}

练习2:计算任意两个整数的平均值,结果是小数想要计算任意两个整数的平均值,那么我们需要给程序输入2个值,这里就需要 scanf 函数;scanf 函数是格式化的输入函数。什么是格式化?什么是输入呢?这里先给大家介绍一下。

第3章第5页配图
第3章第5页配图

第3章第5页配图
第3章第5页配图

代码中的 %d 是占位符,对应的是整数类型,用在 printf 函数中表示要打印一个整型类型的数据;用在scanf函数中表示从接受从键盘输入的一个整型类型的值。

常用的占位符:

课件代码 03-017 · PDF 第 6 页

%d //对应int类型
%f //输出时对应float和double,输入时%f对应float类型,%lf对应double
%c //对应char类型
%s //对应字符串

代码1 代码2

课件代码 03-018 · PDF 第 6 页

#include <stdio.h>
int main()
{
printf("%d\n", 100);
printf("%c\n", 100);
printf("%d-%d-%d\n", 2026, 12, 12);
printf("%d\n", 3.14);//格式错误
return 0;
}

课件代码 03-019 · PDF 第 6 页

#include <stdio.h>
int main()
{
int a = 0;
int b = 0;
scanf("%d", &a);//输入100
printf("%d", a);
scanf("%d", &b);//输入3.14
printf("%d", b);//会输出什 么呢?
return 0;
}

代码3

课件代码 03-020 · PDF 第 6 页

#include <stdio.h>
int main()
{
char c = 0;
scanf("%c", &c);//97
printf("%c", c);
printf("%s\n", "hello world");
printf("change world\n");
return 0;
}

练习参考代码:

课件代码 03-021 · PDF 第 7 页

#include <stdio.h>
int main()
{
int a = 0;
int b = 0;
//输入2个整数
scanf("%d%d", &a, &b);
//计算
float avg = (a + b) / 2.0;
//输出结果
printf("%f\n", avg);
return 0;
}

scanf 和 printf 函数的详细讲解,请参考录播内容: 加餐-详解printf和scanf

2. 赋值操作符:= 和 复合赋值#

在变量创建的时候给一个初始值叫初始化,在变量创建好后,再给一个值,这叫赋值。

课件代码 03-022 · PDF 第 7 页

int a = 100;//初始化
a = 200;//赋值,这里使用的就是赋值操作符

赋值操作符 = 是一个随时可以给变量赋值的操作符。

2.1 连续赋值#

赋值操作符也可以连续赋值,如:

课件代码 03-023 · PDF 第 7 页

int a = 3;
int b = 5;
int c = 0;
c = b = a+3;//连续赋值,从右向左依次赋值的。

C语言虽然支持这种连续赋值,但是写出的代码不容易理解,建议还是拆开来写,这样方便观察代码的执行细节。

课件代码 03-024 · PDF 第 8 页

int a = 3;
int b = 5;
int c = 0;
b = a + 3;
c = b;

这样写,在调试的时候,每一次赋值的细节都是可以很方便的观察的。

2.2 复合赋值符#

在写代码时,我们经常可能对一个数进行自增、自减的操作,如下代码:

课件代码 03-025 · PDF 第 8 页

int a = 10;
a = a + 3;
a = a - 2;

这样代码C语言给提供了更加方便的写法:

课件代码 03-026 · PDF 第 8 页

int a = 10;
a += 3;
a -= 2;

C语言中提供了复合赋值符,方便我们编写代码,这些赋值符有:

课件代码 03-027 · PDF 第 8 页

+= -=
*= /= %=
//下面的操作符后期讲解
>>= <<=
&= |= ^=

3. 单目操作符:++、—、+、-#

前面介绍的操作符都是双目操作符,有2个操作数的。C语言中还有一些操作符只有一个操作数,被称为单目操作符。 ++、—、+(正)、-(负) 就是单目操作符的。

3.1 ++和—#

  • ++是一种自增的操作符,又分为前置++和后置++

🎈 前置++,后置++都是让它的操作数自增1,区别在于表达式的值不同。

  • —是一种自减的操作符,也分为前置—和后置—

🎈 前置—,后置—都是让它的操作数自减1,区别在于表达式的值不同。

3.1.1 前置++#

课件代码 03-028 · PDF 第 9 页

int a = 10;
int b = ++a; //++的操作数是a,是放在a的前面的,就是前置++
printf("a=%d b=%d\n",a , b);

计算口诀:先+1,后使用a原来是10,先+1,后a变成了11,再使用就是赋值给b,b得到的也是11,所以计算技术后,a和b都是11,相当于这样的代码:

课件代码 03-029 · PDF 第 9 页

int a = 10;
a = a+1;
b = a;
printf("a=%d b=%d\n",a , b);

3.1.2 后置++#

课件代码 03-030 · PDF 第 9 页

int a = 10;
int b = a++; //++的操作数是a,是放在a的后面的,就是后置++
printf("a=%d b=%d\n",a , b);

计算口诀:先使用,后+1 a原来是10,先使用,就是先赋值给b,b得到了10,然后再+1,然后a变成了11,所以直接结束后a是11,b是10,相当于这样的代码:

课件代码 03-031 · PDF 第 10 页

int a = 10;
int b = a;
a = a + 1;
printf("a=%d b=%d\n",a , b);

3.1.3 前置—#

如果你听懂了前置++,那前置—是同理的,只是把加1,换成了减1;计算口诀:先-1,后使用

课件代码 03-032 · PDF 第 10 页

int a = 10;
int b = --a; //--的操作数是a,是放在a的前面的,就是前置--
printf("a=%d b=%d\n",a , b);//输出的结果是:9 9

3.1.4 后置—#

同理后置—类似于后置++,只是把加一换成了减一计算口诀:先使用,后-1

课件代码 03-033 · PDF 第 10 页

int a = 10;
int b = a--; //--的操作数是a,是放在a的后面的,就是后置--
printf("a=%d b=%d\n",a , b);//输出的结果是:9 10

3.2 + 和 -#

这里的+是正号,-是负号,都是单目操作符。

运算符 + 对正负值没有影响,是一个完全可以省略的运算符,但是写了也不会报错。

课件代码 03-034 · PDF 第 11 页

int a = +10; 等价于 int a = 10;

运算符 - 用来改变一个值的正负号,负数的前面加上 - 就会得到正数,正数的前面加上 - 会得到负数。

课件代码 03-035 · PDF 第 11 页

int a = 10;
int b = -a;
int c = -10;
printf("b=%d c=%d\n", b, c);//这里的b和c都是-10
int a = -10;
int b = -a;
printf("b=%d\n", b); //这里的b是10

4. 表达式求值#

学会了上述操作符后,我们使用操作符可以写出一些更加复杂的表达式,比如:

课件代码 03-036 · PDF 第 11 页

3 + 4 * 5;
5 * 6 / 2;

那这些表达式的计算顺序是啥?这里就得了解学习一下操作符的属性。

操作符的属性有:优先级和结合性;这两个属性决定了表达式求值的计算顺序。

4.1 操作符的属性#

第3章第12页配图
第3章第12页配图

操作符属性:https://zh.cppreference.com/w/c/language/operator\_precedence

4.1.1 优先级#

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

课件代码 03-037 · PDF 第 13 页

3 + 4 * 5;

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

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

  • 圆括号( () )

  • 自增运算符( ++ ),自减运算符( — )

  • 单目运算符( + 和 - )

  • 乘法( * ),除法( / )

  • 加法( + ),减法( - )

  • 关系运算符( < 、 > 等)

  • 赋值运算符( = )

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

4.1.2 结合性#

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

课件代码 03-038 · PDF 第 13 页

5 * 6 / 2;

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

4.2 类型转换#

在进行表达式求值的时候,有时候会涉及到数据类型的转换,类型转换一般分为:隐式类型转换和显示类型转换。

隐式类型转换,又分为整型提升和常规算术转换,显示类型转换就是强制类型转换了。

隐式类型转换(又称自动类型转换)由编译器自动完成,无需程序员显式写出转换代码。它的目的是使表达式中的操作数类型兼容。

整型提升:表达式中的 char 、 short 等长度小于整型类型的长度,在表达式计算的过程中会被自动提升为整型类型( int 或 unsigned int ),然后参与运算,这里的类型提升就是整型提升。

课件代码 03-039 · PDF 第 14 页

char c = 100;
short s = 2000;
int i = c + s; // c 和 s 都被提升为 int 后再进行加法运算

📌 更精确地说(C11 §6.3.1.1):

  1. 参与运算的类型:char、signed char、unsigned char、short、unsigned short、int 位

段、枚举类型

  1. 判定条件:若 int 的取值范围能覆盖原类型的所有值 → 提升为 int;否则 → 提升为

unsigned int

  1. 提升后的类型:始终是 int 或 unsigned int(不会提升为 long 等更大的类型)

  2. 保留值不变:提升后的值与原值相等

常规算术转换:变量的数据类型的长度是大于等于整型类型的长度时,如果某个操作符的各个操作数属于不同的类型,那么除非其中一个操作数的转换为另一个操作数的类型,否则操作就无法进行。

课件代码 03-040 · PDF 第 14 页

int n = 10;
float f = 5.5f;
float r = n + f; //n会转换为float类型,再和f进行加法运算

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

课件代码 03-041 · PDF 第 15 页

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

强制类型转换:C语言的隐式类型转换都是按照既定的规则来转换的,但是有时候我们需要更大程序上控制类型的转换,所以就提供了强制类型转换。

形式如下:

课件代码 03-042 · PDF 第 15 页

(类型)表达式

代码样例:

课件代码 03-043 · PDF 第 15 页

#include <stdio.h>
int main()
{
int n = 3.14; //有警告
int m = (int)3.14;//将3.14强制类型转换为int类型
int a = 5;
int b = 2;
float c = (float)a / b; //这里如果不强制类型转换就是整数除法的
printf("%d\n", c);
return 0;
}

4.3 问题表达式#

C语言中没有规定子表达式的计算顺序,如果一个表达式比较复杂,包含了多个子表达式,那么子表达式的计算顺序不确定的情况下就会影响表达式的求值结果。比如:

课件代码 03-044 · PDF 第 15 页

(a + b) * (c - d)

这个表达式无法确定 a + b 和 c - d 谁先计算。大部分情况下, a + b 和 c - d 谁先算不影响结果。但是如果子表达式中改变了某个操作数的值的时候,产生的值可能就不一致了。

比如:

课件代码 03-045 · PDF 第 16 页

a = 10;
c = (b = a + 3) - (a = 5); //结果是未定义的

如果先执行 b = a+3 ,则 c = 8 ,如果先执行 a=5 ,则 c = 3 。这类包含了子表达式的表达式,子表达式的计算顺序就可能引发一些未定义行为,这就是问题表达式。

1. 问题表达式1#

课件代码 03-046 · PDF 第 16 页

#include <stdio.h>
int main()
{
int i = 1;
int r = (++i) + (++i) + (++i);
printf("%d\n", r);
return 0;
}

这段代码在不同的编译器上算的结果是不一样的,这就是问题表达式。为什么呢?

第3章第16页配图
第3章第16页配图

第3章第16页配图
第3章第16页配图

VS2026结果 gcc结果

2. 问题表达式2#

课件代码 03-047 · PDF 第 17 页

#include <stdio.h>
int main()
{
int i = 10;
i = i-- - --i * ( i = -3 ) * i++ + ++i;
printf("i = %d\n", i);
return 0;
}

这段代码来自《C和指针》这本书,书的作者测试了下面这么多的编译器,程序运行结果各不相同。

第3章第17页配图
第3章第17页配图

所以我们以后在编写表达式的时候,尽量简化表达式,让表达式能够有唯一的计算路径,这样的代码才是可靠的。

5. AI加餐课#

3.提示词工程

课件中的参考链接#

支持与分享

如果这篇文章对你有帮助,欢迎分享给更多人或打赏支持!

打赏
C语言初阶 03:常见操作符与表达式求值
https://16888000.xyz/posts/c-beginner-03-expressions/
作者
小螺号
发布于
2026-11-14
许可协议
CC BY-NC-SA 4.0
Profile Image of the Author
小螺号
Hello, I'm LittleTrumpet.
公告
欢迎来到我的博客!这是一则示例公告。
分类
标签
最新动态
站点统计
文章
26
分类
4
标签
34
总字数
100,664
运行时长
0 天
最后活动
0 天前
站点信息
构建平台
Cloudflare Workers
博客版本
Firefly v6.16.8
文章许可
CC BY-NC-SA 4.0
文章目录