04 第3章 语句和控制结构.pptx

第1页：第3章 语句和控制结构

第3章 语句和控制结构

掌握C语句的构成与分类；

2.掌握赋值、复合语句与空语句构成与使用要点；

3.熟练掌握字符、格式输入/输出函数的使用方法；

4.能编写简单的顺序结构程序；

5.熟练掌握if语句的三种形式、基本结构及嵌套，并能掌握条件运算符给出的语句与if语句的转化关系；

6.掌握switch语句的一般形式，并能把复杂的分支选择性结构化成switch语句来解决问题；

7.掌握while与do_while语句的结构与使用方法；

8.掌握for语句的结构，熟练掌握其使用方法；

9.会使用常见的循环嵌套形式；

10.能正确区分for、do_while与while三者的不同；

11.掌握break语句和continue的应用及其区别；

12.总结常用的程序设计方法及算法特点，能编写相应的程序；

第2页：3.1 语句

3.1 语句

2顺序结构一、赋值和复合赋值语句二、数据输入输出三、复合语句和空语句四、顺序程序设计举例3.4循环结构一、循环语句二、循环嵌套三、控制语句四、常用机制五、设计实例3.5小结3.3选择结构一、关系运算和逻辑运算二、if语句三、switch结构

第3页：3.1 语句

3.1 语句

变量定义也有“;”，但不是语句，不产生机器操作。

二、语句的语义每个合法的语句都表示一种含义，表明程序执行时要求进行的一个动作。

语句要素:语法、语义!程序区mov ax,3mov [100],ax静态存储区动态存储区int i, j;i=3;地址变量100i104j

• 是描述计算过程的最基本单位。
• 由分号“;”结束。
• 必须符合C语言在形式上的严格要求(既语法规则)。
• 一个语句经编译后产生若干条机器指令。

第4页：语句分类C语言语句不多

语句分类C语言语句不多

可分为下面5类。

1.控制语句完成选择、循环和转移等功能，共9种；

2.函数调用语句由一个函数加一个分号构成；

3.表达式语句由一个表达式加分号构成一个语句。

任何表达式都可以加上分号而成为语句(如：a=3;++x;)，这是C语言的一个重要特色。

因此，C语言也被叫作“表达式语言”。

4.空语句只有一个“;”号的语句。

(如：空循环)5.复合语句将语句用“{…}”括起来的一组语句，用于执行一系列语句，与顺序结构对应。

第5页：C语言语句的书写

C语言语句的书写

• C语言语句的书写非常自由
• 一行可以写多个语句
• 一个语句也可以拆开写在几行上。(不要在""里拆)
• 但清晰的、有层次的良好的语句书写习惯，对于程序的可读性将有很大的帮助。
• 程序中的注释包含在“”之间或“//”之后
• 对程序的功能没有任何影响，注释的目的是帮助人们理解程序(C99可用“//”)，。
• 编译程序对注释、空格、制表符和回车换行的处理一样，只是简单地跳过不予处理。

第6页：3.2 顺序结构本节介绍的语句

3.2 顺序结构本节介绍的语句

将按它们在程序中出现的顺序逐条执行，由这样的语句构成的程序结构是顺序结构。一、赋值语句和复合赋值语句

• 赋值语句由赋值表达式加上一个“;”号组成。如：a=b+c;i=1,j=2;i++;i--;a=10
• 复合赋值语句
• 组成：由复合赋值表达式加上一个“;”号组成。如：sum+=i;n*=i;a>=2
• 特点：第一个运算分量就是赋值对象本身，在程序中常用来表示累加、累积等运算。

第7页：(复合)赋值表达式

(复合)赋值表达式

• 和(复合)赋值语句的不同特点
• 赋值表达式出现在语法上要求使用表达式的地方，而且常常要使用表达式的值
• 赋值语句不能出现在要求使用表达式的地方，使用时，主要用它的赋值功能，不关心其值。
• 例：(a=b)>0是合法的表达式，(a=b;)>0是非法的。

第8页：3.2 顺序结构

3.2 顺序结构

用赋值语句和复合赋值语句时，要求赋值号两侧的数据类型一致，否则，系统按赋值号左边变量的类型进行自动转换。

如：若f是浮点数，语句f = 1.0;比f =1;的运行效率要高。

• 由于C语言赋值表达式形式多样，用法灵活，掌握其运算规律有利于写出正确的赋值语句。
• 赋值语句只能出现在程序的可执行部分。

第9页：数据输入输出

数据输入输出

标准输入是指从标准输入设备(键盘)输入数据，标准输出是指将数据输出到标准输出设备(显示屏)上。

• 概述
• 输入输出(I/O)概念
• 把数据从计算机内部送到外部设备(如显示屏、打印机、磁盘等)的操作称为“输出”。
• 从外部设备(如键盘、磁盘等)将数据送入计算机内部的操作称为“输入”。

第10页：输入输出实现

输入输出实现

scanf ( )，printf ( )

getchar ( )，putchar ( )

• C语言本身没有I/O语句，I/O操作通过函数来实现。
• 不同系统提供的函数的数量、名字和功能不完全相同，有些通用的函数各系统都提供。
• C语言函数库中有一批以标准I/O设备为对象的“标准输入输出函数”
• 本节介绍其中常用的四种：

第11页：输入输出函数

输入输出函数

#include<stdio.h>

#include命令，编译会出现警告，但还能正确运行。

• 的使用
• 使用I/O函数，要在程序开头写入一预编译包含命令：
• stdio.h是一个头文件，其中包括全部I/O库函数的数据类型定义和函数说明。
• 对于VisualC++6.0系统：
• ***.cpp的C++程序# include命令不能省
• ***.c的C程序若省略
• 由于编排的关系，在后面的很多例子中，# include命令都省略，调试时最好加上。

第12页：键盘输入

键盘输入

程序再从缓冲区取数据，如果没有数据，进入等待输入的状态，直到通过键盘输入数据，并按“Enter”键把数据又放入缓冲区，程序才能继续输入操作。

3.2顺序结构1122ababABABb12aAB取数据进缓冲异步操作

getchar( )；scanf ( )；…键盘缓冲区(内存区)98105097656649

• 程序标准输入函数
• 缓冲输入
• 操作系统和C程序标准输入函数采用缓冲输入方式
• 输入数据后，按“Enter”键，数据才能进入缓冲区内。

第13页：字符输入函数getchar

字符输入函数getchar

main( ){ chara,b,c; a=getchar(); b=getchar(); c=getchar(); printf("a=%db=%dc=%d\n",a,b,c); printf("a=%cb=%cc=%c\n",a,b,c); } 键盘输入:3.2顺序结构缓冲区输出：a=49b=10 c=97a=1b=

• ()
• 功能：从标准输入设备读入一字符，没有参数
• 返回：字符的ASCII码值或EOF(文件结束标志)
• c=a98491010971ab1ab

第14页：字符输出函数putchar

字符输出函数putchar

功能：putchar(intc)向标准输出写一个字符；

如果c是某个控制字符的ASCII码，输出控制字符时，会变成相应的设备动作。

如：putchar( '\n' );引起屏幕换行操作

main(){ charc; c=getchar(); putchar(c); putchar('\n'); }

• ()
• 例如：把一个输入字符输出，并换一行。

第15页：格式输出函数printf

格式输出函数printf

printf("格式控制串",参数表); 例：printf("abc=%d\n,b=%8.2f",a,b+1);

• ()
• 功能：按指定格式向显示器输出数据。
• 返回：输出字节数或EOF(出错时)，(较少用)。
• 参数表：要输出的数据，可以是表达式，可以多个(用“,”分隔)，也可以没有。
• 格式控制串：(包含两种信息)
• 原样输出：普通字符或转义序列
• 格式说明：%[修饰符]格式字符

第16页：格式字符

格式字符

printf("%d%d\n",a,b); printf("a=%d,b=%d\n",a,b); 输出结果：34a=3,b=4main(){ unsignedshortu=65535; printf("u=%hd\n",u); } 
第17页：修饰符
修饰符
插在“%”和格式字符之间，说明宽度、对齐方式、正负号和前导符等。(见表2)
长度修饰符
长整型数一定要加l，如“%ld”(VC没用)
h表示短整型或无符号短整型。(TC没用)
宽度控制m.n(后面例子中加红色的要记住)
缺省宽度是数据本身的宽度，采用右对齐。
m是输出数据总的宽度。
当m小于数据宽度时，使用缺省宽度
当m大于数据宽度时，数据右对齐，左边补空格；如：“
1234”
n对不同格式符有不同含义
第18页：3.2 顺序结构
3.2 顺序结构
printf("%2d\n",123); 结果：123printf("%5d\n",123); 结果：
printf("%.5d\n",123); 结果：00123printf("%8.5d\n",123); 结果：
printf ("%g\n", 123.45678); 结果：123.457printf("%.7g\n",123.45678); 结果：1
printf ("%5s\n", "abcdefgh"); 结果：abcde
对整型数−−指定必须输出的数字个数
n小于数据本身宽度时，统使用缺省宽度
n大于数据宽度时，数据右对齐，左边补0。例*：
123(常用)
00123
对g或G−−指定输出的有效数字例*：
对字符串−−指定最多输出的字符个数(VC无效)例*：
第19页：对e、E或f类型实型数−−指定小数点位数
对e、E或f类型实型数−−指定小数点位数
printf("%f\n",123.45); 结果：123.450000(缺省)printf("%12f\n",123.45); 结果：
printf ("%e\n",123.45); 结果：1.234500e+002(缺省)printf("%14e\n",123.45); 结果：
printf("%g\n",123.45); 结果：123.45printf("%8g\n",123.45); 结果：
printf("%7.3f\n",12.34); 结果：
printf("%7.1f\n",123.45); 结果：
小数位数大于n时，按四舍五入截去多余小数
小数位数小于n时，小数右边添0。例*：(红色为常用格式，要记住)
123.450000
234500e+002
123.45
340(右边添0)
123.5(四舍五入)
第20页：左对齐控制
左对齐控制
printf("%4d#\n",123); 结果：
printf("%-4d#\n",123); 结果：123
printf("%8.5f#\n",1.234); 结果：
printf("%-8.5f#\n",1.234); 结果：
在宽度前加“-”(减号)实现。
23400#
#
第21页：正负号显示控制在宽度前加“+”号实现
正负号显示控制在宽度前加“+”号实现
printf("%+d%+d\n",12,-12); 结果：+12-12
printf("%06.0f\n",123.45); 结果：000123
printf("%#o,%#x\n",12,255); 结果：014,0xff
前导字符控制在宽度前加“0”字符实现。如*：
增加八进制和十六进制标志在%或o后x之间插入“#”号实现。如*：
第22页：非正常输出问题
非正常输出问题
由于第一个输出数据60000超出了"%hd"格式的表示范围，输出-5536后，导致其他的输出结果出现混乱。
解决办法是保证输出格式和输出数据在类型和范围的正确对应关系。如：在VC加"%hd" (在TC中，加"%ld")。
printf("%hd%d\n",60000,60000);
格式输出过程中，如果出现非正常输出(如溢出)，可能会引起以后输出内容的混乱。如：
"%d"的表示范围是基本整型数的取值范围，在VC中4字节(在TC中2字节)。
第23页：格式输入函数scanf
格式输入函数scanf
格式控制串(参考printf)用双引号括起来的字符串，由“%”符号、格式字符和其他字符组成。用于指定输入时的数据格式。
scanf("格式控制串",地址表);
()
功能：按指定格式从键盘读入数据，存入地址表指定的存储单元中，并按回车键结束
返回值：正常时，返回输入数据个数(使用不多)
地址表：变量的地址，常用取地址运算符&(各输入项用逗号隔开)如：&a,&b
第24页：格式字符每个格式
格式字符每个格式
scanf()函数正确完成数据输入，需要在程序运行时，
说明都必须用"%"开头，以一个格式字符结束。(见表3)
匹配格式说明的个数应该与输入项数相同，且类型应该一一匹配。不仅如此，要使
第25页：附加格式说明符
附加格式说明符
scanf()函数对它们忽略不计。
scanf()停止工作。
(修饰符)
在“%”和格式字符之间见表4
其他字符：
格式描述串里还可以写各种字符，其中空白字符包括空格、制表符和换行符，
遇到除字符“%”之外的非空白字符(原样字符)，
字符相同则匹配成功；否则匹配失败，
第26页：输入缓冲区字符序列的情况
输入缓冲区字符序列的情况
当程序调用标准输入函数时，实际上是要求用掉输入缓冲区字符序列最前面的一个或几个字符。如
getchar()用掉最前面的一个字符。
scanf()函数，如果序列中的字符符合要求，会用掉最前面的几个字符；如果无法完成指定的转换，可能一个字符也没用掉。
序列中用掉一个字符就少了一个字符，未用掉的字符仍在序列中。
第27页：scanf()函数的工作过程设
scanf()函数的工作过程设
首先读入和丢掉空白字符(可能一个或多个，也可能没有)，找到下一个不为空白的字符，开始转换。
由于%d要求的是十进制数，如果此非空白字符不能看作为数的一部分(不是0~9，也不是正负号)，匹配失败，返回已完成的成功转换项数，输入停留在这个未能成功匹配的字符处，留待以后输入使用。
若遇到的字符是数的一部分，scanf逐个读入字符，直到遇到不属于这个数的字符为止。已读入的字符，转换成整型数的内部形式，赋给变量。(如：-123a)
scanf()正要处理的是转换描述串"%d"，输入序列到达某个地方，scanf()从这里开始工作：
第28页：数据输入操作
数据输入操作
scanf ("%d%d", &a, &b); 若给a输入12，给b输入36。输入为：12
scanf ("%d%o%x",&a,&b,&c); printf ("a=%d, b=%d, c=%d\n",a,b,c); 输入：123123123
(运行时如何正确输入数据？)
输入分隔符
一般以空格、TAB或回车键作为分隔符例1：
36或者：12
36
输出：a=123, b=83, c=29
第29页：其它分隔符
其它分隔符
scanf ("%d:%d:%d", &h, &m, &s); 输入：12:30:45
scanf("%d,%d", &a, &b)输入: 3,4
scanf("a=%d,b=%d", &a, &b); 输入：a=12,b=24
格式串中两个格式符间字符例3：字符":"为分隔符
则：12
h, 30
m, 45
s例4：字符","为分隔符
则: 3
a, 4
b例5：字符作为分隔符
则:12
a,24
b
第30页：输入普通字符“格式字符串”中出现
输入普通字符“格式字符串”中出现
的普通字符，包括转义字符(并不把它当转义字符来解释)，务必原样输入。例如：原样字符的输入
scanf ("a=%d,b=%d\n", &a, &b); 假设给a输入12，给b输入36,正确的输入操作为：a=12,b=36\n
第31页：使用格式
使用格式
scanf ( "%c%c%c",&c1,&c2,&c3); 假设输入：A
scanf("%d%c%f",&a, &b, &c); 若输入：1234a123o.2则：1234
说明符"%c"输入单个字符空格和转义字符均作为有效字符被输入。例如：
B
C
则将：字母'A'
c1，空格'
'
c2，'B'
c3
在输入数据时认为数据结束的情况
遇到空格，或者回车键，或者Tab键
遇到输入域宽度结束；如"%3d"只取3列
遇到非法输入。如：
a，'a'
b，123
c
第32页：输入函数在缓冲区留下的“垃圾”解决方法
输入函数在缓冲区留下的“垃圾”解决方法
getchar()清除
scanf("%d",&x); ch=getchar(); printf("x=%d,ch=%d\n",x,ch); 输入：123
scanf("%d",&x); scanf("%c",&ch); 或：scanf("%d%*c",&x);
用函数fflush(stdin)清除全部剩余内容
用格式串中空格或“%*c”来“吃掉”例1：intx;charch
输出：x=123，ch=10例2：intx;charch
第33页：表1printf()函数格式字符结果
表1printf()函数格式字符结果
举例说明格式十进制整数d,i16进制无符号整数x,X八进制无符号整数o无符号十进制整数u单一字符c字符串s结果指数形式浮点小数e,E小数形式浮点小数fe和f中较短一种g百分号本身%%3.2顺序结构inta=567;
printf ("%d", a); inta=255; printf("%x", a); inta=65; printf("%o", a); inta=567; printf("%u", a); char a=65; printf("%c",a); printf("%s","ABC"); printf("%e", a); printf("%f", a); printf("%g", a); printf("%%"); float a=567.89; 567ff101567AABC5.67800e+002567.89000567.89%
第34页：表2printf()附加格式
表2printf()附加格式
说明符（修饰符）3.2顺序结构功能修饰符输出数据域宽，数据长度<m，左补空格；
否则按实际输出m对实数，指定小数点后位数(四舍五入)对字符串，指定实际输出位数n输出数据在域内左对齐（缺省右对齐)-指定在有符号数的正数前显示正号(+)+输出数值时指定左面不使用的空位置自动填00在八进制和十六进制数前显示前导0，0x#在d, o, x, u前，指定输出精度为long型在e, f, g前，指定输出精度为double型l
第35页：表3scanf()函数格式字符a值输入
表3scanf()函数格式字符a值输入
举例说明字符输入一个字符c输入十进制整型数d输入实型数，可以是带前导0的八进制数或带前导0x(或0X)的十六进制数i以八进制形式输入整型数，可以带前导0，也可以不带o以16进制形式输入整数，可带前导0x或0X，也可不带x按无符号十进制形式输入整数u以带小数点的形式或指数形式输入单精度(双精度)数f(lf)e(le)输入字符串s3.2顺序结构
scanf("%c",&a); scanf("%d",&a); scanf("%i",&a); scanf("%o",&a); scanf("%x",&a); scanf("%u",&a); scanf("%f",&a); scanf("%s",&a); 3.14abcB31010183B301
第36页：表4scanf()附加格式
表4scanf()附加格式
说明符(修饰符)3.2顺序结构功能符号抑制符，指定输入项读入后不赋给变量。
*指定输入数据宽度，遇空格或不可转换字符则结束。
m用于d、o、x前，指定输入为long型整数；
用于e、f前，指定输入为double型实数。
l用于d、o、x前，指定输入为short型整数。
h例1
scanf("%3d%*4d%f",&k,&f); 输入：123456787
scanf("%4d%2d%2d",&y,&m,&d); 例2输入：20111015
scanf("%2d%*3d%2d",&a,&b); 例3输入：1234567
scanf("%3c%2c",&c1,&c2); 输入：abcde
则:123
k,87
f4567不赋给变量
则：2011
y,10
m,15
则:12
a,345不赋给变量,67
则：'a'
c1,'d'
c2
第37页：复合语句和空语句
复合语句和空语句
使用情况C语言中复合语句经常用来表示一些控制结构的执行体。如循环结构的循环体、选择结构中某一条件的执行部分和函数的执行体等。
复合语句(也称“语句块”)
形式：{语句1;语句2;…语句n;}
说明
最后一个语句的分号“;”不能缺少
复合语句内，可有执行语句，还可有定义部分，定义部分应该出现在可执行语句的前面
C编译将整个{…}内的结构视作一条语句。
第38页：空语句
空语句
什么是空语句C程序的所有语句都必须由一个分号“;”结束。如果一个语句只有一个分号，这个语句叫“空语句”。
说明程序中有时需要用空语句来表示存在一条语句，但随意加分号也会导致逻辑上的错误，要特别小心。
功能空语句执行时不产生任何动作。
第39页：顺序程序设计举例
顺序程序设计举例
程序设计基本步骤
分析和分解问题将问题分解为输入、处理和输出三个部分：
首先分析题目要求的输入是什么，用什么方法输入，输入后怎样保存
其次应考虑对输入需要进行什么处理，需要什么空间开销，使用什么程序结构，处理结果如何保存等问题
最后考虑用什么方法和格式输出结果。
画出程序的基本轮廓(流程图，N-S图等工具)
实现该程序
第40页：3.2 顺序结构养成自顶向下分析和分解问
3.2 顺序结构养成自顶向下分析和分解问
题的思维习惯!
第41页：3.2 顺序结构错误的交换过程
3.2 顺序结构错误的交换过程
例1两个整型变量内容的交换。输入两整数给x和y，交换x和y的值，并输出交换前后x和y的值，验证是否正确交换。
分析
本例对输入输出的要求很明确，对输入数据的处理需要交换x和y的值。
不可以简单地用"x=y; y=x; "来实现。3.2顺序结构错误的交换过程:
x=y
y=x;xy
5535
第42页：为了不丢失x的原有值
为了不丢失x的原有值
必须在执行"x=y"之前，把x的值保存到临时变量t中，在执行了"x=y"之后，再把t中的值(原来x的值)赋给y，所以需要一个类型和x、y相同的临时变量。
这个过程和现实生活中交换两个容器中液体的方法类似，一定要借助第三个容器才能完成。3.2顺序结构正确的交换x和y的值的过程：
t=x
x=y
y=t;xy
53t533
第43页：程序#includem
程序#include<stdio.h>m
printf("Enterx&y:");//输入x和yprintf("交换前:x=%dy=%d\n",x,y); t=x; x=y; y=t; printf("交换后:x=%dy=%d\n",x,y); } 3.2顺序结构# include<stdio.h>如果去掉，编译会出现警告，但还能正确运行，上机调试时最好加上。运行结果:Eliter x＆y:234 678
ain(){intx, y, t;// t是临时工作单元
交换前:x＝234 y＝678交换后:x＝678y＝234
第44页：2ASCII码的使用和输出
2ASCII码的使用和输出
从终端输入一个数字字符，输出它的ASCII码，求出该数字字符表示的数值，输出以该值为序号的大写字母。
分析数字字符在计算机内用ASCll码表示，其对应数字值是整型数，用一个整型变量存放，相应序号的大写字母也保存在字符变量中，解决这类问题需要ASCll码编码规律的知识。
第45页：程序main(){charc1,c2
程序main(){charc1,c2
printf("输入一个字符:"); c1=getchar(); printf("%cASCll码%d\n",c1,c1); x=c1-'0'; c2='A'+x-1; printf("No.%d大写字母是%c\n",x,c2); } 
第46页：3.3 选择结构
3.3 选择结构
C语言提供了进行逻辑判断的选择语句，由选择语句构成的选择结构，可以根据逻辑判断的结果决定程序的不同流程。
是结构化程序设计的三种基本结构之一。
要设计选择结构程序，要考虑两个方面的问题：
一是在C语言中如何来表示条件
二是在C语言中实现选择结构用什么语句。
在C语言中表示条件，一般用关系表达式或逻辑表达式，它们是实现选择结构的基础。
实现选择结构用if语句或switch语句。
第47页：关系运算和逻辑运算
关系运算和逻辑运算
C语言中的逻辑值
用1来表示"真"，用0表示"假"
任何基本类型的值都可作为逻辑值使用。
所有非0的值(含负数)被当作"真"使用，而0值被当作"假"使用。
对于任一表达式，若值为0，就代表一个"假"值，只要值是非零都代表一个"真"值。
C89没专门的逻辑值，C99增加true和false
下面要讨论的关系表达式和逻辑表达式，运算的结果都会得到一个逻辑值。
第48页：关系运算符和关系表达式
关系运算符和关系表达式
关系运算概念将两个数据进行比较，判定两个数据是否符合给定的关系。实际上就是“比较运算”。例如：“a>b”中的“>”表示一个大于关系运算。
如果a的值是5，b的值是3，则大于关系运算“>”的结果为"真"，即条件成立
如果a的值是2，b的值是3，则大于关系运算“>”的结果为"假"，即条件不成立。
关系运算种类：>﹑>=﹑<﹑<=﹑==﹑!=
第49页：结合方向
结合方向
在关系运算符中(==﹑!=)(低)《(>﹑>=﹑<﹑<=) (高)(括号里的运算符优先级相同)
例如：c>a+b等价于c>(a+b)a>b!=c等价于(a>b)!=ca==b<c等价于a==(b<c)a=b>c等价于a=(b>c)3.3选择结构注意:"=="与"="!
(自左向右)
优先级别
与其它种类运算符的优先级关系赋值运算符(低)《关系运算符《算术运算符(高)
第50页：什么是关系表达式
什么是关系表达式
例如：下面的关系表达式都是合法的a>=b、(a=5)>(b=6)、'e'>'d'、a!=0
用关系运算符将两个表达式连接起来，进行关系运算的式子。
关系表达式的值
逻辑值"真"或"假"，用整型数1和0表示。
例如：计算下列关系表达式的值，其中：a=8，b=5，c=，f=5.12则：
第51页：3.3 选择结构
3.3 选择结构
a > b == c“>”的优先级高于“==”，先求(a>b)，关系成立，(a>b)的值为1，再求1==c的值，关系成立，值为1。
a + c < b“+”的优先级高于“＜”，先计算a+c的值，结果为9，再计算9＜b的值，关系不成立，所以值为0。
(a=8，b=5，c=1，f=5.12)
a>=b关系成立，表达式的值为1。
第52页：a＞b＞c
a＞b＞c
(a=8，b=5，c=1，f=5.12)式中运算符的优先级一致，从左向右结合，先计算a＞b，值为1，再计算1＞c，值为0。
(从数学角度看，a＞b＞c的关系成立，值应为1，C语言中关系运算符通常只用来比较两个对象的关系，多个对象比较，应使用逻辑运算完成)
f >= b关系运算符两侧的类型不一致，先按照双目运算类型转换原则进行类型转换(b转换成实型)再进行关系运算，关系成立，表表达式值为1。
第53页：关系运算注意事项
关系运算注意事项
C语言中一般不使用连续关系运算符的描述方式。其计算结果往往会出乎人们的预料。例：7 > 5 > 2希望的值为1，实际值为0。
表达式中常出现把“==”写成“=”的错误。例：inta = 0, b = 1;if(a = b)
应避免对实数作相等或不等的判断。例：1.0/3.0*3.0==1.0结果为：0改写为：fabs(1.0/3.0*3.0-1.0)<1e-
printf( "a=b" ); elseprintf ("a!= b");
进行关系运算的两个数据的类型不同时，按照算术运算同样的规则进行转换，再比较。
第54页：条件运算符和条件表达式
条件运算符和条件表达式
如果expr1的值为0 (条件为假)，计算expr3，并将结果作为整个条件表达式的值。
条件运算符?与:成对出现，是C中唯一的三目运算符。
条件表达式一般形式expr1?expr2:expr3
执行过程计算过程和结果依赖expr1
计算expr1
如果其值为非0(条件为真)，计算expr2，将结果作为整个条件表达式的值
第55页：不参加求值运算的部分表达式
不参加求值运算的部分表达式
类型转换：如果expr2和expr3的类型不同，表达式结果值取较高的类型。(*)如：x ?'a' :'b';x=0，值为'b'；x
当expr1的值为非0时，expr3不计算
当expr1的值为0时，expr2不计算。
优先级赋值运算《条件运算《关系和算术运算(高)
结合方式
(从右向左)如：a>b?a:c>d?c:d
a>b?a:(c>d?c:d)
0，值为'a'；x>y?1:1.5;x>y，值为1.0；x<y，值为1.5
第56页：条件运算符可嵌套如
条件运算符可嵌套如
x>y?x+1:x–1x > y的值为0，x-1的值得7，并将其作为整个表达式的值。不再计算x＋l。
x>y?x:ff的类型是float型，x的类型是int型，将x和y转换成float型。
x>0?1:(x<0?-1:0)
例1计算下列条件表达式的值，变量定义如下：intx=8,y=24,z;foatf=5.12
第57页：3.3 选择结构
3.3 选择结构
如果x值为0，x != 0的值为0，根本不会执行y/x，而去执行“:”后面的表达式即为常量1，将1赋给z。
( x = 8, y = 24)
z=x!=0?y/x:1
条件运算符的优先级高于赋值运算符，先计算赋值号右边的条件表达式。
计算x != 0得值1，y/x的值得3，将其作为条件表达式的值赋给z变量。
z的值也是整个表达式的值。
第58页：3.3 选择结构
3.3 选择结构
条件运算符连用，结合方法是从右向左，相当于：x > 0 ? 1 : ( x == 0 ? 0 :-1)
本例x的值为8，x > 0成立，取常量值1，它是整个表达式的值，所以不再计算：(x == 0 ? 0 :-1)
例2使用关系和条件表达式，可表示复杂条件。
如当x的值在闭区间[2,5]之内时，z变量的值取1，其他情况取0；
实现如下：z=(x>=2?(x<=5?1:0):0)
( x = 8, y = 24)
x>0?1:x==0?0:-1
第59页：3.3 选择结构
3.3 选择结构
条件表达式中复杂条件通过条件表达式的嵌套来实现，条件和满足条件应该进行计算的条件表达式嵌套书写在同一个语句行内，在格式上难于控制，当描述复杂条件时，不太直观，可读性差。
需要更简捷的描述方法。
条件表达式求值时只有部分表达式参加计算。
第60页：逻辑运算符和逻辑表达式
逻辑运算符和逻辑表达式
逻辑表达式是逻辑运算符和逻辑量组成的表达式；利用逻辑表达式可直接描述多个条件的组合；如多个条件之一成立或同时成立等。
逻辑运算符：是表示逻辑或命题运算的符号。
运算种类：&&(与)﹑||(或)﹑!(非)
优先级：||《&&《！(高)赋值《||《&&《关系《算术《！
结合方式：
(从左向右)
第61页：运算规则(见逻辑运算真值表)&&
运算规则(见逻辑运算真值表)&&
当且仅当两个运算量的值都为"真"时，运算结果为"真"，否则为"假"。
||：当且仅当两个运算量的值都为“假”时，运算结果为"假"，否则为"真"。
!：当运算量的值为"真"时，结果为"假"；
当运算量的值为"假"时，结果为"真"。
第62页：逻辑运算真值表
逻辑运算真值表
公式由逻辑运算真值表的后四列得到关系式：!(a&&b)=!a||!b!(a||b)=!a&&!b3.3选择结构!a&&!b!(a||b)!a||!b!(a&&b)!b!aa||ba&&bba1111110000001101101000111010010000001111
第63页：例1用逻辑表达式表示条件
例1用逻辑表达式表示条件
的逻辑表达式应为：!(x>3&&x<5)根据公式：!(a&&b)=!a||!b有：!(x>3&&x<5)=!(x>3)||!(x<5)=x<=3||x>=5本题条件简单，直接分析
结论：等价的肯定形式的表达式x<=3||x>=5比!(x>3&&x<5)的可读性好得多。
x的值属于开区间(3，5)
x的值不属于开区间(3，5)。
的逻辑表达式为：x>3&&x<5
也可得相同结果
第64页：短路特性逻辑表达式求解时
短路特性逻辑表达式求解时
并非所有的逻辑运算符都被执行，只是在必须执行下一个逻辑运算符才能求出表达式的解时，才执行该运算符。
例如：a&&b&&c只在a为真时，才判别b的值；
只在a、b都为真时，才判别c的值；
a||b||c只在a为假时，才判别b的值；
只在a、b都为假时，才判别c的值。
a=1;b=2;c=3;d=4;m=1;n=1;(m=a>b)&&(n=c>d)结果：m=0，n=
第65页：例2计算逻辑表达式的值
例2计算逻辑表达式的值
其中变量定义为：intx=3，y=0；
i=1。
!xx为3，即为真，否定运算后为假，即为0。
!(x = 2)(x=2)的值为2 (即真)，对其否定运算，值为假(即0)。
注意(x=2)是赋值表达式。
!(x==2)(x==2)的值为假(0)，对其否定运算，值为真(即1)。
注意(x==2)是关系表达式。
x&&yx的值为3(即为真)，继续计算y，y的值为0(即为假)，所以整个表达式的值为0。
y&&xy的值为0(假)，结果为0，故不再计算x；
第66页：3.3 选择结构
3.3 选择结构
(x=3，y=0；
i=1)y>i||x>i计算y>i的值，值为假(0)，继续计算x>i，值为真(1)。
所以整个表达式的值为1。
y<i||x<i计算y<i的值，条件成立，值为真(1)，所以整个表达式的值为1，不再计算x<i。
y!=0&&x/y>1y的值为0，y!=0的值为0，所以整个表达式的结果为0，不再计算y>1。
如果y的值不为0，则计算后面的表达式x/y>l。
小结
表示复杂条件直观、简捷、可读性好。
要特别注意短路特性
第67页：例3写出判断某一年是闰年逻辑表达式
例3写出判断某一年是闰年逻辑表达式
设y表示年的整型变量，闰年的条件是：y能被4整除，但不能被100整除；或y能被400整除。(y的值四位数如：2011)
用逻辑表达式表示闰年：(y%4==0&&y%100!=0)||y%400==0非闰年：!((y%4==0&&y%100!=0)||y%400==0)3.3选择结构被4整除被100整除被400整除
第68页：if语句
if语句
以一个逻辑条件作为选择的条件，条件成立时执行一种操作，不成立时执行另一种操作。2.if语句的三种形式(if﹑if_else和if_else_if)
printf("%d",x);
if语句作用
构造选择结构，实现对某些操作的选择执行。
形式一
格式：if(表达式){语句组;}
例：if(x>y)
执行过程：3.3选择结构表达式语句组非0=0
第69页：形式二
形式二
格式：if(表达式){语句组1;}[else{语句组2;}]
例：if(x>y)max=x;elsemax=y
执行过程：3.3选择结构表达式语句组1语句组2非0=0
第70页：3.3 选择结构
3.3 选择结构
if语句中“表达式”必须用"("和")"括起来
else子句(可选，不选时为形式一)是if语句的一部分，必须与if配对，不能单独使用
if和else下面的语句组，仅由一条语句构成时，可去掉花括号
if语句允许嵌套(在“语句组”中，又包含有if语句的情况)
第71页：嵌套时
嵌套时
else子句与if的匹配原则：与在它上面、距它最近、且尚未匹配的if配对。
例如：if()if()语句1elseif()语句2else语句33.3选择结构正确写法：if(){if()语句1}else{if()语句2else语句3}强烈建议：将内嵌的if语句,一律用花括号括起来,以明确匹配关系,避免匹配错误。
第72页：形式三
形式三
格式：if(表达式1){语句组1;}elseif(表达式2){语句组2;}…elseif(表达式n){语句组n;}else{语句组n+1;}
执行过程：3.3选择结构表达式1语句组1非0=0表达式2表达式n语句组2语句组n语句组n+1=0=0非0非0
第73页：例4*编程把学生成绩转换为等级
例4*编程把学生成绩转换为等级
main(){ floats; scanf("%f",&s); if(s>=90)g='A'; elseif(s>=80)g='B'; elseif(s>=70)g='C'; elseif(s>=60)g='D'; elseg='E'; printf("成绩:%3.1f",s); printf("等级:%c\n",g); }
90分以上等级为A，
60分以下等级为E，
其余10分一个等级。3.3选择结构
第74页：switch语句
switch语句
形式switch(表达式){case常量表达式1:语句组1;[break;]case常量表达式2:语句组2;[break;]……case常量表达式n:语句组n;[break;][default：语句组n+1;[break;]]}
作用直接处理多分支选择。
第75页：switch语句执行过程
switch语句执行过程
3选择结构表达式E1E2Endefaultcase语句组1…语句组2语句组n语句组n+1
第76页：3.3 选择结构
3.3 选择结构
每个case后面“常量表达式”的值，必须各不相同，否则会出现相互矛盾的现象(即对表达式的同一值，有两种或以上的执行方案)。
case后面的常量表达式仅起语句标号作用，并不进行条件判断。
系统一旦找到入口标号，就从此标号开始执行，所以必须加上break语句，以便结束switch语句。
3.3选择结构switch(表达式){case
E1:语句组1;[break;]caseE2:……[break;]…caseEn:……[break;]default：……[break;]}
switch后面的“表达式”，可以是int、char和枚举型中的一种。
第77页：各case及default子句的先后次序
各case及default子句的先后次序
多个case，可共用同一语句(组)。如：…case'A':case'B':case'C':
用switch语句实现的多分支结构程序，可以用if语句来实现。3.3选择结构switch(表达式){case
E1:语句组1;[break;]caseE2:……[break;]…caseEn:……[break;]default：……[break;]}
printf("s>60"); break;
不影响程序执行结果。
case后可包含多个可执行语句，且不必加{ }。
switch可嵌套。
第78页：实例已知某公司员工的保底薪水为500
实例已知某公司员工的保底薪水为500
某月所接工程的利润profit(整数)与利润提成的关系如下(计量单位为元)：profit≤1000没有提成；
1000＜profit≤2000提成10%；
2000＜profit≤5000提成15%；
5000＜profit≤10000提成20%；
10000＜profit提成25%。
第79页：算法设计要点为使用switch语句
算法设计要点为使用switch语句
必须将利润profit与提成的关系，转换成某些整数与提成的关系。
分析本题可知，提成的变化点都是1000的整数倍(1000、2000、5000、…)，如果将利润profit整除1000，则当：profit≤1000对应0、11000＜profit≤2000对应1、22000＜profit≤5000对应2、3、4、55000＜profit≤10000对应5、6、~、1010000＜profit对应10、11、…
第80页：解决相邻两个区间重叠的方法
解决相邻两个区间重叠的方法
是：profit先减1 (最小增量)，然后再整除1000即可。
profit≤1000对应01000＜profit≤2000对应12000＜profit≤5000对应2、3、45000＜profit≤10000对应5、6、~、910000＜profit对应10、11、…3.3选择结构01k2k3k4k5k6k7k8k9k10k11k12kprofit0123456 7891011 12grade2520151050提成(%)
第81页：程序*main(){intprofit
程序*main(){intprofit
printf("Inputprofit:"); scanf("%d",&profit); grade=(profit-1)/1000; 完整语句见下页 }} 
第82页：switch
switch
(grade)//根据grade，计算salary的值{case0:break;//profit≤1000case1:salary+=profit*0.1;break;//1000~≤2000case2:case3://2000＜profit≤5000case4:salary+=profit*0.15;break;case5:case6:case7:case8://5000＜profit≤10000case9:salary+=profit*0.2;break;default:salary+=profit*0.25;//10000＜profit}
第83页：3.4 循环结构
3.4 循环结构
用于完成程序中需要重复执行的操作，它是结构化程序设计的三种基本结构之一。
熟练掌握选择结构和循环结构的概念及使用是程序设计的最基本要求。
在C语言中有三种可以构成循环结构的循环语句：
for语句
do-while语句
while语句
第84页：while语句
while语句
一般形式：while(表达式){循环体语句组;}
特点：先判断表达式，后执行循环体
执行过程：
说明：
循环体有可能一次也不执行
循环体可为任意类型语句
下列情况，退出while循环：
条件表达式不成立(为零)
循环体内遇break，return，goto
无限循环while(1)循环体;3.4循环结构表达式循环体为0非0
第85页：例1while循环计算1+2+…+n的值
例1while循环计算1+2+…+n的值
分析：循环结构程序设计的一个重要工作是确定在计算过程中的重复动作，并将它们用适当的循环形式正确描述。
要建立一个循环结构，需解决的问题：
如循环中涉及哪些变量
这些变量在循环开始前应该给什么值
循环过程中这些变量的值如何改变
在什么情况下继续或结束循环
循环终止后如何得到所需要的结果等。
第86页：该例有一个重复的累加
该例有一个重复的累加
次数由n决定。
累加的对象是一个int变量，将它设为i，其值由1到n。
累加的中间结果用sum表示。
循环开始前i的初值为1，sum的初值为0，循环过程中，sum记录每次累加的结果，i的值依次递增
结束条件是i>n(循环条件是i≤n)。
循环结束时sum即为所求的和。
第87页：程序*
程序*
#include<stdio.h>main(){ inti,n,sum; scanf("%d",&n); i=1; sum=0; while(i<=n){ sum=sum+i; i++; } printf("sum=%d\n",sum); } 3.4
第88页：do_while语句
do_while语句
while循环的循环体可能一次也不执行，而do_while的循环体至少执行一次。3.4循环结构为0非0表达式循环体
一般形式：do{循环体语句组;}while(表达式)
执行过程：
特点：先执行循环体，后判断表达式。
说明：
do~while可转化成while结构。
do~while与while结构重要的区别是：
在书写上，循环的控制条件出现位置不同
第89页：2*用do_while循环计算1+2+…
2*用do_while循环计算1+2+…
#include<stdio.h>main(){ inti,n,sum; scanf("%d",&n); i=1; sum=0; do{ sum=sum+i; i++; } while(i<=n); printf("sum=%d\n",sum); } 3.4
第90页：for语句
for语句
常用形式for(循环变量赋初值;循环条件;变量增值){循环体语句组;}3.4循环结构表达式2循环体为0非0表达式1表达式3
一般形式：for([表达式1];[表达式2];[表达式3]){循环体语句组;}
执行过程：
说明：
for的三个表达式类型任意，都可省略，但“;”不可省
无限循环：for(;;)
for可以转换成while结构
第91页：例3*用for循环计算1＋2＋…＋n的值
例3*用for循环计算1＋2＋…＋n的值
#include<stdio.h>main(){ inti,n,sum; scanf("%d",&n); for(i=1,sum=0; i<=n; i++)sum=sum+i; printf("sum=%d\n",sum); }
第92页：循环嵌套
循环嵌套
概念
循环语句的循环体内，又包含另一个完整的循环结构，称为循环的嵌套。
的概念，对所有高级语言都是一样的。
说明
三种循环可互相嵌套，层数不限。
外层循环可包含两个以上内循环，但不能相互交叉。
第93页：嵌套循环的执行流程
嵌套循环的执行流程
嵌套循环的跳转禁止情况：
从外层跳入内层
跳入同层的另一循环
向上跳转。3.4循环结构外循环内循环
while(){…while( ){…}…}
while(){…do{…} while();…}
do{…do{…}while();…} while( )
for( ; ; ){…do{…}while();……while(){…}…}
第94页：例4*输出下三角形状的乘法九九表
例4*输出下三角形状的乘法九九表
9--------------------------------------------------
main(){ inti,j; for(i=1; i<=9; i++)printf("%4d",i); for(i=1; i<=38; i++)printf("%c",'-'); for(i=1; i<=9; i++)//循环体执行一次,打印一行{ for(j=1; j<=i; j++)printf("%4d",i*j); } printf("\n"); } 3.4循环结构运行结果:
1
2
3
4
5
6
7
8
1
2 4
3 6 9
4 8 12 16
5 10 15 20 25
6 12 18 24 30 36
7 14 21 28 35 42 49
8 16 24 32 40 48 56 64
9
18
27
36
45
54
63
72
81
第95页：控制语句
控制语句
break不能用于循环语句和switch语句之外的任何其它语句之中。3.4循环结构表达式…break;…为0非0while循环
break语句
形式：break
功能：
在循环语句和switch语句中
终止并跳出循环体或开关体。
对循环控制的影响：
说明：
break只能终止并跳出最近一层的结构
第96页：5*循环体中break语句执行示例mai
5*循环体中break语句执行示例mai
printf("s=%d\n",s); } } 3.4循环结构与if配合使用运行结果:s = 1s = 3
n(){inti,s=0;for(i=1;i<=100;i++){s=s+i;if(s>5)break
第97页：continue语句
continue语句
结束本次循环，跳过循环体中尚未执行的语句，进行下一次是否执行循环体的判断，仅用于循环语句中。
对于for循环，跳过循环体其余语句，转向循环变量增量表达式的计算；对于while和do-while循环，跳过循环体其余语句，但转向循环继续条件的判定。
形式：continue
功能：
说明：continue只能用于循环语句中。
第98页：对循环控制的影响
对循环控制的影响
main()//输入数据用空格分开{ intnum=0,sum=0,i,a; for(i=0; i<10; i++){ scanf("%d",&a); if(a<=0)continue; num++; sum+=a; } printf("正数的个数：%d\n",num); printf("平均值：%6.2f\n",1.0*sum/num); } 3.4循环结构表达式…continue; …为0非0while循环与if配合使用
(见图)
例6*求十个整数中正数的个数及其平均值
第99页：goto语句
goto语句
标号的作用：标号可以写在任何语句前面(标号：语句行)，在程序中起标记作用，作为某个转移的目的地，程序不为其分配空间。
形式：goto标号;…标号：语句
功能：无条件转向标号所在的语句行执行。
说明：
标号的命名：遵循标识符命名规则
标号唯一：goto语句中的标号只能出现在goto所在函数内，且唯一。
第100页：用goto语句能构成循环
用goto语句能构成循环
限用goto语句：结构化程序设计方法，主张限制使用goto语句。因为滥用goto语句，将会导致程序结构无规律、可读性差。
main(){ intn=1,sum=0; loop:sum+=n; n++; if(n<=100)gotoloop; printf("sum=%d\n",sum); }
(但for语句可代替)如*：用goto语句构成循环算1+2+…+n的值
第101页：循环结构中的常用机制
循环结构中的常用机制
增量、减量运算符(++、--)增量、减量运算符在循环中经常用来改变循环控制变量的值。
如for语句的表达式3部分、while和do_while结构的循环体内经常出现。
逗号运算符(,)逗号常用在for语句头部，表达式1中变量赋初值和表达式3中循环变量更新的操作中。
循环结构是构造复杂C程序必用的结构，下面将归纳循环中常用的一些结构和控制机制。
复合赋值在循环体内进行累加、累乘和递减等操作。
第102页：空语句空语句是单独的分号"
空语句空语句是单独的分号"
"，用在程序中语法上需要一条语句、但又什么都不需要做的地方。
使用空语句可保证语法结构的完整性。
如for结构的循环体部分为空，就在其位置上用";"表示。
如果没有此分号，紧接for语句的下一个语句将被编译器解释为地的循环体。
printf("i=%d\n",i);
printf("i=%d\n",i); 
第103页：无限循环程序中表示
无限循环程序中表示
无限循环的常用结构有：while(1)循环、for(;;)循环。无限循环的循环体内一定要有选择结构和beak语句以便最终从循环结构中退出来。
控制语句break，continue，goto
break控制跳出本层循环
continue控制跳过本次循环体中尚未执行的语句，再次开始循环条件的判断
goto和标号结合使用实现任意转移。
第104页：循环结构设计实例
循环结构设计实例
数学方面循环结构在数学问题求解方面有广泛的应用，比如求数列第n项或前n项的和、迭代求解方程的根和使用矩阵解线性方程等。
分析：分析第n项和n的关系，本题有两个累加，第n项的分母由前一项分母加n得到，是int型。
前n项的和由前n-1的和加第n项得到，是float。
循环控制变量用inti表示，i的变化范围从1~n。
例6计算
第105页：实现用两种循环结构实现
实现用两种循环结构实现
#include<stdio.h>main(){ inti,n,s; scanf("%d",&n); s=0; sum=0.0for(i=1; i<=n; i++){ s+=i; sum+=1.0/s; }} 3.4循环结构for(s=0, sum=0.0,i=1; i<= n; i++)可改为for(s=0, sum=0.0,i=1; i<=n; s +=i, sum +=1.0/s,i++); 可改为这种形式可读性差，应避免。与循环控制无关的操作，如本例的s+=i和sum+=1.0/s应尽量放在循环体内。
请比较两者的特点。
采用for循环方法的程序
第106页：采用while循环方法
采用while循环方法
#include<stdio.h>main(){ inti,n,s; floatsum; scanf("%d",&n); s=0; sum=0.0; i=1while(i<=n){ s+=i; sum+=1.0/s; i++; } printf("sum=&f\n",sum); } 3.4循环结构循环体内用到的三个变量需要在循环体外赋初值。循环体内与循环条件有关的变量i的值要改变，
第107页：例7用二分法求方程
例7用二分法求方程
如果函数f(x)在区间[x1，x2]上是单调的，则可以根据f(x1)和f(x2)是否同号来确定方程f(x)=0在区间[x1，x2]内是否有一个实根。
(f(x)=((2*x-4)*x+3)*x–6)
如果f(x1)和f(x2)不同号，则f(x)=0在区间[x1，x2]内有一个实根，如果f(x1)和f(x2)同号，则f(x)=0在区间[x1，x2]内无实根。
2x3－4x2＋3x－6=0在(－10，10)之间的根。
分析
第108页：二分法的思路
二分法的思路
再将[x1，x2]一分为二，判断哪个区间有根，如此不断进行下去，直到区间足够小为止。
3.4循环结构x0为x1与x2间的中点x2f(x2)>0x0f(x0)>0x1f(x1)<0
首先确定x1和x2使f(x1)和f(x2)不同号
第109页：具体方法
具体方法
做下列操作：输入x1和x2的值；计算f(x1)和f(x2)：fx1=f(x1)，fx2=f(x2)直到f(x1) * f(x2) < 0。
做下列操作：x0 = (x1+x2) / 2计算f(x0)：fx0 = f(x0)if ( f(x0) * f(x1) < 0) x2 = x0，fx2 = fx0else x1 = x0，fx1 = fx0直到f(x0) < 10-5
程序*
第110页：#include
#include
main(){ floatx0,x1,x2,fx0,fx1,fx2; do{ printf("Enterx1&x2:"); scanf("%f%f",&x1,&x2); fx1=x1*((2*x1-4)*x1+3)-6; fx2=x2*((2*x2-4)*x2+3)-6; } while(fx1*fx2>0); do{ x0=(x1+x2)/2; fx0=x0*((2*x0-4)*x0+3)-6; if(fx0*fx1<0){ x2=x0; fx2=fx0; } else{ x1=x0; fx1=fx0; } } while(fabs(fx0)>1e-5); printf("x=%6.2f\n",x0); } 3.4循环结构运行结果:Enter x1&x2:1 8
<math.h>
x =
第111页：8用迭代法求方程x3－x－1=0
8用迭代法求方程x3－x－1=0
迭代法解决问题的关键是找到迭代公式，首先把方程变换为迭代公式；即：xn= (xn-1+1)1/3
在x=1.5附近的根。
分析
依题，用1.5作迭代的初值，结束条件为两次近似解之差的绝对值小于0.0001。
第112页：程序*
程序*
#include<stdio.h>#include<math.h>main(){ floatx1,x=1.5; do{ x1=x; x=pow((x1+1),1.0/3.0); } while(fabs(x-x1)>=0.0001); printf("x=%f\n",x); } 3.4循环结构运行结果:x = 1.324726不能写成：x-x1==0
第113页：例9*求菲波那契数列第n项的值
例9*求菲波那契数列第n项的值
分析：数列迭代解法的关键是寻找前后项间的关系，本例有：U1=U2=1，Un=Un-1+Un-2。
main(){ intk,n,u1,u2,u; scanf("%d",&n); u1=u2=1; if(n<=2)u=1; elsefor(k=3; k<=n; k++){ u=u1+u2; u1=u2; u2=u; } printf("u=%d\n",u); } 3.4循环结构变量的变化：1123 5u1u2u运行结果:10
u=55
第114页：分析问题抽象算法
分析问题抽象算法
数学问题因为有成熟的数学模型，算法描述相对容易。但这类问题是初学者进行程序设计最好的练习项目，而且也是初学者应该首先掌握的部分。
分析问题、抽象算法的过程训练是一个长期和坚苦的过程，在初级程序设计课程中只是刚刚起步。
序设计最困难的地方是把实际问题抽象成适合用程序语言描述的操作。
第115页：输入数据的处理要保证程序的正确和健壮
输入数据的处理要保证程序的正确和健壮
程序中对各种错误的输入应该尽可能地做出反应，有些程序对接受输入的反应有功能上的特殊要求，这些都要在输入数据处理中讨论。
我们已经知道，操作系统和C程序标准输入函数采用缓冲的输入方式，在键盘上输入一些字符后，只有按过“Enter”键之后，这些字符才被操作系统送给程序，之后标准输入函数才能读到输入的字符。
第116页：例10*从键盘接收一个表示半径的浮点数
例10*从键盘接收一个表示半径的浮点数
程序运行时由用户输入数据，这对程序员是一个挑战，因为正在执行中的程序无法知道外界提供什么样的信息。
怎样使程序具有对付异常输入的能力，基本的原则应当是尽可能处理所有可能出现的情况，程序中设法获取有关输入的情况就显得尤为重要。
第117页：main(){floatx
main(){floatx
scanf("%f",&x)<1)//
printf("没收到数据\n重新输入："); while(getchar()!='\n');} elseif(x<0)//
printf("输入错误\n重新输入:"); while(getchar()!='\n');} elsebreak;} 3.4循环结构若无此句输入非法字符时，会死循环。利用scanf的返回值判断输入情况。如输入为：abc
while(1){if(
输入项数<1{
非法数据：负数{
得到正常输入值，结束循环}
则返回值<1
第118页：例11编写程序
例11编写程序
结束标记的字符'\n'的处理下面一段程序可以将输入字符序列输出，但是作为结束标记的字符'\n'，不能再作为程序中的正常输入字符。intc;do{c=
getchar(); printf("%c",c); } while(c!='\n'); 
第119页：任意可输入(可编码)字符处理
任意可输入(可编码)字符处理
getchar()函数可以接收所有由键盘输入的字符，C语言的标准库定义了一个常量EOF(EndOfFile)做为文件结束符，getchar()执行中遇到EOF时，就返回EOF。程序中用EOF来判断是否已经读完输入字符。TurboC(VC也适用)将EOF定义为-1(与任意可编码字符的编码不同)。因此，getchar()的返回值是整型。从键盘上输入EOF的方法是：Ctrl+z在VC中在字母后按Ctrl+z无效，必须在新一行(“回车”后)才有效即：
Ctrl+z
第120页：程序*
程序*
#include<stdio.h>//该句若省略，EOF无定义main(){ intc; while(1){ c=getchar(); if(c==EOF)//按
printf("%c",c); } } 3.4循环结构while((c=getchar())!= EOF)printf ( "%c", c ); 可改为运行结果:abcd efgh hijk
Ctrl+z
程序结束break
abcd efgh hijkABCD EFGH
ABCD EFGHCtrl+z
第121页：例12统计单词的使用频率
例12统计单词的使用频率
单词是由空格、制表符和换行符分隔的语言单位，需要三个计数器，统计输入序列中的行数、单词数和字符数。
设置inword为状态标记，为0表示当前字符不在单词中(是分隔符)，为1表示当前字符在单词中。
包括行数、单词数和字符数，要求使用标准输入。
分析
循环结构中不断读入字符并进行判断和统计，结束条件是读入文件结束符。
第122页：程序*
程序*
#include<stdio.h>main(){ intc,inword=0,row=0,wordnum=0,charnum=0; while((c=getchar())!=EOF)//Ctrl+z结束{ charnum++; inword=1; wordnum++; } } if(inword==1)row++; printf("Chars=%d\n",charnum); } 3.4循环结构CnraeleW0101111100110inword
第123页：例13编写输入口令的程序
例13编写输入口令的程序
输入口令时，起码的要求应该是不能将刚键入的口令字符显示在屏幕上，其次，应该让用户知道自己已经键入了几个字符。
getchar函数没这样的功能。
这里介绍一个函数getch()，它不使用缓冲区，可立即无回显地(不在屏幕上显示)从键盘读入一个字符。
利用getch()可以识别功能键和箭头键等特殊键，相关功能请参考的库函数介绍，相关的头文件是conio.h。
分析
常规的处理是每键入一字符，显示一个'*'。
第124页：程序*
程序*
#include<stdio.h>#include<conio.h>main(){ charc; while((c=getch())!='\r')//回车不能用'\n'putchar('*');}
第125页：其他问题循环结构是枚举(穷举)算法常
其他问题循环结构是枚举(穷举)算法常
例14“百鸡百钱”问题：设公鸡5元一只，母鸡3元一只，小鸡1元三只，求100元买100只鸡的方法？
用的结构。
第126页：程序*
程序*
#include<stdio.h>main(){ intx,y,z; for(x=0; x<=20; x++)//x为公鸡数for(y=0; y<=33; y++)//y为母鸡数for(z=0; z<=100; z++)//z为小鸡数if(z%3==0&&x+y+z==100&&5*x+3*y+z/3==100)printf("x=%2d,y=%2d,z=%2d\n",x,y,z); } 3.4循环结构运行结果:x= 0, y=25, z=75x= 4, y=18, z=78x= 8, y=11, z=81x=12, y= 4, z=84
第127页：3.5 小结使用三种基本结构和它们的组合
3.5 小结使用三种基本结构和它们的组合
可以构造各种各样的复杂C程序，本章主要介绍的是C语言中三种基本结构的语法及使用。包括以下一些主要内容。
选择结构包括条件表达式、关系表达式和逻辑表达式及其运算, if、switsh语句的使用等。
顺序结构包括赋值、标准输入输出函数和复合语句的使用。
循环结构包括for、while和do_while的使用方法。
控制语句含break、coninue和goto的作用和用法。
第128页：三种基本结构是程序设计的基础
三种基本结构是程序设计的基础
要熟练掌握它们的使用方法，熟悉各种控制机制的机理。本章的关键点是：
关系表达式、逻辑表达式的求值
条件语句、循环语句的执行过程
标准输入的工作过程
控制语句的合理使用等。