字符型量 % J m# |# t% i9 c) B1 n& T8 c3 z$ q; j1 m1 F6 [
字符型量包括字符常量和字符变量。 0 l( W9 W9 {" G5 t& a ) g! \$ O( V! ^3 y; H \字符常量 + t1 h9 }5 N+ T$ C* j- L1 C字符常量是用单引号括起来的一个字符。例如'a','b','=','+','?'都是合法字符常量。在Ｃ语言中，字符常量有以下特点： ' e9 ~( B" R9 c6 g4 m0 Q, h- a1.字符常量只能用单引号括起来，不能用双引号或其它括号。8 y# f5 O4 @, o6 m
2.字符常量只能是单个字符，不能是字符串。$ J z0 ?: F4 A, k* F& e
3.字符可以是字符集中任意字符。但数字被定义为字符型之后就 / I& M8 D- D! b) n不能参与数值运算。如'5'和5 是不同的。'5'是字符常量，不能参与运算。" X6 b5 f- i+ J+ O
& y3 J# W' j% h- m. V1 i转义字符 / B# U) N$ Q. T: G5 t, q转义字符是一种特殊的字符常量。转义字符以反斜线"\"开头，后跟一个或几个字符。转义字符具有特定的含义，不同于字符原有的意义，故称“转义”字符。例如，在前面各例题printf函数的格式串中用到的“\n”就是一个转义字符，其意义是“回车换行”。转义字符主要用来表示那些用一般字符不便于表示的控制代码。6 h! q0 ?( b* w+ i9 }
常用的转义字符及其含义 ) w3 B+ I, k k. f' h1 f5 V. r转义字符 转义字符的意义9 I4 ~+ M& X+ s0 h
\n 回车换行 P% g8 J. _$ C) ?0 F2 H* q
\t 横向跳到下一制表位置 6 a+ A b- v; F+ V! I\v 竖向跳格* W) o7 A% t5 C, A& R$ H+ p4 h2 R
\b 退格 2 G4 x* y! x' B% n/ ?\r 回车 2 U! ?4 Q1 P. M' \+ q\f 走纸换页 ! k n8 c( ~3 z# L. x\\ 反斜线符"\" 9 u s: }% P# s% V3 ?" ~7 }\' 单引号符 6 |( J8 `6 |( c. Q# Y\a 鸣铃# k6 S- M3 Q- B, _1 x: w" S
\ddd 1～3位八进制数所代表的字符: E8 v" R: `0 `* G$ _1 X4 j/ m
\xhh 1～2位十六进制数所代表的字符 6 ^ ]+ d/ V- p广义地讲，Ｃ语言字符集中的任何一个字符均可用转义字符来表示。表2.2中的\ddd和\xhh正是为此而提出的。ddd和hh分别为八进制和十六进制的ASCII代码。如\101表示字?quot;A" ，\102表示字母"B"，\134表示反斜线，\XOA表示换行等。转义字符的使用( o6 n( D+ \) `; F7 k" _4 Y
void main() ' g2 p/ _# C* C$ u2 f! G{ , k7 v* x/ n! j$ Dint a,b,c; ) l. K( L# I7 c& C M4 Pa=5; b=6; c=7;; L0 |8 z; M7 w2 h6 U: ^3 N1 z* D
printf("%d\n\t%d %d\n %d %d\t\b%d\n",a,b,c,a,b,c);4 j/ Q2 [+ O7 ?+ ~+ A1 t
} 1 B; K) ~4 L. V, h. i此程序练习转义字符的使用 0 U% r' [4 m$ D6 b4 ~a、b、c为整数 5->a,6->b,7->c 7 f; t' m. X% K, t# Y) ~$ u调用printf显示程序运行结果 1 I% X6 ~( _# O$ V/ ?printf("%d\n\t%d %d\n %d %d\t\b%d\n",a,b,c,a,b,c); 7 k# w, R% g& |% m, j; H @9 ^程序在第一列输出a值5之后就是“\n”，故回车换行；接着又是“\t”，于是跳到下一制表位置（设制表位置间隔为8），再输出b值6；空二格再输出c 值7后又是"\n"，因此再回车换行；再空二格之后又输出a值5；再空三格又输出b的值6；再次后"\t"跳到下一制表位置（与上一行的6 对齐），但下一转义字符“\b”又使退回一格，故紧挨着6再输出c值7。 " g( ~' ^% Q5 U% F$ ^4 T5 t9 [2 }0 \4 d0 A9 [% M, |
字符变量4 u0 m# c7 N4 K! V$ W c m
字符变量的取值是字符常量，即单个字符。字符变量的类型说明符是char。字符变量类型说明的格式和书写规则都与整型变量相同。( p4 G# `: h7 [
例如： , T+ Z, Z4 [) D& v5 N5 xchar a,b; 每个字符变量被分配一个字节的内存空间，因此只能存放一个字符。字符值是以ASCII码的形式存放在变量的内存单元之中的。如x的 ' p4 h5 d& {+ v; L+ p" T% Z十进制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/ e' |9 l1 L0 }8 N2 X4 X0 z
b 0 1 1 1 1 0 0 1 ' Y7 j9 D8 B. ~, ?9 b& C8 z所以也可以把它们看成是整型量。 Ｃ语言允许对整型变量赋以字符值，也允许对字符变量赋以整型值。在输出时， 允许把字符变量按整型量输出，也允许把整型量按字符量输出。 整型量为二字节量，字符量为单字节量，当整型量按字符型量处理时， 只有低八位字节参与处理。 % O8 l% D; n" [3 h' F8 j7 G( |main()2 |1 ?+ g; E! q: f; p' O. X- ~7 }
{ 3 J) b; \4 i& _6 d: m char a,b; , _( Q- r5 n" v5 S8 \7 w' i% X a=120; 9 M1 w+ m7 P! {& U) }4 {, X5 \ b=121;4 k! ^; Y/ L3 I) W5 i
printf("%c,%c\n%d,%d\n",a,b,a,b);+ ^8 f$ ~2 l+ s; ]% H4 h: x
} ! [" `% X6 |+ W( d# U* {1 r' S0 sa ■ b ■ , }/ w# Y B( k, L9 P5 va <-- 1206 U1 P. }& R& K
b <--- 121 / X: g& r2 s- Z+ L( t1 U D显示程序结果; k- k+ n @, E4 m
$ F0 u; Z) Z1 j, A' v# T, t7 D6 R本程序中说明a，b为字符型，但在赋值语句中赋以整型值。从结果看，a，b值的输出形式取决于printf函数格式串中的格式符，当格式符为"c"时，对应输出的变量值为字符，当格式符为"d"时，对应输出的变量值为整数。" e/ ]0 W; j z+ ?( b
void main() 7 Y: e: f% @: @" O{! j$ ?7 k6 U" H, v% J. ?& e
char a,b; , o5 P+ K, E% J2 O a='x';1 ?! h# A( l# i* [3 S1 S1 f' z
b='y';) }* m- j3 B2 F" r+ t. d
a=a-32; 2 q/ \' S& M2 q: P9 E/ o b=b-32; $ \; Q" {6 p# E; i4 A X printf("%c,%c\n%d,%d\n",a,b,a,b); . G& `2 v$ o; j" t% H% {) s" Y9 [1 N} }( }; A1 K% W' ]a，b被说明为字符变量并赋予字符值" @: V0 l: v6 W
把小写字母换成大写字母 0 h- X3 P) M( u- z+ ^! d* A, b O以整型和字符型输出 : g3 X0 ~ Q- l* H3 H: H% \5 h. o0 {
本例中，a，b被说明为字符变量并赋予字符值，Ｃ语言允许字符变量参与数值运算，即用字符的ASCII 码参与运算。由于大小写字母的ASCII 码相差32，因此运算后把小写字母换成大写字母。然后分别以整型和字符型输出。 ( L9 P0 x( ?8 j A- ~4 ~[Practice] //charint a=49; ' ~5 g5 {6 m* j/ e/ S1 ~7 kchar b; , \/ f: T1 @+ H/ }# S0 i4 |4 bchar d; 3 g' N/ e# Y N- c7 qb=a+10;0 r6 [! E3 J3 ~& \/ a+ X9 p
d=a+b;'Vtable , B) [6 i7 r8 o* E, V" Ia,2,49. q# j) g) z# Z% T& z# [) q
b,1,随机 " k1 i% f4 J0 H8 N1 t/ md,1,随机. }# p! _. V0 k3 M
of Vtable # d; \) |2 ?, `- q& d0 G'Vupdate- l% T3 a; h( L
1,49! F) ?+ B5 m Y
2,随机 # _$ B& V' C- d3,随机 2 @/ G4 \- r: h r( }+ y: y5 p, X2,';' % M. I+ L8 t/ @! n4 j' R! [3,'l'4 ^, y6 e# D: j8 S
of Vupdate& i5 H( @2 y/ R* ~% @# s
of Practice 3 D6 d/ a( l2 @; ]9 M t5 Q' L[Practice] //char c1,c2;2 A/ d5 E, L, \+ i3 @
c1='a';c2='b'; . i5 }7 N* S: u+ Q% D, e- n* kc1=c1-32;c2=c2-32;'Vtable 4 H( m0 r& s1 D( [c1,1,随机' m' M7 e" m( i9 O
c2,1,随机5 W, o# y: R3 J% h
of Vtable4 m, T; J3 J2 a! ^
'Vupdate 5 z4 c+ \: i9 q# l1 Y$ Y1,随机;2,随机 ) p$ K2 {7 ^& M' d1,'a';2,'b') Z$ a. X% h( |7 t: N: c8 X5 n
1,'A';2,'B' ! `' S) j2 m; U9 L4 Dof Vupdate) S# m8 v3 P3 ] n
of Practice作者: zw2004 时间: 2008-1-21 16:56 标题: C语言之数据类型-运算符-表达式
字符串常量( t1 X3 G8 Q6 o( @, T7 u
字符串常量是由一对双引号括起的字符序列。例如： "CHINA" ，"C program:" ， "$12.5" 等都是合法的字符串常量。字符串常量和字符常量是不同的量。它们之间主要有以下区别： / e0 \3 s" p7 B9 v1.字符常量由单引号括起来，字符串常量由双引号括起来。! V# W! X8 W" A- F+ m, [
2.字符常量只能是单个字符，字符串常量则可以含一个或多个字符。) p/ F/ T) D* j3 c
3.可以把一个字符常量赋予一个字符变量，但不能把一个字符串常量赋予一个字符变量。在Ｃ语言中没有相应的字符串变量。4 [# n+ h; L9 x) E% p2 T7 B
这是与BASIC 语言不同的。但是可以用一个字符数组来存放一个字符串常量。在数组一章内予以介绍。8 V# u0 z7 j7 @$ I( C' A: s
4.字符常量占一个字节的内存空间。字符串常量占的内存字节数等于字符串中字节数加1。增加的一个字节中存放字符"\0"(ASCII码为0)。这是字符串结束的标志。例如，字符串 "C program"在内存中所占的字节为：C program\0。字符常量'a'和字符串常量"a"虽然都只有一个字符，但在内存中的情况是不同的。 6 R V& ?: Z: v, ~ V( z5 x'a'在内存中占一个字节，可表示为：a 6 q# D0 H. W/ h8 B6 U"a"在内存中占二个字节，可表示为：a\0符号常量, v; R% x9 N& u6 n0 t' r* F3 X3 c' {2 x
- O* Z, i' W2 K6 {: B
符号常量 1 Z9 r' e3 `- h7 s3 p+ p, X7 M* d
在Ｃ语言中，可以用一个标识符来表示一个常量，称之为符号常量。符号常量在使用之前必须先定义，其一般形式为： # E2 I; L- K v6 u$ |, D0 J# o2 m& P2 V
#define 标识符 常量 / T" k" J1 [2 u) S( {4 ]其中#define也是一条预处理命令（预处理命令都?quot;#"开头），称为宏定义命令（在第九章预处理程序中将进一步介绍），其功能是把该标识符定义为其后的常量值。一经定义，以后在程序中所有出现该标识符的地方均代之以该常量值。习惯上符号常量的标识符用大写字母，变量标识符用小写字母，以示区别。 & W+ S; L, K, e" u; N#define PI 3.14159 + N3 ]8 r. K" z# [ {0 ]0 gvoid main() 8 v: z# e/ r3 P/ y! j% X! j' ^% P{1 b4 e' F) L5 O' ~1 d
float s,r; " \5 J9 D- R7 x) `0 R. k r=5;3 |" w& _8 O0 u: `( d! ?3 _" n
s=PI*r*r;! z4 p* h5 \2 ]+ T
printf("s=%f\n",s);' s b' B% f: b# E/ F
} R+ D2 A7 A2 m由宏定义命令定义PI 为3.14159 s,r定义为实数 5->r PI*r*r->s ' |! X( c6 F$ y显示程序结果 float s,r; r=5; s=PI*r*r; 本程序在主函数之前由宏定义命令定义PI 为3.14159，在程序中即以该值代替PI 。s=PI*r*r等效于s=3.14159*r*r。应该注意的是，符号常量不是变量，它所代表的值在整个作用域内不能再改变。也就是说，在程序中，不能再用赋值语句对它重新赋值。3 n' c8 [ E" D, N/ N/ E0 d3 V
3 N, N1 i, [7 M) d. X) C变量的初值和类型转换 ; x4 W5 r! `7 T! C! n. i" b) L3 [. s, @, D$ Q I
变量赋初值 ' r# ?- a$ N9 j/ f' p- l1 d在程序中常常需要对变量赋初值，以便使用变量。语言程序中可有多种方法，在定义时赋以初值的方法，这种方法称为初始化。在变量说明中赋初值的一般形式为： 8 u( f& c4 |+ B, m. i- A( w% y9 a
类型说明符 变量1= 值1，变量2= 值2，……； 例如：% \! p, M$ n! V! W5 S; l
int a=b=c=5; ) F3 m2 q$ K+ p* @8 _4 _float x=3.2,y=3f,z=0.75;1 `" |4 `; Y) K4 O
char ch1='K',ch2='P'; 1 r: H& M( u0 v9 I3 m& p# c+ |应注意，在说明中不允许连续赋值，如a=b=c=5是不合法的。 9 l0 O) V' H" N4 w/ pvoid main()0 h v. P; o( d- e9 l+ M
{" ~% h4 L+ p- m; }; @/ {3 @
int a=3,b,c=5; % L$ u+ L, y0 ^4 a) y b=a+c; 5 u* a! I+ j* ^4 x0 i2 k- q printf("a=%d,b=%d,c=%d\n",a,b,c);8 `- |3 Q9 y) G0 R
}- @4 K4 M# R1 t2 H; b! S
a<---3,b<--0,c<---5 8 O* l- P7 S) n$ ^b<--a+c - K/ Z' J8 Q# @0 j2 n' F( b% f显示程序运行结果& r1 w% S/ y. a4 h! U7 V
' l( |7 a: c6 _% J2 z, U
变量类型的转换 / z; e h' [" U变量的数据类型是可以转换的。转换的方法有两种， 一种是自动转换，一种是强制转换。 7 C9 F; M6 x8 Y+ i$ w ( k, {. B$ k3 j& J& H6 J自动转换 6 V: N1 f# W5 C! u自动转换发生在不同数据类型的量混合运算时，由编译系统自动完成。自动转换遵循以下规则： 0 {( d! b+ q5 e9 v$ o( T! ]9 I
1.若参与运算量的类型不同，则先转换成同一类型，然后进行运算。 % f: J# k6 t/ t" }2.转换按数据长度增加的方向进行，以保证精度不降低。如int型和long型运算时，先把int量转成long型后再进行运算。 : b$ M% L. @ X: g5 B% i) c9 m% }' L3.所有的浮点运算都是以双精度进行的，即使仅含float单精度量运算的表达式，也要先转换成double型，再作运算。 ( O4 j6 ^2 ?/ L/ P; A) r1 A4.char型和short型参与运算时，必须先转换成int型。6 B5 Z- u, E3 @
5.在赋值运算中，赋值号两边量的数据类型不同时， 赋值号右边量的类型将转换为左边量的类型。 如果右边量的数据类型长度左边长时，将丢失一部分数据，这样会降低精度， 丢失的部分按四舍五入向前舍入。图21表示了类型自动转换的规则。7 d, U5 G. e7 V
void main() 3 ]6 F, x: H1 s4 s& [8 y{9 P4 [( M/ ]+ Z5 ?
float PI=3.14159;% Y3 J1 B# I4 ~
int s,r=5;& @8 k0 p4 P* W0 i W# h
s=r*r*PI; 3 f! ^( X* V+ M% T$ e printf("s=%d\n",s);2 [+ @" d3 B6 e1 A" P
} 6 [2 V; j z+ Y oPI<--3.14159 % W0 E2 F. q) m- ^2 H+ z; E/ y8 s, ws<--0,r<--5 & y& I2 [: z+ R9 [s<--r*r*PI 2 V' @; ?; R. B6 ?4 T& P5 G8 e显示程序运行结果* ]: C- t4 a& s; P* m. j6 I
float PI=3.14159; ) }- W4 b; j' v, \3 j2 {: V% vint s,r=5; + U6 W! k# w7 a- h4 W$ E- gs=r*r*PI; , {9 t% ]0 Z6 T/ I1 C8 L+ {; X
本例程序中，PI为实型；s，r为整型。在执行s=r*r*PI语句时，r和PI都转换成double型计算，结果也为double型。但由于s为整型，故赋值结果仍为整型，舍去了小数部分。作者: zw2004 时间: 2008-1-21 16:57 标题: C语言之数据类型-运算符-表达式
强制类型转换 * t" d+ \5 {0 H' G+ o# V强制类型转换是通过类型转换运算来实现的。其一般形式为： (类型说明符) (表达式) 其功能是把表达式的运算结果强制转换成类型说明符所表示的类型。例如： (float) a 把a转换为实型(int)(x+y) 把x+y的结果转换为整型在使用强制转换时应注意以下问题：* N. D0 a3 [2 ?' n- _3 ]: E% u5 L
1.类型说明符和表达式都必须加括号(单个变量可以不加括号)，如把(int)(x+y)写成(int)x+y则成了把x转换成int型之后再与y相加了。 0 u) }2 F$ F' t2 w' g8 W, p8 d- v% @2.无论是强制转换或是自动转换，都只是为了本次运算的需要而对变量的数据长度进行的临时性转换，而不改变数据说明时对该变量定义的类型。 5 E N6 l S/ l* p- Nmain()+ q4 @" _0 {4 b& r& d2 O# P
{ # X9 Q* s. I; u1 |( @ float f=5.75; " O! O* T* T1 ]' t printf("(int)f=%d,f=%f\n",(int)f,f); / `3 Y: s; u: J; ^, w} 0 @! c- \6 f& P# T1 c ^. I4 n
f<--5.759 E( ?9 `, E. o5 k) i4 g
将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。 # O/ P( i. W" G+ C/ a, j! P5 B3 `4 D H; k7 O
基本运算符和表达式9 _% \6 B) T& V
$ B! j& Q. r0 ~% `运算符的种类、优先级和结合性 1 d7 U1 {& m, }$ ^Ｃ语言中运算符和表达式数量之多， 在高级语言中是少见的。正是丰富的运算符和表达式使Ｃ语言功能十分完善。 这也是Ｃ语言的主要特点之一。 : j; k7 t, t0 s$ G `+ A# PＣ语言的运算符不仅具有不同的优先级， 而且还有一个特点，就是它的结合性。在表达式中， 各运算量参与运算的先后顺序不仅要遵守运算符优先级别的规定，还要受运算符结合性的制约， 以便确定是自左向右进行运算还是自右向左进行运算。 这种结合性是其它高级语言的运算符所没有的，因此也增加了Ｃ语言的复杂性。* e' |" O }2 e b) l' B1 O
/ y ?8 @; \( _$ u运算符的种类Ｃ语言的运算符可分为以下几类： 6 Q8 p3 V! }0 v1.算术运算符6 U+ s! i7 |* \2 S- Z
用于各类数值运算。包括加(+)、减(-)、乘(*)、除(/)、求余(或称模运算，%)、自增(++)、自减(--)共七种。5 I" V+ I- N9 j7 @
2.关系运算符 + T" j( U/ R& S: [7 X& i用于比较运算。包括大于(>)、小于(<)、等于(==)、 大于等于(>=)、小于等于(<=)和不等于(!=)六种。 " F* k: F# U" Q# x# W8 u8 H. W1 F3.逻辑运算符9 z; H8 F: s' o8 ^$ \
用于逻辑运算。包括与(&&)、或(||)、非(!)三种。3 ^& b/ z) i3 y) ^7 H$ N; A
4.位操作运算符 ( N! ]; w: ?8 v9 a) ~3 k参与运算的量，按二进制位进行运算。包括位与(&)、位或(|)、位非(~)、位异或(^)、左移(<<)、右移(>>)六种。+ p$ X) I; `& u% [9 i
5.赋值运算符7 B' U+ R) j# X) f+ k; x: G
用于赋值运算，分为简单赋值(=)、复合算术赋值(+=,-=,*=,/=,%=)和复合位运算赋值(&=,|=,^=,>>=,<<=)三类共十一种。 8 ^7 R5 t w5 C& W9 T# ^2 V6.条件运算符 # o0 \/ W3 b; X% c! V7 Y9 \这是一个三目运算符，用于条件求值(?。 : {+ h9 L" L$ M- \2 s0 X/ x" z7.逗号运算符2 o$ j/ U5 M5 X; E1 d x
用于把若干表达式组合成一个表达式(，)。 4 |! O/ @+ V$ F3 r8.指针运算符 4 x( c7 r6 l/ |$ i# i8 f- E) ?9 y& ?. g用于取内容(*)和取地址(&)二种运算。 & K7 K \3 c- d; \5 h. O! N9.求字节数运算符* W M, @7 Y/ V( h) R2 _& N
用于计算数据类型所占的字节数(sizeof)。, r+ o! A3 b0 i3 b
10.特殊运算符 9 q" E/ K( \0 y4 O. t9 q& f有括号()，下标[]，成员(→，.)等几种。; D7 b; n, |) Y- o! f
; ~% X, z' V3 j* d6 z; Y9 \
优先级和结合性7 W% o+ Q" a4 e* G
Ｃ语言中，运算符的运算优先级共分为15级。1级最高，15级最低。在表达式中，优先级较高的先于优先级较低的进行运算。 而在一个运算量两侧的运算符优先级相同时， 则按运算符的结合性所规定的结合方向处理。 Ｃ语言中各运算符的结合性分为两种，即左结合性(自左至右)和右结合性(自右至左)。例如算术运算符的结合性是自左至右，即先左后右。如有表达式x-y+z则y应先与“-”号结合， 执行x-y运算，然后再执行+z的运算。这种自左至右的结合方向就称为“左结合性”。而自右至左的结合方向称为“右结合性”。 最典型的右结合性运算符是赋值运算符。如x=y=z,由于“=”的右结合性，应先执行y=z再执行x=(y=z)运算。 Ｃ语言运算符中有不少为右结合性，应注意区别，以避免理解错误。, m z, }0 k1 C4 Y4 S
2 {) G" B! @& K2 g1 L算术运算符和算术表达式基本的算术运算符 . `( J1 L L7 B& U, o- l- p4 ^2 T1.加法运算符“+”加法运算符为双目运算符，即应有两个量参与加法运算。如a+b,4+8等。具有右结合性。- E" \- `) K. B3 A' b
2.减法运算符“-”减法运算符为双目运算符。但“-”也可作负值运算符，此时为单目运算，如-x,-5等具有左结合性。$ N" |1 s# T7 K$ L
3.乘法运算符“*”双目运算，具有左结合性。 - F( J" w& g* x1 G! a4.除法运算符“/”双目运算具有左结合性。参与运算量均为整型时， 结果也为整型，舍去小数。如果运算量中有一个是实型，则结果为双精度实型。 $ w6 C. G' g2 f. B$ v+ ovoid main(){. U* S K1 r. `) @4 U9 q
printf("\n\n%d,%d\n",20/7,-20/7); * X( P3 o* c& m D& S9 Rprintf("%f,%f\n",20.0/7,-20.0/7); 2 E7 z/ u/ }6 ~}. G+ e, [) q+ D1 M, a
双目运算具有左结合性。参与运算量均为整型时， 结果也为整型，舍去小数。如果运算量中有一个是实型，则结果为双精度实型。 printf("\n\n%d,%d\n",20/7,-20/7); 1 Y; W, S( l) S$ k4 j& V! yprintf("%f,%f\n",20.0/7,-20.0/7); 9 _6 @) Z$ r! H3 |# c$ i本例中，20/7，-20/7的结果均为整型，小数全部舍去。而20.0/7和-20.0/7由于有实数参与运算，因此结果也为实型。 " V: _3 W" k& @6 C5.求余运算符(模运算符)“%”双目运算，具有左结合性。要求参与运算的量均为整型。 求余运算的结果等于两数相除后的余数。 & l+ n' d' K; ]void main(){$ j R7 `7 C/ g% u- T; P" f
printf("%d\n",100%3); ' E# A( Q- r, h$ J2 v5 U} % l0 T8 T4 B4 g1 J% E* f双目运算，具有左结合性。求余运算符% 要求参与运算的量均为整型。本例输出100除以3所得的余数1。& h3 y3 Y. V9 ~* B* l) o1 u
& Q% ^, y ^+ Y) ?8 G+ s自增１，自减１运算符# P; ^# R5 o' P2 \
自增1运算符记为“++”，其功能是使变量的值自增1。自减1运算符记为“--”，其功能是使变量值自减1。自增1，自减1运算符均为单目运算，都具有右结合性。可有以下几种形式： ++i i自增1后再参与其它运算。--i i自减1后再参与其它运算。 `0 i) x9 o. L8 U: J, k9 O+ Ri++ i参与运算后，i的值再自增1。) ]. d( A% t; t# |4 B T x2 g0 t
i-- i参与运算后，i的值再自减1。 " Z9 \8 u3 \% }4 I
在理解和使用上容易出错的是i++和i--。 特别是当它们出在较复杂的表达式或语句中时，常常难于弄清，因此应仔细分析。8 W, l: ? [: B: H9 n0 o
void main(){ ! w; `' {; ?! Iint i=8; , n; T# D# D$ y! e. Aprintf("%d\n",++i); 1 _. x i3 ^% n5 ? d% [1 C, Z+ y% Gprintf("%d\n",--i);0 D1 }. \# l, o$ M2 j" r, `
printf("%d\n",i++); & ?( ^' W- L5 K Mprintf("%d\n",i--); n5 l! p) n/ d |
printf("%d\n",-i++);8 Z: J' d2 _" y7 ~+ I. e" T
printf("%d\n",-i--); % M3 j3 Z+ s+ n1 I, _* v} i<--8 2 S1 g' M* b/ H: w+ ^i<--i+1) {0 \ [8 z6 i, U. Z3 g6 S: l
i<--i-1 7 j, u- H: n4 I$ D9 ^$ N: ji<--i+12 ]/ o b, M0 G2 F4 s+ Y! N3 O
i<--i-1 ! x- N- z- x1 X3 Ai<--i+1- c) N! X" s0 r: ]" Z: H
i<--i-1 int i=8;# K) l# @0 Z- o1 M
printf("%d\n",++i); . G8 r0 X3 ~( P* o- v( L Iprintf("%d\n",--i); 8 R$ K' z# k8 c/ zprintf("%d\n",i++);. }4 X4 A& t1 |2 n8 V
printf("%d\n",i--);; |" R' S- J0 i( x+ O* c( ^
printf("%d\n",-i++); 9 l3 _6 N. h ^printf("%d\n",-i--); - x% U+ G# \" Z5 E! A; m# U: Oi的初值为8- }+ @& ]/ u, A. @5 R
第2行i加1后输出故为9； ! J1 N9 d' g5 c) P& |, M/ d第3行减1后输出故为8； ' e: k; P* U4 K( y" a) o" O第4行输出i为8之后再加1(为9)；: t! v" F' c. o! l
第5行输出i为9之后再减1(为8) ； l2 I( e& F; Q# v5 ]8 x2 G+ H# n8 M
第6行输出-8之后再加1(为9)；$ L& R2 g# S9 u
第7行输出-9之后再减1(为8)+ \% G. H* f6 T. V2 p% }) x! U
void main(){ " |! V) }$ U1 Dint i=5,j=5,p,q; ; l' m3 X* r# d& x3 kp=(i++)+(i++)+(i++); ' y- v R9 q" B3 F# \q=(++j)+(++j)+(++j);6 r3 v! [ P! V2 p# X8 C' g! ^
printf("%d,%d,%d,%d",p,q,i,j); 0 y# Y% o2 Q5 w+ E}& z; U* O# c& d% a. C& D, ?: s
i<--5,j<--5,p<--0,q<--09 w t# [5 A; ^0 p6 \8 ^
i+i+i--->p,i+1-->i,i+1-->i,i+1-->i - f. `4 c b) qj+1->j,j+1->j,j+1->j,j+j+j->q int i=5,j=5,p,q;3 q9 W) C" { K5 y4 I5 Q7 J
p=(i++)+(i++)+(i++);: @. w2 Q0 Z$ Y4 O6 V
q=(++j)+(++j)+(++j);. P( Y! T' g' J
这个程序中，对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。算术表达式表达式是由常量、变量、函数和运算符组合起来的式子。 一个表达式有一个值及其类型， 它们等于计算表达式所得结果的值和类型。表达式求值按运算符的优先级和结合性规定的顺序进行。 单个的常量、变量、函数可以看作是表达式的特例。作者: zw2004 时间: 2008-1-21 16:58 标题: C语言之数据类型-运算符-表达式
。