1.类型4 H- Q8 H% D# r4 W) j/ W
表示输入数据的类型，其格式符和意义下表所示。
格式 字符意义 @0 O0 G1 `5 Z0 D
d 输入十进制整数
o 输入八进制整数
x 输入十六进制整数
u 输入无符号十进制整数2 U( k$ p; _7 g+ X* I) q
f或e 输入实型数(用小数形式或指数形式)4 {% C3 J3 z& U6 I
c 输入单个字符# x( u+ p8 b) Q U% y: G
s 输入字符串* Y5 n' N0 L0 o9 k, M
2.“*”符2 {# X% H. |5 W. z i4 b& G
用以表示该输入项读入后不赋予相应的变量，即跳过该输入值。 如 scanf("%d %*d %d",&a,&b);当输入为：1 2 3 时，把1赋予a，2被跳过，3赋予b。
3.宽度0 f5 y- ?; d* o5 x1 h" B' k
用十进制整数指定输入的宽度(即字符数)。例如： scanf("%5d",&a);
输入：
12345678
只把12345赋予变量a，其余部分被截去。又如： scanf("%4d%4d",&a,&b);) q, m5 V5 }% K; h$ l* v! C
输入：5 n1 a+ e, @: U/ J' C2 }9 l
12345678将把1234赋予a，而把5678赋予b。
4.长度
长度格式符为l和h，l表示输入长整型数据(如%ld) 和双精度浮点数(如%lf)。h表示输入短整型数据。
使用scanf函数还必须注意以下几点：4 s! X0 j w5 @9 a% j* M1 t7 m
a. scanf函数中没有精度控制，如： scanf("%5.2f",&a); 是非法的。不能企图用此语句输入小数为2位的实数。
b. scanf中要求给出变量地址，如给出变量名则会出错。如 scanf("%d",a);是非法的，应改为scnaf("%d",&a);才是合法的。
c. 在输入多个数值数据时，若格式控制串中没有非格式字符作输入数据之间的间隔则可用空格，TAB或回车作间隔。C编译在碰到空格，TAB，回车或非法数据(如对“%d”输入“12A”时，A即为非法数据)时即认为该数据结束。
d. 在输入字符数据时，若格式控制串中无非格式字符，则认为所有输入的字符均为有效字符。例如：# I' V( o) u3 x2 f
scanf("%c%c%c",&a,&b,&c);
输入为：
d e f3 {/ T* ~) m# R O8 T- i/ q$ N
则把'd'赋予a, 'f'赋予b,'e'赋予c。只有当输入为：
def
时，才能把'd'赋于a,'e'赋予b,'f'赋予c。 如果在格式控制中加入空格作为间隔，如 scanf ("%c %c %c",&a,&b,&c);则输入时各数据之间可加空格。
void main(){3 R% V. b9 ^; h/ |. y
char a,b;) f/ e% D2 }9 K0 i5 |8 {
printf("input character a,b\n");
scanf("%c%c",&a,&b);" ^2 m% H6 a7 @2 |1 Q
printf("%c%c\n",a,b);
} 1 d) ?- _3 V# U+ e+ D4 D
scanf("'C14F14%c%c",&a,&b);
printf("%c%c\n",a,b); 由于scanf函数"%c%c"中没有空格，输入M N，结果输出只有M。
而输入改为MN时则可输出MN两字符，见下面的输入运行情况： input character a,b: d# C$ S' A/ e) x8 b
MN
MN- D) w* Z/ H* v8 ^. Z5 K6 \
void main(){+ \7 v% e& f0 U8 M. M# ]% G/ ^
char a,b;7 T+ l! D4 K' L: V j
printf("input character a,b\n");
scanf("%c %c",&a,&b);) K# d: y! P7 S: C! Y& q
printf("\n%c%c\n",a,b);6 d4 g( t8 u$ B) v+ i1 |0 m
}
scanf("%c %c",&a,&b); 本例表示scanf格式控制串"%c %c"之间有空格时， 输入的数据之间可以有空格间隔。e. 如果格式控制串中有非格式字符则输入时也要输入该非格式字符。8 _3 p4 F6 K, K# m. ?" g9 \
例如：
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");/ J. K( R) _5 K; Y& n: M* Z
scanf("%d",&a);
printf("%ld",a);
}
由于输入数据类型为整型， 而输出语句的格式串中说明为长整型，因此输出结果和输入数据不符。如改动程序如下： 2 k/ F7 M: S( B- s7 a
void main(){
long a;
printf("input a long integer\n");, z0 ^) \+ {- F- n& M' V4 C2 A
scanf("%ld",&a);
printf("%ld",a);/ i" t) W) z5 {% @: Y4 E
}
运行结果为：7 f& k9 |) _7 i4 z9 }$ b
input a long integer6 J9 V9 l( d p3 o; k+ s; q$ l& n
1234567890$ _$ v, V/ \- E) Y
1234567890 当输入数据改为长整型后，输入输出数据相等。- V6 z' {( }# h: g1 | A& F8 B7 @
键盘输入函数/ H# q0 G( D0 s3 c
getchar函数getchar函数的功能是从键盘上输入一个字符。其一般形式为： getchar(); 通常把输入的字符赋予一个字符变量，构成赋值语句，如：/ x! h2 q6 |1 Z. ^: M/ q- M
char c;
c=getchar();
#include<stdio.h>" m; K% g. c$ J
void main(){
char c;/ @% t# K: l9 `4 l4 E. _$ ~9 {; s
printf("input a character\n");
c=getchar();" r, O8 S, T6 Z6 d( |( I; m
putchar(c);
}
作者: zw2004 时间: 2008-1-21 17:07 标题: C语言程序设计初步
使用getchar函数还应注意几个问题：
1.getchar函数只能接受单个字符，输入数字也按字符处理。输入多于一个字符时，只接收第一个字符。 ' ~+ [) { y. R" S! x
2.使用本函数前必须包含文件“stdio.h”。
3.在TC屏幕下运行含本函数程序时，将退出TC 屏幕进入用户屏幕等待用户输入。输入完毕再返回TC屏幕。
void main(){
char a,b,c;/ a! m; N S+ m3 w6 h
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);4 e2 u, K$ `1 w a: I$ V
}
输入三个小写字母* _) J5 P0 z8 ^2 X& m
输出其ASCII码和对应的大写字母。 . g; @7 V3 E4 p- j# v: P
void main(){4 \5 Y+ p( ]( Z, {
int a;
long b;
float f;+ p* {( i# }& O4 l0 U' h
double d;
char c;
printf("%d,%d,%d,%d,%d",sizeof(a),sizeof(b),sizeof(f)# U0 ~8 M+ F! U* t2 k; j
,sizeof(d),sizeof(c));
}! d8 @+ E; Y% o: w/ e. G
输出各种数据类型的字节长度。% m4 h% O8 z2 _; K8 F& O0 h T, q4 G
分支结构程序
关系运算符和表达式
在程序中经常需要比较两个量的大小关系， 以决定程序下一步的工作。比较两个量的运算符称为关系运算符。 在Ｃ语言中有以下关系运算符：! w9 P: I- @! T ^7 u3 ^* z, s
< 小于4 D8 ]+ D5 c5 z4 F4 x) H; `! M/ z
<= 小于或等于
> 大于( H( C4 B9 e; @8 i
>= 大于或等于
== 等于 ?+ x" l' p; G) h; k6 m
!= 不等于
关系运算符都是双目运算符，其结合性均为左结合。 关系运算符的优先级低于算术运算符，高于赋值运算符。 在六个关系运算符中，<,<=,>,>=的优先级相同，高于==和!=，==和!=的优先级相同。! i+ ?0 Y2 S. S( C. Q
关系表达式4 t2 X) f! U+ t1 T+ [& j) x
关系表达式的一般形式为： 表达式 关系运算符 表达式 例如：a+b>c-d,x>3/2,'a'+1<c,-i-5*j==k+1;都是合法的关系表达式。由于表达式也可以又是关系表达式。 因此也允许出现嵌套的情况，例如：a>(b>c),a!=(c==d)等。关系表达式的值是“真”和“假”，用“1”和“0”表示。
如： 5>0的值为“真”，即为1。(a=3)>(b=5)由于3>5不成立，故其值为假，即为0。" r8 m8 J( {+ e3 @* @
void main(){8 G9 Y1 z3 O) f7 ^1 W% \
char c='k';
int i=1,j=2,k=3;" J1 i( s m4 u; N0 ~
float x=3e+5,y=0.85;& }9 z/ L |8 O$ W! Y
printf("%d,%d\n",'a'+5<c,-i-2*j>=k+1); \) [% q1 j/ b
printf("%d,%d\n",1<j<5,x-5.25<=x+y);5 n8 g9 p! ~0 K6 m
printf("%d,%d\n",i+j+k==-2*j,k==j==i+5);. n$ U$ L! t# o* U' O
}
char c='k';
int i=1,j=2,k=3;
float x=3e+5,y=0.85;
printf("%d,%d\n",'a'+5<c,-i-2*j>=k+1);
printf("%d,%d\n",1<j<5,x-5.25<=x+y);
printf("%d,%d\n",i+j+k==-2*j,k==j==i+5); ' ^ ?+ F% q, K: `* w. Y. D: ]
在本例中求出了各种关系运算符的值。 字符变量是以它对应的ASCII码参与运算的。对于含多个关系运算符的表达式，如k==j==i+5,根据运算符的左结合性，先计算k==j,该式不成立，其值为0，再计算0==i+5，也不成立，故表达式值为0。$ c% ?5 m3 {1 W/ K# ^
) D" M, R! Q( w5 o% I$ e
逻辑运算符和表达式
逻辑运算符Ｃ语言中提供了三种逻辑运算符 && 与运算 || 或运算 ! 非运算 与运算符&&和或运算符||均为双目运算符。具有左结合性。 非2 d. k9 N. L! j$ V/ A# F) J# c: U9 L
运算符!为单目运算符，具有右结合性。逻辑运算符和其它运算符优先级的关系可表示如下：
按照运算符的优先顺序可以得出：
a>b && c>d等价于(a>b) && (c>d)0 L9 J/ x2 W- m& @" Y
!b==c||d<a等价于((!b)==c)||(d<a)
a+b>c && x+y<b等价于((a+b)>c) && ((x+y)<b)- d' ~+ {- d# _# [- a0 z1 o
逻辑运算的值
逻辑运算的值也为“真”和“假”两种，用“1”和“0 ”来表示。其求值规则如下：
1.与运算&&参与运算的两个量都为真时，结果才为真，否则为假。例如，5>0 && 4>2,由于5>0为真，4>2也为真，相与的结果也为真。$ g y! B8 z& j
2.或运算||参与运算的两个量只要有一个为真，结果就为真。 两个量都为假时，结果为假。例如：5>0||5>8,由于5>0为真，相或的结果也就为真
3.非运算!参与运算量为真时，结果为假；参与运算量为假时，结果为真。
例如：!(5>0)的结果为假。2 G; _, a6 N& ?4 R$ \
虽然Ｃ编译在给出逻辑运算值时，以“1”代表“真”，“0 ”代表“假”。 但反过来在判断一个量是为“真”还是为“假”时，以“0”代表“假”，以非“0”的数值作为“真”。例如：由于5和3均为非“0”因此5&&3的值为“真”，即为1。3 p: f% {$ r7 @/ e6 k
又如：5||0的值为“真”，即为1。
逻辑表达式逻辑表达式的一般形式为： 表达式 逻辑运算符 表达式 其中的表达式可以又是逻辑表达式，从而组成了嵌套的情形。例如：(a&&b)&&c根据逻辑运算符的左结合性，上式也可写为： a&&b&&c 逻辑表达式的值是式中各种逻辑运算的最后值，以“1”和“0”分别代表“真”和“假”。
void main(){2 ~0 t' d& `3 J3 U
char c='k';
int i=1,j=2,k=3;
float x=3e+5,y=0.85;2 \% o4 o5 L7 y6 J6 y$ l
printf("%d,%d\n",!x*!y,!!!x);; D0 \$ B, A2 @4 i
printf("%d,%d\n",x||i&&j-3,i<j&&x<y);
printf("%d,%d\n",i==5&&c&&(j=8),x+y||i+j+k); m* V2 u% \% t( {% t3 @
}
本例中!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。- w! W; d# C7 b) P+ [( b, S9 b
! n6 `1 u' A6 ?5 G- T6 _5 r
ｉｆ语句
: _" h |* A! k* U* K0 G
用if语句可以构成分支结构。它根据给定的条件进行判断， 以决定执行某个分支程序段。Ｃ语言的if语句有三种基本形式。
! P: [* e# q8 ?, ` l/ B
1.第一种形式为基本形式 if(表达式) 语句； 其语义是：如果表达式的值为真，则执行其后的语句， 否则不执行该语句。其过程可表示为下图9 W+ o' g5 L$ R" v* ^! h o
void main(){
int a,b,max;7 s1 K. q7 `5 q0 m! Y9 Y
printf("\n input two numbers: ");. ~9 S% G' S; ^, ]6 c
scanf("%d%d",&a,&b);9 Z+ M' z5 ^$ W# l, Y! C' _
max=a;
if (max<b) max=b;
printf("max=%d",max);& H% S4 Q# V! j8 a! U5 e3 k t
}
输入两个整数，输出其中的大数。
scanf("%d%d",&a,&b);5 M+ g# J' P& r6 P+ C
max=a;
if (max<b) max=b;
printf("max=%d",max);) R. ]+ ?5 N% e/ _
本例程序中，输入两个数a,b。把a先赋予变量max，再用if语句判别max和b的大小，如max小于b，则把b赋予max。因此max中总是大数，最后输出max的值。
2.第二种形式为if-else形式 $ F p0 Q, c* ?- Z! m
if(表达式)
语句1；
else $ H' J7 ], ]- n
语句2；# u$ \7 x" N( U$ |0 \/ u" Z1 D+ t2 A0 P6 @
其语义是：如果表达式的值为真，则执行语句1，否则执行语句2 。
void main(){$ e5 U3 o i* k# f/ y6 q; H( W' Q
int a, b;2 d, `4 e2 ^- w7 @/ O; U) w5 F& @' Z. O
printf("input two numbers: ");; n8 }3 J/ n2 _/ u5 l; V8 ?
scanf("%d%d",&a,&b);% @+ R+ U' z. T$ @$ R7 P" w7 s
if(a>b)
printf("max=%d\n",a);, h2 b' U- K" ~# _
else: R1 b7 h! w1 h' Q
printf("max=%d\n",b);6 T, g! N" g0 ?2 l
}3 y7 G# }% b( K5 c! [5 M: u
输入两个整数，输出其中的大数。改用if-else语句判别a,b的大小，若a大，则输出a，否则输出b.& g M# Y, U6 f d
3.第三种形式为if-else-if形式
前二种形式的if语句一般都用于两个分支的情况。 当有多个分支选择时，可采用if-else-if语句，其一般形式为： ( f y1 G4 e. C& C) P# O
if(表达式1)
语句1； $ p: V$ Q Y7 A3 a
else if(表达式2) 3 l! ~+ R/ ~! U! L3 ~5 s
语句2； ( Z: O8 [/ @- j8 w. U
else if(表达式3) . L* y4 t; E% e0 f
语句3；
… ) b- g. Z/ v' I; s0 ~8 X. c
else if(表达式m)
语句m；
else 1 |) l' A F! @' j3 H
语句n；
其语义是：依次判断表达式的值，当出现某个值为真时， 则执行其对应的语句。然后跳到整个if语句之外继续执行程序。 如果所有的表达式均为假，则执行语句n 。 然后继续执行后续程序。 if-else-if语句的执行过程如图3—3所示。4 \8 k& T) j& m* H
#include"stdio.h"
void main(){
char c;. v, C& x. J. n9 h. y
printf("input a character: ");
c=getchar();
if(c<32)
printf("This is a control character\n");
else if(c>='0'&&c<='9')% E+ n- ^& Q! @0 m' Z0 e
printf("This is a digit\n");
else if(c>='A'&&c<='Z')
printf("This is a capital letter\n");; T$ N9 Q* Q+ r8 o9 l( X
else if(c>='a'&&c<='z')
printf("This is a small letter\n");
else4 i( B6 O( P& \6 P7 ^
printf("This is an other character\n");
}
本例要求判别键盘输入字符的类别。可以根据输入字符的ASCII码来判别类型。由ASCII码表可知ASCII值小于32的为控制字符。 在“0”和“9”之间的为数字，在“A”和“Z”之间为大写字母， 在“a”和“z”之间为小写字母，其余则为其它字符。 这是一个多分支选择的问题，用if-else-if语句编程，判断输入字符ASCII码所在的范围，分别给出不同的输出。例如输入为“g”，输出显示它为小写字符。
作者: zw2004 时间: 2008-1-21 17:08 标题: C语言程序设计初步
4.在使用if语句中还应注意以下问题( o! O1 v1 a/ b2 r
3 j7 l! V5 x7 V$ T
(1) 在三种形式的if语句中，在if关键字之后均为表达式。 该表达式通常是逻辑表达式或关系表达式， 但也可以是其它表达式，如赋值表达式等，甚至也可以是一个变量。例如： if(a=5) 语句；if(b) 语句； 都是允许的。只要表达式的值为非0，即为“真”。如在if(a=5)…；中表达式的值永远为非0，所以其后的语句总是要执行的，当然这种情况在程序中不一定会出现，但在语法上是合法的。) _& ?& { b" r o" w
又如，有程序段： if(a=b)+ t4 d' ?$ b' O( ?7 B5 v f6 F6 X
printf("%d",a);
else; a# x& C. _) w- ~# q
printf("a=0"); 本语句的语义是，把b值赋予a，如为非0则输出该值，否则输出“a=0”字符串。这种用法在程序中是经常出现的。* k9 d( }" \; T. O) @$ Y
( l# ~* }8 A& L* r& M5 ]
(2) 在if语句中，条件判断表达式必须用括号括起来， 在语句之后必须加分号。) r$ f9 |+ Z4 K0 _6 Y
# E- N8 e( k: u9 J* \( J4 M) {
(3) 在if语句的三种形式中，所有的语句应为单个语句，如果要想在满足条件时执行一组(多个)语句，则必须把这一组语句用{} 括起来组成一个复合语句。但要注意的是在}之后不能再加分号。
例如：
if(a>b){
a++; g& X/ f% U8 k9 R5 d a& f
b++;* c% j3 w* i, G
}
else{% C$ C+ ^, B1 V( k2 Y$ H3 V
a=0;$ r! W7 ]" ~7 q' g
b=10;" X% N' C) V8 i2 y8 R6 o
}
ｉｆ语句的嵌套
当if语句中的执行语句又是if语句时，则构成了if 语句嵌套的情形。其一般形式可表示如下：
if(表达式)
if语句； & Y5 g* o# r8 H, V6 p
或者为
if(表达式) , @- u. B4 z! A# ]. d! A- C
if语句；
else # S9 [' v$ ?- O2 a2 C/ A F
if语句；
在嵌套内的if语句可能又是if-else型的，这将会出现多个if和多个else重叠的情况，这时要特别注意if和else的配对问题。例如：7 [, `% H3 H- c& ]9 G; T
if(表达式1). I7 v. _/ g0 `8 r( \7 @" B
if(表达式2)
语句1；2 S/ k1 w7 N% k! u2 _
else: m0 g& l& d1 h! _
语句2；
其中的else究竟是与哪一个if配对呢?
应该理解为： 还是应理解为： ! H1 l4 s8 b8 g- g# H: M2 ~' ~5 q
if(表达式1) if(表达式1)$ z, f# d, q+ M' Q
if(表达式2) if(表达式2)$ g9 B1 ^$ F2 K6 ]3 a3 j, C
语句1； 语句1；9 P' a$ H; d+ @6 w! k
else else X5 K+ o% K6 c
语句2； 语句2；
为了避免这种二义性，Ｃ语言规定，else 总是与它前面最近的if配对，因此对上述例子应按前一种情况理解。2 r" X: }" C. {) u- O
比较两个数的大小关系。! z- {1 E* J# n. r- u0 S( u4 n
void main(){
int a,b;( a2 L- [* a2 I1 a$ Z
printf("please input A,B: ");! N% g0 }* H5 A0 F6 l
scanf("%d%d",&a,&b);: h, p# p7 Z6 \ u2 ]9 N
if(a!=b)- A* y1 W6 S7 W2 e/ u- e- v9 U, G
if(a>b) printf("A>B\n");6 Z8 ^2 B! k# s
else printf("A<B\n");
else printf("A=B\n");6 D! V. ?% J4 `4 O
}
本例中用了if语句的嵌套结构。 采用嵌套结构实质上是为了进行多分支选择，例3.16实际上有三种选择即A>B、A<B或A=B。这种问题用if-else-if语句也可以完成。而且程序更加清晰。因此， 在一般情况下较少使用if语句的嵌套结构。 以使程序更便于阅读理解。
void main(){+ N; G' [* e8 z6 r# ^+ y
int a,b;
printf("please input A,B: ");
scanf("%d%d",&a,&b);
if(a==b) printf("A=B\n"); r% L; s( A# o! |4 E% _8 C9 `
else if(a>b) printf("A>B\n");4 \! Z; N) V/ L+ M' O5 f$ j0 t
else printf("A<B\n");3 B0 U. j1 \3 i; `
}
条件运算符和条件表达式
如果在条件语句中，只执行单个的赋值语句时， 常可使用条件表达式来实现。不但使程序简洁，也提高了运行效率。% O- q, { D3 |& u" @% e8 X
条件运算符为?和：，它是一个三目运算符，即有三个参与运算的量。由条件运算符组成条件表达式的一般形式为：
表达式1? 表达式2： 表达式3
其求值规则为：如果表达式1的值为真，则以表达式2 的值作为条件表达式的值，否则以表达式2的值作为整个条件表达式的值。 条件表达式通常用于赋值语句之中。2 l: S" m, U3 V0 I/ _
例如条件语句： 9 y% u, p) N7 ^( w M+ R4 F" X$ |2 T
if(a>b) max=a;( U4 `4 [ S* }' W
else max=b;4 O j1 t Y/ C* N3 o+ D8 ?
可用条件表达式写为 max=(a>b)?a:b; 执行该语句的语义是：如a>b为真，则把a赋予max，否则把b 赋予max。
使用条件表达式时，还应注意以下几点：( \$ y# p3 k$ L& G7 J2 i* K1 A
1. 条件运算符的运算优先级低于关系运算符和算术运算符，但高于赋值符。因此 max=(a>b)?a:b可以去掉括号而写为 max=a>b?a:b
2. 条件运算符?和：是一对运算符，不能分开单独使用。
3. 条件运算符的结合方向是自右至左。
例如：9 R ?% W% U2 k# q3 X: e3 E9 g
a>b?a:c>d?c:d应理解为
a>b?a
c>d?c:d) 这也就是条件表达式嵌套的情形，即其中的表达式3又是一个条件表达式。
void main(){
int a,b,max;2 V7 }( i1 y1 L* F
printf("\n input two numbers: ");1 `* w+ h3 F" K9 q8 p/ U
scanf("%d%d",&a,&b);0 d* x- t: H- b0 k- F- |
printf("max=%d",a>b?a:b);2 Q% [3 u$ _9 C8 h, W
}3 m- Y: v4 n" e, v I& n
用条件表达式对上例重新编程，输出两个数中的大数。
作者: zw2004 时间: 2008-1-21 17:09 标题: C语言程序设计初步
ｓｗｉｔｃｈ语句
Ｃ语言还提供了另一种用于多分支选择的switch语句， 其一般形式为：
switch(表达式){ # b& r$ X2 G3 B/ E
case常量表达式1: 语句1;
case常量表达式2: 语句2;
… 8 J4 [* R- d9 |7 m( ?6 x
case常量表达式n: 语句n;
default : 语句n+1; 1 n% m$ {* }0 M& }9 X- u/ D
}
其语义是：计算表达式的值。 并逐个与其后的常量表达式值相比较，当表达式的值与某个常量表达式的值相等时， 即执行其后的语句，然后不再进行判断，继续执行后面所有case后的语句。 如表达式的值与所有case后的常量表达式均不相同时，则执行default后的语句。; s* w' Z8 i$ C/ _- v! W& x' B
void main(){" A; i% Z% C8 M9 J/ x
int a;
printf("input integer number: ");
scanf("%d",&a);
switch (a){ ' a& \. I2 ~0 v! H P9 k1 U
case 1:printf("Monday\n");
case 2:printf("Tuesday\n");
case 3:printf("Wednesday\n");3 j* @ A2 G5 S9 U* I, ^$ |
case 4:printf("Thursday\n"); ^) P/ Q4 o) D3 T! Q3 V4 U
case 5:printf("Friday\n");& A1 I5 C2 R! v$ ~
case 6:printf("Saturday\n");. I1 O8 N# M9 n# Q- }, p3 ]7 R6 _
case 7:printf("Sunday\n");+ T1 Q7 t* }% b/ H% v
default:printf("error\n");4 D) |3 v! p8 s6 m3 {. ~6 s0 a% ^
}
}# k3 n6 K4 z! s( b
+ }' A0 P3 p ?& B- v# W( f9 e& K* o
本程序是要求输入一个数字，输出一个英文单词。但是当输入3之后，却执行了case3以及以后的所有语句，输出了Wednesday 及以后的所有单词。这当然是不希望的。为什么会出现这种情况呢?这恰恰反应了switch语句的一个特点。在switch语句中，“case 常量表达式”只相当于一个语句标号， 表达式的值和某标号相等则转向该标号执行，但不能在执行完该标号的语句后自动跳出整个switch 语句，所以出现了继续执行所有后面case语句的情况。 这是与前面介绍的if语句完全不同的，应特别注意。为了避免上述情况， Ｃ语言还提供了一种break语句，专用于跳出switch语句，break 语句只有关键字break，没有参数。在后面还将详细介绍。修改例题的程序，在每一case语句之后增加break 语句， 使每一次执行之后均可跳出switch语句，从而避免输出不应有的结果。
void main(){
int a;
printf("input integer number: ");" h! }3 |7 R4 R: K0 j Z0 x, Q
scanf("%d",&a);- M4 M7 a- X* W* S: C" @+ v
switch (a){
case 1:printf("Monday\n");break;/ W' r. @8 s8 ~; h3 @+ ?
case 2:printf("Tuesday\n"); break;9 T# s1 c6 L$ H* ]
case 3:printf("Wednesday\n");break;
case 4:printf("Thursday\n");break;
case 5:printf("Friday\n");break;" [0 {8 @7 R1 i
case 6:printf("Saturday\n");break;
case 7:printf("Sunday\n");break;7 j' n( L2 a! m
default:printf("error\n");
}
}
在使用switch语句时还应注意以下几点：, P( I% `# V% [- w1 _/ b
1.在case后的各常量表达式的值不能相同，否则会出现错误。) z7 v5 f" U# J! m' m$ ~9 G
2.在case后，允许有多个语句，可以不用{}括起来。
3.各case和default子句的先后顺序可以变动，而不会影响程序执行结果。
4.default子句可以省略不用。程序举例
输入三个整数，输出最大数和最小数。: I/ D; |% a+ T1 N+ G2 g
void main(){
int a,b,c,max,min;! S2 o+ _0 Y- {- x
printf("input three numbers: ");
scanf("%d%d%d",&a,&b,&c);
if(a>b)
{max=a;min=b;}
else
{max=b;min=a;}& m% x' O. f5 t( d# V0 ~3 L- b3 i
if(max<c)
max=c;- w2 g1 s4 f4 C1 L4 E, _5 e
else: k* v* B( j' s% `3 Y3 Z' J
if(min>c) r$ `0 P) K! b4 [
min=c;: E: J+ ?! M( e3 ^' W& ~
printf("max=%d\nmin=%d",max,min);' S2 e0 {8 f! b* ?6 D8 }
}3 o0 M- J- y( b6 v! X
本程序中，首先比较输入的a,b的大小，并把大数装入max， 小数装入min中，然后再与c比较，若max小于c，则把c赋予max；如果c小于min，则把c赋予min。因此max内总是最大数，而min内总是最小数。最后输出max和min的值即可。 计算器程序。用户输入运算数和四则运算符， 输出计算结果。
void main(){
float a,b,s;2 A# x( V% g/ C( R/ p0 W- B
char c; S! P+ ]. h! i
printf("input expression: a+(-,*,/)b \n");( p" a8 c, K5 n- h6 Q6 l% Q7 u
scanf("%f%c%f",&a,&c,&b);
switch(c){# y$ n9 B m& J
case '+': printf("%f\n",a+b);break;
case '-': printf("%f\n",a-b);break;+ @$ m( _. s5 ^# b7 p
case '*': printf("%f\n",a*b);break;
case '/': printf("%f\n",a/b);break;
default: printf("input error\n");
}& w0 X% J7 W6 R* c) F0 ^2 X) m% |4 A
}
本例可用于四则运算求值。switch语句用于判断运算符， 然后输出运算值。当输入运算符不是+,-,*,/时给出错误提示。
) [+ H/ t3 |! t, V/ ]' [
循环结构程序
循环结构是程序中一种很重要的结构。其特点是， 在给定条件成立时，反复执行某程序段，直到条件不成立为止。 给定的条件称为循环条件，反复执行的程序段称为循环体。 Ｃ语言提供了多种循环语句，可以组成各种不同形式的循环结构。6 G$ d& P. a! s& |( s& {
2 G! O, C8 G7 C2 ~# j6 {9 L
ｗｈｉｌｅ语句7 l! Z; G, A, C, y: _1 V0 s
while语句的一般形式为： while(表达式)语句； 其中表达式是循环条件，语句为循环体。
while语句的语义是：计算表达式的值，当值为真(非0)时， 执行循环体语句。其执行过程可用图3—4表示。 统计从键盘输入一行字符的个数。% K0 D' c, j, H) X7 e
#include <stdio.h>
void main(){; D# c9 R, X4 }- ?" K% J$ c3 [* x
int n=0;
printf("input a string:\n");
while(getchar()!='\n') n++;
printf("%d",n);1 H. n9 C; A& a+ N4 @4 m9 e
}
本例程序中的循环条件为getchar()!='\n',其意义是， 只要从键盘输入的字符不是回车就继续循环。循环体n++完成对输入字符个数计数。从而程序实现了对输入一行字符的字符个数计数。
使用while语句应注意以下几点：' t; n' B' h, S$ J: j6 A; P
1.while语句中的表达式一般是关系表达或逻辑表达式，只要表达式的值为真(非0)即可继续循环。
void main(){0 _& Q! @3 H- r( y
int a=0,n;
printf("\n input n: ");
scanf("%d",&n);9 m5 r x5 g/ P& w0 J
while (n--)
printf("%d ",a++*2);8 i! V% D3 B: U$ \
}
作者: zw2004 时间: 2008-1-21 17:09 标题: C语言程序设计初步
本例程序将执行n次循环，每执行一次，n值减1。循环体输出表达式a++*2的值。该表达式等效于(a*2；a++)8 p. Z- l* {4 t k* L3 }; Q6 @( R
2.循环体如包括有一个以上的语句，则必须用{}括起来， 组成复合语句。2 p+ w/ j2 W" N, I1 z( B; }8 w$ W
3.应注意循环条件的选择以避免死循环。- [' K0 S$ a, P& v( r
void main(){
int a,n=0;
while(a=5)* W4 E$ _! a' O0 B# Y0 U3 ^
printf("%d ",n++);2 B5 f4 `9 i4 @% }
}9 [% \1 Z4 ^$ u. @3 N8 g
本例中while语句的循环条件为赋值表达式a=5， 因此该表达式的值永远为真，而循环体中又没有其它中止循环的手段， 因此该循环将无休止地进行下去，形成死循环。4.允许while语句的循环体又是while语句，从而形成双重循环。
3 F' m# z" z" S# |
ｄｏ－ｗｈｉｌｅ语句% v8 X$ u' O; x
do-while语句的一般形式为：
do+ z7 G, f# O. t
语句； % k$ K' e( }. u+ `
while(表达式)； 5 ]) l. Y3 P( n9 q: p7 l$ X
其中语句是循环体，表达式是循环条件。# n; e0 ]8 ^' z+ `7 I; V0 M
do-while语句的语义是：
先执行循环体语句一次， 再判别表达式的值，若为真(非0)则继续循环，否则终止循环。
do-while语句和while语句的区别在于do-while是先执行后判断，因此do-while至少要执行一次循环体。而while是先判断后执行，如果条件不满足，则一次循环体语句也不执行。$ r4 o/ s- f) E' n2 Y0 Z
while语句和do-while语句一般都可以相互改写。
void main(){( i- A1 ~1 v' C+ P4 t
int a=0,n;+ y" J( \' Q# Q) r3 W7 a7 R) Q
printf("\n input n: ");
scanf("%d",&n);. k, O6 X+ y+ {
do printf("%d ",a++*2);/ x4 V. t8 }! B+ B$ ?
while (--n);7 R U! h+ o) v6 s9 f+ W
} 9 R) L& U! D7 ]; N
$ g5 y2 |& t( s* y) [" {8 v$ B( {
在本例中，循环条件改为--n，否则将多执行一次循环。这是由于先执行后判断而造成的。
对于do-while语句还应注意以下几点：
1.在if语句，while语句中， 表达式后面都不能加分号， 而在 do-while语句的表达式后面则必须加分号。* ?' ~* f' v$ W$ C, N7 u+ _
2.do-while语句也可以组成多重循环，而且也可以和while语句相互嵌套。
3.在do和while之间的循环体由多个语句组成时，也必须用{}括起来组成一个复合语句。
4.do-while和while语句相互替换时，要注意修改循环控制条件。
ｆｏｒ语句
for语句是Ｃ语言所提供的功能更强，使用更广泛的一种循环语句。其一般形式为：
for(表达式1；表达式2；表达3) / i' X6 o! C# Z$ _" h- P* m
语句； 9 _( i/ f; c: w! Y7 {& b9 w4 [
表达式1 通常用来给循环变量赋初值，一般是赋值表达式。也允许在for语句外给循环变量赋初值，此时可以省略该表达式。
表达式2 通常是循环条件，一般为关系表达式或逻辑表达式。" z _( P7 q% j
表达式3 通常可用来修改循环变量的值，一般是赋值语句。
这三个表达式都可以是逗号表达式， 即每个表达式都可由多个表达式组成。三个表达式都是任选项，都可以省略。
一般形式中的“语句”即为循环体语句。for语句的语义是：
1.首先计算表达式1的值。5 J5 L" G( @1 |0 V/ y" o) T% O
2.再计算表达式2的值，若值为真(非0)则执行循环体一次， 否则跳出循环。
3.然后再计算表达式3的值，转回第2步重复执行。在整个for循环过程中，表达式1只计算一次，表达式2和表达式，3则可能计算多次。循环体可能多次执行，也可能一次都不执行。for 语句的执行过程如图所示。# w7 b) ~1 `$ a$ g" ]+ N
void main(){, x2 q7 I- j/ @- n: n
int n,s=0;6 Y& I% i& [: d1 X, B: _1 c
for(n=1;n<=100;n++), b7 P/ [$ j+ E9 j1 A7 [
s=s+n;% a* b/ o& l" A2 E4 w- n
printf("s=%d\n",s);
} 5 a- T" G3 Y+ e& t z7 ?
用for语句计算s=1+2+3+...+99+100
5 m1 X4 x% C3 q/ x1 @4 k" X/ i
int n,s=0;
for(n=1;n<=100;n++)( u/ @4 U9 B$ }) z
s=s+n;
printf("s=%d\n",s);
本例for语句中的表达式3为n++，实际上也是一种赋值语句，相当于n=n+1，以改变循环变量的值。& j5 D: @! d( A% j |: l7 n# r
void main(){
int a=0,n;
printf("\n input n: ");
scanf("%d",&n);: w. {( s; Q; D
for(;n>0;a++,n--): X! L1 F. g. J E2 A. j8 ]
printf("%d ",a*2);: s+ u9 x& c0 w# w" S! j, _2 u# y
}
用for语句修改例题。从0开始，输出n个连续的偶数。
int a=0,n;+ H# `. S' l4 c0 @7 @5 M
printf("\n input n: ");
scanf("%d",&n);
for(;n>0;a++,n--)
printf("%d ",a*2);0 e/ T% g0 c, r" e. p# m) Q. B
本例的for语句中，表达式1已省去，循环变量的初值在for语句之前由scanf语句取得，表达式3是一个逗号表达式，由a++，n-- 两个表达式组成。每循环一次a自增1，n自减1。a的变化使输出的偶数递增，n的变化控制循次数。. w8 }. w6 `! u' L1 ^
在使用for语句中要注意以下几点
1.for语句中的各表达式都可省略，但分号间隔符不能少。如：for(；表达式；表达式)省去了表达式1。for(表达式；；表达式)省去了表达式2。
for(表达式；表达式；)省去了表达式3。for(；；)省去了全部表达式。
2.在循环变量已赋初值时，可省去表达式1，如例3.27即属于这种情形。如省去表达式2或表达式3则将造成无限循环， 这时应在循环体内设法结束循环。例题即属于此情况。8 v! ]& X6 C9 h+ K
void main(){
int a=0,n;
printf("\n input n: ");5 @$ B+ ?1 g: R4 Z! G2 O+ P3 [
scanf("%d",&n);! w8 G3 G9 `/ V
for(;n>0;)
{ a++;n--;6 w p6 G$ B7 o& f
printf("%d ",a*2);
}
}* B+ _% a- c& w8 \' `5 o; G8 U# L
本例中省略了表达式1和表达式3，由循环体内的n--语句进行循环变量n的递减，以控制循环次数。
void main(){
int a=0,n;1 H* Z) k& f, y# U
printf("\n input n: ");
scanf("%d",&n);& o! _! n2 T" S
for(;;){& O8 u$ p8 c8 n% y. R
a++;n--;
printf("%d ",a*2);
if(n==0)break;
} S. V! \2 r" k$ V' D
}/ E7 Y8 A4 W3 f/ `
本例中for语句的表达式全部省去。由循环体中的语句实现循环变量的递减和循环条件的判断。当n值为0时，由break语句中止循环，转去执行for以后的程序。在此情况下，for语句已等效于while( 1)语句。如在循环体中没有相应的控制手段，则造成死循环。
3.循环体可以是空语句。
#include"stdio.h"
void main(){
int n=0;2 `6 K0 ]0 N2 F4 w& |8 J, |2 ?) a
printf("input a string:\n");
for(;getchar()!='\n';n++);
printf("%d",n);
}
作者: zw2004 时间: 2008-1-21 17:09 标题: C语言程序设计初步
本例中，省去了for语句的表达式1，表达式3也不是用来修改循环变量，而是用作输入字符的计数。这样， 就把本应在循环体中完成的计数放在表达式中完成了。因此循环体是空语句。应注意的是，空语句后的分号不可少，如缺少此分号，则把后面的printf 语句当成循环体来执行。反过来说，如循环体不为空语句时， 决不能在表达式的括号后加分号， 这样又会认为循环体是空语句而不能反复执行。这些都是编程中常见的错误，要十分注意。, W( d) ~3 c" S' i) {
4.for语句也可与while,do-while语句相互嵌套，构成多重循环。以下形成都合法的嵌套。0 d- c/ U4 p. U5 I
(1)for(){…
while()1 p: w( a" {& R/ {; Y4 `0 w* t7 c
{…}* e2 I' l; {, a
…& I( Q0 U8 g' T% W' ~# Q
}% M- h5 f( |2 F% \8 c( E
(2)do{: T) R; E* M8 v: Z; D& N- f
…* }4 a0 C( C0 p/ t* M
for(), F- b( L7 w( c5 S& U' e
{…}
…
}while();
(3)while(){
…. E3 |; X* O: n- W X' _
for()
{…}
…
}
(4)for(){
…
for(){5 J. U5 s- h5 {" u3 ^& ~) W
…
}( M* I$ Z7 s* _
}. g. ^3 |; F3 G# p6 d1 q/ |
void main(){
int i,j,k;
for(i=1;i<=3;i++)) s: ^; t/ c; U5 T f
{ for(j=1;j<=3-i+5;j++)
printf(" ");
for(k=1;k<=2*i-1+5;k++)
{1 \- y# b4 W1 A5 k# w! l
if(k<=5) printf(" ");5 O5 F$ ^* Y+ `3 v& W) T2 z
else printf("*");! C* e" x7 ^- H1 b( H
}
printf("\n");
}
}
0 n+ @( }, b, d( g/ W( o% w
转移语句
: A7 e7 E: B" Z0 t, u
程序中的语句通常总是按顺序方向， 或按语句功能所定义的方向执行的。如果需要改变程序的正常流向， 可以使用本小节介绍的转移语句。在Ｃ语言中提供了4种转移语句：
goto,break, continue和return。
其中的return语句只能出现在被调函数中， 用于返回主调函数，我们将在函数一章中具体介绍。 本小节介绍前三种转移语句。9 y2 q p6 R& q6 A
- ^0 V: v8 ]. _/ M. p2 ~$ f1 `, ~
1.goto语句, s9 w% M8 |1 c) n% P6 r
* y9 i% W1 g+ s: m
goto语句也称为无条件转移语句，其一般格式如下： goto 语句标号； 其中语句标号是按标识符规定书写的符号， 放在某一语句行的
前面，标号后加冒号(：)。语句标号起标识语句的作用，与goto 语句配合使用。
如： label: i++; 1 _: x5 w- u* ~' q! D
loop: while(x<7); 2 z4 ?9 S* G! D. C
Ｃ语言不限制程序中使用标号的次数，但各标号不得重名。goto语句的语义是改变程序流向， 转去执行语句标号所标识的语句。) c$ o# {4 C. i+ r6 b, q
goto语句通常与条件语句配合使用。可用来实现条件转移， 构成循环，跳出循环体等功能。
但是，在结构化程序设计中一般不主张使用goto语句， 以免造成程序流程的混乱，使理解和调试程序都产生困难。$ Y9 e/ H" e2 O
统计从键盘输入一行字符的个数。
#include"stdio.h"$ Q. y( u! T, x. h8 H
void main(){2 v' Q/ I! r* g# f0 ^
int n=0;: ~ [, J, \5 P4 w9 C
printf("input a string\n");6 w8 [2 b$ s. X3 ^$ m9 M# q+ c
loop: if(getchar()!='\n')2 J# }6 ^, Z8 M" e4 y& J! K
{ n++;
goto loop;2 b1 O$ M: t* d1 Z
}
printf("%d",n);* g* s4 S. }6 M) L
}
本例用if语句和goto语句构成循环结构。当输入字符不为'\n'时即执行n++进行计数，然后转移至if语句循环执行。直至输入字符为'\n'才停止循环。- O( Z- k+ c& i0 o9 @7 ~
) L& } D( H- p) {$ n: o
ｂｒｅａｋ语句
break语句只能用在switch 语句或循环语句中， 其作用是跳出switch语句或跳出本层循环，转去执行后面的程序。由于break语句的转移方向是明确的，所以不需要语句标号与之配合。break语句的一般形式为： break; 上面例题中分别在switch语句和for语句中使用了break 语句作为跳转。使用break语句可以使循环语句有多个出口，在一些场合下使编程更加灵活、方便。7 X0 ^* g+ `2 q
ｃｏｎｔｉｎｕｅ语句
continue语句只能用在循环体中，其一般格式是：+ {) o; k7 w( Z% e* k, c
continue;4 q' E) W# E% S# U. f. W4 W
其语义是：结束本次循环，即不再执行循环体中continue 语句之后的语句，转入下一次循环条件的判断与执行。应注意的是， 本语句只结束本层本次的循环，并不跳出循环。
void main(){
int n;9 F' j4 d5 _; i4 p# L* e0 {, |
for(n=7;n<=100;n++)
{
if (n%7!=0)
continue;1 t3 A% G1 l8 |& s. _7 R
printf("%d ",n);
}
}
输出100以内能被7整除的数。 6 S/ G6 a& v9 v/ j
int n;' X& o7 M: L3 G% c2 O8 G
for(n=7;n<=100;n++)
{
if (n%7!=0)# s8 `2 } H4 T$ m: F& {
continue;
printf("%d ",n);; P$ X9 P+ V2 h: ]6 R
}8 ^9 R5 W: J& X9 d" V
本例中，对7～100的每一个数进行测试，如该数不能被7整除，即模运算不为0，则由continus语句转去下一次循环。只有模运算为0时，才能执行后面的printf语句，输出能被7整除的数。
#include"stdio.h"
void main(){
char a,b;; Q+ l$ l! u" a7 {# }
printf("input a string:\n");
b=getchar();) `( r: y8 U0 E3 ^0 w
while((a=getchar())!='\n'){% G8 s' ^+ E6 Y" A! V5 I' _+ c
if(a==b){+ ~; [2 S F9 V7 v6 |1 S- X8 B
printf("same character\n");' D9 `9 ]1 p/ e- f0 m' |1 s/ j1 E
break;
}b=a;
}. N3 R) N/ W8 k9 C1 A* |
}
检查输入的一行中有无相邻两字符相同。
char a,b;
printf("input a string:\n");
b=getchar();
while((a=getchar())!='\n'){
if(a==b){3 b u) t% J9 j8 m, j! W3 f
printf("same character\n");
break;' {; S# r( ]& o3 |- q
}b=a;
}
作者: zw2004 时间: 2008-1-21 17:10 标题: C语言程序设计初步（完）
本例程序中，把第一个读入的字符送入b。然后进入循环，把下一字符读入a，比较a,b是否相等，若相等则输出提示串并中止循环，若不相等则把a中的字符赋予b，输入下一次循环。
输出100以内的素数。素数是只能被1 和本身整除的数。可用穷举法来判断一个数是否是素数。
void main(){
int n,i;0 R h9 N8 ~ H; A t. H$ c
for(n=2;n<=100;n++){! Q. {# d1 r% ]* N+ ]
for(i=2;i<n;i++)
if(n%i==0) break;
if(i>=n) printf("\t%d",n);6 G, ]0 C* n& p5 T/ _" ~
}- D* o" y+ f- A* t% _" {* W) a
} int n,i;
for(n=2;n<=100;n++){0 F3 M1 G8 H/ H5 {+ Y! h4 u- h& t! {
for(i=2;i<n;i++)
if(n%i==0) break;
if(i>=n) printf("\t%d",n);/ d) c1 B$ s" Q/ W
}
本例程序中，第一层循环表示对1～100这100个数逐个判断是否是素数，共循环100次，在第二层循环中则对数n用2～n-1逐个去除，若某次除尽则跳出该层循环，说明不是素数。 如果在所有的数都是未除尽的情况下结束循环，则为素数，此时有i>=n， 故可经此判断后输出素数。然后转入下一次大循环。实际上，2以上的所有偶数均不是素数，因此可以使循环变量的步长值改为2，即每次增加2，此外只需对数n用2～n去除就可判断该数是否素数。这样将大大减少循环次数，减少程序运行时间。
#include"math.h"+ Y+ s2 b8 S3 p( ^
void main(){
int n,i,k;
for(n=2;n<=100;n+=2){
k=sqrt(n);+ B& S# \: s9 t2 x: N
for(i=2;i<k;i++)
if(n%i==0) break;
if(i>=k) printf("\t%2d",n);
}
}( g9 _. {8 l1 `5 U( I
6 }" v$ t+ m4 }" K
4 x% r1 M# t/ U$ h% @
# z" B/ L3 Y+ j- e4 z6 w3 q
小结0 Q$ }5 S0 `: S: Y5 }
% i% i! `* {6 T; X$ A- E8 V9 s" f
1.从程序执行的流程来看， 程序可分为三种最基本的结构： 顺序结构，分支结构以及循环结构 " l. P2 z4 n. q9 l1 M: I
2.程序中执行部分最基本的单位是语句。Ｃ语言的语句可分为五类：
(1)表达式语句 任何表达式末尾加上分号即可构成表达式语句， 常用的表达式语句为赋值语句。
(2)函数调用语句 由函数调用加上分号即组成函数调用语句。
(3)控制语句 用于控制程序流程，由专门的语句定义符及所需的表达式组成。主要有条件判断执行语句，循环执行语句，转向语句等。0 R4 Z, v9 m+ X1 G* s' t
(4)复合语句 由{}把多个语句括起来组成一个语句。 复合语句被认为是单条语句，它可出现在所有允许出现语句的地方，如循环体等。
(5)空语句 仅由分号组成，无实际功能。
3.Ｃ语言中没有提供专门的输入输出语句， 所有的输入输出都是由调用标准库函数中的输入输出函数来实现的。
scanf和getchar函数是输入函数，接收来自键盘的输入数据。/ g4 H( X# m5 h) g
scanf是格式输入函数， 可按指定的格式输入任意类型数据。2 H E( F! X: ]' J+ f
getchar函数是字符输入函数， 只能接收单个字符。
printf和putchar函数是输出函数，向显示器屏幕输出数据。% d* R6 Z8 k, O3 Q+ X+ D( e: x
printf是格式输出函数，可按指定的格式显示任意类型的数据。8 |' G, ?! q1 v1 L* s( G/ k. h, h
putchar是字符显示函数，只能显示单个字符。 . n; z/ Y9 ] N8 m& d
/ k* G8 \& [9 J y$ S, g* X/ }( `
4.关系表达式和逻辑表达式是两种重要的表达式， 主要用于条件执行的判断和循环执行的判断。
* X& ^( S( o: B ~
5.Ｃ语言提供了多种形式的条件语句以构成分支结构。
(1)if语句主要用于单向选择。
(2)if-else语句主要用于双向选择。
(3)if-else-if语和switch语句用于多向选择。2 a7 O: j- g$ t
这几种形式的条件语句一般来说是可以互相替代的。% ^3 }1 \+ O6 ^% J( e6 R( c9 p" Y. E
' q/ a7 c- G6 g" J8 w
6.Ｃ语言提供了三种循环语句。# w* h2 Z1 a0 U4 ]+ ^4 y
(1)for语句主要用于给定循环变量初值， 步长增量以及循环次数的循环结构。) B* B* Y* w9 R3 _5 \( t7 @5 s
(2)循环次数及控制条件要在循环过程中才能确定的循环可用 while或do-while语句。
(3)三种循环语句可以相互嵌套组成多重循环。循环之间可以并列但不能交叉。: U" `( `' T+ l7 K5 X
(4)可用转移语句把流程转出循环体外，但不能从外面转向循环体内。" |" q! H3 U+ O2 b2 W$ E
(5)在循环程序中应避免出现死循环，即应保证循环变量的值在运行过程中可以得到修改，并使循环条件逐步变为假，从而结束循环。
7 r9 H& v" \9 f; k! H
7.Ｃ语言语句小结0 F8 Q( B2 G- y! u5 r
名 称 一 般 形 式0 U6 z, u/ r. y P
简单语句 表达式语句表达式; / U9 ?3 l' Z9 ?; A' v
空语句;
复合语句 { 语句 }! w, r* F; o' J. V- I, \6 M$ \
条件语句 if(表达式)语句; ; j* q! n' u, j) d8 F" B
if(表达式)语句1; else语句2; 0 s- k6 @$ r. e1 E: ~4 I4 Z
if(表达式1)语句1; else if(表达式2) 语句2…else语句 n;4 _+ D3 x. `9 e6 z+ u. E
开关语句 switch(表达式){ case常量表达式: 语句…default: 语句; }
循环语句 while语句
while(表达式)语句; + z" I4 ?5 ], z8 \3 V! ~
for语句 for(表达式1; 表达式2; 表达式3)语句; # ?0 y4 H- d9 y3 G. a! G' U
break语句 break; ( N; P( w4 }1 \9 C( {
goto语句 goto; / V; m. `+ W- |2 Y0 k% q9 X
continue语句 continue; 3 J: c+ h: p* j' u- E; m
return 语句 return(表达式);
作者: 周汇 时间: 2008-1-21 22:09 标题: 好长呀！！！
需要多多学习一下哦！~~
| 欢迎光临 捌玖网络工作室 (http://89w.org/) | Powered by Discuz! 7.2 |