C语言程序设计初步

zw2004

Ｃ语言程序设计
( }" c: X" t& u2 r; \4 k; ?( s; |) Y9 l$ g+ t* \; v. \
本课介绍Ｃ语言程序设计的基本方法和基本的程序语句。
5 I3 B9 K" u  ]8 e从程序流程的角度来看，程序可以分为三种基本结构， 即顺序结构、分支结构、循环结构。 这三种基本结构可以组成所有的各种复杂程序。Ｃ语言提供了多种语句来实现这些程序结构。 本章介绍这些基本语句及其应用，使读者对Ｃ程序有一个初步的认识， 为后面各章的学习打下基础。
- Q1 z1 d( C7 b, i4 w" Y7 K5 u2 a( n# x( N) O3 J* ^3 _8 d  e# \7 j
Ｃ程序的语句7 z6 D" `1 K3 j- q4 H/ o+ P
9 y+ B4 _4 j0 s$ N, I2 T- X4 {
Ｃ程序的执行部分是由语句组成的。 程序的功能也是由执行语句实现的。
6 e5 e, y6 H9 c" I% R4 gC语句可分为以下五类：
# y1 B$ k" B2 B; ?. l  S- Q1.表达式语句$ Q. q) q( ]- o: p/ G$ t
2.函数调用语句! O& _% h4 P: \  ~' I
3.控制语句/ R+ b/ d) P- r8 W0 y  R$ p, P
4.复合语句
* K% ]6 t5 ~% V' w5.空语句
4 M6 S" K- ]" L- u
2 \4 i" o% ^* D% [! N, o* E2 P' v1.表达式语句
2 T' t2 @, m/ A# E; i) A
) l! `: ]$ u0 G. ~) c" Y& j表达式语句由表达式加上分号“；”组成。其一般形式为： 表达式； 执行表达式语句就是计算表达式的值。例如： x=y+z; 赋值语句y+z; 加法运算语句，但计算结果不能保留，无实际意义i++; 自增1语句，i值增1# k2 v$ E( z) n5 m% P2 L8 C6 d

/ {) l  q4 T5 k+ O1 I  B( q7 B
* ]7 V  D8 S( a3 g) S: [2 l2.函数调用语句
9 r& c5 Z9 a  V: I4 L) F- {5 z, \
: ^- p! ~, ]5 k由函数名、实际参数加上分号“；”组成。其一般形式为： 函数名(实际参数表)； 执行函数语句就是调用函数体并把实际参数赋予函数定义中的形式参数，然后执行被调函数体中的语句，求取函数值。(在第五章函数中再详细介绍)例如printf("C Program");调用库函数，输出字符串。
, ^0 F$ k  A! N7 ]4 c# z9 \- L3 C( P
3.控制语句
8 k& J& q$ l. }  Z' X  V
8 l1 p# C0 H$ {* n3 E控制语句用于控制程序的流程， 以实现程序的各种结构方式。
( j3 X; G1 h- G8 r它们由特定的语句定义符组成。Ｃ语言有九种控制语句。 可分成以下三类：$ @( w) e7 N! A8 K2 Y" o
(1) 条件判断语句
8 d" v. |: g* ~　　if语句，switch语句
  h# f: ~9 J% ?) i: Z/ n# n(2) 循环执行语句
. r4 \9 j7 x. U- t( E; L　　do while语句，while语句，for语句9 l  L5 Y1 [: N  U. D2 f. w) D8 Y  W2 X- \
(3) 转向语句
) x& C/ T) M- n) K& j& }　　break语句，goto语句，continue语句，return语句& ^, b) B) T. y+ B/ Z5 }

5 j! ^& o7 \# {  k4.复合语句- I+ {; d# l; G6 |

# |3 O! U% x0 I! ^7 A. z把多个语句用括号{}括起来组成的一个语句称复合语句。 在程序中应把复合语句看成是单条语句，而不是多条语句，例如 % O' _  d" i7 h: K! n' A
{2 ~9 C5 e* ~* W
x=y+z;
' G1 r: y/ j, J' h( ?a=b+c;2 U0 x$ I& p4 n9 Z% R
printf(“%d%d”，x，a)；: L" Z: B, a, d) x! Y9 O
}! Q3 r5 \! X/ H
是一条复合语句。复合语句内的各条语句都必须以分号“;”结尾，在括号“}”外不能加分号。$ B9 a' E/ r1 i  K/ A0 n4 V

% l1 l1 b4 e  F# z7 s7 \; B+ V" L4 ^5.空语句5 d  H1 o5 }- H5 x+ a

+ b* @; C; h4 I: ~9 ]5 C, _& W2 `只有分号“；”组成的语句称为空语句。 空语句是什么也不执行的语句。在程序中空语句可用来作空循环体。例如 while(getchar()!='\n'); 本语句的功能是，只要从键盘输入的字符不是回车则重新输入。这里的循环体为空语句。+ x/ D# ^# G) s8 z- X% h
* H- x9 N- K% p- q! r0 D
赋值语句, P1 \" y5 b7 y1 c

$ r( \  k: i4 {; e. V赋值语句是由赋值表达式再加上分号构成的表达式语句。 其一般形式为： 变量=表达式; 赋值语句的功能和特点都与赋值表达式相同。 它是程序中使用最多的语句之一。 在赋值语句的使用中需要注意以下几点：! k. p: y) q8 _( u" I0 h

8 h" S1 x6 `/ S, ^/ {, J1.由于在赋值符“=”右边的表达式也可以又是一个赋值表达式，因此，下述形式 变量=(变量=表达式); 是成立的，从而形成嵌套的情形。其展开之后的一般形式为： 变量=变量=…=表达式; ! I$ ^+ h% J4 o" Z
例如：- ~. L# c/ k: b9 {; O; p) a
a=b=c=d=e=5;按照赋值运算符的右接合性，因此实际上等效于： 8 n( [6 ~* a+ H. @% V% c2 Y$ O% m
e=5;
0 w8 H2 v# }8 O+ Q! d+ jd=e;( }% E( o8 b$ G( k; D6 m0 S
c=d;4 t3 K: a' a6 W7 c
b=c;% d7 Q; [4 M! e" z; }9 ~* O5 Y, p
a=b;
0 b- g  N5 B$ s- v( @2.注意在变量说明中给变量赋初值和赋值语句的区别。给变量赋初值是变量说明的一部分，赋初值后的变量与其后的其它同类变量之间仍必须用逗号间隔，而赋值语句则必须用分号结尾。 + }' g1 ~1 ^# p, A) C3 ~
3.在变量说明中，不允许连续给多个变量赋初值。 如下述说明是错误的： int a=b=c=5 必须写为 int a=5,b=5,c=5; 而赋值语句允许连续赋值
  j$ Q4 }/ i2 H5 }7 L4.注意赋值表达式和赋值语句的区别。赋值表达式是一种表达式，它可以出现在任何允许表达式出现的地方，而赋值语句则不能。
1 L2 P' b5 A. Z下述语句是合法的： if((x=y+5)>0) z=x; 语句的功能是，若表达式x=y+5大于0则z=x。下述语句是非法的： if((x=y+5;)>0) z=x; 因为=y+5;是语句，不能出现在表达式中。
8 R  w% w" }% D* H1 r( M( g0 B. e! {7 _% W/ n+ ]9 c$ G, c7 ]
数据输出语句
6 X9 S0 {! ?' {4 w0 R( r+ M
3 |( `4 m: m8 @# ]本小节介绍的是向标准输出设备显示器输出数据的语句。在Ｃ语言中，所有的数据输入／输出都是由库函数完成的。 因此都是函数语句。本小节先介绍printf函数和putchar函数。printf函数printf函数称为格式输出函数，其关键字最末一个字母f即为“格式”(format)之意。其功能是按用户指定的格式， 把指定的数据显示到显示器屏幕上。在前面的例题中我们已多次使用过这个函数。3 r: y9 R/ Z9 H! i& i

0 u% i# x5 U/ Q/ o* e7 Q. }  t一、printf函数调用的一般形式/ m) {4 {2 r5 f& R: `
- O1 r7 w% z" l- S
printf函数是一个标准库函数，它的函数原型在头文件“stdio.h”中。但作为一个特例，不要求在使用 printf 函数之前必须包含stdio.h文件。printf函数调用的一般形式为： printf(“格式控制字符串”，输出表列)其中格式控制字符串用于指定输出格式。 格式控制串可由格式字符串和非格式字符串两种组成。格式字符串是以%开头的字符串，在%后面跟有各种格式字符，以说明输出数据的类型、形式、长度、小数位数等。如“%d”表示按十进制整型输出，“%ld”表示按十进制长整型输出，“%c”表示按字符型输出等。后面将专门给予讨论。
! o' k7 X" E" r1 S* J) b7 x7 h
* t4 Q" R0 w, c9 m4 ^( d非格式字符串在输出时原样照印，在显示中起提示作用。 输出表列中给出了各个输出项， 要求格式字符串和各输出项在数量和类型上应该一一对应。
5 Y: T0 n4 r; z0 E' Q6 p6 tvoid main()
& f4 V, E# ~& P8 `" s. n4 X{
- Z2 H" o- K" |  P. U1 mint a=88,b=89;
6 T  Q/ ?# Q3 Z3 J, \printf("%d %d\n",a,b);* p; G7 b/ l7 {) Y& w
printf("%d,%d\n",a,b);
' x) h1 Q. G9 Yprintf("%c,%c\n",a,b);
( p+ E' U3 k. X) O6 |+ {; b8 sprintf("a=%d,b=%d",a,b);
" v: x  ~2 D! Q2 J2 d9 \; ~; [}
) f5 |  E; H' r0 g& Y/ O6 ya<--8,b<--89
1 D5 \/ z. v- U2 ]" q% n  y6 d# D3 h4 [% g1 ?6 ?
printf("%d %d\n",a,b);/ }: s; ~# J) N5 e0 a
printf("%d,%d\n",a,b);. ]: I' P4 |2 K* O
printf("%c,%c\n",a,b);& ?5 I, z) T7 ?: g8 ^
printf("a=%d,b=%d",a,b);( ~+ ], M6 O6 h, [- E
本例中四次输出了a,b的值，但由于格式控制串不同，输出的结果也不相同。第四行的输出语句格式控制串中，两格式串%d 之间加了一个空格(非格式字符)，所以输出的a,b值之间有一个空格。第五行的printf语句格式控制串中加入的是非格式字符逗号， 因此输出的a,b值之间加了一个逗号。第六行的格式串要求按字符型输出 a,b值。第七行中为了提示输出结果又增加了非格式字符串。

zw2004

二、格式字符串
1 Q+ Z* U/ G8 j8 q
- j% ~' X+ S- ?+ P) ^在Turbo C中格式字符串的一般形式为： [标志][输出最小宽度][.精度][长度]类型 其中方括号[]中的项为可选项。各项的意义介绍如下：* a7 `6 X9 X* M( Z6 D3 b
1.类型类型字符用以表示输出数据的类型，其格式符和意义下表所示：  I! O/ @! G( u$ r' n3 g
表示输出类型的格式字符 　　　　　　格式字符意义
5 h0 _# g% C7 i& ~4 d. Q( u& ud 　　　　　　　　　　　　　　　　以十进制形式输出带符号整数(正数不输出符号)
0 q; ^0 J' J! lo 　　　　　　　　　　　　　　　　以八进制形式输出无符号整数(不输出前缀O)
3 }& D) F( L  r8 Q$ U3 Ex 　　　　　　　　　　　　　　　　以十六进制形式输出无符号整数(不输出前缀OX)
" P  L. J! V7 U: k; eu 　　　　　　　　　　　　　　　　以十进制形式输出无符号整数
" _" H' U9 o8 z; a9 m4 gf 　　　　　　　　　　　　　　　　以小数形式输出单、双精度实数9 ^4 _$ y2 D$ f
e 　　　　　　　　　　　　　　　　以指数形式输出单、双精度实数
+ e9 y3 H; r' \% G0 O$ d* A! v; hg 　　　　　　　　　　　　　　　　以%f%e中较短的输出宽度输出单、双精度实数
3 S. i+ X, m5 m9 G2 f2 nc 　　　　　　　　　　　　　　　　输出单个字符
8 a* m: c* y& p1 b, N2 I6 hs 　　　　　　　　　　　　　　　　输出字符串, C& T3 P& v7 j$ R
2.标志" Q* U% X! e! O; X7 ^5 F
标志字符为-、+、#、空格四种，其意义下表所示： 3 E: C6 X% t, k  U7 Z7 i5 p. P
标志格式字符 　　　　　标 志 意 义
- u8 ~7 J$ s" o, c( Q) h9 k- 　　　　　　　　　结果左对齐，右边填空格5 L' L' P$ O8 F+ g  w
+ 　　　　　　　　　输出符号(正号或负号)空格输出值为正时冠以空格，为负时冠以负号
, J' u) M5 a% `4 Q/ o# 　　　　　　　　　对c，s，d，u类无影响；对o类， 在输出时加前( p6 N. r7 V$ ^3 Q; c0 {+ _
缀o　　　　　　　　 对x类，在输出时加前缀0x；对e,g,f 类当结果有小数时才给出小数点
5 _. T& U: F5 k9 M. G3.输出最小宽度
  ^: F# U6 J0 {! A用十进制整数来表示输出的最少位数。 若实际位数多于定义的宽度，则按实际位数输出， 若实际位数少于定义的宽度则补以空格或0。
( P' c0 i; m7 n# m4.精度- [/ N2 x# v6 @# ?8 ~
精度格式符以“.”开头，后跟十进制整数。本项的意义是：如果输出数字，则表示小数的位数；如果输出的是字符， 则表示输出字符的个数；若实际位数大于所定义的精度数，则截去超过的部分。
. r# s7 j- \' g/ j7 _) Q5.长度) i# ]6 u+ W2 @! }0 B
长度格式符为h,l两种，h表示按短整型量输出，l表示按长整型量输出。
% B6 P; S6 K5 l/ p& T5 A. P1 \void main(){
- `/ Q& E: |9 n. U; Q# mint a=15;9 n' C: \4 b$ T0 e* @
float b=138.3576278;  s% j" w4 s7 M/ g8 ?% x# w2 j
double c=35648256.3645687;/ H3 \* J8 |$ ~0 X
char d='p';
1 D. R+ O" w' @  p7 A3 Q3 s, n+ |printf("a=%d,%5d,%o,%x\n",a,a,a,a);
) T0 }$ I% o# f, z3 ?# `printf("b=%f,%lf,%5.4lf,%e\n",b,b,b,b);0 p+ \  K  {9 [- ^* t6 W
printf("c=%lf,%f,%8.4lf\n",c,c,c);
1 f- G. \; v5 r) }# |printf("d=%c,%8c\n",d,d);% s( x% d$ x: |2 V
} a<--15
  L) O# v( h- Q$ V; n" nb<--138.3576278
) B9 H3 F4 z: ~& g1 r" b. ^c<--35648256.3645687
, F' m' R& i( `d<--'p'/ ?, A$ i+ S2 ^% _+ @0 g) e. K$ m' O

) F/ |" f9 K* ^main()
4 k7 F$ E. \. a  M4 G5 \3 a{" Z, I3 x5 P' g0 D5 c% E2 z# m8 L
int a=29;! u' d, F( j" t
float b=1243.2341;
" b( p- k* w8 \. A! D) Gdouble c=24212345.24232;& ]  ]2 o+ f3 P( p9 H% x
char d='h';6 F% ?6 o: V) t  a
printf("a=%d,%5d,%o,%x\n",a,a,a,a);
6 B* t9 M/ k' X9 yprintf("b=%f,%lf,%5.4lf,%e\n",b,b,b,b);
& Z1 M& m. K( X  |$ Dprintf("c=%lf,%f,%8.4lf\n",c,c,c);: Y- t! q. s$ ?0 c
printf("d=%c,%8c\n",d,d);
" z. X- p. `6 F/ a" [# `$ ^" |}
  N& }1 G4 N5 \1 x6 w8 W7 z/ m# t本例第七行中以四种格式输出整型变量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个空格。# O- o* V. B6 v0 N( L! G" c

8 \  Z  W, a% s2 j7 o0 o; V使用printf函数时还要注意一个问题， 那就是输出表列中的求值顺序。不同的编译系统不一定相同，可以从左到右， 也可从右到左。Turbo C是按从右到左进行的。如把例2.13改写如下述形式：
7 d' C, m0 V( y' K* {void main(){6 @1 A6 d9 n) l
int i=8;
  c; P; p) k% ?. H, R  n% Jprintf("%d\n%d\n%d\n%d\n%d\n%d\n",++i,--i,i--,i++,-i--);0 V1 @# Q2 A' A$ i5 N' l; W$ o
} i<--81 C7 }* ?& Z$ W% q) Z0 V% a
$ o5 a! N5 K( f3 o" q+ c
这个程序与例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。但是必须注意， 求值顺序虽是自右至左，但是输出顺序还是从左至右， 因此得到的结果是上述输出结果

zw2004

字符输出函数. |1 i  D1 {6 J8 t
6 }4 ~- B' n* I+ A
putchar 函数
3 ]9 n& T3 J. P: l
6 T2 u4 P2 c3 D: Nputchar 函数是字符输出函数， 其功能是在显示器上输出单个字符。其一般形式为： putchar(字符变量) 例如：
% {: z- {3 y7 @% M( e2 ^1 @# Hputchar('A'); 输出大写字母A
4 ~2 T& f) p! Uputchar(x); 输出字符变量x的值: I3 |# j1 P# r/ e8 T! M0 ~- r( R7 t
putchar('\n'); 换行 对控制字符则执行控制功能，不在屏幕上显示。 使用本函数前必须要用文件包含命令：
- [1 w: U: `% Q4 c' Z#include<stdio.h>
) T5 Y: Z* G& E  A0 w5 S" ?2 f! X# ^void main(){, w2 r9 O, s, J! k1 S8 O) |7 q- c
char a='B',b='o',c='k';' U' F1 y2 Z; }. B5 z+ C5 o
putchar(a);putchar(b);putchar(b);putchar(c);putchar('\t');3 |4 B  \& a3 M7 Q& D! ^
putchar(a);putchar(b);2 N/ F6 p) |0 V2 X% e, d. a% c
putchar('\n');
8 C# W8 J1 ?) L! F( C) Sputchar(b);putchar(c);
: V7 g6 F6 G+ `' B}  W& B- C, y# j8 ^( f- G
- W4 q* Q; t6 P* ^
数据输入语句4 E: X% e/ m2 S3 F" T) Q

; ?4 b3 `- H) i8 z) d2 p, JＣ语言的数据输入也是由函数语句完成的。 本节介绍从标准输入设备—键盘上输入数据的函数scanf和getchar。 scanf函数 scanf函数称为格式输入函数，即按用户指定的格式从键盘上把数据输入到指定的变量之中。' C, X' _: _% J) E( ?5 z: |- v
; |. d* S' S$ ^. f0 V4 f
一、scanf函数的一般形式 5 L2 Y' r- L9 N. y4 P+ s9 C
, i6 k% C/ A6 O5 o: V0 }5 W0 ^
scanf函数是一个标准库函数，它的函数原型在头文件“stdio.h”中，与printf函数相同，Ｃ语言也允许在使用scanf函数之前不必包含stdio.h文件。scanf函数的一般形式为： scanf(“格式控制字符串”，地址表列); 其中，格式控制字符串的作用与printf函数相同，但不能显示非格式字符串， 也就是不能显示提示字符串。地址表列中给出各变量的地址。 地址是由地址运算符“&”后跟变量名组成的。例如，&a,&b分别表示变量a和变量b 的地址。这个地址就是编译系统在内存中给a,b变量分配的地址。在Ｃ语言中，使用了地址这个概念，这是与其它语言不同的。 应该把变量的值和变量的地址这两个不同的概念区别开来。变量的地址是C编译系统分配的，用户不必关心具体的地址是多少。 变量的地址和变量值的关系如下： &a--->a567 a为变量名，567是变量的值，&a是变量a的地址。在赋值表达式中给变量赋值，如： a=567 在赋值号左边是变量名，不能写地址，而scanf函数在本质上也是给变量赋值，但要求写变量的地址，如&a。 这两者在形式上是不同的。&是一个取地址运算符，&a是一个表达式，其功能是求变量的地址。2 t8 X( A+ I) y) Y" L8 k# U
void main(){
0 E0 q6 n8 B3 \7 }: Aint a,b,c;
: U: ]) l/ h" Sprintf("input a,b,c\n");
- u" r# M/ y. [, L. K' X& w2 _scanf("%d%d%d",&a,&b,&c);
* ]" E2 U4 E/ @8 b# |) }printf("a=%d,b=%d,c=%d",a,b,c);7 c; {9 G& A, X
}
0 D* z3 Z8 f+ e注意&的用法!
3 B' O# e+ |2 o- q4 W2 p& h/ |在本例中，由于scanf函数本身不能显示提示串，故先用printf语句在屏幕上输出提示，请用户输入a、b、c的值。执行scanf语句，则退出TC屏幕进入用户屏幕等待用户输入。用户输入7、8、9后按下回车键，此时，系统又将返回TC屏幕。在scanf语句的格式串中由于没有非格式字符在“%d%d%d”之间作输入时的间隔， 因此在输入时要用一个以上的空格或回车键作为每两个输入数之间的间隔。  G  G5 H1 K+ D
如： 7 8 9
; m& n! t6 B# b! v  v7 b或
, Y6 V9 w5 ^9 }) M7
6 C# K( `' W$ n" U3 O3 o8 s7 L6 W8( f1 b; l$ Z. o0 ~* [0 R" F
97 h/ t( _- C8 `4 F! g$ j
格式字符串- R- O$ k3 m+ c! x, |  |

1 Y( I, h5 _( j格式字符串的一般形式为： %

[输入数据宽度][长度]类型 其中有方括号[]的项为任选项。各项的意义如下：- o5 B: G! J; p- I" Y, @
1.类型
1 q& _$ D5 J& D+ Q* U% x- F" m5 e表示输入数据的类型，其格式符和意义下表所示。
: j3 j( x! g4 U3 M0 C格式 　　　字符意义 ; M' d* I  C) ~8 R9 h# S$ x  {4 ?
d 　　　　输入十进制整数  q9 B5 L6 o! T
o 　　　　输入八进制整数3 S) @- H/ Z3 c  ?
x 　　　　输入十六进制整数8 M; K8 @! E0 w
u 　　　　输入无符号十进制整数
2 a; h" X0 |4 Q- E1 _- I. N) Tf或e 　　 输入实型数(用小数形式或指数形式)! k" R9 ?' ]5 O& I) m4 h+ x
c 　　　　输入单个字符
3 m3 \8 L3 B  I+ l' k& V/ Ys 　　　　输入字符串) o4 D3 ^* ?1 }  s: O
2.“*”符/ N' y6 U+ I! w- }$ D: E2 q
用以表示该输入项读入后不赋予相应的变量，即跳过该输入值。 如 scanf("%d %*d %d",&a,&b);当输入为：1 2 3 时，把1赋予a，2被跳过，3赋予b。
# C' `7 O' m# ?3.宽度1 [2 D6 k2 U* _* Z! z
用十进制整数指定输入的宽度(即字符数)。例如： scanf("%5d",&a);. N' e% u7 o/ C, L6 v
输入：; o7 ?5 e* {( M2 k
12345678
7 ~0 `8 p- B8 r. h# u0 J, }" o6 p只把12345赋予变量a，其余部分被截去。又如： scanf("%4d%4d",&a,&b);8 L% p2 |3 \# C5 F( o
输入：4 P, N$ Q- n' H( }  C( B
12345678将把1234赋予a，而把5678赋予b。: E, [2 ?, l/ @' _
4.长度
: L& N' r+ n/ e/ Q- r, J长度格式符为l和h，l表示输入长整型数据(如%ld) 和双精度浮点数(如%lf)。h表示输入短整型数据。1 X' }1 `! W6 e; _/ `
使用scanf函数还必须注意以下几点：$ ^; f3 }7 @, }( J
a. scanf函数中没有精度控制，如： scanf("%5.2f",&a); 是非法的。不能企图用此语句输入小数为2位的实数。
/ k0 @9 `: c, L+ j$ @b. scanf中要求给出变量地址，如给出变量名则会出错。如 scanf("%d",a);是非法的，应改为scnaf("%d",&a);才是合法的。1 Z' Y$ [$ I6 n+ U- I( I
c. 在输入多个数值数据时，若格式控制串中没有非格式字符作输入数据之间的间隔则可用空格，TAB或回车作间隔。C编译在碰到空格，TAB，回车或非法数据(如对“%d”输入“12A”时，A即为非法数据)时即认为该数据结束。% G  X( f7 n2 E1 O2 |, i
d. 在输入字符数据时，若格式控制串中无非格式字符，则认为所有输入的字符均为有效字符。例如：( v9 g  K' R1 D+ a/ }" \
scanf("%c%c%c",&a,&b,&c);
1 J0 @+ A" H; r0 ~输入为：& I2 L  t$ x  y& S& {
d e f
. S# \: Z7 P! q* m9 c& S  y则把'd'赋予a, 'f'赋予b,'e'赋予c。只有当输入为：# m" \! _; w1 t3 W  }/ f2 F
def
0 y- x8 O0 i. Z, Q# d% X* q时，才能把'd'赋于a,'e'赋予b,'f'赋予c。 如果在格式控制中加入空格作为间隔，如 scanf ("%c %c %c",&a,&b,&c);则输入时各数据之间可加空格。% K7 x8 k* h5 C6 t% z, X
void main(){6 l1 n- s6 Q: N$ }
char a,b;1 K) Z" K6 g# ?* E' g
printf("input character a,b\n");4 c4 e4 T% D7 y
scanf("%c%c",&a,&b);7 k- i# l2 [) i: Y$ N' O
printf("%c%c\n",a,b);
' P% @6 P8 f1 l/ d}
% o  S: Q- y6 {scanf("'C14F14%c%c",&a,&b);) ~& ]1 @; @- h
printf("%c%c\n",a,b); 由于scanf函数"%c%c"中没有空格，输入M N，结果输出只有M。
; g  {! r% \7 {% n而输入改为MN时则可输出MN两字符，见下面的输入运行情况： input character a,b( U2 ?# u  Z. O  U5 p
MN
- j' C% ^4 B5 T& Z) b6 TMN  {9 U) @, Q4 ?' M* ^3 \. c
void main(){
* E7 B; J  u- j1 Achar a,b;3 c) _$ j; U+ t# [$ m, r1 P
printf("input character a,b\n");
! h: _7 C) ~' l) `% V% z$ G3 {( {scanf("%c %c",&a,&b);( h' n- Y1 N5 e1 A6 u
printf("\n%c%c\n",a,b);5 M8 R* `1 p, ?5 {
}# g2 h+ N0 A7 u
scanf("%c %c",&a,&b); 本例表示scanf格式控制串"%c %c"之间有空格时， 输入的数据之间可以有空格间隔。e. 如果格式控制串中有非格式字符则输入时也要输入该非格式字符。
6 o% Q# a; B  m* ~/ ?9 E例如：
6 t' ^. Y' K) ]* z2 b6 dscanf("%d,%d,%d",&a,&b,&c); 其中用非格式符“ , ”作间隔符，故输入时应为： 5,6,7
; `' w* h0 f5 J) Z! q又如： scanf("a=%d,b=%d,c=%d",&a,&b,&c);
) g" e8 U) u9 T6 L+ H6 f. n! Q1 Y则输入应为
+ I3 C7 \* M  t: v0 _, F; fa=5,b=6,c=7g. 如输入的数据与输出的类型不一致时，虽然编译能够通过，但结果将不正确。; W( e, s$ L% |9 k; ]
void main(){, i* y* O$ Q# c" S
int a;; k" A0 r: t1 p3 G4 o: i
printf("input a number\n");
1 t% {7 x) n+ ~scanf("%d",&a);0 ^: c3 M- W7 b- J! `
printf("%ld",a);* [* B( n3 x6 Y' t3 l& T
}
/ \/ Y. T8 ?2 ^& Y" B# r: x由于输入数据类型为整型， 而输出语句的格式串中说明为长整型，因此输出结果和输入数据不符。如改动程序如下： ; M, x0 M* S5 \/ l* U
void main(){
! I# R9 r2 v; Rlong a;) X4 r7 y# d9 E; u
printf("input a long integer\n");
8 r# `. @1 r8 N' j$ U3 B& `3 o2 Nscanf("%ld",&a);9 {# y& h# D0 y, \- ?3 ~
printf("%ld",a);$ A  a2 a! N8 C. o
}
2 [! ^1 L" }/ T0 D- Z运行结果为：
8 k7 a1 d0 V- Z" }9 s4 O& f/ vinput a long integer
) s. k- B8 v4 s4 B1234567890# }, g$ q: f4 Q* r
1234567890 当输入数据改为长整型后，输入输出数据相等。' u6 {( W+ T$ |8 d

- c" H* t0 W$ H8 G! f# w, Z; m+ Z键盘输入函数: X0 s7 Q! z* Z  N8 v( ~
getchar函数getchar函数的功能是从键盘上输入一个字符。其一般形式为： getchar(); 通常把输入的字符赋予一个字符变量，构成赋值语句，如：
2 j" K4 d* L, G5 `/ h8 d, V0 z. e/ ychar c;
' }2 ~' k% N+ V' [; x1 Y9 S7 D. c4 Kc=getchar();6 l0 y! k/ q, W2 K" J+ l+ A: e
#include<stdio.h>
* `" L$ k) `( s$ X7 q3 b! Xvoid main(){
. K* X, m4 s4 Pchar c;! M7 d( O; x5 \6 n
printf("input a character\n");6 z9 L: l, Y) v& T. l8 p
c=getchar();1 ^8 M1 j: t1 {6 {
putchar(c);
/ z2 x  _0 q. J. b" g' r" ?}

zw2004

使用getchar函数还应注意几个问题：! @$ K4 F7 c9 q
1.getchar函数只能接受单个字符，输入数字也按字符处理。输入多于一个字符时，只接收第一个字符。
  v' R, b! `% j: J2.使用本函数前必须包含文件“stdio.h”。 , Y/ x, H0 X+ a8 g
3.在TC屏幕下运行含本函数程序时，将退出TC 屏幕进入用户屏幕等待用户输入。输入完毕再返回TC屏幕。
! {+ I; T0 f9 T0 K1 t  Zvoid main(){
: n- `$ Q) |" B  ]char a,b,c;
. G% V: S+ a/ G8 U1 Hprintf("input character a,b,c\n");
0 T# ]8 Q& d( a/ y& fscanf("%c %c %c",&a,&b,&c);/ z& R# W! @0 _: E( Z! S6 [
printf("%d,%d,%d\n%c,%c,%c\n",a,b,c,a-32,b-32,c-32);9 m7 c9 z/ }7 d" F+ ]/ Y/ E
}
$ M2 e% ^7 Z0 t, Z输入三个小写字母: t* y& @* q$ ^. n/ T$ D# y
输出其ASCII码和对应的大写字母。
; W1 V. O2 \# F! v: H( b8 ]void main(){# y1 U  ~: d" N, I# P# z
int a;4 K6 H8 L( U* b! x1 n
long b;. M  Y& t$ q; l/ J8 Y
float f;# e# l/ Q1 P, A; n* j" N
double d;. t- f& U! |5 O
char c;
! y* _/ P" K8 T: pprintf("%d,%d,%d,%d,%d",sizeof(a),sizeof(b),sizeof(f). ~: [  ?" Q# n9 _' q0 n  A
,sizeof(d),sizeof(c));
  z7 U& H! K% d1 X, y. o% s* I; L}% m" i' F& D+ L' h
输出各种数据类型的字节长度。0 T8 U4 F! F- F# ^
分支结构程序
3 l1 q" I" K! I+ {0 x8 ~
7 r: ?/ H5 s1 N$ ~1 y) l关系运算符和表达式
3 }2 C" ]( h% Y6 r1 m$ _2 X1 U
& o7 e& }# n5 I/ K* K! i; q. b' F在程序中经常需要比较两个量的大小关系， 以决定程序下一步的工作。比较两个量的运算符称为关系运算符。 在Ｃ语言中有以下关系运算符：) X5 R$ [% ^6 p7 B) }
< 小于
4 d, M6 S* t. S<= 小于或等于 ' w6 \) y' d% ?% V4 ^  ?& x$ D, ^1 {
> 大于
& `  n8 r! c/ J4 I: c5 a9 v>= 大于或等于& N+ F" l& H8 Z' x
== 等于( G1 O4 X# Y2 n+ [' r9 p7 Y
!= 不等于
; d- q4 Y3 j& S! F7 `% t, t关系运算符都是双目运算符，其结合性均为左结合。 关系运算符的优先级低于算术运算符，高于赋值运算符。 在六个关系运算符中，<,<=,>,>=的优先级相同，高于==和!=，==和!=的优先级相同。
& }1 [8 q0 Y' J" E1 E5 j$ T- w关系表达式2 \$ a2 n5 {3 c
关系表达式的一般形式为： 表达式 关系运算符 表达式 例如：a+b>c-d,x>3/2,'a'+1<c,-i-5*j==k+1;都是合法的关系表达式。由于表达式也可以又是关系表达式。 因此也允许出现嵌套的情况，例如：a>(b>c),a!=(c==d)等。关系表达式的值是“真”和“假”，用“1”和“0”表示。8 K" j! Z( l5 _' G' G9 L
如： 5>0的值为“真”，即为1。(a=3)>(b=5)由于3>5不成立，故其值为假，即为0。$ o3 N/ P/ ^3 ^  e  c1 s
void main(){; c3 [4 q% d( w1 m* m. |
char c='k';
8 f! p$ Q# U5 d% Lint i=1,j=2,k=3;
. b& Q# l; R; [- [$ {float x=3e+5,y=0.85;
7 {. X! \# Q; n  Kprintf("%d,%d\n",'a'+5<c,-i-2*j>=k+1);5 Q4 N! Y1 h, E3 O" ~0 V2 {
printf("%d,%d\n",1<j<5,x-5.25<=x+y);% y* B+ N$ {' i' n
printf("%d,%d\n",i+j+k==-2*j,k==j==i+5);
4 Z7 ?/ x/ s1 g  Z3 E/ f}9 a  }5 a7 t0 F1 l! S1 z
char c='k';
9 X! X9 ^, {! k4 Q( j& d) G0 z6 Tint i=1,j=2,k=3;
! z. M" a# I1 @1 ofloat x=3e+5,y=0.85;
: s- G1 G. W) wprintf("%d,%d\n",'a'+5<c,-i-2*j>=k+1);9 a& c- M- `) _  R2 F" U
printf("%d,%d\n",1<j<5,x-5.25<=x+y);
$ t0 Q; P4 y' }6 oprintf("%d,%d\n",i+j+k==-2*j,k==j==i+5);
3 g5 Q) M9 V8 v  v) F7 J在本例中求出了各种关系运算符的值。 字符变量是以它对应的ASCII码参与运算的。对于含多个关系运算符的表达式，如k==j==i+5,根据运算符的左结合性，先计算k==j,该式不成立，其值为0，再计算0==i+5，也不成立，故表达式值为0。
- x. S4 s1 j9 {4 d0 t$ d# e3 g3 \3 s) m& l9 s
逻辑运算符和表达式
5 i/ B6 {" q+ ]; Z: i5 s( P) A
+ o0 g8 t& C7 T7 B! L逻辑运算符Ｃ语言中提供了三种逻辑运算符 && 与运算　|| 或运算　! 非运算 与运算符&&和或运算符||均为双目运算符。具有左结合性。 非$ \) U5 q$ y( d# a- \/ K
运算符!为单目运算符，具有右结合性。逻辑运算符和其它运算符优先级的关系可表示如下： ! F5 t  u+ ~* |. E$ R0 @# b
按照运算符的优先顺序可以得出：
& K; I! t- G3 T9 n( b; s& ?* ja>b && c>d等价于(a>b) && (c>d)
/ r) M4 h- M9 p6 l  x!b==c||d<a等价于((!b)==c)||(d<a)( w; v, E' ^2 S7 k, S' G4 {
a+b>c && x+y<b等价于((a+b)>c) && ((x+y)<b)3 t$ M3 t- c* ^& L! A' d( x
逻辑运算的值% |" T' B% s7 U( @# E
逻辑运算的值也为“真”和“假”两种，用“1”和“0 ”来表示。其求值规则如下：' x1 r1 X% u6 _) k: v( n% P
1.与运算&&参与运算的两个量都为真时，结果才为真，否则为假。例如，5>0 && 4>2,由于5>0为真，4>2也为真，相与的结果也为真。
# E( H. u1 X) H3 K3 K2.或运算||参与运算的两个量只要有一个为真，结果就为真。 两个量都为假时，结果为假。例如：5>0||5>8,由于5>0为真，相或的结果也就为真7 b9 b% F5 g2 x: V+ }) {6 z3 p
3.非运算!参与运算量为真时，结果为假；参与运算量为假时，结果为真。
. b+ A3 E* E$ l* ?6 s$ i例如：!(5>0)的结果为假。& d8 V. b( H/ d
虽然Ｃ编译在给出逻辑运算值时，以“1”代表“真”，“0 ”代表“假”。 但反过来在判断一个量是为“真”还是为“假”时，以“0”代表“假”，以非“0”的数值作为“真”。例如：由于5和3均为非“0”因此5&&3的值为“真”，即为1。7 E& L' v% Q3 @& T" X
又如：5||0的值为“真”，即为1。  @' z" l# ?" p5 v: W1 ^; C
逻辑表达式逻辑表达式的一般形式为： 表达式 逻辑运算符 表达式 其中的表达式可以又是逻辑表达式，从而组成了嵌套的情形。例如：(a&&b)&&c根据逻辑运算符的左结合性，上式也可写为： a&&b&&c 逻辑表达式的值是式中各种逻辑运算的最后值，以“1”和“0”分别代表“真”和“假”。
: B; w3 q+ \6 svoid main(){
+ A: B2 ~  Q0 g7 a# mchar c='k';- `) S) H. C* s0 J4 j3 o
int i=1,j=2,k=3;
* |5 \( I  P# Bfloat x=3e+5,y=0.85;
5 q0 E* [. Y- Wprintf("%d,%d\n",!x*!y,!!!x);
' h3 E( v, z& p; p3 Qprintf("%d,%d\n",x||i&&j-3,i<j&&x<y);$ R& U, a3 G9 E" Z. W
printf("%d,%d\n",i==5&&c&&(j=8),x+y||i+j+k);
8 D' a- s5 p9 Q}8 L8 J/ [5 _! D2 |  h9 F  \
本例中!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<j&&x<y式，由于i<j的值为1，而x<y为0故表达式的值为1，0相与，最后为0，对i==5&&c&&(j=8)式，由于i==5为假，即值为0， 该表达式由两个与运算组成，所以整个表达式的值为0。对于式x+ y||i+j+k　由于x+y的值为非0，故整个或表达式的值为1。! v, H1 C- `5 A$ G1 l! e
, D, a7 c+ I" X7 C2 a
ｉｆ语句
  O6 q( u7 ~5 t# X2 {& D+ @
, r  I2 C- V, [, T用if语句可以构成分支结构。它根据给定的条件进行判断， 以决定执行某个分支程序段。Ｃ语言的if语句有三种基本形式。* B/ @( D8 N: e7 v- c& X. K

, Z' r8 j5 {- ~4 L1.第一种形式为基本形式 if(表达式) 语句； 其语义是：如果表达式的值为真，则执行其后的语句， 否则不执行该语句。其过程可表示为下图
$ ?8 H7 g+ l2 R2 yvoid main(){# y' Z% }6 q1 w* o0 l5 J
int a,b,max;
0 w& f" o* B& ^$ q/ ^: `' R$ Oprintf("\n input two numbers: ");
) E5 v. \4 p, J: D# d' ^+ R; lscanf("%d%d",&a,&b);
$ A$ V! Q' ^+ ~6 Ymax=a;& J' P; _$ ?- E, E. B
if (max<b) max=b;8 `# a, `6 x) Z& F+ L- E
printf("max=%d",max);
1 ^. S4 a* }; Q+ D}
$ a; P# a* m( u输入两个整数，输出其中的大数。 ) u- r, D0 V) Z
scanf("%d%d",&a,&b);
. S, Y: G: M6 ]3 Omax=a;
+ C: D& i1 v3 ^/ m! Jif (max<b) max=b;! @7 C( G! v9 h5 _
printf("max=%d",max);
$ x+ `* B3 S' j% u. h1 ?7 |3 j9 r# E9 j. M' Q
本例程序中，输入两个数a,b。把a先赋予变量max，再用if语句判别max和b的大小，如max小于b，则把b赋予max。因此max中总是大数，最后输出max的值。
* v/ X, H) S# ]8 G4 Z5 V5 H2.第二种形式为if-else形式 , G& S) Q$ l+ ?% r( [( f
if(表达式) + m2 f# R5 g7 I& p$ Z
语句1； 5 D4 m. |; k2 B5 S; p
else 5 \, o/ W/ S3 ]% [1 a; |1 Q& o
语句2；
" `1 e3 r& P% R6 r+ D其语义是：如果表达式的值为真，则执行语句1，否则执行语句2 。
' [4 c5 j! d$ V* d9 }void main(){( h$ j0 `7 F) f& Y; I
int a, b;# X. u+ b! U1 r/ ^4 d: v
printf("input two numbers: ");
  }* _! r$ a  @! rscanf("%d%d",&a,&b);/ o; L' V. w1 q
if(a>b)  X2 e$ I/ s# U' A( [0 W9 |; \& h+ Y
printf("max=%d\n",a);
8 _0 M( P0 `. O) Helse, F8 f& z8 a9 X2 a) T7 g
printf("max=%d\n",b);% X4 q* |; Z1 J6 L9 y+ `1 Q$ @
}1 p9 `: |' s$ k7 p, ^1 R
输入两个整数，输出其中的大数。改用if-else语句判别a,b的大小，若a大，则输出a，否则输出b.
  g4 r/ v$ a( |3.第三种形式为if-else-if形式0 ^7 k: T( d7 u; d
前二种形式的if语句一般都用于两个分支的情况。 当有多个分支选择时，可采用if-else-if语句，其一般形式为：
( d' i1 i8 X- V( Z' S3 W' b4 aif(表达式1)
2 T6 N; y9 ]0 ]5 J语句1；
9 R* a! c$ I& ^, Zelse if(表达式2)
4 v; r- y3 e0 h, ?1 R' C语句2； ( }- |/ p3 W8 U5 M# u- k
else if(表达式3) 7 i* E2 w  w  ?! G+ F# F* v
语句3；
  J7 `0 l. |9 |$ S…
8 d! r4 A$ ^2 @: C! T! t: q4 A2 Yelse if(表达式m) - y- e  V  f) B1 {' Z7 Y3 Q9 ]; l
语句m；
! z6 i3 L6 V3 z! Q% ^4 m, l* Delse
% }; M/ \* z/ B- G, O, X语句n； 4 n+ C+ w3 A' m) z4 k( M. `! B  K
其语义是：依次判断表达式的值，当出现某个值为真时， 则执行其对应的语句。然后跳到整个if语句之外继续执行程序。 如果所有的表达式均为假，则执行语句n 。 然后继续执行后续程序。 if-else-if语句的执行过程如图3—3所示。+ l8 P0 Q$ O( R2 b- ]
#include"stdio.h"
) [* _: Z' G9 F& I. H4 qvoid main(){" z) `/ ]5 }, g* t( l' g
char c;
% {7 w* h4 {( `  L( Q3 @& oprintf("input a character: ");/ |$ n. g, m) q4 a8 c- Z& a
c=getchar();9 Y3 j- g& i5 O, j5 K( g/ y5 [. [
if(c<32)
6 W2 T  Z0 @4 r( |- J4 m' `printf("This is a control character\n");
" H8 |( r5 _' t; F) f  I4 y% E* pelse if(c>='0'&&c<='9')0 P6 N1 S9 h& W2 B/ \
printf("This is a digit\n");
- d. ?* y2 P1 _/ {, Kelse if(c>='A'&&c<='Z')! q% q3 H! m' u3 f/ n
printf("This is a capital letter\n");
' J  `$ v. X3 R7 s* l" telse if(c>='a'&&c<='z')$ k" x1 L/ F. u9 S
printf("This is a small letter\n");% P- n0 L4 C7 k
else+ `: K4 c4 N6 U0 N
printf("This is an other character\n");
7 g' d2 Q$ Y% Z- A}
  n9 a  H* p* }, k# Q; }本例要求判别键盘输入字符的类别。可以根据输入字符的ASCII码来判别类型。由ASCII码表可知ASCII值小于32的为控制字符。 在“0”和“9”之间的为数字，在“A”和“Z”之间为大写字母， 在“a”和“z”之间为小写字母，其余则为其它字符。 这是一个多分支选择的问题，用if-else-if语句编程，判断输入字符ASCII码所在的范围，分别给出不同的输出。例如输入为“g”，输出显示它为小写字符。

zw2004

4.在使用if语句中还应注意以下问题! _* S5 f3 p; S
' C$ @  l: R5 f1 K: r1 e: n
(1) 在三种形式的if语句中，在if关键字之后均为表达式。 该表达式通常是逻辑表达式或关系表达式， 但也可以是其它表达式，如赋值表达式等，甚至也可以是一个变量。例如： if(a=5) 语句；if(b) 语句； 都是允许的。只要表达式的值为非0，即为“真”。如在if(a=5)…；中表达式的值永远为非0，所以其后的语句总是要执行的，当然这种情况在程序中不一定会出现，但在语法上是合法的。
" A8 `9 V8 c5 H, l& F9 c: k又如，有程序段： if(a=b)
7 Z# r! e$ l. Lprintf("%d",a);
' I  o( Q* o3 w' u. K/ I+ L3 Jelse
: y/ H! L4 C& \printf("a=0"); 本语句的语义是，把b值赋予a，如为非0则输出该值，否则输出“a=0”字符串。这种用法在程序中是经常出现的。6 _5 x* \5 u- A$ e

9 }. @' b/ |# f3 a% l: f(2) 在if语句中，条件判断表达式必须用括号括起来， 在语句之后必须加分号。8 X! F& w. h8 y, v% v; V

6 ]2 J; ]& K# O( O2 y8 w(3) 在if语句的三种形式中，所有的语句应为单个语句，如果要想在满足条件时执行一组(多个)语句，则必须把这一组语句用{} 括起来组成一个复合语句。但要注意的是在}之后不能再加分号。) x( Z) Q5 D% a
例如：
( n; v+ U5 f; H" F$ q4 a) Hif(a>b){
  ^4 r( {: F/ m+ k* ya++;
, t' B' M; r$ w! N7 j: nb++;
/ f- ?  e9 e9 y' M, U- m/ S}
( ]) _# G8 K' f; L3 T0 o9 welse{
5 B, [: @, `( V/ U# `, oa=0;5 A9 l: [( @& ~. n& F
b=10;! k6 b/ Z) ?- T( _% e" [9 u
}
6 D8 |* \$ j5 M# V0 S9 {! t) b% }" K, P: w" |- f8 M' p$ |
ｉｆ语句的嵌套: X5 z. s1 a# W( q/ ?5 g, L

% _. h  l' g8 S9 l/ s, U# f4 ]当if语句中的执行语句又是if语句时，则构成了if 语句嵌套的情形。其一般形式可表示如下： ' E3 B/ b' G* j
if(表达式) 7 s; s1 x4 m" O. f; Q0 @
if语句；
  ^) W* Z  ]& Z或者为
, o' I/ M, f' ?  o1 |if(表达式) ' |! F5 Q* v6 U0 N0 C: |
if语句；
1 C+ n/ j* k1 j: l8 p: C5 Kelse 9 C$ L8 k$ z8 o
if语句； # ?! Y2 Y* C/ r) D
在嵌套内的if语句可能又是if-else型的，这将会出现多个if和多个else重叠的情况，这时要特别注意if和else的配对问题。例如：
) B5 v; _7 a, ~- Z5 r# E, r# U8 ~. xif(表达式1)6 T3 L* R) W8 k) A$ T
if(表达式2)
: `% }6 N2 G) \1 D+ [语句1；* l- Y( D8 S* o7 ~( N/ B
else
6 C/ y9 m+ c4 F) m: v+ b% B+ ^' ~语句2；
2 c+ X' Q5 M* q3 Q5 L4 \7 R其中的else究竟是与哪一个if配对呢?
* i5 V3 g5 r# ?% B应该理解为：　　　还是应理解为：
6 ?8 z4 u7 s+ o+ M% z2 Aif(表达式1) 　　　if(表达式1)) V9 L2 X7 ^6 n0 J
　if(表达式2) 　　　　if(表达式2)
8 S" L; F; ?7 p" H5 Q　　语句1； 　　　　　　语句1；
7 M. ^' ]; H! R: x7 f" T) Gelse 　　　　　　　 else3 f8 c- Z$ c4 ^2 D
　　语句2； 　　　　　　语句2；
8 Q2 a( B4 _- H5 v: H8 W为了避免这种二义性，Ｃ语言规定，else 总是与它前面最近的if配对，因此对上述例子应按前一种情况理解。
& S- D  B+ U/ j& l# x比较两个数的大小关系。
. M4 G+ Q8 F* \9 `! H; ovoid main(){1 T5 c& ^6 y5 L6 b
int a,b;# k; Q$ R- I( l. w& T" d- R
printf("please input A,B: ");3 O1 W. L  B, ^  C% R
scanf("%d%d",&a,&b);
, A# y$ `% b) I7 f3 c/ wif(a!=b)7 |9 Z, @# {2 E) D- q& f6 l$ w7 p& k! _
if(a>b) printf("A>B\n");
. j) t% n8 q) d( [8 n1 Z2 Melse printf("A<B\n");
/ l* F8 @4 f4 {) @else printf("A=B\n");: B$ m% C& B- H* u  ~- Z4 o
}
7 G8 w$ V. j6 C) U2 j$ r: A3 g本例中用了if语句的嵌套结构。 采用嵌套结构实质上是为了进行多分支选择，例3.16实际上有三种选择即A>B、A<B或A=B。这种问题用if-else-if语句也可以完成。而且程序更加清晰。因此， 在一般情况下较少使用if语句的嵌套结构。 以使程序更便于阅读理解。
' H6 A0 O2 F# V$ k) A9 Rvoid main(){; ^9 H9 j: w& W8 F$ t  i
int a,b;
7 e# Y; m$ Y5 m/ }5 I9 x6 o7 |' uprintf("please input A,B: ");
4 i: K) [" t7 ]- Wscanf("%d%d",&a,&b);  R! }. e: M4 m. H' ]. ^( N  k
if(a==b) printf("A=B\n");
# }2 L; e1 `2 t3 ^/ helse if(a>b) printf("A>B\n");
; s! l9 o& U5 Selse printf("A<B\n");
! @2 N6 M* F* f4 l; W, y}" S0 h. o9 S  J9 _- q, y, y7 X4 W- j4 I
5 c2 ~5 D5 l0 y
条件运算符和条件表达式
/ z( ^$ U( C/ u7 n, E. X
, B+ Y$ k; Q. f9 y- e) E2 ?如果在条件语句中，只执行单个的赋值语句时， 常可使用条件表达式来实现。不但使程序简洁，也提高了运行效率。
  U2 z( Z) C# v% @, u条件运算符为?和：，它是一个三目运算符，即有三个参与运算的量。由条件运算符组成条件表达式的一般形式为：
9 L6 k$ g8 A  V- l/ H5 c, c表达式1? 表达式2： 表达式3 3 f0 E* j2 a- |! E
其求值规则为：如果表达式1的值为真，则以表达式2 的值作为条件表达式的值，否则以表达式2的值作为整个条件表达式的值。 条件表达式通常用于赋值语句之中。
* J* A& F  {6 o$ G例如条件语句： * e; h2 G0 @$ _( A) p9 v" c1 f
if(a>b) max=a;
. B9 Q  @$ F) k2 oelse max=b;
- p! l1 ^) P: a9 j8 H# y可用条件表达式写为 max=(a>b)?a:b; 执行该语句的语义是：如a>b为真，则把a赋予max，否则把b 赋予max。
0 Y8 `5 S! l& m9 w+ ]使用条件表达式时，还应注意以下几点：4 e+ Z7 H! z  t" X' Z
1. 条件运算符的运算优先级低于关系运算符和算术运算符，但高于赋值符。因此 max=(a>b)?a:b可以去掉括号而写为 max=a>b?a:b
0 O( e8 p7 N& f9 i* `6 r5 o" f" _2 w$ B2. 条件运算符?和：是一对运算符，不能分开单独使用。% |9 {$ n' t7 E/ `. \. v' g
3. 条件运算符的结合方向是自右至左。
! J' q4 n) P! p- z$ Y例如：
0 {0 j$ _/ B( f# ]a>b?a:c>d?c:d应理解为; d0 t7 A# ?. m" O8 k% k( G% j
a>b?ac>d?c:d) 这也就是条件表达式嵌套的情形，即其中的表达式3又是一个条
6 Z: Y7 j9 i# u件表达式。, `; [: M& ?, X. f; m
void main(){3 p8 r% X# \9 S' H; V
int a,b,max;, s3 @" \7 e! ], `8 F: o
printf("\n input two numbers: ");! w' x% x1 J# c# u6 h0 B
scanf("%d%d",&a,&b);
; W6 y6 ^: R9 b- b) c" K: eprintf("max=%d",a>b?a:b);
) d% A6 p) m  _+ i3 ]+ Y2 t4 O7 W- M}
% z- `0 h9 \( J% V3 r5 \5 ]用条件表达式对上例重新编程，输出两个数中的大数。

zw2004

ｓｗｉｔｃｈ语句
, i3 h- N9 U4 G
3 t" n- |5 a4 T* ?Ｃ语言还提供了另一种用于多分支选择的switch语句， 其一般形式为： 4 T/ s$ s" H/ I0 e
switch(表达式){
. c/ {+ q! N7 B$ `( L0 Fcase常量表达式1: 语句1;
1 s& M5 p* Y0 x% x8 e/ ucase常量表达式2: 语句2;
. S8 Y: y, z6 Y( r5 T' }6 G… ! {" ~1 m3 y  Z
case常量表达式n: 语句n; ) \, M8 S9 C* S9 q
default : 语句n+1; # ~, s. i' r7 w) z6 P  k3 |
}
; m* L! c; Y* ~其语义是：计算表达式的值。 并逐个与其后的常量表达式值相比较，当表达式的值与某个常量表达式的值相等时， 即执行其后的语句，然后不再进行判断，继续执行后面所有case后的语句。 如表达式的值与所有case后的常量表达式均不相同时，则执行default后的语句。1 W5 C2 x  N( M' z1 n& u
void main(){( W! a9 @% P- G1 s: }; S9 M. n
int a;
* @0 F7 s- N, p6 F) W+ l8 @) Gprintf("input integer number: ");4 }7 K* J$ F4 f
scanf("%d",&a);0 D+ z# O* k5 t' _( V* n# [
switch (a){ 2 I0 G  |4 _9 y! A  R
case 1:printf("Monday\n");
6 ?& m- V% Y- g  jcase 2:printf("Tuesday\n");
8 j+ @. b0 p5 lcase 3:printf("Wednesday\n");
! h- j% ]7 B* I  V+ E  k$ ?2 |case 4:printf("Thursday\n");
9 P' t# f, v1 P: H" b! M1 Ncase 5:printf("Friday\n");( n; N* a8 A# \0 y
case 6:printf("Saturday\n");
" C1 @' n0 `' b6 E0 u  `' Jcase 7:printf("Sunday\n");
' c, l2 J4 D4 O* R+ k" K0 a: f' y1 Ldefault:printf("error\n");& h3 j! m8 c0 i4 {# d& }$ A! \) p3 _
}
, `2 ~! i6 o4 X9 R}! `$ |! T# Q" O0 U3 k

/ {' G2 c4 Y0 P2 ]本程序是要求输入一个数字，输出一个英文单词。但是当输入3之后，却执行了case3以及以后的所有语句，输出了Wednesday 及以后的所有单词。这当然是不希望的。为什么会出现这种情况呢?这恰恰反应了switch语句的一个特点。在switch语句中，“case 常量表达式”只相当于一个语句标号， 表达式的值和某标号相等则转向该标号执行，但不能在执行完该标号的语句后自动跳出整个switch 语句，所以出现了继续执行所有后面case语句的情况。 这是与前面介绍的if语句完全不同的，应特别注意。为了避免上述情况， Ｃ语言还提供了一种break语句，专用于跳出switch语句，break 语句只有关键字break，没有参数。在后面还将详细介绍。修改例题的程序，在每一case语句之后增加break 语句， 使每一次执行之后均可跳出switch语句，从而避免输出不应有的结果。
' h. A2 N4 S; K# {  v: ~void main(){
/ a% P& f* [& u1 E1 N" J& w- Eint a;7 s! E7 D9 u* l; V8 Y
printf("input integer number: ");
6 j& c7 w# Z! R  Nscanf("%d",&a);
8 n4 g5 t$ |$ F" l$ @/ r" Jswitch (a){
! t/ _, @* x8 y5 o- Hcase 1:printf("Monday\n");break;
4 m8 }6 i/ V/ ^9 ^6 h, ]$ rcase 2:printf("Tuesday\n"); break;
9 L2 g  g6 t9 X6 w! w+ Z9 pcase 3:printf("Wednesday\n");break;* R$ T: i* E. E. u$ n4 K7 a
case 4:printf("Thursday\n");break;# H1 B2 u7 Z' K$ K
case 5:printf("Friday\n");break;
  X+ `3 k: O; \" Dcase 6:printf("Saturday\n");break;  w9 i; ]& }, D, x
case 7:printf("Sunday\n");break;
6 Y0 n5 I! S$ C1 u3 p7 Cdefault:printf("error\n");
! B4 f4 \; ^! K- Y6 J: \8 m+ L  d; j8 o}
5 f3 G4 X' k& f! g& i+ C4 P}
3 T& b, ]/ f/ e/ G+ ]6 Z7 Z8 C; V在使用switch语句时还应注意以下几点：. b  M( C" L  e( B) f
1.在case后的各常量表达式的值不能相同，否则会出现错误。
4 n( G. c2 _) g1 q; s7 c; f2.在case后，允许有多个语句，可以不用{}括起来。
1 l: i* u6 {6 y! \7 \  L3.各case和default子句的先后顺序可以变动，而不会影响程序执行结果。
  d7 e; I1 m9 n' `0 l" C+ T, w4.default子句可以省略不用。程序举例  m  f% T; l1 @1 V& y2 z
输入三个整数，输出最大数和最小数。
6 a; P  F! ?9 O' X: nvoid main(){
0 [1 i6 o0 u" Kint a,b,c,max,min;
' u! |" F  j5 a  B7 @$ Qprintf("input three numbers: ");/ h5 o/ a$ g8 _- P$ I: i
scanf("%d%d%d",&a,&b,&c);
' D$ F7 [, F4 F1 d6 S$ ^9 Lif(a>b)
5 ^: x! O) C/ ]" z) p: H6 F- A{max=a;min=b;}1 p( P" z$ @0 F9 z
else1 o( k, B9 T- s! Y, U5 j
{max=b;min=a;}
6 Q& E0 I( z7 b! C0 j1 ^6 Z* H7 Qif(max<c)/ l6 j" J/ o* i) s  o! f3 b
max=c;- O3 z- T) B6 x% p( `! f) l" H, W7 N
else
  s( A0 `0 F) C" l# Zif(min>c)5 z6 {, }! C. n, `( T
min=c;  b" |& v% M  R% M
printf("max=%d\nmin=%d",max,min);
, K2 L( |6 s+ S+ Z$ y% ~) z4 o}1 B* C: N% L) y9 t9 Q3 `" x/ V

7 B7 n. Z: U# l4 y. g) q本程序中，首先比较输入的a,b的大小，并把大数装入max， 小数装入min中，然后再与c比较，若max小于c，则把c赋予max；如果c小于min，则把c赋予min。因此max内总是最大数，而min内总是最小数。最后输出max和min的值即可。 计算器程序。用户输入运算数和四则运算符， 输出计算结果。
' r$ d* U9 E2 E+ [0 j% y1 q9 i  Wvoid main(){' N) Z5 _3 ^- k; v$ ~
float a,b,s;+ r: N, }! F6 K! P7 Y  G
char c;
, s3 @  g+ a1 g9 H0 Nprintf("input expression: a+(-,*,/)b \n");7 B& o% a+ W/ f
scanf("%f%c%f",&a,&c,&b);
& x: }0 q( ^% t# w  q: x; Qswitch(c){, Q/ |2 b4 {* Q4 @
case '+': printf("%f\n",a+b);break;$ q( I/ R" w% C- P; |1 }/ [
case '-': printf("%f\n",a-b);break;7 K' m- c1 P1 T$ K. B. g5 o
case '*': printf("%f\n",a*b);break;
7 Z& u3 K- W8 K' Icase '/': printf("%f\n",a/b);break;- P- ^3 Q  [: R+ S- \# g# A& t
default: printf("input error\n");: A, p1 Q3 J: k" i$ `+ @! q* Z
}
! R5 z' Y4 q" U. n4 ]}
0 u' V5 q# g; L- |9 G6 A! p- l. S5 j6 o* y  r0 E
本例可用于四则运算求值。switch语句用于判断运算符， 然后输出运算值。当输入运算符不是+,-,*,/时给出错误提示。
, I* }; ~0 p7 |$ I* W6 @: H2 ^) h6 ~- {: R: W& r
循环结构程序
% A( l7 x3 H) H& K* E* q# z- V( ^: R
循环结构是程序中一种很重要的结构。其特点是， 在给定条件成立时，反复执行某程序段，直到条件不成立为止。 给定的条件称为循环条件，反复执行的程序段称为循环体。 Ｃ语言提供了多种循环语句，可以组成各种不同形式的循环结构。, |+ @% u4 ]$ L2 O0 D6 B; F

5 K7 c3 p. U- Oｗｈｉｌｅ语句
% ~* `7 a+ P9 _! X$ b" y
4 m( E6 Q2 ]6 i; Y/ swhile语句的一般形式为： while(表达式)语句； 其中表达式是循环条件，语句为循环体。
- I  G8 ^/ U! A5 l$ wwhile语句的语义是：计算表达式的值，当值为真(非0)时， 执行循环体语句。其执行过程可用图3—4表示。 统计从键盘输入一行字符的个数。8 t! r, \5 r( q  X
#include <stdio.h>6 b2 z/ J" v! I1 L
void main(){/ S" y' y# P: A, j) h( d1 I
int n=0;( q2 l0 G2 \0 |9 Q( `
printf("input a string:\n");& `- }) L! T/ M
while(getchar()!='\n') n++;) P" z6 g% N8 z& t
printf("%d",n);
' O, t! ?* ]# L+ U# f* f: @8 A1 ^}& x9 B+ Z( I& P2 C& z' J+ `9 H) V
本例程序中的循环条件为getchar()!='\n',其意义是， 只要从键盘输入的字符不是回车就继续循环。循环体n++完成对输入字符个数计数。从而程序实现了对输入一行字符的字符个数计数。. P$ b7 i! ]5 {5 R& P7 F
使用while语句应注意以下几点：
) q5 B' a, _! B1.while语句中的表达式一般是关系表达或逻辑表达式，只要表达式的值为真(非0)即可继续循环。% v. ^2 c5 G, K3 L& T
void main(){
1 p0 t: x4 b% u' j# O4 fint a=0,n;
# Z4 ~: g5 P7 k( `9 u, }printf("\n input n: ");
* E% o  n+ G- ~1 w2 Wscanf("%d",&n);1 C% y( x" C3 }$ k  a) `
while (n--)
6 a; x% L. [. m4 n5 R4 iprintf("%d ",a++*2);
- ]3 @. H. E+ [, g% L9 k. c/ L  u}

zw2004

本例程序将执行n次循环，每执行一次，n值减1。循环体输出表达式a++*2的值。该表达式等效于(a*2；a++)
) a4 h* }8 S. }3 o; I* R$ g" j! D2.循环体如包括有一个以上的语句，则必须用{}括起来， 组成复合语句。
- e) |0 E# Y4 r) S, ~6 `( G3.应注意循环条件的选择以避免死循环。* n7 [1 j' ~1 x- ]9 e  W2 T1 i% b+ y
void main(){
) s, S5 s2 J! E0 Hint a,n=0;
7 k& b/ o8 M0 @# V$ c7 _while(a=5)
: |3 o6 o3 G6 q, {" r# k/ r/ fprintf("%d ",n++);
  `! E9 a7 M) Z1 d7 J/ I}
) d, e4 z# A4 `5 g; ^8 l$ N6 d2 A本例中while语句的循环条件为赋值表达式a=5， 因此该表达式的值永远为真，而循环体中又没有其它中止循环的手段， 因此该循环将无休止地进行下去，形成死循环。4.允许while语句的循环体又是while语句，从而形成双重循环。8 u; l7 g* H) j( `

- M0 G5 F" P  h6 f: t6 |ｄｏ－ｗｈｉｌｅ语句
# m/ c  I2 {+ `" o3 {
3 J' b6 L# R" M, ~do-while语句的一般形式为： 6 [1 {& b, o( i9 O- h" [
do1 }8 A" w- G( ~9 J3 y9 a
语句；
; q; z4 t+ Z9 k' Q! |while(表达式)； - K! [8 _" m( d% v
其中语句是循环体，表达式是循环条件。& T5 w/ p3 Z+ d" N- u' [
do-while语句的语义是：
$ [: R6 w, S9 W( q5 I先执行循环体语句一次， 再判别表达式的值，若为真(非0)则继续循环，否则终止循环。
3 b4 H% I2 O0 y+ \4 k  B2 Xdo-while语句和while语句的区别在于do-while是先执行后判断，因此do-while至少要执行一次循环体。而while是先判断后执行，如果条件不满足，则一次循环体语句也不执行。( |1 G: a; D( s( b+ V
while语句和do-while语句一般都可以相互改写。- }* `& U' ?. z0 u  L8 @
void main(){
8 Q& x6 o: d; C' k; W7 B$ Cint a=0,n;; D" }/ @8 L& f1 v. v& @7 `
printf("\n input n: ");
6 K: p7 J# I, `  jscanf("%d",&n);7 t5 c; @1 v- ~' W1 C5 ]
do printf("%d ",a++*2);! B! L3 n& Y3 {( Q: Q8 P2 |* [
while (--n);
( P5 }8 s. O7 ~2 k- C- T! F} 7 n8 F8 e# u0 O" P# m2 Z- }
2 E( f+ {+ n/ Z: l' W  B
在本例中，循环条件改为--n，否则将多执行一次循环。这是由于先执行后判断而造成的。5 D2 n  A2 ~' X6 q
对于do-while语句还应注意以下几点：; Z1 Y* M7 C5 F
1.在if语句，while语句中， 表达式后面都不能加分号， 而在 do-while语句的表达式后面则必须加分号。
9 w; h  z9 m1 t0 i- G# i4 w) y2.do-while语句也可以组成多重循环，而且也可以和while语句相互嵌套。: U# C5 V7 G% O* R& l, B, d& g
3.在do和while之间的循环体由多个语句组成时，也必须用{}括起来组成一个复合语句。- }: \* B+ M, x, A% [
4.do-while和while语句相互替换时，要注意修改循环控制条件。
7 W0 |7 Y& e# J; C1 H. `$ N) X9 N$ Z7 p8 N
ｆｏｒ语句4 ~* w8 ~1 X' u  j$ j
9 v4 C4 h- D7 W6 i) F5 N
for语句是Ｃ语言所提供的功能更强，使用更广泛的一种循环语句。其一般形式为： & n; S. @% I# o( f
for(表达式1；表达式2；表达3)
  k  i) x3 O2 e1 u9 M( ^" x语句；
/ [4 q9 N/ T4 F5 x: }表达式1　通常用来给循环变量赋初值，一般是赋值表达式。也允许在for语句外给循环变量赋初值，此时可以省略该表达式。- e: ?. q9 I4 y; Q
表达式2　通常是循环条件，一般为关系表达式或逻辑表达式。5 |1 E2 c" t. |* [- F
表达式3　通常可用来修改循环变量的值，一般是赋值语句。8 b/ P" O7 t2 O& d
这三个表达式都可以是逗号表达式， 即每个表达式都可由多个表达式组成。三个表达式都是任选项，都可以省略。
# t; L1 C" P( V3 m* K一般形式中的“语句”即为循环体语句。for语句的语义是：
$ s/ w% ?7 d+ j7 Z: _1.首先计算表达式1的值。* v0 T% k* z: k) O9 h) ^
2.再计算表达式2的值，若值为真(非0)则执行循环体一次， 否则跳出循环。
- O8 @) {. a% z0 O5 d4 ]9 {3.然后再计算表达式3的值，转回第2步重复执行。在整个for循环过程中，表达式1只计算一次，表达式2和表达式，3则可能计算多次。循环体可能多次执行，也可能一次都不执行。for 语句的执行过程如图所示。5 P, f/ z* |2 @, h
void main(){. O6 g7 \$ y7 u$ N: W9 |" L+ ?
int n,s=0;2 @. E' v6 S3 Z: Y
for(n=1;n<=100;n++)
- r+ G( E- l1 cs=s+n;9 ~% q% ^/ d4 M' {  H1 O
printf("s=%d\n",s);
# V1 t' [$ D5 r- A. v# M3 J" p3 }}
) h4 S' c6 B( a8 y) H$ d用for语句计算s=1+2+3+...+99+100
7 i4 M: P5 k, d7 Q) U
; I7 A0 k5 w' k+ t7 a( N2 yint n,s=0;5 m. {) ], W4 L  v
for(n=1;n<=100;n++)- O4 C1 r( n3 t7 G  W& `
s=s+n;
9 Q* {  B' R1 Z4 X9 N# j3 O  F- eprintf("s=%d\n",s);
3 j4 Q1 U, V1 _本例for语句中的表达式3为n++，实际上也是一种赋值语句，相当于n=n+1，以改变循环变量的值。
( r/ t1 Z, T) U+ r* xvoid main(){8 j: ]5 @6 m7 y% m
int a=0,n;
+ X4 c) }9 Q; e  K: E4 Nprintf("\n input n: ");- V' ?( Q  K% U3 p; A
scanf("%d",&n);6 u! x  p* w6 o( o! F
for(;n>0;a++,n--)' w+ z9 ^8 {5 m5 S2 C6 B
printf("%d ",a*2);$ D& h+ e7 S* k& _  I, o" Z
}$ Z5 f( N- E; K! |7 L& m. r
用for语句修改例题。从0开始，输出n个连续的偶数。
4 x, Y, h* ?$ k  F: }8 n4 K" kint a=0,n;
# @$ ]/ ^! u& {' z' J* r$ N( iprintf("\n input n: ");& |6 g9 D: X; U' o2 \
scanf("%d",&n);& Q8 O  v# q4 J, O: [2 X1 v: @' P
for(;n>0;a++,n--)
$ ^0 |! G$ l0 S) vprintf("%d ",a*2);5 s) I0 u& M2 N$ Q: _% Y1 ~6 ~
本例的for语句中，表达式1已省去，循环变量的初值在for语句之前由scanf语句取得，表达式3是一个逗号表达式，由a++，n-- 两个表达式组成。每循环一次a自增1，n自减1。a的变化使输出的偶数递增，n的变化控制循次数。: |; T; i. m- C6 t- z7 z/ s3 M
在使用for语句中要注意以下几点; A% c' Q- M1 `
1.for语句中的各表达式都可省略，但分号间隔符不能少。如：for(；表达式；表达式)省去了表达式1。for(表达式；；表达式)省去了表达式2。
+ _8 M. d2 f6 @( R+ L& G  Lfor(表达式；表达式；)省去了表达式3。for(；；)省去了全部表达式。
/ W" d% u2 Y" ~$ w9 C2.在循环变量已赋初值时，可省去表达式1，如例3.27即属于这种情形。如省去表达式2或表达式3则将造成无限循环， 这时应在循环体内设法结束循环。例题即属于此情况。% G5 m1 P$ ~' `+ b4 f  }# o
void main(){
$ X) w. D( [7 q. D% X6 {# K; \  @int a=0,n;
4 H& O1 I& n0 n4 M. _* ?. G) \0 }printf("\n input n: ");9 e% L* M' |4 p; j) k- ^( C/ ^, T
scanf("%d",&n);
: ]3 \" O$ Z2 g: q# ^for(;n>0;)# a- n' T; S: V  Z
{ a++;n--;/ t- X! u  ~3 k6 m& y- }0 Y
printf("%d ",a*2);( H" u) N5 @( N" t
}- F  K) ?/ p) j- e
}
$ t" i# X$ ~  D7 b% v本例中省略了表达式1和表达式3，由循环体内的n--语句进行循环变量n的递减，以控制循环次数。. U: A* b  R) d, f
void main(){
! N% _8 y" \5 p6 Bint a=0,n;3 ~, q2 u0 Z2 Q! s4 y. f1 b0 s% ~
printf("\n input n: ");* m9 Z3 a$ m# R- z; r) c( M- _
scanf("%d",&n);6 g7 s( `/ t5 s4 c4 C# X
for(;;){
& {' Y% R! C) J5 i6 z1 x# ~5 I, T; Da++;n--;
- p0 x6 w+ y/ e6 t; r  s" Q* X5 G& n9 _printf("%d ",a*2);8 Z% o; c: o0 c6 R8 f2 r
if(n==0)break;/ B/ w, ~; X( r8 j! E5 ]
}; c0 D5 X! z. w; ^6 l* V: x7 _
}; m+ P- C6 m' N3 o$ D
本例中for语句的表达式全部省去。由循环体中的语句实现循环变量的递减和循环条件的判断。当n值为0时，由break语句中止循环，转去执行for以后的程序。在此情况下，for语句已等效于while( 1)语句。如在循环体中没有相应的控制手段，则造成死循环。" J/ _8 |2 F# P5 I! F3 {
3.循环体可以是空语句。
* Q5 e  _7 B7 U#include"stdio.h"
7 q5 m' M/ A) A+ {% `void main(){
. q6 ]: J1 ]0 l* K% T: K/ t( t7 W3 |int n=0;. T) ]. R4 Q' l* r& ^
printf("input a string:\n");
" E' {3 B" [/ P7 f, r# gfor(;getchar()!='\n';n++);
& w( H" [- \5 X' ~printf("%d",n);
7 h0 l/ g0 N/ f" t! A* w9 K" O7 H, |}

zw2004

本例中，省去了for语句的表达式1，表达式3也不是用来修改循环变量，而是用作输入字符的计数。这样， 就把本应在循环体中完成的计数放在表达式中完成了。因此循环体是空语句。应注意的是，空语句后的分号不可少，如缺少此分号，则把后面的printf 语句当成循环体来执行。反过来说，如循环体不为空语句时， 决不能在表达式的括号后加分号， 这样又会认为循环体是空语句而不能反复执行。这些都是编程中常见的错误，要十分注意。
; n) @& {. W/ Y2 C/ N9 S4.for语句也可与while,do-while语句相互嵌套，构成多重循环。以下形成都合法的嵌套。1 ?* H5 p: m! M$ B/ O/ A
(1)for(){…
" Z$ a4 u" b7 b; U$ i　　while()
, b6 w4 @8 f$ V3 A+ a. ~+ G0 t9 F　　　{…}
0 m: q2 B) U' g　　…
1 F' M9 `7 \: S8 r8 A4 M9 q- \　　　　}, g0 w! y' f, R% z8 R
(2)do{  j9 K4 s0 I% ?7 e' u
　　　…1 v: n( o% R. A' J5 y  g8 j6 `
　　for()
4 a% x: \- }2 o! Q3 o　　　{…}
; d3 w1 d/ [" K1 g. ^　　…
' Z: e$ N* ^3 g/ ^　　}while();9 Q% q* r& w( V8 R4 Q/ G
(3)while(){5 I+ n; X: Z1 z
　　　　　　…
& l$ h, I* P: _, U( {- E　　　　　　for()
& t( Q  |1 Y( K0 m2 n. L　　　　　　　{…}; Q& h% f) K7 M; l% R  e
　　　　　　…
7 _. {- ^, ^) V& }. o　　　　　}, Y1 B- Q% \* S3 @
(4)for(){. A  t; B4 y$ K  _) I
　　　　…6 u& U1 @' K% Y& k
　　　　for(){
/ \! U! E: z; f: r　　　　…
* g; v! j# M" x  o$ n! b2 x* a　　　　　}
& J# X. [  M. C, x　　　　}& c# m4 H) G( x1 v& `
void main(){5 {! U! K; `$ X
int i,j,k;
6 a- A% i' m: B( u& W# f9 e9 Cfor(i=1;i<=3;i++)
1 y( P5 G) X: K" |' E{ for(j=1;j<=3-i+5;j++)  {* A/ a1 S5 D& O; H- `  l
printf(" ");
5 T: o9 S! O! K$ w* \3 g6 Bfor(k=1;k<=2*i-1+5;k++)
& `9 V/ `( X2 d3 Z: I{  X; `: }" R6 s: H, _+ w
if(k<=5) printf(" ");
7 {/ D& _( B% Q' W0 Jelse printf("*");
. K" F% w( {( v# O}
: t. ~, p6 D% d9 B1 z1 zprintf("\n");
7 |" {3 U* z: J/ F# B) g: I# F. u) |}! y8 b' }" V: j# c
}  E# H' o: G* k' x
) V* u2 f- O& H$ w7 B& H9 ^
转移语句. ]) S8 z/ ~0 t$ M9 U5 g, j  s
8 z5 z9 \5 {2 N5 ^3 \9 {+ F
程序中的语句通常总是按顺序方向， 或按语句功能所定义的方向执行的。如果需要改变程序的正常流向， 可以使用本小节介绍的转移语句。在Ｃ语言中提供了4种转移语句：; A7 l/ u+ t0 X+ m' }4 B& L& i
goto,break, continue和return。7 p+ ~0 V% m% L7 x/ F; T  i6 x
其中的return语句只能出现在被调函数中， 用于返回主调函数，我们将在函数一章中具体介绍。 本小节介绍前三种转移语句。
; _, T$ N) X1 O+ y" b; g
1 }3 R( r  c9 y1 c$ ~1.goto语句
2 p, O9 _4 k: c3 f& R; q. X3 P; D
# P  r* O+ d6 ~) @4 ~" v, Xgoto语句也称为无条件转移语句，其一般格式如下： goto 语句标号； 其中语句标号是按标识符规定书写的符号， 放在某一语句行的6 w$ @1 V' B+ j& D/ z2 _4 y
前面，标号后加冒号(：)。语句标号起标识语句的作用，与goto 语句配合使用。* O: Z7 v, H0 A5 f' g, p& Y/ e
如： label: i++; 4 ?- c+ `: T) p
loop: while(x<7); ' m; k. f0 ?; |
Ｃ语言不限制程序中使用标号的次数，但各标号不得重名。goto语句的语义是改变程序流向， 转去执行语句标号所标识的语句。
! X" o$ |* d6 M) O3 q# Ugoto语句通常与条件语句配合使用。可用来实现条件转移， 构成循环，跳出循环体等功能。* o7 r, k: D% o( P
但是，在结构化程序设计中一般不主张使用goto语句， 以免造成程序流程的混乱，使理解和调试程序都产生困难。- D. A' @% V# `- ^' S
统计从键盘输入一行字符的个数。- p* W. N1 z' ~8 }7 R
#include"stdio.h"# I/ O% }9 k. @0 @6 d3 [
void main(){
; x  T2 |0 M: p6 |/ w: }int n=0;# Z/ \" l$ P4 O+ ^% U$ _# R( m' r
printf("input a string\n");- y4 I; S3 v$ W
loop: if(getchar()!='\n')3 R$ ~  U4 j3 h0 U0 `
{ n++;3 y- [. }; x. ^# b
goto loop;
* S+ X3 t5 P7 v) N+ Z2 r" \}/ Q' t. P9 R, B8 W$ ^
printf("%d",n);
, u3 z! y$ L. ~2 ?. y; j& j% f}
+ f& ^3 a! _5 h; A6 x本例用if语句和goto语句构成循环结构。当输入字符不为'\n'时即执行n++进行计数，然后转移至if语句循环执行。直至输入字符为'\n'才停止循环。
* P$ r3 F$ k5 j7 \7 \6 A
/ v* g0 V% o* M7 f' x. M5 B  Mｂｒｅａｋ语句
- G$ ~; B# _# e) \8 U# `* F0 k3 o0 I% p3 s
break语句只能用在switch 语句或循环语句中， 其作用是跳出switch语句或跳出本层循环，转去执行后面的程序。由于break语句的转移方向是明确的，所以不需要语句标号与之配合。break语句的一般形式为： break; 上面例题中分别在switch语句和for语句中使用了break 语句作为跳转。使用break语句可以使循环语句有多个出口，在一些场合下使编程更加灵活、方便。2 C/ c3 C9 z9 W& h

# M2 x6 h4 K7 ~ｃｏｎｔｉｎｕｅ语句 8 C& B" ?8 }9 U) ]  A% V/ S
' x- e, u# w* H% ~1 i
continue语句只能用在循环体中，其一般格式是：
1 Z8 v1 y; E# F- \: R  ~continue;
; q% B9 M+ L! R' @9 \+ E其语义是：结束本次循环，即不再执行循环体中continue 语句之后的语句，转入下一次循环条件的判断与执行。应注意的是， 本语句只结束本层本次的循环，并不跳出循环。
5 z' K, g; K/ D  C  L1 `5 H/ Gvoid main(){8 r- l4 ?+ F4 w" P  K! e) d0 R
int n;, R, ^5 ]6 T. ]2 R1 G
for(n=7;n<=100;n++)6 h" f0 ~4 Z9 y( O. C
{
5 d2 k' T9 w. Y4 E$ Wif (n%7!=0)
5 z: f9 V7 r  i0 Q/ M8 Scontinue;9 T6 h1 n8 _( [
printf("%d ",n);; P" L" ]8 ~+ Z7 n
}$ x& j/ B! m' J# z
}
9 ]& D, V/ P/ S3 A% q' p8 i输出100以内能被7整除的数。 " T/ N( z' w3 J/ _$ m) w# L
int n;
3 _5 w$ }: c- hfor(n=7;n<=100;n++): f/ S* {/ r/ Y' B
{
$ V) w7 R6 @3 v. w% E) h! Cif (n%7!=0); H4 i1 e; ~! T6 K
continue;
7 \5 u  c% O; z. v1 z7 g: n# sprintf("%d ",n);
6 x+ X& M6 c! P  X8 U! N}3 W5 k# _; A, H. C( {. ~/ t( T8 `
本例中，对7～100的每一个数进行测试，如该数不能被7整除，即模运算不为0，则由continus语句转去下一次循环。只有模运算为0时，才能执行后面的printf语句，输出能被7整除的数。2 V  p) N1 v9 v& f. i
#include"stdio.h"4 I( e  i3 Z+ d
void main(){
  G9 R2 w9 ?9 b. ]$ ]2 tchar a,b;
5 m- g) V- v. L  J6 Q! k: {printf("input a string:\n");
6 K- ^- x! g# r9 r( t6 mb=getchar();/ x4 A8 U! ~! J$ ^* k% S* H
while((a=getchar())!='\n'){
% B/ l5 u; N! v; Q/ ~" Sif(a==b){
; K6 b" D3 b( T- |  k+ Nprintf("same character\n");% H8 F/ o3 y% i/ u6 ^) ?5 Z+ o
break;; ~8 a  r: _+ y/ S+ Y  F4 Q4 l
}b=a;2 N3 s) i9 V* U3 p# m( v# a
}
6 d& n+ ?6 {/ V- A& v}1 h0 v2 J* b* u
检查输入的一行中有无相邻两字符相同。
% u: ]5 ~) B& Q/ T% g3 `$ rchar a,b;
% Q( @0 r5 @: Y# lprintf("input a string:\n");
  U& b, ?! \. _& z7 xb=getchar();
& ?- E9 Z# P, h5 |while((a=getchar())!='\n'){
$ C: N7 y( U8 A6 _! u) _4 Nif(a==b){
0 _( N: P# V. w/ ^# ^, gprintf("same character\n");
- ~5 d( ~- q! j! V) N2 bbreak;/ `9 [2 A$ h; c0 n' o0 I6 i
}b=a;
4 q/ C7 B& D  [( t# |7 O' l}

zw2004

本例程序中，把第一个读入的字符送入b。然后进入循环，把下一字符读入a，比较a,b是否相等，若相等则输出提示串并中止循环，若不相等则把a中的字符赋予b，输入下一次循环。 ! X' j! e$ u7 ~
输出100以内的素数。素数是只能被1 和本身整除的数。可用穷举法来判断一个数是否是素数。% G0 h2 p0 h! n5 f5 j1 B3 \% y
void main(){
/ ^8 z4 W6 k; pint n,i;2 F+ k" P# p* `
for(n=2;n<=100;n++){! x: @. k7 p/ _7 Q0 `# D( I
for(i=2;i<n;i++)2 u2 O9 M7 R" j" F" B; K3 p
if(n%i==0) break;
. c- P% l- [% w; E2 Jif(i>=n) printf("\t%d",n);' h5 g. Y3 K! E4 b5 a
}
/ c0 ~+ K! M+ S3 D7 Q2 ~+ E+ r} int n,i;' ]0 L$ i! o7 [" _
for(n=2;n<=100;n++){! _: A7 O, t! t9 [4 I1 W0 H4 ^' v( b
for(i=2;i<n;i++)
: w9 F" a+ ~& G7 bif(n%i==0) break;
4 q/ \2 C+ S/ h; Y+ {. Wif(i>=n) printf("\t%d",n);) t/ Q- f7 C* c: t/ Y
}1 W8 _2 x4 W1 p  P3 Z0 W
本例程序中，第一层循环表示对1～100这100个数逐个判断是否是素数，共循环100次，在第二层循环中则对数n用2～n-1逐个去除，若某次除尽则跳出该层循环，说明不是素数。 如果在所有的数都是未除尽的情况下结束循环，则为素数，此时有i>=n， 故可经此判断后输出素数。然后转入下一次大循环。实际上，2以上的所有偶数均不是素数，因此可以使循环变量的步长值改为2，即每次增加2，此外只需对数n用2～n去除就可判断该数是否素数。这样将大大减少循环次数，减少程序运行时间。2 J' }( N3 j/ `8 c$ `
#include"math.h"
; k$ E& T* _6 E6 `! b% Jvoid main(){) T; m6 X2 J& M
int n,i,k;+ f3 E+ X* X! L$ l9 k& R
for(n=2;n<=100;n+=2){( h- ?; g* ~( a
k=sqrt(n);2 E+ q& K+ i9 t4 i. I; K
for(i=2;i<k;i++)
  Q4 ^8 a; E" N9 Bif(n%i==0) break;* G9 {5 v9 p( x6 \& P
if(i>=k) printf("\t%2d",n);
4 t, X+ W" J8 f1 p6 G- H, w}
3 u/ j, ^2 M9 j1 _. R0 H}
, \$ K8 E( G2 Z$ s2 x" i- O6 ^* O3 f- S' s  j
7 m) H, `! {- o9 E( k/ A
: D1 h8 s! p. [9 G6 J% {. Q

. `# q) k1 k5 H5 g2 L: _小结9 S/ ?' x( S# C: S9 g$ w; h

  \7 S. z7 X1 o$ d1 H; F1.从程序执行的流程来看， 程序可分为三种最基本的结构： 顺序结构，分支结构以及循环结构 1 S9 I; o. n; }, w* m& N! I- d

) u7 ~) y, M. l. E  d$ v  b2.程序中执行部分最基本的单位是语句。Ｃ语言的语句可分为五类：& M. z! G! d. g
(1)表达式语句　　任何表达式末尾加上分号即可构成表达式语句， 常用的表达式语句为赋值语句。' N3 K4 J9 Y, h- @* h! U$ f1 A
(2)函数调用语句　　由函数调用加上分号即组成函数调用语句。
% k2 z( b* \# j4 M. w% F/ I+ U(3)控制语句　　用于控制程序流程，由专门的语句定义符及所需的表达式组成。主要有条件判断执行语句，循环执行语句，转向语句等。  N. ]3 P) o5 k2 L
(4)复合语句　　由{}把多个语句括起来组成一个语句。 复合语句被认为是单条语句，它可出现在所有允许出现语句的地方，如循环体等。; @5 w/ n6 [+ F7 |% d2 f5 I
(5)空语句　　仅由分号组成，无实际功能。
6 c" h' |+ W% A$ I) B5 Y& f$ S8 [5 X1 a& s
3.Ｃ语言中没有提供专门的输入输出语句， 所有的输入输出都是由调用标准库函数中的输入输出函数来实现的。
) u  g" q2 ?; H% N9 r! _8 Bscanf和getchar函数是输入函数，接收来自键盘的输入数据。
3 n1 [/ J( }! ~' u. Y$ F) w  Hscanf是格式输入函数， 可按指定的格式输入任意类型数据。& [' X1 H* V/ S5 }, Z
getchar函数是字符输入函数， 只能接收单个字符。 7 R2 k0 ]& D/ ?: `- _9 S" a
printf和putchar函数是输出函数，向显示器屏幕输出数据。
* B6 k1 M  \) c( T9 xprintf是格式输出函数，可按指定的格式显示任意类型的数据。5 z/ I7 ]% n' k" ]
putchar是字符显示函数，只能显示单个字符。
' l0 i9 B6 t; y6 x$ f4 Z) m+ J4 I1 G/ N. ]( w
4.关系表达式和逻辑表达式是两种重要的表达式， 主要用于条件执行的判断和循环执行的判断。
1 V3 W7 g5 }% W4 `
* B1 k3 U: I( F2 t: O5 J5.Ｃ语言提供了多种形式的条件语句以构成分支结构。
0 ^: q% G6 x( N  X) W' g- Q(1)if语句主要用于单向选择。
8 ^/ ?3 |. n6 c+ v3 O& z(2)if-else语句主要用于双向选择。$ G3 L" ]' \# {1 y! h
(3)if-else-if语和switch语句用于多向选择。
, _( Y: k4 Z7 l5 J2 @8 ^5 z这几种形式的条件语句一般来说是可以互相替代的。
% }5 p. [  U. j8 v! w1 K  W5 h" h2 t; E' o8 P5 E8 a+ ?; G2 c. x$ c
6.Ｃ语言提供了三种循环语句。
- H* C8 t, t, R" s1 u(1)for语句主要用于给定循环变量初值， 步长增量以及循环次数的循环结构。
8 x0 J. d% Y) H5 p2 y2 _" X(2)循环次数及控制条件要在循环过程中才能确定的循环可用 while或do-while语句。
1 F" |& K8 |8 {1 l2 ]/ m' j* C7 a(3)三种循环语句可以相互嵌套组成多重循环。循环之间可以并列但不能交叉。& C# ~8 g4 ]9 G' W( s
(4)可用转移语句把流程转出循环体外，但不能从外面转向循环体内。
, ]6 `4 s" H1 p6 o+ @( [(5)在循环程序中应避免出现死循环，即应保证循环变量的值在运行过程中可以得到修改，并使循环条件逐步变为假，从而结束循环。: N: z$ n) z, N6 `, t5 e" p

. a2 S4 T0 M0 j0 U/ D7.Ｃ语言语句小结
2 k0 s4 o: e6 K: d( I5 b名 称　　　　　　　　　一 般 形 式( M8 ?* x$ V8 A: f2 T9 P
简单语句　　　　　　　表达式语句表达式; , I! x% ^7 g: V, q5 t' J: q
空语句;
4 `5 H& H* \- a: E" S复合语句 　　　　　　 { 语句 }' }5 ?& |7 a; B
条件语句　　　　　　　if(表达式)语句;
. }. z! l# d  m% F* L/ W: x) S　　　　　　　　　　　if(表达式)语句1; else语句2;
+ g7 N7 X7 |4 `8 P2 r2 }　　　　　　　　　　　if(表达式1)语句1; else if(表达式2) 语句2…else语句 n;
+ V* C" S) Y6 ]  u( G0 R: C开关语句 　　　　　　 switch(表达式){ case常量表达式: 语句…default: 语句; }
- c; L3 Z# S4 x循环语句　　　　　　　while语句
- x. O: q7 [: `, a　　　　　　　　　　　while(表达式)语句;
* Y/ O! E2 R: }* A; [- x　　　　　　　　　　　for语句 for(表达式1; 表达式2; 表达式3)语句; % J: F7 ^, Q& C5 b- E: l' p
　　　　　　　　　　　break语句 break;
- m4 B* y; d7 K4 [! H$ h　　　　　　　　　　　goto语句 goto; . s( c9 {. E# B+ X1 ^/ \2 k
　　　　　　　　　　　continue语句 continue; 7 v1 M- N! z$ [9 ^8 f2 Z" U
　　　　　　　　　　　return 语句 return(表达式);

周汇

需要多多学习一下哦！~~