社区
学无止境
学习打卡
帖子详情
码银
Python领域新星创作者
2023-02-21 14:54:39
1.C语言中的语句可分为5类,即控制语句 空语句 复合语句 表达式语句 。 2.putchar函数的作用是 向终端输出一个字符 。
...全文
44
回复
打赏
收藏
1.C语言中的语句可分为5类,即控制语句 空语句 复合语句 表达式语句 。 2.putchar函数的作用是 向终端输出一个字符 。
复制链接
扫一扫
分享
转发到动态
举报
写回复
配置赞助广告
用AI写文章
回复
切换为时间正序
请发表友善的回复…
发表回复
打赏红包
C
语言
程序设计-C
语言
的基本
语句
.pptx
C
语言
的基本
语句
2 C
语言
的基本
语句
表达式
语句
的一般形式为:
表达式
; 即在任何一个
表达式
的后面添加一个分号就构成
表达式
语句
。 最常见的
表达式
语句
是由赋值
表达式
构成的赋值
表达式
语句
,简称赋值
语句
。例如: z=x+y 是
表达式
z=x+y;是赋值
语句
2-1
表达式
语句
只有一个分号的
语句
是空
语句
。空
语句
的存在只是出于语法上的需要,在某些必需的场合占据一个
语句
的位置。在程序
中
空
语句
经常被用作循环体。 2-2 空
语句
程序
中
用大括号对括起来的若干
语句
称为
复合
语句
。
复合
语句
的一般形式为: { 说明
语句
; 可执行
语句
; }
复合
语句
在语法上相当于一个
语句
。当单一
语句
位置上的功能必须用多个
语句
才能实现时就需要使用
复合
语句
。 2-3
复合
语句
函数
调用
语句
其实也是一种
表达式
语句
。在一个
函数
的后面添加一个分号就构成了一个
函数
调用
语句
。 如: printf("input(a,f,b):"); scanf("%d,%f,%d",&a,&f,&b); c=getchar();
putchar
(ch); 2-4
函数
调用
语句
流程
控制
语句
主要是对程序的走向起
控制
作用
。一般来说,程序的执行不可能都是顺
C
语言
程序设计标准教程
比较详实 第三章: C
语言
程序设计初步 C
语言
程序设计 本课介绍C
语言
程序设计的基本方法和基本的程序
语句
。 从程序流程的角度来看,程序可以
分为
三种基本结构, 即顺序结构、分支结构、循环结构。 这三种基本结构可以组成所有的各种复杂程序。C
语言
提供了多种
语句
来实现这些程序结构。 本章介绍这些基本
语句
及其应用,使读者对C程序有一个初步的认识, 为后面各章的学习打下基础。 C程序的
语句
C程序的执行部分是由
语句
组成的。 程序的功能也是由执行
语句
实现的。 C
语句
可
分为
以下五类: 1.
表达式
语句
2.
函数
调用
语句
3.
控制
语句
4.
复合
语句
5.空
语句
1.
表达式
语句
表达式
语句
由
表达式
加上分号“;”组成。其一般形式为:
表达式
; 执行
表达式
语句
就是计算
表达式
的值。例如: x=y+z; 赋值
语句
y+z; 加法运算
语句
,但计算结果不能保留,无实际意义i++; 自增1
语句
,i值增1 2.
函数
调用
语句
由
函数
名、实际参数加上分号“;”组成。其一般形式为:
函数
名(实际参数表); 执行
函数
语句
就是调用
函数
体并把实际参数赋予
函数
定义
中
的形式参数,然后执行被调
函数
体
中
的
语句
,求取
函数
值。(在第五章
函数
中
再详细介绍)例如printf("C Program");调用库
函数
,
输出
字符
串。 3.
控制
语句
控制
语句
用于
控制
程序的流程, 以实现程序的各种结构方式。 它们由特定的
语句
定义符组成。C
语言
有九种
控制
语句
。 可分成以下三类: (1) 条件判断
语句
if
语句
,switch
语句
(2) 循环执行
语句
do while
语句
,while
语句
,for
语句
(3) 转向
语句
break
语句
,goto
语句
,continue
语句
,return
语句
4.
复合
语句
把多个
语句
用括号{}括起来组成的一个
语句
称
复合
语句
。 在程序
中
应把
复合
语句
看成是单条
语句
,而不是多条
语句
,例如 { x=y+z; a=b+c; printf(“%d%d”,x,a); } 是一条
复合
语句
。
复合
语句
内的各条
语句
都必须以分号“;”结尾,在括号“}”外不能加分号。 5.空
语句
只有分号“;”组成的
语句
称为空
语句
。 空
语句
是什么也不执行的
语句
。在程序
中
空
语句
可用来作空循环体。例如 while(getchar()!='\n'); 本
语句
的功能是,只要从键盘输入的
字符
不是回车则重新输入。这里的循环体为空
语句
。 赋值
语句
赋值
语句
是由赋值
表达式
再加上分号构成的
表达式
语句
。 其一般形式为: 变量=
表达式
; 赋值
语句
的功能和特点都与赋值
表达式
相同。 它是程序
中
使用最多的
语句
之一。 在赋值
语句
的使用
中
需要注意以下几点: 1.由于在赋值符“=”右边的
表达式
也可以又是一个赋值
表达式
,因此,下述形式 变量=(变量=
表达式
); 是成立的,从而形成嵌套的情形。其展开之后的一般形式为: 变量=变量=…=
表达式
; 例如: a=b=c=d=e=5;按照赋值运算符的右接合性,因此实际上等效于: e=5; d=e; c=d; b=c; a=b; 2.注意在变量说明
中
给变量赋初值和赋值
语句
的区别。给变量赋初值是变量说明的一部分,赋初值后的变量与其后的其它同类变量之间仍必须用逗号间隔,而赋值
语句
则必须用分号结尾。 3.在变量说明
中
,不允许连续给多个变量赋初值。 如下述说明是错误的: int a=b=c=5 必须写为 int a=5,b=5,c=5; 而赋值
语句
允许连续赋值 4.注意赋值
表达式
和赋值
语句
的区别。赋值
表达式
是一种
表达式
,它可以出现在任何允许
表达式
出现的地方,而赋值
语句
则不能。 下述
语句
是合法的: if((x=y+5)>0) z=x;
语句
的功能是,若
表达式
x=y+5大于0则z=x。下述
语句
是非法的: if((x=y+5;)>0) z=x; 因为=y+5;是
语句
,不能出现在
表达式
中
。 数据
输出
语句
本小节介绍的是向标准
输出
设备显示器
输出
数据的
语句
。在C
语言
中
,所有的数据输入/
输出
都是由库
函数
完成的。 因此都是
函数
语句
。本小节先介绍printf
函数
和
putchar
函数
。printf
函数
printf
函数
称为格式
输出
函数
,其关键字最末一个字母f即为“格式”(format)之意。其功能是按用户指定的格式, 把指定的数据显示到显示器屏幕上。在前面的例题
中
我们已多次使用过这个
函数
。 一、printf
函数
调用的一般形式 printf
函数
是一个标准库
函数
,它的
函数
原型在头文件“stdio.h”
中
。但作为一个特例,不要求在使用 printf
函数
之前必须包含stdio.h文件。printf
函数
调用的一般形式为: printf(“格式
控制
字符
串”,
输出
表列)其
中
格式
控制
字符
串用于指定
输出
格式。 格式
控制
串可由格式
字符
串和非格式
字符
串两种组成。格式
字符
串是以%开头的
字符
串,在%后面跟有各种格式
字符
,以说明
输出
数据的类型、形式、长度、小数位数等。如“%d”表示按十进制整型
输出
,“%ld”表示按十进制长整型
输出
,“%c”表示按
字符
型
输出
等。后面将专门给予讨论。 非格式
字符
串在
输出
时原样照印,在显示
中
起提示
作用
。
输出
表列
中
给出了各个
输出
项, 要求格式
字符
串和各
输出
项在数量和类型上应该一一对应。 void main() { int a=88,b=89; printf("%d %d\n",a,b); printf("%d,%d\n",a,b); printf("%c,%c\n",a,b); printf("a=%d,b=%d",a,b); } a<--8,b<--89 printf("%d %d\n",a,b); printf("%d,%d\n",a,b); printf("%c,%c\n",a,b); printf("a=%d,b=%d",a,b); 本例
中
四次
输出
了a,b的值,但由于格式
控制
串不同,
输出
的结果也不相同。第四行的
输出
语句
格式
控制
串
中
,两格式串%d 之间加了一个空格(非格式
字符
),所以
输出
的a,b值之间有一个空格。第五行的printf
语句
格式
控制
串
中
加入的是非格式
字符
逗号, 因此
输出
的a,b值之间加了一个逗号。第六行的格式串要求按
字符
型
输出
a,b值。第七行
中
为了提示
输出
结果又增加了非格式
字符
串。 二、格式
字符
串 在Turbo C
中
格式
字符
串的一般形式为: [标志][
输出
最小宽度][.精度][长度]类型 其
中
方括号[]
中
的项为可选项。各项的意义介绍如下: 1.类型类型
字符
用以表示
输出
数据的类型,其格式符和意义下表所示: 表示
输出
类型的格式
字符
格式
字符
意义 d 以十进制形式
输出
带符号整数(正数不
输出
符号) o 以八进制形式
输出
无符号整数(不
输出
前缀O) x 以十六进制形式
输出
无符号整数(不
输出
前缀OX) u 以十进制形式
输出
无符号整数 f 以小数形式
输出
单、双精度实数 e 以指数形式
输出
单、双精度实数 g 以%f%e
中
较短的
输出
宽度
输出
单、双精度实数 c
输出
单个
字符
s
输出
字符
串 2.标志 标志
字符
为-、+、#、空格四种,其意义下表所示: 标志格式
字符
标 志 意 义 - 结果左对齐,右边填空格 +
输出
符号(正号或负号)空格
输出
值为正时冠以空格,为负时冠以负号 # 对c,s,d,u类无影响;对o类, 在
输出
时加前 缀o 对x类,在
输出
时加前缀0x;对e,g,f 类当结果有小数时才给出小数点 3.
输出
最小宽度 用十进制整数来表示
输出
的最少位数。 若实际位数多于定义的宽度,则按实际位数
输出
, 若实际位数少于定义的宽度则补以空格或0。 4.精度 精度格式符以“.”开头,后跟十进制整数。本项的意义是:如果
输出
数字,则表示小数的位数;如果
输出
的是
字符
, 则表示
输出
字符
的个数;若实际位数大于所定义的精度数,则截去超过的部分。 5.长度 长度格式符为h,l两种,h表示按短整型量
输出
,l表示按长整型量
输出
。 void main(){ int a=15; float b=138.3576278; double c=35648256.3645687; char d='p'; printf("a=%d,%5d,%o,%x\n",a,a,a,a); printf("b=%f,%lf,%5.4lf,%e\n",b,b,b,b); printf("c=%lf,%f,%8.4lf\n",c,c,c); printf("d=%c,%8c\n",d,d); } a<--15 b<--138.3576278 c<--35648256.3645687 d<--'p' main() { int a=29; float b=1243.2341; double c=24212345.24232; char d='h'; printf("a=%d,%5d,%o,%x\n",a,a,a,a); printf("b=%f,%lf,%5.4lf,%e\n",b,b,b,b); printf("c=%lf,%f,%8.4lf\n",c,c,c); printf("d=%c,%8c\n",d,d); } 本例第七行
中
以四种格式
输出
整型变量a的值,其
中
“%5d ”要求
输出
宽度为5,而a值为15只有两位故补三个空格。 第八行
中
以四种格式
输出
实型量b的值。其
中
“%f”和“%lf ”格式的
输出
相同,说明“l”符对“f”类型无影响。“%5.4lf”指定
输出
宽度为5,精度为4,由于实际长度超过5故应该按实际位数
输出
,小数位数超过4位部分被截去。第九行
输出
双精度实数,“%8.4lf ”由于指定精度为4位故截去了超过4位的部分。第十行
输出
字符
量d,其
中
“%bc ”指定
输出
宽度为8故在
输出
字符
p之前补加7个空格。 使用printf
函数
时还要注意一个问题, 那就是
输出
表列
中
的求值顺序。不同的编译系统不一定相同,可以从左到右, 也可从右到左。Turbo C是按从右到左进行的。如把例2.13改写如下述形式: void main(){ int i=8; printf("%d\n%d\n%d\n%d\n%d\n%d\n",++i,--i,i--,i++,-i--); } i<--8 这个程序与例2.13相比只是把多个printf
语句
改一个printf
语句
输出
。但从结果可以看出是不同的。为什么结果会不同呢?就是因为printf
函数
对
输出
表
中
各量求值的顺序是自右至左进行 的。在式
中
,先对最后一项“-i--”求值,结果为-8,然后i自减1后为7。 再对“-i++”项求值得-7,然后i自增1后为8。再对“i--”项求值得8,然后i再自减1后为7。再求“i++”项得7,然后I再自增1后为8。 再求“--i”项,i先自减1后
输出
,
输出
值为7。 最后才求
输出
表列
中
的第一项“++i”,此时i自增1后
输出
8。但是必须注意, 求值顺序虽是自右至左,但是
输出
顺序还是从左至右, 因此得到的结果是上述
输出
结果。
字符
输出
函数
putchar
函数
putchar
函数
是
字符
输出
函数
, 其功能是在显示器上
输出
单个
字符
。其一般形式为:
putchar
(
字符
变量) 例如:
putchar
('A');
输出
大写字母A
putchar
(x);
输出
字符
变量x的值
putchar
('\n'); 换行 对
控制
字符
则执行
控制
功能,不在屏幕上显示。 使用本
函数
前必须要用文件包含命令: #include
void main(){ char a='B',b='o',c='k';
putchar
(a);
putchar
(b);
putchar
(b);
putchar
(c);
putchar
('\t');
putchar
(a);
putchar
(b);
putchar
('\n');
putchar
(b);
putchar
(c); } 数据输入
语句
C
语言
的数据输入也是由
函数
语句
完成的。 本节介绍从标准输入设备—键盘上输入数据的
函数
scanf和getchar。 scanf
函数
scanf
函数
称为格式输入
函数
,即按用户指定的格式从键盘上把数据输入到指定的变量之
中
。 一、scanf
函数
的一般形式 scanf
函数
是一个标准库
函数
,它的
函数
原型在头文件“stdio.h”
中
,与printf
函数
相同,C
语言
也允许在使用scanf
函数
之前不必包含stdio.h文件。scanf
函数
的一般形式为: scanf(“格式
控制
字符
串”,地址表列); 其
中
,格式
控制
字符
串的
作用
与printf
函数
相同,但不能显示非格式
字符
串, 也就是不能显示提示
字符
串。地址表列
中
给出各变量的地址。 地址是由地址运算符“&”后跟变量名组成的。例如,&a,&b分别表示变量a和变量b 的地址。这个地址就是编译系统在内存
中
给a,b变量分配的地址。在C
语言
中
,使用了地址这个概念,这是与其它
语言
不同的。 应该把变量的值和变量的地址这两个不同的概念区别开来。变量的地址是C编译系统分配的,用户不必关心具体的地址是多少。 变量的地址和变量值的关系如下: &a--->a567 a为变量名,567是变量的值,&a是变量a的地址。在赋值
表达式
中
给变量赋值,如: a=567 在赋值号左边是变量名,不能写地址,而scanf
函数
在本质上也是给变量赋值,但要求写变量的地址,如&a。 这两者在形式上是不同的。&是一个取地址运算符,&a是一个
表达式
,其功能是求变量的地址。 void main(){ int a,b,c; printf("input a,b,c\n"); scanf("%d%d%d",&a,&b,&c); printf("a=%d,b=%d,c=%d",a,b,c); } 注意&的用法! 在本例
中
,由于scanf
函数
本身不能显示提示串,故先用printf
语句
在屏幕上
输出
提示,请用户输入a、b、c的值。执行scanf
语句
,则退出TC屏幕进入用户屏幕等待用户输入。用户输入7、8、9后按下回车键,此时,系统又将返回TC屏幕。在scanf
语句
的格式串
中
由于没有非格式
字符
在“%d%d%d”之间作输入时的间隔, 因此在输入时要用一个以上的空格或回车键作为每两个输入数之间的间隔。 如: 7 8 9 或 7 8 9 格式
字符
串 格式
字符
串的一般形式为: %[*][输入数据宽度][长度]类型 其
中
有方括号[]的项为任选项。各项的意义如下: 1.类型 表示输入数据的类型,其格式符和意义下表所示。 格式
字符
意义 d 输入十进制整数 o 输入八进制整数 x 输入十六进制整数 u 输入无符号十进制整数 f或e 输入实型数(用小数形式或指数形式) c 输入单个
字符
s 输入
字符
串 2.“*”符 用以表示该输入项读入后不赋予相应的变量,即跳过该输入值。 如 scanf("%d %*d %d",&a,&b);当输入为:1 2 3 时,把1赋予a,2被跳过,3赋予b。 3.宽度 用十进制整数指定输入的宽度(即
字符
数)。例如: scanf("%5d",&a); 输入: 12345678 只把12345赋予变量a,其余部分被截去。又如: scanf("%4d%4d",&a,&b); 输入: 12345678将把1234赋予a,而把5678赋予b。 4.长度 长度格式符为l和h,l表示输入长整型数据(如%ld) 和双精度浮点数(如%lf)。h表示输入短整型数据。 使用scanf
函数
还必须注意以下几点: a. scanf
函数
中
没有精度
控制
,如: scanf("%5.2f",&a); 是非法的。不能企图用此
语句
输入小数为2位的实数。 b. scanf
中
要求给出变量地址,如给出变量名则会出错。如 scanf("%d",a);是非法的,应改为scnaf("%d",&a);才是合法的。 c. 在输入多个数值数据时,若格式
控制
串
中
没有非格式
字符
作输入数据之间的间隔则可用空格,TAB或回车作间隔。C编译在碰到空格,TAB,回车或非法数据(如对“%d”输入“12A”时,A即为非法数据)时即认为该数据结束。 d. 在输入
字符
数据时,若格式
控制
串
中
无非格式
字符
,则认为所有输入的
字符
均为有效
字符
。例如: scanf("%c%c%c",&a,&b,&c); 输入为: d e f 则把'd'赋予a, 'f'赋予b,'e'赋予c。只有当输入为: def 时,才能把'd'赋于a,'e'赋予b,'f'赋予c。 如果在格式
控制
中
加入空格作为间隔,如 scanf ("%c %c %c",&a,&b,&c);则输入时各数据之间可加空格。 void main(){ char a,b; printf("input character a,b\n"); scanf("%c%c",&a,&b); printf("%c%c\n",a,b); } scanf("'C14F14%c%c",&a,&b); printf("%c%c\n",a,b); 由于scanf
函数
"%c%c"
中
没有空格,输入M N,结果
输出
只有M。 而输入改为MN时则可
输出
MN两
字符
,见下面的输入运行情况: input character a,b MN MN void main(){ char a,b; printf("input character a,b\n"); scanf("%c %c",&a,&b); printf("\n%c%c\n",a,b); } scanf("%c %c",&a,&b); 本例表示scanf格式
控制
串"%c %c"之间有空格时, 输入的数据之间可以有空格间隔。e. 如果格式
控制
串
中
有非格式
字符
则输入时也要输入该非格式
字符
。 例如: scanf("%d,%d,%d",&a,&b,&c); 其
中
用非格式符“ , ”作间隔符,故输入时应为: 5,6,7 又如: scanf("a=%d,b=%d,c=%d",&a,&b,&c); 则输入应为 a=5,b=6,c=7g. 如输入的数据与
输出
的类型不一致时,虽然编译能够通过,但结果将不正确。 void main(){ int a; printf("input a number\n"); scanf("%d",&a); printf("%ld",a); } 由于输入数据类型为整型, 而
输出
语句
的格式串
中
说明为长整型,因此
输出
结果和输入数据不符。如改动程序如下: void main(){ long a; printf("input a long integer\n"); scanf("%ld",&a); printf("%ld",a); } 运行结果为: input a long integer 1234567890 1234567890 当输入数据改为长整型后,输入
输出
数据相等。 键盘输入
函数
getchar
函数
getchar
函数
的功能是从键盘上输入一个
字符
。其一般形式为: getchar(); 通常把输入的
字符
赋予一个
字符
变量,构成赋值
语句
,如: char c; c=getchar(); #include
void main(){ char c; printf("input a character\n"); c=getchar();
putchar
(c); } 使用getchar
函数
还应注意几个问题: 1.getchar
函数
只能接受单个
字符
,输入数字也按
字符
处理。输入多于一个
字符
时,只接收第一个
字符
。 2.使用本
函数
前必须包含文件“stdio.h”。 3.在TC屏幕下运行含本
函数
程序时,将退出TC 屏幕进入用户屏幕等待用户输入。输入完毕再返回TC屏幕。 void main(){ char a,b,c; printf("input character a,b,c\n"); scanf("%c %c %c",&a,&b,&c); printf("%d,%d,%d\n%c,%c,%c\n",a,b,c,a-32,b-32,c-32); } 输入三个小写字母
输出
其ASCII码和对应的大写字母。 void main(){ int a; long b; float f; double d; char c; printf("%d,%d,%d,%d,%d",sizeof(a),sizeof(b),sizeof(f) ,sizeof(d),sizeof(c)); }
输出
各种数据类型的字节长度。 分支结构程序 关系运算符和
表达式
在程序
中
经常需要比较两个量的大小关系, 以决定程序下一步的工作。比较两个量的运算符称为关系运算符。 在C
语言
中
有以下关系运算符: < 小于 <= 小于或等于 > 大于 >= 大于或等于 == 等于 != 不等于 关系运算符都是双目运算符,其结合性均为左结合。 关系运算符的优先级低于算术运算符,高于赋值运算符。 在六个关系运算符
中
,<,<=,>,>=的优先级相同,高于==和!=,==和!=的优先级相同。 关系
表达式
关系
表达式
的一般形式为:
表达式
关系运算符
表达式
例如:a+b>c-d,x>3/2,'a'+1
表达式。由于
表达式
也可以又是关系
表达式
。 因此也允许出现嵌套的情况,例如:a>(b>c),a!=(c==d)等。关系
表达式
的值是“真”和“假”,用“1”和“0”表示。 如: 5>0的值为“真”,即为1。(a=3)>(b=5)由于3>5不成立,故其值为假,即为0。 void main(){ char c='k'; int i=1,j=2,k=3; float x=3e+5,y=0.85; printf("%d,%d\n",'a'+5
=k+1); printf("%d,%d\n",1
=k+1); printf("%d,%d\n",1
中求出了各种关系运算符的值。
字符
变量是以它对应的ASCII码参与运算的。对于含多个关系运算符的
表达式
,如k==j==i+5,根据运算符的左结合性,先计算k==j,该式不成立,其值为0,再计算0==i+5,也不成立,故
表达式
值为0。 逻辑运算符和
表达式
逻辑运算符C
语言
中
提供了三种逻辑运算符 && 与运算 || 或运算 ! 非运算 与运算符&&和或运算符||均为双目运算符。具有左结合性。 非 运算符!为单目运算符,具有右结合性。逻辑运算符和其它运算符优先级的关系可表示如下: 按照运算符的优先顺序可以得出: a>b && c>d等价于(a>b) && (c>d) !b==c||d
c && x+y
c) && ((x+y)
0 && 4>2,由于5>0为真,4>2也为真,相与的结果也为真。 2.或运算||参与运算的两个量只要有一个为真,结果就为真。 两个量都为假时,结果为假。例如:5>0||5>8,由于5>0为真,相或的结果也就为真 3.非运算!参与运算量为真时,结果为假;参与运算量为假时,结果为真。 例如:!(5>0)的结果为假。 虽然C编译在给出逻辑运算值时,以“1”代表“真”,“0 ”代表“假”。 但反过来在判断一个量是为“真”还是为“假”时,以“0”代表“假”,以非“0”的数值作为“真”。例如:由于5和3均为非“0”因此5&&3的值为“真”,即为1。 又如:5||0的值为“真”,即为1。 逻辑
表达式
逻辑
表达式
的一般形式为:
表达式
逻辑运算符
表达式
其
中
的
表达式
可以又是逻辑
表达式
,从而组成了嵌套的情形。例如:(a&&b)&&c根据逻辑运算符的左结合性,上式也可写为: a&&b&&c 逻辑
表达式
的值是式
中
各种逻辑运算的最后值,以“1”和“0”分别代表“真”和“假”。 void main(){ char c='k'; int i=1,j=2,k=3; float x=3e+5,y=0.85; printf("%d,%d\n",!x*!y,!!!x); printf("%d,%d\n",x||i&&j-3,i
中!x和!y分别为0,!x*!y也为0,故其
输出
值为0。由于x为非0,故!!!x的逻辑值为0。对x|| i && j-3式,先计算j-3的值为非0,再求i && j-3的逻辑值为1,故x||i&&j-3的逻辑值为 1。对i
表达式的值为1,0相与,最后为0,对i==5&&c&&(j=8)式,由于i==5为假,即值为0, 该
表达式
由两个与运算组成,所以整个
表达式
的值为0。对于式x+ y||i+j+k 由于x+y的值为非0,故整个或
表达式
的值为1。 if
语句
用if
语句
可以构成分支结构。它根据给定的条件进行判断, 以决定执行某个分支程序段。C
语言
的if
语句
有三种基本形式。 1.第一种形式为基本形式 if(
表达式
)
语句
; 其语义是:如果
表达式
的值为真,则执行其后的
语句
, 否则不执行该
语句
。其过程可表示为下图 void main(){ int a,b,max; printf("\n input two numbers: "); scanf("%d%d",&a,&b); max=a; if (max
输出其
中
的大数。 scanf("%d%d",&a,&b); max=a; if (max
中,输入两个数a,b。把a先赋予变量max,再用if
语句
判别max和b的大小,如max小于b,则把b赋予max。因此max
中
总是大数,最后
输出
max的值。 2.第二种形式为if-else形式 if(
表达式
)
语句
1; else
语句
2; 其语义是:如果
表达式
的值为真,则执行
语句
1,否则执行
语句
2 。 void main(){ int a, b; printf("input two numbers: "); scanf("%d%d",&a,&b); if(a>b) printf("max=%d\n",a); else printf("max=%d\n",b); } 输入两个整数,
输出
其
中
的大数。改用if-else
语句
判别a,b的大小,若a大,则
输出
a,否则
输出
b。 3.第三种形式为if-else-if形式 前二种形式的if
语句
一般都用于两个分支的情况。 当有多个分支选择时,可采用if-else-if
语句
,其一般形式为: if(
表达式
1)
语句
1; else if(
表达式
2)
语句
2; else if(
表达式
3)
语句
3; … else if(
表达式
m)
语句
m; else
语句
n; 其语义是:依次判断
表达式
的值,当出现某个值为真时, 则执行其对应的
语句
。然后跳到整个if
语句
之外继续执行程序。 如果所有的
表达式
均为假,则执行
语句
n 。 然后继续执行后续程序。 if-else-if
语句
的执行过程如图3—3所示。 #include"stdio.h" void main(){ char c; printf("input a character: "); c=getchar(); if(c<32) printf("This is a control character\n"); else if(c>='0'&&c<='9') printf("This is a digit\n"); else if(c>='A'&&c<='Z') printf("This is a capital letter\n"); else if(c>='a'&&c<='z') printf("This is a small letter\n"); else printf("This is an other character\n"); } 本例要求判别键盘输入
字符
的类别。可以根据输入
字符
的ASCII码来判别类型。由ASCII码表可知ASCII值小于32的为
控制
字符
。 在“0”和“9”之间的为数字,在“A”和“Z”之间为大写字母, 在“a”和“z”之间为小写字母,其余则为其它
字符
。 这是一个多分支选择的问题,用if-else-if
语句
编程,判断输入
字符
ASCII码所在的范围,分别给出不同的
输出
。例如输入为“g”,
输出
显示它为小写
字符
。 4.在使用if
语句
中
还应注意以下问题 (1) 在三种形式的if
语句
中
,在if关键字之后均为
表达式
。 该
表达式
通常是逻辑
表达式
或关系
表达式
, 但也可以是其它
表达式
,如赋值
表达式
等,甚至也可以是一个变量。例如: if(a=5)
语句
;if(b)
语句
; 都是允许的。只要
表达式
的值为非0,即为“真”。如在if(a=5)…;
中
表达式
的值永远为非0,所以其后的
语句
总是要执行的,当然这种情况在程序
中
不一定会出现,但在语法上是合法的。 又如,有程序段: if(a=b) printf("%d",a); else printf("a=0"); 本
语句
的语义是,把b值赋予a,如为非0则
输出
该值,否则
输出
“a=0”
字符
串。这种用法在程序
中
是经常出现的。 (2) 在if
语句
中
,条件判断
表达式
必须用括号括起来, 在
语句
之后必须加分号。 (3) 在if
语句
的三种形式
中
,所有的
语句
应为单个
语句
,如果要想在满足条件时执行一组(多个)
语句
,则必须把这一组
语句
用{} 括起来组成一个
复合
语句
。但要注意的是在}之后不能再加分号。 例如: if(a>b){ a++; b++; } else{ a=0; b=10; } if
语句
的嵌套 当if
语句
中
的执行
语句
又是if
语句
时,则构成了if
语句
嵌套的情形。其一般形式可表示如下: if(
表达式
) if
语句
; 或者为 if(
表达式
) if
语句
; else if
语句
; 在嵌套内的if
语句
可能又是if-else型的,这将会出现多个if和多个else重叠的情况,这时要特别注意if和else的配对问题。例如: if(
表达式
1) if(
表达式
2)
语句
1; else
语句
2; 其
中
的else究竟是与哪一个if配对呢? 应该理解为: 还是应理解为: if(
表达式
1) if(
表达式
1) if(
表达式
2) if(
表达式
2)
语句
1;
语句
1; else else
语句
2;
语句
2; 为了避免这种二义性,C
语言
规定,else 总是与它前面最近的if配对,因此对上述例子应按前一种情况理解。 比较两个数的大小关系。 void main(){ int a,b; printf("please input A,B: "); scanf("%d%d",&a,&b); if(a!=b) if(a>b) printf("A>B\n"); else printf("A
中用了if
语句
的嵌套结构。 采用嵌套结构实质上是为了进行多分支选择,例3.16实际上有三种选择即A>B、A
语句也可以完成。而且程序更加清晰。因此, 在一般情况下较少使用if
语句
的嵌套结构。 以使程序更便于阅读理解。 void main(){ int a,b; printf("please input A,B: "); scanf("%d%d",&a,&b); if(a==b) printf("A=B\n"); else if(a>b) printf("A>B\n"); else printf("A
表达式 如果在条件
语句
中
,只执行单个的赋值
语句
时, 常可使用条件
表达式
来实现。不但使程序简洁,也提高了运行效率。 条件运算符为?和:,它是一个三目运算符,即有三个参与运算的量。由条件运算符组成条件
表达式
的一般形式为:
表达式
1?
表达式
2:
表达式
3 其求值规则为:如果
表达式
1的值为真,则以
表达式
2 的值作为条件
表达式
的值,否则以
表达式
2的值作为整个条件
表达式
的值。 条件
表达式
通常用于赋值
语句
之
中
。 例如条件
语句
: if(a>b) max=a; else max=b; 可用条件
表达式
写为 max=(a>b)?a:b; 执行该
语句
的语义是:如a>b为真,则把a赋予max,否则把b 赋予max。 使用条件
表达式
时,还应注意以下几点: 1. 条件运算符的运算优先级低于关系运算符和算术运算符,但高于赋值符。因此 max=(a>b)?a:b可以去掉括号而写为 max=a>b?a:b 2. 条件运算符?和:是一对运算符,不能分开单独使用。 3. 条件运算符的结合方向是自右至左。 例如: a>b?a:c>d?c:d应理解为 a>b?a:(c>d?c:d) 这也就是条件
表达式
嵌套的情形,即其
中
的
表达式
3又是一个条 件
表达式
。 void main(){ int a,b,max; printf("\n input two numbers: "); scanf("%d%d",&a,&b); printf("max=%d",a>b?a:b); } 用条件
表达式
对上例重新编程,
输出
两个数
中
的大数。 switch
语句
C
语言
还提供了另一种用于多分支选择的switch
语句
, 其一般形式为: switch(
表达式
){ case常量
表达式
1:
语句
1; case常量
表达式
2:
语句
2; … case常量
表达式
n:
语句
n; default :
语句
n+1; } 其语义是:计算
表达式
的值。 并逐个与其后的常量
表达式
值相比较,当
表达式
的值与某个常量
表达式
的值相等时, 即执行其后的
语句
,然后不再进行判断,继续执行后面所有case后的
语句
。 如
表达式
的值与所有case后的常量
表达式
均不相同时,则执行default后的
语句
。 void main(){ int a; printf("input integer number: "); scanf("%d",&a); switch (a){ case 1:printf("Monday\n"); case 2:printf("Tuesday\n"); case 3:printf("Wednesday\n"); case 4:printf("Thursday\n"); case 5:printf("Friday\n"); case 6:printf("Saturday\n"); case 7:printf("Sunday\n"); default:printf("error\n"); } } 本程序是要求输入一个数字,
输出
一个英文单词。但是当输入3之后,却执行了case3以及以后的所有
语句
,
输出
了Wednesday 及以后的所有单词。这当然是不希望的。为什么会出现这种情况呢?这恰恰反应了switch
语句
的一个特点。在switch
语句
中
,“case 常量
表达式
”只相当于一个
语句
标号,
表达式
的值和某标号相等则转向该标号执行,但不能在执行完该标号的
语句
后自动跳出整个switch
语句
,所以出现了继续执行所有后面case
语句
的情况。 这是与前面介绍的if
语句
完全不同的,应特别注意。为了避免上述情况, C
语言
还提供了一种break
语句
,专用于跳出switch
语句
,break
语句
只有关键字break,没有参数。在后面还将详细介绍。修改例题的程序,在每一case
语句
之后增加break
语句
, 使每一次执行之后均可跳出switch
语句
,从而避免
输出
不应有的结果。 void main(){ int a; printf("input integer number: "); scanf("%d",&a); switch (a){ case 1:printf("Monday\n");break; case 2:printf("Tuesday\n"); break; case 3:printf("Wednesday\n");break; case 4:printf("Thursday\n");break; case 5:printf("Friday\n");break; case 6:printf("Saturday\n");break; case 7:printf("Sunday\n");break; default:printf("error\n"); } } 在使用switch
语句
时还应注意以下几点: 1.在case后的各常量
表达式
的值不能相同,否则会出现错误。 2.在case后,允许有多个
语句
,可以不用{}括起来。 3.各case和default子句的先后顺序可以变动,而不会影响程序执行结果。 4.default子句可以省略不用。程序举例 输入三个整数,
输出
最大数和最小数。 void main(){ int a,b,c,max,min; printf("input three numbers: "); scanf("%d%d%d",&a,&b,&c); if(a>b) {max=a;min=b;} else {max=b;min=a;} if(max
c) min=c; printf("max=%d\nmin=%d",max,min); } 本程序
中
,首先比较输入的a,b的大小,并把大数装入max, 小数装入min
中
,然后再与c比较,若max小于c,则把c赋予max;如果c小于min,则把c赋予min。因此max内总是最大数,而min内总是最小数。最后
输出
max和min的值即可。 计算器程序。用户输入运算数和四则运算符,
输出
计算结果。 void main(){ float a,b,s; char c; printf("input expression: a+(-,*,/)b \n"); scanf("%f%c%f",&a,&c,&b); switch(c){ case '+': printf("%f\n",a+b);break; case '-': printf("%f\n",a-b);break; case '*': printf("%f\n",a*b);break; case '/': printf("%f\n",a/b);break; default: printf("input error\n"); } } 本例可用于四则运算求值。switch
语句
用于判断运算符, 然后
输出
运算值。当输入运算符不是+,-,*,/时给出错误提示。 循环结构程序 循环结构是程序
中
一种很重要的结构。其特点是, 在给定条件成立时,反复执行某程序段,直到条件不成立为止。 给定的条件称为循环条件,反复执行的程序段称为循环体。 C
语言
提供了多种循环
语句
,可以组成各种不同形式的循环结构。 while
语句
while
语句
的一般形式为: while(
表达式
)
语句
; 其
中
表达式
是循环条件,
语句
为循环体。 while
语句
的语义是:计算
表达式
的值,当值为真(非0)时, 执行循环体
语句
。其执行过程可用图3—4表示。 统计从键盘输入一行
字符
的个数。 #include
void main(){ int n=0; printf("input a string:\n"); while(getchar()!='\n') n++; printf("%d",n); } 本例程序
中
的循环条件为getchar()!='\n',其意义是, 只要从键盘输入的
字符
不是回车就继续循环。循环体n++完成对输入
字符
个数计数。从而程序实现了对输入一行
字符
的
字符
个数计数。 使用while
语句
应注意以下几点: 1.while
语句
中
的
表达式
一般是关系表达或逻辑
表达式
,只要
表达式
的值为真(非0)即可继续循环。 void main(){ int a=0,n; printf("\n input n: "); scanf("%d",&n); while (n--) printf("%d ",a++*2); } 本例程序将执行n次循环,每执行一次,n值减1。循环体
输出
表达式
a++*2的值。该
表达式
等效于(a*2;a++) 2.循环体如包括有一个以上的
语句
,则必须用{}括起来, 组成
复合
语句
。 3.应注意循环条件的选择以避免死循环。 void main(){ int a,n=0; while(a=5) printf("%d ",n++); } 本例
中
while
语句
的循环条件为赋值
表达式
a=5, 因此该
表达式
的值永远为真,而循环体
中
又没有其它
中
止循环的手段, 因此该循环将无休止地进行下去,形成死循环。4.允许while
语句
的循环体又是while
语句
,从而形成双重循环。 do-while
语句
do-while
语句
的一般形式为: do
语句
; while(
表达式
); 其
中
语句
是循环体,
表达式
是循环条件。 do-while
语句
的语义是: 先执行循环体
语句
一次, 再判别
表达式
的值,若为真(非0)则继续循环,否则终止循环。 do-while
语句
和while
语句
的区别在于do-while是先执行后判断,因此do-while至少要执行一次循环体。而while是先判断后执行,如果条件不满足,则一次循环体
语句
也不执行。 while
语句
和do-while
语句
一般都可以相互改写。 void main(){ int a=0,n; printf("\n input n: "); scanf("%d",&n); do printf("%d ",a++*2); while (--n); } 在本例
中
,循环条件改为--n,否则将多执行一次循环。这是由于先执行后判断而造成的。 对于do-while
语句
还应注意以下几点: 1.在if
语句
,while
语句
中
,
表达式
后面都不能加分号, 而在 do-while
语句
的
表达式
后面则必须加分号。 2.do-while
语句
也可以组成多重循环,而且也可以和while
语句
相互嵌套。 3.在do和while之间的循环体由多个
语句
组成时,也必须用{}括起来组成一个
复合
语句
。 4.do-while和while
语句
相互替换时,要注意修改循环
控制
条件。 for
语句
for
语句
是C
语言
所提供的功能更强,使用更广泛的一种循环
语句
。其一般形式为: for(
表达式
1;
表达式
2;表达3)
语句
;
表达式
1 通常用来给循环变量赋初值,一般是赋值
表达式
。也允许在for
语句
外给循环变量赋初值,此时可以省略该
表达式
。
表达式
2 通常是循环条件,一般为关系
表达式
或逻辑
表达式
。
表达式
3 通常可用来修改循环变量的值,一般是赋值
语句
。 这三个
表达式
都可以是逗号
表达式
, 即每个
表达式
都可由多个
表达式
组成。三个
表达式
都是任选项,都可以省略。 一般形式
中
的“
语句
”即为循环体
语句
。for
语句
的语义是: 1.首先计算
表达式
1的值。 2.再计算
表达式
2的值,若值为真(非0)则执行循环体一次, 否则跳出循环。 3.然后再计算
表达式
3的值,转回第2步重复执行。在整个for循环过程
中
,
表达式
1只计算一次,
表达式
2和
表达式
,3则可能计算多次。循环体可能多次执行,也可能一次都不执行。for
语句
的执行过程如图所示。 void main(){ int n,s=0; for(n=1;n<=100;n++) s=s+n; printf("s=%d\n",s); } 用for
语句
计算s=1+2+3+...+99+100 int n,s=0; for(n=1;n<=100;n++) s=s+n; printf("s=%d\n",s); 本例for
语句
中
的
表达式
3为n++,实际上也是一种赋值
语句
,相当于n=n+1,以改变循环变量的值。 void main(){ int a=0,n; printf("\n input n: "); scanf("%d",&n); for(;n>0;a++,n--) printf("%d ",a*2); } 用for
语句
修改例题。从0开始,
输出
n个连续的偶数。 int a=0,n; printf("\n input n: "); scanf("%d",&n); for(;n>0;a++,n--) printf("%d ",a*2); 本例的for
语句
中
,
表达式
1已省去,循环变量的初值在for
语句
之前由scanf
语句
取得,
表达式
3是一个逗号
表达式
,由a++,n-- 两个
表达式
组成。每循环一次a自增1,n自减1。a的变化使
输出
的偶数递增,n的变化
控制
循次数。 在使用for
语句
中
要注意以下几点 1.for
语句
中
的各
表达式
都可省略,但分号间隔符不能少。如:for(;
表达式
;
表达式
)省去了
表达式
1。for(
表达式
;;
表达式
)省去了
表达式
2。 for(
表达式
;
表达式
;)省去了
表达式
3。for(;;)省去了全部
表达式
。 2.在循环变量已赋初值时,可省去
表达式
1,如例3.27即属于这种情形。如省去
表达式
2或
表达式
3则将造成无限循环, 这时应在循环体内设法结束循环。例题即属于此情况。 void main(){ int a=0,n; printf("\n input n: "); scanf("%d",&n); for(;n>0;) { a++;n--; printf("%d ",a*2); } } 本例
中
省略了
表达式
1和
表达式
3,由循环体内的n--
语句
进行循环变量n的递减,以
控制
循环次数。 void main(){ int a=0,n; printf("\n input n: "); scanf("%d",&n); for(;;){ a++;n--; printf("%d ",a*2); if(n==0)break; } } 本例
中
for
语句
的
表达式
全部省去。由循环体
中
的
语句
实现循环变量的递减和循环条件的判断。当n值为0时,由break
语句
中
止循环,转去执行for以后的程序。在此情况下,for
语句
已等效于while( 1)
语句
。如在循环体
中
没有相应的
控制
手段,则造成死循环。 3.循环体可以是空
语句
。 #include"stdio.h" void main(){ int n=0; printf("input a string:\n"); for(;getchar()!='\n';n++); printf("%d",n); } 本例
中
,省去了for
语句
的
表达式
1,
表达式
3也不是用来修改循环变量,而是用作输入
字符
的计数。这样, 就把本应在循环体
中
完成的计数放在
表达式
中
完成了。因此循环体是空
语句
。应注意的是,空
语句
后的分号不可少,如缺少此分号,则把后面的printf
语句
当成循环体来执行。反过来说,如循环体不为空
语句
时, 决不能在
表达式
的括号后加分号, 这样又会认为循环体是空
语句
而不能反复执行。这些都是编程
中
常见的错误,要十分注意。 4.for
语句
也可与while,do-while
语句
相互嵌套,构成多重循环。以下形成都合法的嵌套。 (1)for(){… while() {…} … } (2)do{ … for() {…} … }while(); (3)while(){ … for() {…} … } (4)for(){ … for(){ … } } void main(){ int i,j,k; for(i=1;i<=3;i++) { for(j=1;j<=3-i+5;j++) printf(" "); for(k=1;k<=2*i-1+5;k++) { if(k<=5) printf(" "); else printf("*"); } printf("\n"); } } 转移
语句
程序
中
的
语句
通常总是按顺序方向, 或按
语句
功能所定义的方向执行的。如果需要改变程序的正常流向, 可以使用本小节介绍的转移
语句
。在C
语言
中
提供了4种转移
语句
: goto,break, continue和return。 其
中
的return
语句
只能出现在被调
函数
中
, 用于返回主调
函数
,我们将在
函数
一章
中
具体介绍。 本小节介绍前三种转移
语句
。 1.goto
语句
goto
语句
也称为无条件转移
语句
,其一般格式如下: goto
语句
标号; 其
中
语句
标号是按标识符规定书写的符号, 放在某一
语句
行的 前面,标号后加冒号(:)。
语句
标号起标识
语句
的
作用
,与goto
语句
配合使用。 如: label: i++; loop: while(x<7); C
语言
不限制程序
中
使用标号的次数,但各标号不得重名。goto
语句
的语义是改变程序流向, 转去执行
语句
标号所标识的
语句
。 goto
语句
通常与条件
语句
配合使用。可用来实现条件转移, 构成循环,跳出循环体等功能。 但是,在结构化程序设计
中
一般不主张使用goto
语句
, 以免造成程序流程的混乱,使理解和调试程序都产生困难。 统计从键盘输入一行
字符
的个数。 #include"stdio.h" void main(){ int n=0; printf("input a string\n"); loop: if(getchar()!='\n') { n++; goto loop; } printf("%d",n); } 本例用if
语句
和goto
语句
构成循环结构。当输入
字符
不为'\n'时即执行n++进行计数,然后转移至if
语句
循环执行。直至输入
字符
为'\n'才停止循环。 break
语句
break
语句
只能用在switch
语句
或循环
语句
中
, 其
作用
是跳出switch
语句
或跳出本层循环,转去执行后面的程序。由于break
语句
的转移方向是明确的,所以不需要
语句
标号与之配合。break
语句
的一般形式为: break; 上面例题
中
分别在switch
语句
和for
语句
中
使用了break
语句
作为跳转。使用break
语句
可以使循环
语句
有多个出口,在一些场合下使编程更加灵活、方便。 continue
语句
continue
语句
只能用在循环体
中
,其一般格式是: continue; 其语义是:结束本次循环,即不再执行循环体
中
continue
语句
之后的
语句
,转入下一次循环条件的判断与执行。应注意的是, 本
语句
只结束本层本次的循环,并不跳出循环。 void main(){ int n; for(n=7;n<=100;n++) { if (n%7!=0) continue; printf("%d ",n); } }
输出
100以内能被7整除的数。 int n; for(n=7;n<=100;n++) { if (n%7!=0) continue; printf("%d ",n); } 本例
中
,对7~100的每一个数进行测试,如该数不能被7整除,即模运算不为0,则由continus
语句
转去下一次循环。只有模运算为0时,才能执行后面的printf
语句
,
输出
能被7整除的数。 #include"stdio.h" void main(){ char a,b; printf("input a string:\n"); b=getchar(); while((a=getchar())!='\n'){ if(a==b){ printf("same character\n"); break; }b=a; } } 检查输入的一行
中
有无相邻两
字符
相同。 char a,b; printf("input a string:\n"); b=getchar(); while((a=getchar())!='\n'){ if(a==b){ printf("same character\n"); break; }b=a; } 本例程序
中
,把第一个读入的
字符
送入b。然后进入循环,把下一
字符
读入a,比较a,b是否相等,若相等则
输出
提示串并
中
止循环,若不相等则把a
中
的
字符
赋予b,输入下一次循环。
输出
100以内的素数。素数是只能被1 和本身整除的数。可用穷举法来判断一个数是否是素数。 void main(){ int n,i; for(n=2;n<=100;n++){ for(i=2;i
=n) printf("\t%d",n); } } int n,i; for(n=2;n<=100;n++){ for(i=2;i
=n) printf("\t%d",n); } 本例程序
中
,第一层循环表示对1~100这100个数逐个判断是否是素数,共循环100次,在第二层循环
中
则对数n用2~n-1逐个去除,若某次除尽则跳出该层循环,说明不是素数。 如果在所有的数都是未除尽的情况下结束循环,则为素数,此时有i>=n, 故可经此判断后
输出
素数。然后转入下一次大循环。实际上,2以上的所有偶数均不是素数,因此可以使循环变量的步长值改为2,即每次增加2,此外只需对数n用2~n去除就可判断该数是否素数。这样将大大减少循环次数,减少程序运行时间。 #include"math.h" void main(){ int n,i,k; for(n=2;n<=100;n+=2){ k=sqrt(n); for(i=2;i
=k) printf("\t%2d",n); } } 小结 1.从程序执行的流程来看, 程序可
分为
三种最基本的结构: 顺序结构,分支结构以及循环结构 2.程序
中
执行部分最基本的单位是
语句
。C
语言
的
语句
可
分为
五类: (1)
表达式
语句
任何
表达式
末尾加上分号即可构成
表达式
语句
, 常用的
表达式
语句
为赋值
语句
。 (2)
函数
调用
语句
由
函数
调用加上分号即组成
函数
调用
语句
。 (3)
控制
语句
用于
控制
程序流程,由专门的
语句
定义符及所需的
表达式
组成。主要有条件判断执行
语句
,循环执行
语句
,转向
语句
等。 (4)
复合
语句
由{}把多个
语句
括起来组成一个
语句
。
复合
语句
被认为是单条
语句
,它可出现在所有允许出现
语句
的地方,如循环体等。 (5)空
语句
仅由分号组成,无实际功能。 3.C
语言
中
没有提供专门的输入
输出
语句
, 所有的输入
输出
都是由调用标准库
函数
中
的输入
输出
函数
来实现的。 scanf和getchar
函数
是输入
函数
,接收来自键盘的输入数据。 scanf是格式输入
函数
, 可按指定的格式输入任意类型数据。 getchar
函数
是
字符
输入
函数
, 只能接收单个
字符
。 printf和
putchar
函数
是
输出
函数
,向显示器屏幕
输出
数据。 printf是格式
输出
函数
,可按指定的格式显示任意类型的数据。
putchar
是
字符
显示
函数
,只能显示单个
字符
。 4.关系
表达式
和逻辑
表达式
是两种重要的
表达式
, 主要用于条件执行的判断和循环执行的判断。 5.C
语言
提供了多种形式的条件
语句
以构成分支结构。 (1)if
语句
主要用于单向选择。 (2)if-else
语句
主要用于双向选择。 (3)if-else-if语和switch
语句
用于多向选择。 这几种形式的条件
语句
一般来说是可以互相替代的。 6.C
语言
提供了三种循环
语句
。 (1)for
语句
主要用于给定循环变量初值, 步长增量以及循环次数的循环结构。 (2)循环次数及
控制
条件要在循环过程
中
才能确定的循环可用 while或do-while
语句
。 (3)三种循环
语句
可以相互嵌套组成多重循环。循环之间可以并列但不能交叉。 (4)可用转移
语句
把流程转出循环体外,但不能从外面转向循环体内。 (5)在循环程序
中
应避免出现死循环,即应保证循环变量的值在运行过程
中
可以得到修改,并使循环条件逐步变为假,从而结束循环。 7.C
语言
语句
小结 名 称 一 般 形 式 简单
语句
表达式
语句
表达式
; 空
语句
;
复合
语句
{
语句
} 条件
语句
if(
表达式
)
语句
; if(
表达式
)
语句
1; else
语句
2; if(
表达式
1)
语句
1; else if(
表达式
2)
语句
2…else
语句
n; 开关
语句
switch(
表达式
){ case常量
表达式
:
语句
…default:
语句
; } 循环
语句
while
语句
while(
表达式
)
语句
; for
语句
for(
表达式
1;
表达式
2;
表达式
3)
语句
; break
语句
break; goto
语句
goto; continue
语句
continue; return
语句
return(
表达式
); 资料收集:beck Copyright 2002 www.vcok.com, All Rights Reserved
明解C
语言
(第3版)入门篇.[日]柴田望洋(带详细书签).pdf 【半高清】
《明解C
语言
第3版 入门篇》是日本的C
语言
经典教材,自出版以来不断重印、修订,被誉为“C
语言
圣经”。 《明解C
语言
第3版 入门篇》图文并茂,示例丰富,第3版从190段代码和164幅图表增加到205段代码和220幅图表,对C
语言
的基础知识进行了彻底剖析,内容涉及数组、
函数
、指针、文件操作等。对于C
语言
语法以及一些难以理解的概念,均以精心绘制的示意图,清晰、通俗地进行讲解。原著在日本广受欢迎,始终位于网上书店C
语言
著作排行榜首位。 第1章 初识C
语言
1 1-1 显示计算结果 2 计算整数的和并显示结果 2 程序和编译 2 注释 3 固定代码 4 printf
函数
:格式化
输出
函数
4
语句
5 计算并显示整数的差 5 格式化
字符
串和转换说明 6 符号的称呼 8 无格式化
输出
8
字符
串常量 10 转义
字符
10 1-2 变量 11 变量和声明 11 赋值 12 初始化 13 声明时初始化 14 初始化和赋值 14 1-3 输入和显示 16 通过键盘进行输入 16 格式化输入
函数
scanf 16 乘法运算 17
输出
函数
puts 18 总结 21 第2章 运算和数据类型 23 2-1 运算 24 运算符和操作数 24 乘除运算符和加减运算符 25 除法运算的商和余数 25 使用printf
函数
打印% 26 获取整数的最后一位数字 26 多个转换说明 27 单目运算符 28 赋值运算符 29
表达式
和赋值
表达式
30
表达式
语句
30 2-2 数据类型 31 求平均值 31 数据类型 32 数据类型和对象 33 整型常量和浮点型常量 34 double类型的运算 34 数据类型和运算 35 类型转换 37 转换说明 39 总结 42 第3章 分支结构程序 45 3-1 if
语句
46 if
语句
·其1 46 奇数的判定 47 if
语句
·其2 48 奇数·偶数的判断 49 非0的判断 49 if
语句
的结构图 50 相等运算符 52 余数的判断 53 关系运算符 54 嵌套的if
语句
55 判断 57 计算较大值 58 计算三个数的最大值 59 条件运算符 60 差值计算 61
复合
语句
(程序块) 62 逻辑运算符 65 短路求值 67 3-2 switch
语句
70 switch
语句
和break
语句
70 复杂的switch
语句
72 switch
语句
和if
语句
73 选择
语句
74 总结 75 第4章 程序的循环
控制
77 4-1 do
语句
78 do
语句
78
复合
语句
(程序块)
中
的声明 79 读取一定范围内的值 80 逻辑非运算符·德摩根定律 81 德摩根定律 81 求多个整数的和及平均值 82
复合
赋值运算符 84 后置递增运算符和后置递减运算符 85 4-2 while
语句
87 while
语句
87 用递减运算符简化程序代码 88 数据递增 90 限定次数的循环操作 91
字符
常量和
putchar
函数
92 do
语句
和while
语句
93 前置递增运算符和前置递减运算符 93 do
语句
的显示 95 逆向显示整数值 96 4-3 for
语句
99 for
语句
99 使用for
语句
实现固定次数的循环 101 偶数的枚举 103 约数的枚举 104
表达式
语句
和空
语句
104 循环
语句
105 4-4 多重循环 107 二重循环 107 用break
语句
强制结束循环 108 显示图形 109 多重循环 111 4-5 程序的组成元素和格式 114 关键字 114 运算符 114 标识符 114 分隔符 115 常量和
字符
串常量 115 自由的书写格式 116 连接相邻的
字符
串常量 117 缩进 117 总结 118 第5章 数组 121 5-1 数组 122 数组 122 数组的声明(使用数组前的准备) 123 访问数组(数组的使用方法) 123 数组的遍历 124 数组初始化 126 数组的复制 127 输入数组元素的值 129 对数组的元素进行倒序排列 129 使用数组进行成绩处理 131 对象式宏 131 数组元素的最大值和最小值 133 赋值
表达式
的判断 134 数组的元素个数 135 5-2 多维数组 138 多维数组 138 总结 142 第6章
函数
145 6-1 什么是
函数
146 main
函数
和库
函数
146 什么是
函数
146
函数
定义 147
函数
调用 148 三个数
中
的最大值 151 将
函数
的返回值作为参数传递给
函数
152 调用其他
函数
154 值传递 155 6-2
函数
设计 158 没有返回值的
函数
158 通用性 159 不含形参的
函数
160
函数
返回值的初始化 161
作用
域 161 文件
作用
域 162 声明和定义 163
函数
原型声明 163 头文件和文件包含指令 164
函数
的通用性 165 数组的传递 166
函数
的传递和const类型的修饰符 168 线性查找(顺序查找) 170 哨兵查找法 172 多维数组的传递 175 6-3
作用
域和存储期 178
作用
域和标识符的可见性 178 存储期 180 总结 185 第7章 基本数据类型 189 7-1 基本数据类型和数 190 算数类型和基本数据类型 190 基数 191 基数转换 192 7-2 整型和
字符
型 195 整型和
字符
型 195 头文件 196
字符
型 199 位和CHAR_BIT 200 sizeof运算符 200 size_t型和typedef声明 202 整型的灵活运用 202 整型的内部表示 204 无符号整数的内部表示 205 有符号整数的内部表示 207 按位操作的逻辑运算 209 位移运算符 212 整型常量 216 整型常量的数据类型 218 整数的显示 218 数据溢出和异常 220 7-3 浮点型 221 浮点型 221 浮点型常量 223 头文件 224 循环的
控制
225 7-4 运算和运算符 228 运算符的优先级和结合性 228 优先级 228 结合性 228 数据类型转换 230 总结 232 第8章 动手编写各种程序吧 235 8-1
函数
式宏 236
函数
和数据类型 236
函数
式宏 237
函数
和
函数
式宏 238 不带参数的
函数
式宏 239
函数
式宏和逗号运算符 240 8-2 排序 243 冒泡排序法 243 8-3 枚举类型 246 枚举类型 246 枚举常量 248 命名空间 250 8-4 递归
函数
251
函数
和类型 251 阶乘 252 8-5 输入
输出
和
字符
255 getchar
函数
和EOF 255 从输入复制到
输出
256 数字
字符
计数 256
字符
258 转义
字符
261 总结 263 第9章
字符
串的基本知识 265 9-1 什么是
字符
串 266
字符
串字面量 266
字符
串字面量的长度 266
字符
串 268
字符
数组的初始化赋值 269 空
字符
串 270
字符
串的读取 270 格式化显示
字符
串 271 9-2
字符
串数组 273
字符
串数组 273 读取
字符
串数组
中
的
字符
串 274 9-3
字符
串处理 275
字符
串长度 275 显示
字符
串 277 数字
字符
的出现次数 278 大小写
字符
转换 279
字符
串数组的参数传递 280 总结 283 第10章 指针 285 10-1 指针 286
函数
的参数 286 对象和地址 287 取址运算符 288 指针 289 指针运算符 291 10-2 指针和
函数
293 作为
函数
参数的指针 293 计算和与差 294 二值互换 296 将两个值排序 297 scanf
函数
和指针 298 指针的类型 299 空指针 300 标量型 301 10-3 指针和数组 302 指针和数组 302 指针运算符和下标运算符 304 数组和指针的不同点 306 数组的传递 308 总结 311 第11章
字符
串和指针 315 11-1
字符
串和指针 316 用数组实现的
字符
串和用指针实现的
字符
串 316 用数组实现的
字符
串和用指针实现的
字符
串的不同点 318
字符
串数组 320 11-2 通过指针操作
字符
串 323 判断
字符
串长度 323
字符
串的复制 325 不正确的
字符
串复制 328 返回指针的
函数
329 11-3
字符
串处理库
函数
330 strlen
函数
:求
字符
串的长度 330 strcpy
函数
、strncpy
函数
:复制
字符
串 331 strcat
函数
、strncat
函数
:连接
字符
串 332 strcmp
函数
、strncmp
函数
:比较
字符
串的大小关系 332 atoi
函数
、atol
函数
、atof
函数
:转换
字符
串 333 总结 336 第12章 结构体 339 12-1 结构体 340 数据关联性 340 结构体 342 结构体成员和运算符 344 成员的初始化 345 结构体成员和->运算符 346 结构体和typedef 348 结构体和程序 350 聚合类型 351 返回结构体的
函数
351 命名空间 353 结构体数组 353 派生类型 355 12-2 作为成员的结构体 356 表示坐标的结构体 356 具有结构体成员的结构体 357 总结 361 第13章 文件处理 363 13-1 文件与流 364 文件与流 364 标准流 365 FILE型 365 打开文件 365 关闭文件 368 打开与关闭文件示例 369 文件数据汇总 370 写入日期和时间 372 获取上一次运行时的信息 376 显示文件内容 378 文件的复制 380 13-2 文本和二进制 382 在文本文件
中
保存实数 382 文本文件和二进制文件 383 在二进制文件
中
保存实数 384 显示文件自身 386 13-3 printf
函数
与scanf
函数
389 printf
函数
:带格式
输出
389 scanf
函数
:带格式的输入 393 总结 397 附录 C
语言
简介 399 C
语言
的历史 400 K&R——C
语言
的圣经 400 C
语言
标准规范 400 结语 402 参考文献 405
新概念C
语言
.李一波(带详细书签).pdf
“新概念C
语言
”突破了以往任何一种
语言
教材的旧的模式,将教学内容
分为
入门篇和提高篇两个篇章。在入门篇
中
只引进程序设计必要的语法现象,达到快速入门。激发兴趣的目的。在入门篇和提高篇之间插一个强化上机实验周,巩固学习内容。在提高篇
中
完成完整的语法、算法、程序设计思想等教学目的的学习任务。由于学生对
语言
已具有了初步的了解并掌握了最基本的语法和程序设计思想,能设计较简单的程序,所以在提高篇的学习
中
,不论对灵活语法的学习和掌握,还是对程序设计思想的掌握都更加容易,从而可以较容易达到教学目标。 第一部分 入门篇 1 第1章 C
语言
的产生及其工作流程 3 1.1 C
语言
的产生 3 1.2 程序和程序设计 3 1.2.1 C程序 3 1.2.2 程序设计 4 习题 4 第2章 C程序设计的初步知识 5 2.1 简单C程序的构成和格式 5 2.2 常量、变量和标识符 6 2.2.1 标识符 6 2.2.2 常量 7 2.2.3 用定义一个符号名的方法来代表一个常量 7 2.2.4 变量 8 2.3 整型数据 8 2.3.1 整型常量 8 2.3.2 整型变量 8 2.4 实型数据 9 2.4.1 实型常量 9 2.4.2 实型变量 9 2.5
字符
型数据 10 2.5.1
字符
常量 10 2.5.2
字符
串常量 11 2.5.3
字符
变量 11 2.6 算术
表达式
11 2.6.1 基本的算术运算符 11 2.6.2 运算符的优先级、结合性和算术
表达式
12 2.6.3 强制类型转换
表达式
13 2.7 赋值
表达式
13 2.7.1 赋值运算符和赋值
表达式
13 2.7.2 赋值运算
中
的类型转换 14 习题 15 第3章 顺序结构程序 16 3.1
复合
语句
和空
语句
16 3.1.1
复合
语句
16 3.1.2 空
语句
16 3.2 程序举例 16 习题 17 第4章 选择结构 19 4.1 关系运算和逻辑运算 19 4.1.1 C
语言
中
的逻辑值 19 4.1.2 关系运算符和关系
表达式
19 4.1.3 逻辑运算符和逻辑
表达式
20 4.2 if
语句
和用if
语句
构成的选择结构 21 习题 22 第5章 循环结构 25 5.1 for
语句
和用for
语句
构成的循环结构 25 5.1.1 for
语句
构成的循环结构 25 5.1.2 for循环的执行过程 25 5.1.3 有关for
语句
的说明 25 5.2 循环结构的嵌套 27 习题 28 第6章
函数
30 6.1
函数
的定义和返回值 30 6.1.1
函数
定义的语法 30 6.1.2
函数
的返回值 30 6.2
函数
的调用 32 6.2.1
函数
的调用方式 32 6.2.2
函数
调用时的语法要求 32 6.3
函数
的说明 33 6.3.1
函数
说明的形式 33 6.3.2
函数
说明的位置 34 6.4 调用
函数
和被调用
函数
之间的数据传递 34 6.5 库
函数
36 6.6 数据输入
输出
及常用库
函数
37 6.6.1 printf
函数
(格式
输出
函数
) 37 6.6.2 scanf
函数
(格式输入
函数
) 39 6.6.3 调用
putchar
和getchar
函数
输出
和输入
字符
40 6.7 程序举例 41 习题 43 第7章 数组 45 7.1 一维数组的定义和一维数组元素的引用 45 7.1.1 一维数组的定义 45 7.1.2 一维数组元素的引用 46 7.1.3 一维数组的初始化 46 7.1.4 一维数组的定义和数组元素引用举例 47 7.2
函数
之间对一维数组和数组元素的引用 47 7.2.1 数组元素做实参 47 7.2.2 数组名做实参 49 7.3 一维数组应用举例 50 7.4
字符
数组 53 7.4.1
字符
数组的定义 53 7.4.2
字符
数组的初始化 54 7.4.3
字符
数组的引用 54 7.4.4
字符
串与
字符
串结束标志 55 7.4.5
字符
数组的输入
输出
56 7.4.6
字符
串处理
函数
58 7.4.7
字符
数组应用举例 60 习题 61 第8章 文件 63 8.1 C
语言
文件的概念 63 8.2 打开文件 64 8.3 关闭文件 65 8.4 调用getc(fgetc)和putc(fputc)等常用
函数
进行输入和
输出
65 8.5 判断文件结束
函数
feof 68 习题 69 第二部分 提高篇 71 第9章 算法 73 9.1 算法 73 9.2 结构化程序设计和模块化结构 74 9.2.1 结
C
语言
讲义.doc
1 愉快的开始-HELLO WORLD 14 1.1 INCLUDE头文件包含 14 1.2 MAIN
函数
14 1.3 注释 14 1.4 {}括号,程序题和代码块 14 1.5 声明 14 1.6 C
语言
自定义名字的要求 15 1.7 PRINTF
函数
15 1.8 RETURN
语句
15 1.9 SYSTEM系统调用 15 1.9.1 System返回值在windows和unix下的不同, 15 1.9.2 POSIX 15 1.10 C
语言
编译过程,GCC参数简介 16 1.10.1 C
语言
编译过程 16 1.10.2 -E预编译 16 1.10.3 -S汇编 16 1.10.4 -c编译 16 1.10.5 链接 16 1.11 操作系统结构 17 1.11.1 用户模式 17 1.11.2 内核模式 17 1.12 64位,32位系统区别 18 1.12.1 CPU内部结构与寄存器 18 1.12.2 RISC与CISC CPU构架 18 1.12.3 SPARC,x86与ARM 18 1.13 汇编
语言
18 1.13.1 I386汇编简介 18 1.13.2 VS反汇编 19 1.14 IDE工具 19 1.14.1 QT常用快捷键 19 1.14.2 VS常用快捷键 19 1.14.3 VS断点,调试 19 2 C
语言
中
的数据类型 19 2.1 常量 19 2.1.1 #define 19 2.1.2 const 19 2.2
字符
串常量 20 2.3 二进制数、位、字节与字 20 2.4 八进制 20 2.5 十六进制 20 2.6 原码 21 2.7 反码 21 2.8 补码 21 2.9 SIZEOF关键字 22 2.10 INT类型 22 2.10.1 int常量,变量 22 2.10.2 printf
输出
int值 23 2.10.3 printf
输出
八进制和十六进制 23 2.10.4 short,long,long long,unsigned int 23 2.10.5 整数溢出 23 2.10.6 大端对齐与小端对齐 23 2.11 CHAR类型 24 2.11.1 char常量,变量 24 2.11.2 printf
输出
char 24 2.11.3 不可打印char转义符 24 2.11.4 char和unsigned char 25 2.12 浮点FLOAT,DOUBLE,LONG DOUBLE类型 25 2.12.1 浮点常量,变量 25 2.12.2 printf
输出
浮点数 25 2.13 类型限定 25 2.13.1 const 25 2.13.2 volatile 26 2.13.3 register 26 3
字符
串格式化
输出
和输入 26 3.1
字符
串在计算机内部的存储方式 26 3.2 PRINTF
函数
,
PUTCHAR
函数
27 3.3 SCANF
函数
与GETCHAR
函数
28 4 运算符
表达式
和
语句
29 4.1 基本运算符 29 4.1.1 = 29 4.1.2 + 29 4.1.3 – 29 4.1.4 * 29 4.1.5 / 29 4.1.6 % 29 4.1.7 += 29 4.1.8 -= 29 4.1.9 *= 29 4.1.10 /= 30 4.1.11 %= 30 4.1.12 ++ 30 4.1.13 -- 30 4.1.14 逗号运算符 30 4.1.15 运算符优先级 30 4.2
复合
语句
31 4.3 空
语句
31 4.4 类型转化 31 5 条件分支
语句
31 5.1 关系运算符 31 5.1.1 < 31 5.1.2 <= 31 5.1.3 > 32 5.1.4 >= 32 5.1.5 == 32 5.1.6 != 32 5.2 关系运算符优先级 32 5.3 逻辑运算符 32 5.3.1 && 32 5.3.2 || 32 5.3.3 ! 33 5.4 IF 33 5.5 IF ELSE 34 5.6 IF ELSE IF 34 5.7 SWITCH与BREAK,DEFAULT 35 5.8 条件运算符? 36 5.9 GOTO
语句
与标号 36 6 循环
语句
36 6.1 WHILE 36 6.2 CONTINUE 37 6.3 BREAK 37 6.4 DO WHILE 37 6.5 FOR 37 6.6 循环嵌套 37 7 数组 38 7.1 一维数组定义与使用 38 7.2 数组在内存的存储方式 38 7.3 一维数组初始化 38 7.4 二维数组定义与使用 39 7.5 二维数组初始化 39 8
字符
串与
字符
数组 39 8.1
字符
数组定义 39 8.2
字符
数组初始化 39 8.3
字符
数组使用 40 8.4 随机数产生
函数
RAND与SRAND 40 8.5 用SCANF输入
字符
串 40 8.6
字符
串的结束标志 41 8.7
字符
串处理
函数
41 8.7.1 gets 41 8.7.2 fgets
函数
41 8.7.3 puts
函数
42 8.7.4 fputs
函数
42 8.7.5 strlen,
字符
串长度 42 8.7.6 strcat,
字符
串追加 42 8.7.7 strncat,
字符
串有限追加 43 8.7.8 strcmp,
字符
串比较 43 8.7.9 strncmp,
字符
串有限比较 43 8.7.10 strcpy
字符
串拷贝 43 8.7.11 strncpy
字符
串有限拷贝 43 8.7.12 sprintf,格式化
字符
串 43 8.7.13 Sscanf
函数
44 8.7.14 strchr查找
字符
44 8.7.15 strstr查找子串 44 8.7.16 strtok分割
字符
串 44 8.7.17 atoi转化为int 45 8.7.18 atof转化为float 45 8.7.19 atol转化为long 45 9
函数
45 9.1
函数
的原型和调用 45 9.2
函数
的形参与实参 45 9.3
函数
的返回类型与返回值 46 9.4 MAIN
函数
与EXIT
函数
与
函数
的RETURN
语句
46 9.5 多个源代码文件程序的编译 47 9.5.1 头文件的使用 47 9.5.2 #include与#define的意义 47 9.5.3 #ifndef与#endif 47 9.6
函数
的递归 48 9.6.1 递归的过程分析 48 9.6.2 递归的优点 52 9.6.3 递归的缺点 52 1 指针 52 1.1 指针 52 1.1.1 指针的概念 52 1.1.2 指针变量的定义 52 1.1.3 &取地址运算符 52 1.1.4 无类型指针 52 1.1.5 NULL 53 1.1.6 空指针与野指针 53 1.1.7 指针的兼容性 53 1.1.8 指向常量的指针与指针常量 54 1.1.9 指针与数组的关系 54 1.1.10 指针运算 54 1.1.11 通过指针使用数组元素 55 1.1.12 指针数组 55 1.1.13 指向指针的指针(二级指针) 55 1.1.14 指向二维数组的指针 57 1.1.15 指针变量做为
函数
的参数 57 1.1.16 一维数组名作为
函数
参数 57 1.1.17 二维数组名作为
函数
参数 58 1.1.18 const关键字保护数组内容 58 1.1.19 指针做为
函数
的返回值 58 1.1.20 指向
函数
的指针 59 1.1.21 把指向
函数
的指针做为
函数
的参数 60 1.1.22 memset,memcpy,memmove
函数
61 1.1.23 指针小结 63 2
字符
指针与
字符
串 64 2.1 指针和
字符
串 64 2.2 通过指针访问
字符
串数组 64 2.3
函数
的参数为CHAR * 64 2.4 指针数组做为MAIN
函数
的形参 65 3 内存管理 65 3.1
作用
域 65 3.1.1 auto自动变量 65 3.1.2 register寄存器变量 65 3.1.3 代码块
作用
域的静态变量 66 3.1.4 代码块
作用
域外的静态变量 66 3.1.5 全局变量 66 3.1.6 外部变量与extern关键字 66 3.1.7 全局
函数
和静态
函数
66 3.2 内存四区 66 3.2.1 代码区 67 3.2.2 静态区 67 3.2.3 栈区 67 3.2.4 栈溢出 68 3.2.5 堆区 68 3.3 堆的分配和释放 70 3.3.1 malloc 70 3.3.2 free 70 3.3.3 calloc: 70 3.3.4 realloc 71 4 结构体,联合体,枚举与TYPEDEF 71 4.1 结构体 71 4.1.1 定义结构体struct和初始化 71 4.1.2 访问结构体成员 71 4.1.3 结构体的内存对齐模式 72 4.1.4 指定结构体元素的位字段 72 4.1.5 结构数组 72 4.1.6 嵌套结构 73 4.1.7 结构体的赋值 73 4.1.8 指向结构体的指针 73 4.1.9 指向结构体数组的指针 73 4.1.10 结构
中
的数组成员和指针成员 73 4.1.11 在堆
中
创建的结构体 74 4.1.12 将结构作为
函数
参数 74 4.1.13 结构,还是指向结构的指针 74 4.2 联合体 75 4.3 枚举类型 75 4.3.1 枚举定义 75 4.3.2 默认值 76 4.4 TYPEDEF 76 4.5 通过TYPEDEF定义
函数
指针 76 5 文件操作 77 5.1 FOPEN 77 5.2 二进制和文本模式的区别 77 5.3 FCLOSE 78 5.4 GETC和PUTC
函数
78 5.5 EOF与FEOF
函数
文件结尾 78 5.6 FPRINTF,FSCANF,FGETS,FPUTS
函数
78 5.7 STAT
函数
78 5.8 FREAD和FWRITE
函数
79 5.9 FREAD与FEOF 79 5.10 通过FWRITE将结构保存到二进制文件
中
79 5.11 FSEEK
函数
80 5.12 FTELL
函数
80 5.13 FFLUSH
函数
80 5.14 REMOVE
函数
81 5.15 RENAME
函数
81 6 基础数据结构与算法 82 6.1 什么是数据结构 82 6.2 什么是算法 82 6.3 排序 83 6.3.1 冒泡排序 83 6.3.2 选择排序 83 6.4 查找 83 6.4.1 顺序查找 83 6.4.2 二分查找 83 6.5 链表 84 6.5.1 单向链表定义 84 6.5.2 单向链表数据结构定义 85 6.5.3 单向链表的实现 85
学无止境
785
社区成员
344
社区内容
发帖
与我相关
我的任务
学无止境
你的一生其实就是在进行寻找哪些人可以来出席你的葬礼的一场面试。
复制链接
扫一扫
分享
社区描述
你的一生其实就是在进行寻找哪些人可以来出席你的葬礼的一场面试。
考研
前端
python
个人社区
吉林省·长春市
社区管理员
加入社区
获取链接或二维码
近7日
近30日
至今
加载中
查看更多榜单
社区公告
暂无公告
试试用AI创作助手写篇文章吧
+ 用AI写文章