Ｃ语言的数据类型; b# j6 s. c' s5 G4 X( b. y

+ d5 d, ~: T. N- s: ~9 w" W. f7 ^( A4 X　　在第一课中，我们已经看到程序中使用的各种变量都应预先加以说明，即先说明，后使用。对变量的说明可以包括三个方面：
8 U: x$ V7 f6 E2 ?# t0 U·数据类型
1 [% w) }& c1 c8 p' ?" b·存储类型+ k$ `! @+ l& Q2 ?5 D/ f0 q# r/ Y
·作用域
; Z$ e- }* K4 P# M: B% d3 M　　在本课中，我们只介绍数据类型说明。其它说明在以后各章中陆续介绍。所谓数据类型是按被说明量的性质，表示形式，占据存储空间的多少，构造特点来划分的。在Ｃ语言中，数据类型可分为：基本数据类型，构造数据类型，指针类型，空类型四大类。
- X4 L  v/ d! Z& Y$ [" i9 m. t
: [* V9 ?$ t- G# m$ G  _* i1.基本数据类型
0 @) N6 p8 Y% I3 o4 L" s0 G, A, }1 r: T% _
　　基本数据类型最主要的特点是，其值不可以再分解为其它类型。也就是说，基本数据类型是自我说明的。  @& o* ]( a% X$ g8 a+ c: P

, x0 c9 Q6 B: J1 T1 `2.构造数据类型构造数据类型
1 Z& A9 F* z8 M, Q7 M( X$ Z3 a' z) o$ l( v6 U
　　是根据已定义的一个或多个数据类型用构造的方法来定义的。也就是说，一个构造类型的值可以分解成若干个“成员”或“元素”。每个“成员”都是一个基本数据类型或又是一个构造类型。在C语言中，构造类型有以下几种：
" I  @4 u3 z5 v5 R4 P·数组类型# p5 S% z# {+ P2 T! a8 }0 H" t
·结构类型; T  Z- @/ G7 N4 N6 C
·联合类型
( M/ i# Q5 \3 P+ r1 d1 A" V$ G$ u5 ~2 m
3.指针类型
$ h- ~9 i, R) I$ i# b* P  z1 X4 D: Z
　　指针是一种特殊的，同时又是具有重要作用的数据类型。其值用来表示某个量在内存储器中的地址。虽然指针变量的取值类似于整型量，但这是两个类型完全不同的量，因此不能混为一谈。4.空类型在调用函数值时，通常应向调用者返回一个函数值。这个返回的函数值是具有一定的数据类型的，应在函数定义及函数说明中给以说明，例如在例题中给出的max函数定义中，函数头为： int max(int a,int b);其中“int ”类型说明符即表示该函数的返回值为整型量。又如在例题中，使用了库函数 sin，由于系统规定其函数返回值为双精度浮点型，因此在赋值语句s=sin (x);中，s 也必须是双精度浮点型，以便与sin函数的返回值一致。所以在说明部分，把s说明为双精度浮点型。但是，也有一类函数，调用后并不需要向调用者返回函数值， 这种函数可以定义为“空类型”。其类型说明符为void。在第五章函数中还要详细介绍。在本章中，我们先介绍基本数据类型中的整型、浮点型和字符型。其余类型在以后各章中陆续介绍。2 \. i# D4 @; V* X2 Q

3 u. d  ]) |) b, D) k1 X) F. t　　对于基本数据类型量，按其取值是否可改变又分为常量和变量两种。在程序执行过程中，其值不发生改变的量称为常量，取值可变的量称为变量。它们可与数据类型结合起来分类。例如，可分为整型常量、整型变量、浮点常量、浮点变量、字符常量、字符变量、枚举常量、枚举变量。在程序中，常量是可以不经说明而直接引用的，而变量则必须先说明后使用。
  @3 V, L  x6 T4 P
$ I+ l$ ^, J* C  ]+ m整型量
# k# a# z4 P! {# W' L
3 i2 d& y9 b8 i3 t! _& b3 ~3 m整型量包括整型常量、整型变量。整型常量就是整常数。在Ｃ语言中，使用的整常数有八进制、十六进制和十进制三种。
( N: W7 {6 d9 ?) B8 D3 }  E
# Y9 J) ]+ X. c2 h, g  L2 B1 X整型常量7 }5 T" ?7 c( g; t

) M* W5 E/ d% D1.八进制整常数八进制整常数必须以0开头，即以0作为八进制数的前缀。数码取值为0～7。八进制数通常是无符号数。0 n9 Z) A& t" ^* A( c
以下各数是合法的八进制数：
% m9 k: W5 r2 B; {- Z9 r015(十进制为13)　0101(十进制为65)　0177777(十进制为65535)
6 J1 O5 I3 t' w$ T8 m0 ^, b3 q以下各数不是合法的八进制数：
% N* W1 M: Z8 a, J6 t1 s  q256(无前缀0) 03A2(包含了非八进制数码)　-0127(出现了负号)
$ h, d* m! G! q7 P) V  _& V+ e2 k
) q, J' q  n3 X& {2.十六进制整常数
  z, Q; u9 r2 F, _  V+ [十六进制整常数的前缀为0X或0x。其数码取值为0~9，A~F或a~f。
4 I) K1 C. ^. D+ `' N7 `以下各数是合法的十六进制整常数：
9 }! Q, s9 q6 r( ?2 g" Z0X2A(十进制为42)　　0XA0 (十进制为160)　　0XFFFF (十进制为65535)
) k4 V* Y1 J0 L, m7 R以下各数不是合法的十六进制整常数：
/ e- w' M3 j. J7 d7 C5A (无前缀0X)　　0X3H (含有非十六进制数码)7 N) J# o/ q  ]% _, J3 Q
3 y0 L2 f$ L4 G$ M, r8 Y9 `2 e- p! _
3.十进制整常数
2 x$ x. e# d# Y; W1 ~3 g十进制整常数没有前缀。其数码为0～9。) y( G" G0 \' o0 J1 e) ^0 d
以下各数是合法的十进制整常数：  z7 D, p# U+ W. K1 }4 {' b
237 -568 65535 1627
  Q9 W8 s$ B" M3 ~- B以下各数不是合法的十进制整常数：% ]0 \+ }  ~  m- Q
023 (不能有前导0)　23D (含有非十进制数码)

在程序中是根据前缀来区分各种进制数的。因此在书写常数时不要把前缀弄错造成结果不正确。4.整型常数的后缀在16位字长的机器上，基本整型的长度也为16位，因此表示的数的范围也是有限定的。十进制无符号整常数的范围为0～65535，有符号数为-32768～+32767。八进制无符号数的表示范围为0～0177777。十六进制无符号数的表示范围为0X0～0XFFFF或0x0～0xFFFF。如果使用的数超过了上述范围，就必须用长整型数来表示。长整型数是用后缀“L”或“l”来表示的。例如：8 B$ a$ m4 _! x; x& Y* v' B
十进制长整常数 158L (十进制为158) 358000L (十进制为-358000)) b6 v: v6 x) \6 z" q' G) |8 N5 r
八进制长整常数 012L (十进制为10) 077L (十进制为63)　0200000L (十进制为65536)# E2 C% i9 \$ X- \
十六进制长整常数 0X15L (十进制为21) 0XA5L (十进制为165)　0X10000L (十进制为65536)
9 j  g$ Z' [% p. T　　
- J5 R  @* h! Y3 v　　长整数158L和基本整常数158 在数值上并无区别。但对158L，因为是长整型量，Ｃ编译系统将为它分配4个字节存储空间。而对158，因为是基本整型，只分配2 个字节的存储空间。因此在运算和输出格式上要予以注意，避免出错。无符号数也可用后缀表示，整型常数的无符号数的后缀为“U”或“u”。例如： 358u,0x38Au,235Lu 均为无符号数。前缀，后缀可同时使用以表示各种类型的数。如0XA5Lu表示十六进制无符号长整数A5，其十进制为165。2 P9 F( `8 ^0 ~8 d9 C7 G

1 {% `8 X, w4 y9 S4 v1 J整型变量
- C; r5 m1 ~) \1 k& Q4 M5 S$ r/ H
- @0 Q: y- @8 }; V/ d整型变量可分为以下几类：! F% y0 \7 C- M: s
1.基本型
  d3 {6 J: l5 l" e3 @, c* W类型说明符为int，在内存中占2个字节，其取值为基本整常数。2 t/ P6 X; {2 u5 W  t0 l
2.短整量
) v" A7 Z, G3 @/ {/ E6 V+ O" Z/ x$ U类型说明符为short int或short'C110F1。所占字节和取值范围均与基本型相同。! u4 A5 L6 |  T- }6 R5 U& H
3.长整型  {# M% c% v+ F# r/ n: O3 ?- X
类型说明符为long int或long ，在内存中占4个字节，其取值为长整常数。: c9 V% h# Q) B) z
4.无符号型# h( E% r" `* c) h7 z( J
类型说明符为unsigned。, |! u: n0 R- x0 n" X. L# S) {
无符号型又可与上述三种类型匹配而构成：% h$ ?4 G# k% l0 {, e8 W1 d
(1)无符号基本型 类型说明符为unsigned int或unsigned。, [: o. Q, j0 u, Y
(2)无符号短整型 类型说明符为unsigned short
2 b$ s' i" ^7 }! I9 T+ g0 x(3)无符号长整型 类型说明符为unsigned long
5 L: ]& B9 I, i; R0 g+ [/ \1 _4 H各种无符号类型量所占的内存空间字节数与相应的有符号类型量相同。但由于省去了符号位，故不能表示负数。 下表列出了Turbo C中各类整型量所分配的内存字节数及数的表示范围。* h1 v0 y7 j- T# U1 o3 S* j! X  N
类型说明符　　　　数的范围 　　　　分配字节数0 F' o* C! G7 x6 O9 l5 ^
int 　　　　　　-32768~32767 　　　　■■
  l1 A, ]& K2 V4 dshort int 　　　-32768~32767 　　　　■■  H  n3 C3 p% z& v9 a4 h- _/ q4 ~
signed int 　　 -32768~32767 　　　　■■% U2 M5 B) X+ D& e, \* p9 a
unsigned int 　 0~65535 　　　　　　 ■■
2 X, n* C2 r9 a5 d; g5 z4 ^long int 　-2147483648~2147483647　　■■■■
2 t0 h% D' Z8 U8 y- h4 v, l* iunsigned long 　0~4294967295 　　　　■■■■% G' f( {  S# D# e
整型变量的说明
4 T. P, Q  A6 b变量说明的一般形式为： 类型说明符 变量名标识符，变量名标识符，...; 例如：
1 \  d6 z! U' }' @% C; H; Oint a,b,c; (a,b,c为整型变量)
) H* X7 e$ l5 z- a+ Nlong x,y; (x,y为长整型变量)
, _* a$ Y; n& y, u0 Junsigned p,q; (p,q为无符号整型变量)+ J* K7 Y3 |$ m

2 p) L" k# z, A/ E' h在书写变量说明时，应注意以下几点：
& r# N0 m5 ?) `/ w/ m1.允许在一个类型说明符后，说明多个相同类型的变量。各变量名之间用逗号间隔。类型说明符与变量名之间至少用一个空格间隔。
6 M" e& A- w; ~' X. }% {2.最后一个变量名之后必须以“；”号结尾。" ~5 A( j$ f6 L4 P
3.变量说明必须放在变量使用之前。一般放在函数体的开头部分。
3 q6 Q3 M7 |- V2 c# t4 [[Practice] //1int a,b;
3 Z4 V6 Z& d, M4 ^1 O2 Oshort int c;8 {! b+ Q6 h4 j6 c" H
short d=100;6 d- R5 s4 _; L$ W( c) u5 K+ v
a=d-20;
2 t5 j8 |: Y1 Z& s. Q4 n. mb=a+d;
* f9 ?  J" Q0 v5 gc=a+b+d;
+ C, F% L2 ^6 J0 G3 ]$ u1 |2 E+ Hd=d-a+c-b;'Vtable
6 H0 _* A( t* q$ }* Va,2,0$ D7 T+ ]: d, [4 G- U+ p7 ~
b,2,06 n5 b: g/ J% V
c,2,0
6 J. I1 a/ h, W/ D! L4 Qd,2,100: ]; v: W7 G  p7 E
of Vtable- h: r, W6 r7 O
'Vupdate9 y- ?6 `2 S& Q
1,0;2,0* j* x3 E& f3 S& `
3,0
, H4 C& \( Q) D# r: I& f) @: m5 o4,100
4 a* |' Q$ I" }1 `1,80
" u2 k) p1 g+ y. W  h2,1802 X5 ?, W6 ]! }# Q
3,360
2 d0 t* f) k& x9 O4,2005 N6 Z. i' ^5 f
of Vupdate
- z/ F; m4 }. @of Practice
- Y+ n  Y2 M/ b2 g& p# G: K2 R[Practice] //2int a=5;0 e# P5 @# L4 {
int b=9;" R/ k5 S5 e+ E! H
long int c;
' ^. S9 [# ^; F$ k0 n+ G+ `) d6 \- Dlong d;7 l7 P- b9 y2 D" p5 z% c: K
c=a+b-7;$ G$ E% R- v2 s
d=a*b*c;
+ R- N$ s% w: y1 e! ec=d*d*d;
# Y, H  q. m1 D& h$ [- _a=c-d;'Vtable
  K, K. D& |9 _, q4 ma,2,51 {, a3 q! P" a# x9 A
b,2,9
6 Y/ c; t2 j" g/ z+ {c,4,0% V! {4 [0 M& M  {0 ?4 s
d,4,0
1 R# K. y7 l9 @* Q' \2 }$ |3 Kof Vtable
1 y' Q3 u, Q# C: C/ A% `; L'Vupdate, e1 D) y; A$ _; ^
1,51 C& H# x7 [# G& Z1 f9 p
2,9
8 F3 ?" [. f% Z: w3,0
" R; X) T; M: g+ G4 C5 Y4,0& r: x, S' b$ v0 w2 n1 y
3,7
. f% f2 A: Y; Q# ~4,315
, v8 x6 Z; V3 S/ z* v8 ]3,31255875
  P9 s) E3 [2 ]- w4 ^1,-51129 F9 C3 H! w" ?! U' \) w
of Vupdate
1 r& }7 W; c0 iof Practice* V3 [# R8 B) z" b
[Practice] //3int a=6,b=19;1 ^0 X9 a! K/ b7 y! W2 X1 }
unsigned int c;9 j/ p7 h7 }, J: j
int d;
; x0 k; J6 r6 B- O# Bc=a-b+7;% ?+ e6 N6 x" }! Y
d=b*c;
4 v+ L  d) A: F# U- p0 Y% A0 |a=b+c+d;; H* a# F& S+ W! C: j0 s3 M, q
b=-a;'Vtable
* Q; K9 J1 h2 T8 \4 }a,2,6
1 T; M1 F6 {3 c: ?# Yb,2,19% C# I$ `% y+ r, E+ ^0 {( b: p
c,2,0: e5 l2 T  c8 O8 B, ]
d,2,0
% D9 q2 D" O  Z- Fof Vtable
% ]  f8 R2 d' }' H! G* |, J4 H'Vupdate
0 y3 B, M( l; F4 q: k. a$ ]  P/ h4 ^1,6;2,193 ?5 D" ^( J# \5 S4 T
3,0! H# ?: x4 a6 L
4,0
1 q0 u. Q& U# y  C( S4 k5 [3,655306 x/ z* z6 ?6 ~  W
4,-114
. H0 u1 U; D; a' e+ x' {$ p1,-101% Q$ h/ z  [' x- [+ ^
2,1010 x3 @4 J/ ^4 ^2 _; R* Y! B. N6 C
of Vupdate
% w$ j! H: e* h( \! wof Practice
) m3 H4 ]+ m0 e3 P$ @void main(){
; l5 B* D: o2 @: klong x,y;  F4 w7 j! s( Q/ k
int a,b,c,d;5 W% Z( T2 N7 e0 C6 e
x=5;, I7 M. O- s  M: D9 n0 q2 |
y=6;
2 L7 D: W1 E) pa=7;9 r3 X; j" W" }1 X9 J, D
b=8;' }6 s' h9 [! o7 c8 c3 y9 k
c=x+a;
' s. I" M6 E* G" T# n2 _8 ud=y+b;
" Q' L4 X  `3 F) Xprintf("c=x+a=%d,d=y+b=%d\n",c,d);" O" {+ ~7 W1 f3 T8 J
}* a6 e& F+ d9 |: L7 ~
将main说明为返回void,即不返回任何类型的值( @; K/ O0 O  {" Z7 v/ z2 h
x,y被定义为long型
5 j+ T: L' t5 wa,b,c,d被定义为int型# s0 ?7 b, @- J$ }0 P
5->x
# H# }& o/ e# e: \* x' a/ ~4 \7 a+ F6->y
$ N' O4 `) G3 j4 a7 A# o7->a
( y: [. W# }! ~, j& \7 V: \8->b$ _7 b- ~! [% B& t$ j
x+a->c
) Q) W5 {4 S/ R! @% N# \6 my+b->d
0 W# R0 b6 @$ \# g9 s显示程序运行结果 of long x,y;/ h' H) T8 W$ i! O
int a,b,c,d;- }" n8 G  I7 x* R: q$ P
c=x+a;
% c" I' u+ {! H% U% H# c: Jd=y+b;
" h9 [4 V. Z. L% e　　从程序中可以看到：x, y是长整型变量，a, b是基本整型变量。它们之间允许进行运算，运算结果为长整型。但c，d被定义为基本整型，因此最后结果为基本整型。本例说明，不同类型的量可以参与运算并相互赋值。其中的类型转换是由编译系统自动完成的。有关类型转换的规则将在以后介绍。

实型量
- X) P- _7 [  C5 w! t2 ]
# h, B6 O1 g8 I' u6 U8 N/ K% o' _$ V实型常量
' ^1 x3 L  ]0 c* s8 T" r: O0 V8 z/ @  _5 ]
实型也称为浮点型。实型常量也称为实数或者浮点数。在Ｃ语言中，实数只采用十进制。它有二种形式： 十进制数形式指数形式  \; n2 b) x! g1 g" ]1 B* S8 U
1.十进制数形式0 r: N( B! J" [+ B! n
由数码0~ 9和小数点组成。例如：0.0，.25，5.789，0.13，5.0，300.，-267.8230等均为合法的实数。
2 G3 f- R9 t) G- O0 Y& q7 [2.指数形式
9 M  p$ a9 t7 k9 r; ^由十进制数，加阶码标志“e”或“E”以及阶码（只能为整数，可以带符号）组成。其一般形式为a E n （a为十进制数，n为十进制整数）其值为 a*10,n　如： 2.1E5 (等于2.1*10,5), 3.7E-2 (等于3.7*10,)-2*)　0.5E7 (等于0.5*10,7), -2.8E-2 (等于-2.8*10,)-2*)以下不是合法的实数 345 (无小数点)　E7 (阶码标志E之前无数字)　 -5 (无阶码标志)　53.-E3 (负号位置不对)　2.7E (无阶码)
% U1 T& `/ C8 n. |9 K2 T$ O标准Ｃ允许浮点数使用后缀。后缀为“f”或“F”即表示该数为浮点数。如356f和356.是等价的。例2.2说明了这种情况：
7 z1 B5 V- Q+ @1 C( C5 Kvoid main()
; H' D: e+ E$ p{
$ y" A8 B9 a3 c0 W$ N printf("%f\n%f\n",356.,356f);# d$ T' x" d" b1 n, W
}9 G) ~+ N, C- {4 G$ B4 ~8 G! W) s9 S# m
void 指明main不返回任何值　利用printf显示结果　结束
& `) K0 }7 j9 q5 G# T+ v2 H2 p' z2 ^/ F* w! ^0 H* ~
实型变量, h5 L& v) K* _! y3 r+ @% d8 X

$ S* k, E/ @0 V实型变量分为两类：单精度型和双精度型，: N& {- a5 B4 ^. J* O4 y. M' J
其类型说明符为float 单精度说明符，double 双精度说明符。在Turbo C中单精度型占4个字节（32位）内存空间，其数值范围为3.4E-38～3.4E+38，只能提供七位有效数字。双精度型占8 个字节（64位）内存空间，其数值范围为1.7E-308～1.7E+308，可提供16位有效数字。
1 F- X3 i' o3 K& v. X& ]实型变量说明的格式和书写规则与整型相同。
# G% l% l' }& G3 }例如： float x,y; (x,y为单精度实型量)
8 h" S5 R1 q. g; n- H6 {/ v: E　　　 double a,b,c; (a,b,c为双精度实型量)
3 u5 \& a8 |: H5 {实型常数不分单、双精度，都按双精度double型处理。; t# M% ?8 X7 W8 i! Z! `0 n
void main()7 g4 Q7 d2 A2 d
{
% e" f/ S) ^5 x/ Y  float a;
; U$ X# d, [6 T' A1 A& X8 G  double b;2 a  n5 Y9 z3 ~# X+ X: L# c7 B
  a=33333.33333;: e3 R" ]: h& U
  b=33333.33333333333333;
  y& I" @9 A5 n% Y  printf("%f\n%f\n",a,b);& ^& G, `* m9 O
}! m+ Y4 f0 n: S2 m6 M" w
此程序说明float、double的不同
- T  _: Q' U; Q0 I! [2 Pa ■■■■
" [8 `; X" |' ^) i8 Hb ■■■■■■■■  i8 ]; _0 m7 i' s7 o2 |7 D/ s
a<---33333.33333
* N: A- e+ g% ~) X4 X/ Hb<---33333.33333333333;;
- O4 i- P" L4 P( t$ O; m1 N% K2 I显示程序结果. _0 ~3 o* N7 f4 }
此程序说明float、double的不同
. `1 `( K5 Q7 o7 b; A, rfloat a;- Q( p  Q5 ~% \$ X5 s' x5 ?- g
double b;
1 C( B) |$ _5 v2 n( _! v4 W# Pa=33333.33333;
- J, s/ \% V( Z1 G8 X; r* ab=33333.33333333333333; 从本例可以看出，由于a 是单精度浮点型，有效位数只有七位。而整数已占五位，故小数二位后之后均为无效数字。b 是双精度型，有效位为十六位。但Turbo C 规定小数后最多保留六位，其余部分四舍五入。
0 ]! r- p! A+ O3 v/ L* h[Practice] //floatint a=32;
' a% M! o1 o9 ?5 K5 C3 Jfloat b;
& a, H+ Y( E. }' adouble d;
6 [) p% C' f. m* I( tb=12345678;# _, i7 {, X7 b2 z7 t0 v& }  v9 J$ T- d
d=b*100;9 N2 P6 t9 F  G5 S& g- o
d=d+a;
. ?9 K% h! F2 ^5 U6 Sd=d+58.123456;'Vtable1 p# E8 e! ~( ?6 T6 Z* c7 Y
a,2,32
. e" s* ~+ v6 }6 c5 ab,4,0.0
# o7 [6 V9 @8 n# b, Jd,8,0.0+ b" e$ u+ G2 ]+ _* R# G
of Vtable/ `$ t* K( d$ t) t# Y4 r1 m
'Vupdate
4 Q* v% U- W8 ?. ]- J1,32+ K1 k/ R1 O7 _! g/ J1 V( h3 v
2,0; I* y! C2 p5 x9 x- b- n& @
3,0
' F2 ]/ q* N4 W$ ~3 G/ `2,12345678.00000& U% j( t# S1 X5 B; y0 l
3,1234567800
' \; u" O: a, A. J7 {' X. u9 h* N3 X3,1234567832
7 j7 \3 N% z( ?* D6 U2 R: L3,1234567890.123456+ r# `$ O+ U; v8 q
of Vupdate
7 w( O5 o; G; a% O. r  d3 rof Practice. N6 F" T5 r$ ^# N- C! L3 e
[Practice] //1int a=543;' J" u6 Y. Y4 _! L
float b;2 s$ D( R6 H  w1 q5 q8 a
b=123.123962+a;
) D* l  M% |! J. [: p, E5 C) Bb=b-100;% D0 e- D6 J, B) z
a=b;'Vtable
) m8 W; G. G. |2 J# Da,2,543
$ Z) h7 P) g% l$ Tb,4,0.00 B; V! I/ s  w( m: ?
of Vtable$ n1 K7 M0 G. z( V1 r4 i
'Vupdate
* u7 R9 S5 A' `% t# U( z1,543  F4 {" v5 @' w7 e+ r
2,0.0
0 d. x; h, S  X& ]2,123.123962
! ]# w& J" Z) l3 [0 u3 }* B- i0 L5 d2,23.123962: Y7 i6 f, I3 N* r; F" |1 a! g& c& q
1,23
; |4 G1 f( @) G- x: v2 Xof Vupdate
8 C  t! r) _9 J8 g) c2 xof Practice

字符型量
- Y5 c  v: }- Z) ~) L
$ O$ a$ @. `5 j* E. x字符型量包括字符常量和字符变量。
; B* f2 E- A( ?% B* i: z$ a" [2 ^9 i3 _; V" o$ J* e
字符常量
  C6 P) d7 V  ]! ]1 c; r# Q字符常量是用单引号括起来的一个字符。例如'a','b','=','+','?'都是合法字符常量。在Ｃ语言中，字符常量有以下特点：
, H% U9 _* d1 q7 T8 h8 r1 Y1.字符常量只能用单引号括起来，不能用双引号或其它括号。, W8 H0 p9 O) P- L- n
2.字符常量只能是单个字符，不能是字符串。
/ a4 o/ i  ]! v7 H% g3.字符可以是字符集中任意字符。但数字被定义为字符型之后就) `  y/ Y  h2 ]# c$ G5 H
不能参与数值运算。如'5'和5 是不同的。'5'是字符常量，不能参与运算。& c! W6 f' q. D& Q0 z3 t

4 u8 m8 ?8 B8 B+ g4 {9 }& h转义字符" @0 x  `% {4 q4 f+ L
转义字符是一种特殊的字符常量。转义字符以反斜线"\"开头，后跟一个或几个字符。转义字符具有特定的含义，不同于字符原有的意义，故称“转义”字符。例如，在前面各例题printf函数的格式串中用到的“\n”就是一个转义字符，其意义是“回车换行”。转义字符主要用来表示那些用一般字符不便于表示的控制代码。' S% M; n- ~1 i3 h
常用的转义字符及其含义) b5 v7 Z" c5 D" }% N) m1 Q
转义字符 　转义字符的意义: [( y" \& q" |: x5 m' t( ^& q
\n 　　　　　回车换行
' u  @1 J' F! u9 g\t 　　　　　横向跳到下一制表位置
' i0 h) [3 j# K" S\v 　　　　　竖向跳格- t" q, B0 ]5 m9 P5 z8 J, d
\b 　　　　　退格
5 l  k( I, Q: ]1 D0 {$ a" t- @\r 　　　　　回车9 m( I4 g) |6 n" P, p4 b
\f　　　　 　走纸换页
/ P# U( ^1 _5 f\\ 　　　　　反斜线符"\"
# D" ~- P9 ?/ L3 X\' 　　　　　单引号符
* y9 O  ?# M# P, F: C0 F3 f\a 　　　　　鸣铃
& M; ~! t# r! s' P7 X. b& g1 @5 s\ddd 　　　　1～3位八进制数所代表的字符
$ R6 _# D0 S) J9 K8 E, C* a8 M, D\xhh 　　　　1～2位十六进制数所代表的字符
2 N1 M& o- o( r广义地讲，Ｃ语言字符集中的任何一个字符均可用转义字符来表示。表2.2中的\ddd和\xhh正是为此而提出的。ddd和hh分别为八进制和十六进制的ASCII代码。如\101表示字?quot;A" ，\102表示字母"B"，\134表示反斜线，\XOA表示换行等。转义字符的使用) r& Y2 h" [5 k7 z8 l' g9 p; M3 @
void main()
  R3 u( T" o" ?) d9 F9 k1 R- k1 G{& O  Y& r5 x, V* ]
int a,b,c;/ A# q& A0 N4 M% V
a=5; b=6; c=7;  q0 v; e' _2 U0 p0 z
printf("%d\n\t%d %d\n %d %d\t\b%d\n",a,b,c,a,b,c);: h; J5 ~1 Z8 c) Z
}
8 H* S% w# r. K- K9 e. e' |此程序练习转义字符的使用, M' p" x9 W9 O3 A, \
a、b、c为整数　5->a,6->b,7->c
' f( \# H" h8 b8 S: g0 {3 Y) M4 l0 W调用printf显示程序运行结果
) |" @% ?) @2 j( i0 jprintf("%d\n\t%d %d\n %d %d\t\b%d\n",a,b,c,a,b,c);' z7 o+ `) e2 a
程序在第一列输出a值5之后就是“\n”，故回车换行；接着又是“\t”，于是跳到下一制表位置（设制表位置间隔为8），再输出b值6；空二格再输出c 值7后又是"\n"，因此再回车换行；再空二格之后又输出a值5；再空三格又输出b的值6；再次后"\t"跳到下一制表位置（与上一行的6 对齐），但下一转义字符“\b”又使退回一格，故紧挨着6再输出c值7。* a1 p( G8 B) d
7 W- G2 L* g8 ^+ u' r
字符变量
% p2 P* x7 }$ R  E字符变量的取值是字符常量，即单个字符。字符变量的类型说明符是char。字符变量类型说明的格式和书写规则都与整型变量相同。
* V- Y8 i% ^4 f8 l6 H' X例如：
- }# G6 T3 B3 F: O3 Mchar a,b; 每个字符变量被分配一个字节的内存空间，因此只能存放一个字符。字符值是以ASCII码的形式存放在变量的内存单元之中的。如x的
8 t+ q% L1 w8 t! L" Q6 P; P2 o; L十进制ASCII码是120，y的十进制ASCII码是121。对字符变量a,b赋予'x'和'y'值： a='x';b='y';实际上是在a,b两个单元内存放120和121的二进制代码： a　0 1 1 1 1 0 0 0
; S6 B4 m6 W2 Y/ g) W5 z　　　　 b　0 1 1 1 1 0 0 14 K+ L8 E) `9 k
所以也可以把它们看成是整型量。 Ｃ语言允许对整型变量赋以字符值，也允许对字符变量赋以整型值。在输出时， 允许把字符变量按整型量输出，也允许把整型量按字符量输出。 整型量为二字节量，字符量为单字节量，当整型量按字符型量处理时， 只有低八位字节参与处理。& R1 }( g: ]( D( ~( ]( {5 k( M
main()
! ^4 t( v! I2 H  f- q/ i" I7 l{1 _1 ~( X; A1 ^' k4 x% B
  char a,b;
! ~. d" Y' B5 n& v' |  a=120;- ?  e3 W. a4 L3 ~. ^+ k7 r* b9 {6 j
  b=121;2 b, V/ D# O2 P6 J' G1 j9 J$ k. _! s
  printf("%c,%c\n%d,%d\n",a,b,a,b);
8 ^, I9 r6 ]' Y" K} 7 s6 Q) E* B3 J7 M
a ■ b ■  Y9 z( p! l9 v( s: e/ j
a <-- 120
4 i+ `) S* B3 J; @$ \+ ~$ \& {. Db <--- 121
, d4 E% g3 O+ E; {* A2 R  C% j" I显示程序结果+ R! i  V+ u0 i: u. M( J/ W

+ p( o+ S, h- N本程序中说明a，b为字符型，但在赋值语句中赋以整型值。从结果看，a，b值的输出形式取决于printf函数格式串中的格式符，当格式符为"c"时，对应输出的变量值为字符，当格式符为"d"时，对应输出的变量值为整数。, r, {% I2 B  I4 c) l
void main(). X3 @* ]0 W3 e" {( l
{
/ h) ~: ~! {* j& b  char a,b;
- s  i) B8 d1 P$ \) K  a='x';
3 g% `6 C; L5 `4 L  b='y';
+ S2 C, f/ i7 D1 d/ O4 [  a=a-32;
5 t! b) V  r, f: x0 {# ]" U( K0 L. F3 q  b=b-32;
1 x/ z4 m* ^( O: D0 X0 `1 _  printf("%c,%c\n%d,%d\n",a,b,a,b);8 `7 N# P' G+ J+ t9 Z; g' g
}
* u( Y- a% \/ }6 Ba，b被说明为字符变量并赋予字符值& D- t9 ^% {  }7 I' v7 r
把小写字母换成大写字母: l  Q# T/ I' a0 k1 h
以整型和字符型输出
5 [- b/ [; V' V& U本例中，a，b被说明为字符变量并赋予字符值，Ｃ语言允许字符变量参与数值运算，即用字符的ASCII 码参与运算。由于大小写字母的ASCII 码相差32，因此运算后把小写字母换成大写字母。然后分别以整型和字符型输出。
* h9 u% A  e1 V1 g" O[Practice] //charint a=49;: O/ k5 s( W$ Q0 k
char b;
- g) t% P! d9 A) T. schar d;' ]& t: A. ~$ l. M6 J! L  z
b=a+10;
. y  H* H( u  T# |d=a+b;'Vtable
$ E3 Q7 N; O$ c) ^  [8 ea,2,49
/ x% w9 O, r* n* f# Kb,1,随机- @2 ^% ~: r; o- {# O8 Y& L" T/ o
d,1,随机
/ g  s- c% K+ uof Vtable
( N, h$ @. ^" O8 w'Vupdate+ a1 |- q$ O% Y
1,49
+ [6 {. E+ i" Y1 y8 r2,随机; s8 R8 }( W5 Y! J
3,随机2 |% w) X6 P( d# V
2,';'
$ C" v0 \6 }6 W8 o+ r4 [2 h$ M3,'l'; M/ v) I% T4 n/ K
of Vupdate5 c# l! Z6 X7 Z" C6 q8 ]! Q* x
of Practice
" U/ C. W: i. m- p6 \[Practice] //char c1,c2;/ J% w% a3 N3 b
c1='a';c2='b';
7 g' b. Z' v+ B7 F# ^6 z! mc1=c1-32;c2=c2-32;'Vtable
1 `& z9 H0 B& Oc1,1,随机1 P/ S! @$ }/ E9 O. B+ k% ]
c2,1,随机& p" `% E* A  }6 ]$ z; p
of Vtable# j8 C* D# A' K% Y
'Vupdate
$ ~" C$ X9 f% x6 v$ i9 S  |- p1,随机;2,随机% O: I" t) u, y( X- p
1,'a';2,'b'& `8 ]2 ^; L% n( r
1,'A';2,'B'0 T$ v) k( u2 Z$ R
of Vupdate
& G. y9 N" N2 Y% U5 L5 b$ Lof Practice

字符串常量3 D/ O- B% l$ B2 {, s8 V6 b2 a
字符串常量是由一对双引号括起的字符序列。例如： "CHINA" ，"C program:" ， "$12.5" 等都是合法的字符串常量。字符串常量和字符常量是不同的量。它们之间主要有以下区别：
& ^0 _7 r' k! d1.字符常量由单引号括起来，字符串常量由双引号括起来。- P+ s* K, {- C6 A, D# X# ?
2.字符常量只能是单个字符，字符串常量则可以含一个或多个字符。
! k& I1 R( @- F: v* R! V3.可以把一个字符常量赋予一个字符变量，但不能把一个字符串常量赋予一个字符变量。在Ｃ语言中没有相应的字符串变量。) o- Z& w3 V( a" b
这是与BASIC 语言不同的。但是可以用一个字符数组来存放一个字符串常量。在数组一章内予以介绍。
/ u# k% t7 V! m- Y. a8 _$ c* v4.字符常量占一个字节的内存空间。字符串常量占的内存字节数等于字符串中字节数加1。增加的一个字节中存放字符"\0"(ASCII码为0)。这是字符串结束的标志。例如，字符串 "C program"在内存中所占的字节为：C program\0。字符常量'a'和字符串常量"a"虽然都只有一个字符，但在内存中的情况是不同的。 ) M1 A: R0 P; p
'a'在内存中占一个字节，可表示为：a
. D* m7 k: t% s: a7 M8 w"a"在内存中占二个字节，可表示为：a\0符号常量
) c* r/ X# S* c7 Y& \3 q+ X3 r" n. i' D( g( F! D
符号常量 / E- a: h: B4 e
在Ｃ语言中，可以用一个标识符来表示一个常量，称之为符号常量。符号常量在使用之前必须先定义，其一般形式为： " c  k  b1 N) w6 T* h- c$ t+ _
#define 标识符 常量 4 C; Q% G' W3 R& t
其中#define也是一条预处理命令（预处理命令都?quot;#"开头），称为宏定义命令（在第九章预处理程序中将进一步介绍），其功能是把该标识符定义为其后的常量值。一经定义，以后在程序中所有出现该标识符的地方均代之以该常量值。习惯上符号常量的标识符用大写字母，变量标识符用小写字母，以示区别。
! F7 A% V( E: L( |#define PI 3.14159
: u, Y8 Q4 P5 i: W+ Z! Yvoid main()
* p5 X+ I+ \6 P* t- D{
% A! _* y, \9 \  c& M3 N! l  float s,r;
; r  r4 }8 t% I$ c7 K  r=5;
1 N3 P) Q" I* X/ z9 o/ ?, Z  s=PI*r*r;$ M- [8 T4 {5 t, Z+ N
  printf("s=%f\n",s);
8 {7 }3 L9 @) ^0 C}# k' d7 F5 Z+ j! {+ B' x0 i
由宏定义命令定义PI 为3.14159 s,r定义为实数　5->r　PI*r*r->s
$ c+ J9 Q- H* r2 @, M显示程序结果 float s,r;　r=5;　s=PI*r*r; 本程序在主函数之前由宏定义命令定义PI 为3.14159，在程序中即以该值代替PI 。s=PI*r*r等效于s=3.14159*r*r。应该注意的是，符号常量不是变量，它所代表的值在整个作用域内不能再改变。也就是说，在程序中，不能再用赋值语句对它重新赋值。: H( r" u2 z' T0 n  \4 O
! G/ T' {8 L+ R7 s' \4 d
变量的初值和类型转换4 N  b) I0 ]+ q$ |3 c9 s; z

  i( _; N( Q# x& J+ |变量赋初值
6 ~4 u; P( R$ V0 d在程序中常常需要对变量赋初值，以便使用变量。语言程序中可有多种方法，在定义时赋以初值的方法，这种方法称为初始化。在变量说明中赋初值的一般形式为： / I3 o2 x" S" _  `$ k
类型说明符 变量1= 值1，变量2= 值2，……； 例如：
2 @& [' j2 s9 [: ^8 dint a=b=c=5;/ j2 H" ^/ s; |7 D8 n) j* m4 n
float x=3.2,y=3f,z=0.75;
2 t1 t7 C, ]8 Pchar ch1='K',ch2='P';* m+ Q$ ^7 k7 l: W3 j" I
应注意，在说明中不允许连续赋值，如a=b=c=5是不合法的。
# k$ O& {( D; zvoid main()+ F9 ]; @; K% C' T1 E. `1 w6 p" q
{/ |3 S1 S/ X- p' G( z7 R
  int a=3,b,c=5;  g8 \2 Y" R* W2 Q' S3 a
  b=a+c;7 Z, O$ ^  U; Y
  printf("a=%d,b=%d,c=%d\n",a,b,c);
! S1 z- a* @5 A}% }( \5 W* R, _3 W% ]' [4 O
a<---3,b<--0,c<---5  n: R2 q1 I1 t5 R
b<--a+c+ U/ w- B6 k! d: G, S/ `8 k; @
显示程序运行结果# n7 J: [% l* y. B: y+ z  P

2 |9 x* ^9 m/ R, p: m变量类型的转换
6 }2 o+ r" v$ A9 X2 p) U变量的数据类型是可以转换的。转换的方法有两种， 一种是自动转换，一种是强制转换。 & w. s& k! J$ c

+ y6 \& w  U6 N) B自动转换
+ T. d4 G% ^1 Q! h2 z7 ]自动转换发生在不同数据类型的量混合运算时，由编译系统自动完成。自动转换遵循以下规则： ( x$ A7 S6 w5 f4 M" a1 p3 O1 m
1.若参与运算量的类型不同，则先转换成同一类型，然后进行运算。. Z( v9 }: E' a5 J2 p3 V
2.转换按数据长度增加的方向进行，以保证精度不降低。如int型和long型运算时，先把int量转成long型后再进行运算。6 {& M7 [; p1 a$ A" C
3.所有的浮点运算都是以双精度进行的，即使仅含float单精度量运算的表达式，也要先转换成double型，再作运算。0 `5 R9 }. B" |: c6 `
4.char型和short型参与运算时，必须先转换成int型。) i7 s: w7 V2 H4 @6 n# E! q/ p
5.在赋值运算中，赋值号两边量的数据类型不同时， 赋值号右边量的类型将转换为左边量的类型。 如果右边量的数据类型长度左边长时，将丢失一部分数据，这样会降低精度， 丢失的部分按四舍五入向前舍入。图21表示了类型自动转换的规则。/ k: p2 n8 t: ]% h1 J8 w
void main()
8 w) \, L8 M8 K0 v{! b, V: z, ^4 H! \  _7 C" Y
  float PI=3.14159;
0 C% s) ^! A4 m5 _: j% M! e  int s,r=5;: W$ B  g+ N! H, Q
  s=r*r*PI;' F  \! h5 b9 ^# c+ z* U! r
  printf("s=%d\n",s);( ^* B" }/ n9 O6 z
}
! z/ I' f: L9 M. l; ZPI<--3.14159; L. |- E7 E+ S- \2 K1 f3 ^5 h* V
s<--0,r<--5/ d; X* P" H+ p2 x5 W
s<--r*r*PI! \4 t0 ^2 t% b! H
显示程序运行结果2 l3 E) J2 {/ e3 x7 }5 t
float PI=3.14159;
6 g% o) L) g9 r" k/ xint s,r=5;9 t* e" z9 l* D0 `8 j
s=r*r*PI; 5 G& l* L/ X& T% ~1 M9 X3 P2 i
本例程序中，PI为实型；s，r为整型。在执行s=r*r*PI语句时，r和PI都转换成double型计算，结果也为double型。但由于s为整型，故赋值结果仍为整型，舍去了小数部分。

强制类型转换% Y6 i8 v! u" [/ o
强制类型转换是通过类型转换运算来实现的。其一般形式为： (类型说明符) (表达式) 其功能是把表达式的运算结果强制转换成类型说明符所表示的类型。例如： (float) a 把a转换为实型(int)(x+y) 把x+y的结果转换为整型在使用强制转换时应注意以下问题：* W* O2 h1 E* m7 ~. X
1.类型说明符和表达式都必须加括号(单个变量可以不加括号)，如把(int)(x+y)写成(int)x+y则成了把x转换成int型之后再与y相加了。/ y# e& R+ y; X1 f
2.无论是强制转换或是自动转换，都只是为了本次运算的需要而对变量的数据长度进行的临时性转换，而不改变数据说明时对该变量定义的类型。: n" Q( s! _9 D0 y- ]
main()
; A6 X; E8 `# p% ]& G# Q- O! I{# X0 V5 T$ _) }# s7 h
  float f=5.75;$ e2 D/ Z7 \9 ?6 Q6 h7 s+ n, j
  printf("(int)f=%d,f=%f\n",(int)f,f);
% W" S- o" _- J2 Q7 |} 1 ]* V. p, O1 w: A* v/ o% S
f<--5.75
" h) _8 w: z) m6 J9 D( l4 H将float f强制转换成int f float f=5.75;printf("(int)f=%d,f=%f\n",(int)f,f); 本例表明，f虽强制转为int型，但只在运算中起作用， 是临时的，而f本身的类型并不改变。因此，(int)f的值为 5(删去了小数)而f的值仍为5.75。. p1 B) ^% S5 z5 e7 k

! O8 I3 d" X" Y4 C基本运算符和表达式8 m" T) i% E0 Y$ h! A- R2 S
0 k' r$ t: R: N% ^/ r0 M% o* z
运算符的种类、优先级和结合性: l6 ~- z' L3 S% x4 _2 G
Ｃ语言中运算符和表达式数量之多， 在高级语言中是少见的。正是丰富的运算符和表达式使Ｃ语言功能十分完善。 这也是Ｃ语言的主要特点之一。, \1 r0 g$ x) z1 l, e5 a2 k) S
Ｃ语言的运算符不仅具有不同的优先级， 而且还有一个特点，就是它的结合性。在表达式中， 各运算量参与运算的先后顺序不仅要遵守运算符优先级别的规定，还要受运算符结合性的制约， 以便确定是自左向右进行运算还是自右向左进行运算。 这种结合性是其它高级语言的运算符所没有的，因此也增加了Ｃ语言的复杂性。
- n; }: X9 h3 J- B/ g1 v7 z- ?4 F; X$ _  ~
运算符的种类Ｃ语言的运算符可分为以下几类：2 q' \  \0 {8 z0 [: c; ^6 h
1.算术运算符1 ?8 s$ ^" L% x! U+ y. w
用于各类数值运算。包括加(+)、减(-)、乘(*)、除(/)、求余(或称模运算，%)、自增(++)、自减(--)共七种。
/ f/ Z+ \+ E" _4 {2.关系运算符
- w1 E( V$ b5 x3 Z* ?# |! n" [用于比较运算。包括大于(>)、小于(<)、等于(==)、 大于等于(>=)、小于等于(<=)和不等于(!=)六种。, c  v, x, B8 h( \; j2 z
3.逻辑运算符
7 ~4 S% [: e' O1 P8 N# K/ ]4 a" R/ N& r用于逻辑运算。包括与(&&)、或(||)、非(!)三种。
' l; D  v4 c. U3 C4.位操作运算符9 Z# g0 j1 J9 O5 ~; S- C
参与运算的量，按二进制位进行运算。包括位与(&)、位或(|)、位非(~)、位异或(^)、左移(<<)、右移(>>)六种。& @! G4 k6 p# G/ {; s+ w+ v
5.赋值运算符, l4 \" {2 u  O; t: o; c
用于赋值运算，分为简单赋值(=)、复合算术赋值(+=,-=,*=,/=,%=)和复合位运算赋值(&=,|=,^=,>>=,<<=)三类共十一种。
: {  F  T  d5 v7 f& F6.条件运算符- k' i) ?. F2 _4 |0 K( X
这是一个三目运算符，用于条件求值(?。6 w3 Z7 ?3 ~5 n1 m$ v
7.逗号运算符
( n# Y) ?9 u5 z1 d( t4 O' s9 K用于把若干表达式组合成一个表达式(，)。/ _  a0 s+ T2 R' m
8.指针运算符' @0 r0 y9 z* T4 a8 s* q
用于取内容(*)和取地址(&)二种运算。
& n3 k' b! Y' \; S9.求字节数运算符0 i, H% M9 j3 P  N8 ~! R
用于计算数据类型所占的字节数(sizeof)。
" p, a( ~) o7 x* U# o* j; G10.特殊运算符
! Y1 p' ?! ^( {! ^有括号()，下标[]，成员(→，.)等几种。8 M; c$ Q: H. K' X: ]
; i! T3 u. q6 Z% Q8 H" @3 U
优先级和结合性
4 m4 e& U  D% c2 s9 TＣ语言中，运算符的运算优先级共分为15级。1级最高，15级最低。在表达式中，优先级较高的先于优先级较低的进行运算。 而在一个运算量两侧的运算符优先级相同时， 则按运算符的结合性所规定的结合方向处理。 Ｃ语言中各运算符的结合性分为两种，即左结合性(自左至右)和右结合性(自右至左)。例如算术运算符的结合性是自左至右，即先左后右。如有表达式x-y+z则y应先与“-”号结合， 执行x-y运算，然后再执行+z的运算。这种自左至右的结合方向就称为“左结合性”。而自右至左的结合方向称为“右结合性”。 最典型的右结合性运算符是赋值运算符。如x=y=z,由于“=”的右结合性，应先执行y=z再执行x=(y=z)运算。 Ｃ语言运算符中有不少为右结合性，应注意区别，以避免理解错误。" z. f) l$ L! z! ~; t% i0 W) L4 R# x
% h+ v# m1 z* t7 g4 Y# x
算术运算符和算术表达式基本的算术运算符' j# U" s3 @$ j, j( m
1.加法运算符“+”加法运算符为双目运算符，即应有两个量参与加法运算。如a+b,4+8等。具有右结合性。
' S' [; F: {, \  P" `- K2.减法运算符“-”减法运算符为双目运算符。但“-”也可作负值运算符，此时为单目运算，如-x,-5等具有左结合性。
' b! H' N8 j1 b1 R3.乘法运算符“*”双目运算，具有左结合性。
, W& D- n1 p% j; u2 H$ |4 o; B4.除法运算符“/”双目运算具有左结合性。参与运算量均为整型时， 结果也为整型，舍去小数。如果运算量中有一个是实型，则结果为双精度实型。
4 ^) Z! q$ h; U. {void main(){9 r& [1 z# p& ?* d- y
printf("\n\n%d,%d\n",20/7,-20/7);- O' g: }. A# q( }! b  ^0 h
printf("%f,%f\n",20.0/7,-20.0/7);
( y. S; h2 R6 h7 [0 M9 H}8 ]7 `% ?( q$ @5 Z" J+ U! r
双目运算具有左结合性。参与运算量均为整型时， 结果也为整型，舍去小数。如果运算量中有一个是实型，则结果为双精度实型。 printf("\n\n%d,%d\n",20/7,-20/7);
, @' Z8 A5 h. u' rprintf("%f,%f\n",20.0/7,-20.0/7);1 o/ O; Z7 \3 E9 j
本例中，20/7，-20/7的结果均为整型，小数全部舍去。而20.0/7和-20.0/7由于有实数参与运算，因此结果也为实型。5 X5 e# @- Z/ |
5.求余运算符(模运算符)“%”双目运算，具有左结合性。要求参与运算的量均为整型。 求余运算的结果等于两数相除后的余数。
# K, z+ t4 |7 p, K) Dvoid main(){4 o% E) t) K& h0 ]  S3 m
printf("%d\n",100%3);. h  Z0 w- C) i1 D) s; R
}/ K3 U. v- a, L" ?; K& p
双目运算，具有左结合性。求余运算符% 要求参与运算的量均为整型。本例输出100除以3所得的余数1。5 M; S/ M' y4 [; ^" j
: B3 W$ R1 K; O' H% o
自增１，自减１运算符
! {7 \1 w$ W  S% r自增1运算符记为“++”，其功能是使变量的值自增1。自减1运算符记为“--”，其功能是使变量值自减1。自增1，自减1运算符均为单目运算，都具有右结合性。可有以下几种形式： ++i i自增1后再参与其它运算。--i i自减1后再参与其它运算。) v( u0 j- J$ U; z) M- ]- H
i++ 　i参与运算后，i的值再自增1。+ `" V% f2 m7 t5 e
i-- 　i参与运算后，i的值再自减1。
% O7 p- p/ |7 f* b在理解和使用上容易出错的是i++和i--。 特别是当它们出在较复杂的表达式或语句中时，常常难于弄清，因此应仔细分析。' X, Y' L/ q$ Z7 F$ u& [
void main(){, e3 @/ l) T, [0 ?2 w+ T7 ^, P( S
int i=8;) G4 h% V0 ~9 ^5 ~0 b
printf("%d\n",++i);
8 t9 [. C( n, V, \, Eprintf("%d\n",--i);4 {: h' f' q+ E' Z( e5 p
printf("%d\n",i++);
8 a, v, b, `0 i( I" m" Aprintf("%d\n",i--);# Q4 |9 @- k" r; E* v6 p
printf("%d\n",-i++);' Z( i* |# {) B- l' g9 A/ Z. }- S
printf("%d\n",-i--);7 N: _2 R- u# L9 v' X# y
} i<--80 c3 v- @+ q2 q5 t
i<--i+1
$ G! e: `) p3 di<--i-1
5 e& _0 S& G  }i<--i+1
! u: [! a3 u+ \i<--i-1
8 _6 @8 O: U: d! p9 R2 U' Li<--i+17 w) A0 H1 \1 k/ c/ `& K+ x
i<--i-1 int i=8;
( O$ ?; }, Q2 y- Kprintf("%d\n",++i);
1 t, A, v" W+ F. F8 r! Gprintf("%d\n",--i);7 p6 u9 t& z. o2 _  v3 x! V$ u3 F$ c
printf("%d\n",i++);" Q: ?, Z3 `- L1 |4 i7 O$ @
printf("%d\n",i--);
! \  w5 h, o* q$ I% h3 O  [/ xprintf("%d\n",-i++);
) v# u3 a; J8 V. x* \3 Uprintf("%d\n",-i--);
* ?0 O9 S3 ~' y+ di的初值为8
' R3 [8 B# `6 o# q7 p; J4 X第2行i加1后输出故为9；* S  d9 H' U' b4 B9 D# y% @1 h& \
第3行减1后输出故为8；
. R% I8 N( P9 ~) c( Z$ [第4行输出i为8之后再加1(为9)；
# W7 X) h/ G+ J4 G, v3 t第5行输出i为9之后再减1(为8) ；
, }+ X$ m- O& q第6行输出-8之后再加1(为9)；9 U4 b8 e5 n; y* O. A4 Z5 O
第7行输出-9之后再减1(为8)
3 E9 Y' j# a$ g: p( _void main(){9 y+ G8 V2 }: a' [9 P' N- j) z
int i=5,j=5,p,q;
: ?! O5 Z: t) ^7 N* Y$ S' P6 @, mp=(i++)+(i++)+(i++);
8 F3 l* Q1 ]: e  }( z7 eq=(++j)+(++j)+(++j);
/ ^1 p( c" k, K  j. iprintf("%d,%d,%d,%d",p,q,i,j);
7 ^" T$ ~: ~  G+ U3 }4 k7 z}
0 P5 q& `& u, O6 Q- d2 d8 }0 xi<--5,j<--5,p<--0,q<--0
$ K+ p3 R6 P* p2 B4 Di+i+i--->p,i+1-->i,i+1-->i,i+1-->i
5 P/ [3 [% `* q: Hj+1->j,j+1->j,j+1->j,j+j+j->q int i=5,j=5,p,q;/ e" s/ @/ f5 P( Q
p=(i++)+(i++)+(i++);
# a& ]& `; r) `- D& g4 r# ]q=(++j)+(++j)+(++j);7 a, u5 P/ J( r. n. N. _* G4 ]
这个程序中，对P=(i++)+(i++)+(i++)应理解为三个i相加，故P值为15。然后i再自增1三次相当于加3故i的最后值为8。而对于q 的值则不然，q=(++j)+(++j)+(++j)应理解为q先自增1，再参与运算，由于q自增1三次后值为8，三个8相加的和为24，j的最后值仍为8。算术表达式表达式是由常量、变量、函数和运算符组合起来的式子。 一个表达式有一个值及其类型， 它们等于计算表达式所得结果的值和类型。表达式求值按运算符的优先级和结合性规定的顺序进行。 单个的常量、变量、函数可以看作是表达式的特例。