C语言基础(05-运算符和表达式)

JKSOU

有风

Rank: 1

楼主大中小发表于 2007-12-15 10:43 只看该作者

C语言基础(05-运算符和表达式)

　运算符（也叫操作符）－－运算符是一个表示特定的数学或逻辑操作的符号。如'+'号，表示了一个相加运算；'&&'号表示了一个逻辑‘与’的运算。由运算符把需要进行运算的各个量（常量或变量）连接起来组成一个表达式。
/ ~# D0 f* w9 I- U/ {+ H: i
　　下面要讲的是标准的运算符，在C＋＋中还有另外的一些运算符。" Q4 Q1 e/ z, ]( C7 z) D
2 z  K$ y. V# V+ l0 u
　　运算符: R. S. J  ^: a- Q& A) V+ Z

　　进行的运算6 B& m, f' F6 B/ D7 x( D. n
9 `! [2 P( ?1 M* Y0 y
　　所属类别  p* W" v% K2 I& @# d

　　备注( K" T8 o4 H7 n4 o( ]# p- S/ \
  S% T  z2 p" R$ \
　　[ ], p' `0 G3 L: e. u5 M" m* l
* m. V% B( N0 u" v: I, z4 E0 z
　　间隔符9 R/ f. Q3 A+ k

　　标点符号6 i! ]% ?7 a4 H$ c, f, F

　　( )
9 U$ y. x3 Q2 d8 B3 y  k/ ]4 \
　　间隔符0 w- k+ `' }# g% E9 ?( L

　　标点符号  T% N: F' r3 g3 h# ?

　　·

　　直接分量选择# u7 H: O4 M; [$ t4 i" o
3 E1 ~$ k, \$ [9 K4 B; u1 l
　　双目操作符

　　->6 f# w" ~1 Q1 Q$ v" ~5 J

　　间接分量选择9 J6 w9 O8 E- }( l; Y. q

　　双目操作符

　　++9 {0 S. O2 \4 ^8 @& q" h7 C; t

　　前增量、后增量

　　单目操作符$ t. ?- L% q8 Y# |# N' J- G2 k' [
* I& g/ X. V$ Z7 H, r7 Q- h
　　--' K1 m- O/ S. i7 T( c1 V+ ?9 q
: Q* c/ R9 U  s4 k
　　前减量、后减量
9 m* X7 E1 P4 H2 l! S# L! P
　　单目操作符8 s# A, K0 s! n  t/ @+ _
# d  M3 C4 f1 M% e
　　+( n4 U6 h% [/ E* a4 m7 I

　　加. t& G( n8 `2 C: |7 p7 u& Y0 l( q

　　双目操作符、单目操作符
! F$ ]: l1 c) x/ h
　　-
* H& I/ K  }5 T$ b- Q' ?
　　减

　　双目操作符、单目操作符

　　*2 ?( l( X' X$ x! n
5 L2 G( H+ X; J, h
　　1）乘　2）间接引用2 R) g/ w* ^% Y$ i1 Q( C

　　双目操作符、单目操作符# d+ g4 G( ^6 p: M+ S' {. I5 _

　　/
- q! X/ y$ i' ]8 `# v$ _7 X/ }- P( X
　　除

　　双目操作符
/ @# ]9 E. S% }& ~' \  b9 i
　　%
/ D7 ~2 H/ q; N2 X5 {
　　求余. f! L0 Z4 y" S8 g- ?  b  O- Y

　　双目操作符* \! `6 D0 Y( U& C9 Z" Y, d  w
7 o+ ]6 S- e& i7 c
　　&! ~$ F* g8 j+ ?2 X2 T1 b1 N
: o% {& e; I3 {5 j5 W+ L+ `
　　1）位‘与’2）取地址* e9 A4 q7 B6 x
1 X  v2 k5 e, k
　　双目操作符、单目操作符
  i) t: l: X% W
　　!6 J" q( M% F4 Q* t; F  O
# f, @* l! ]  r7 ^
　　逻辑‘非’4 D  `* o0 t6 `/ O$ g7 N* p7 o0 u

　　单目操作符

　　&&
4 P1 W/ [2 H& g3 _" W
　　逻辑‘与’

　　双目操作符1 M: `, \0 f& @& u
# F8 k9 T8 D' t1 Q7 d& T. j
　　||$ @* `3 o8 F; ~
& j) S$ M3 |7 ^( j$ t; q
　　逻辑‘或’( R5 ]& T7 t4 g/ i: f7 r- d3 j; M

　　双目操作符1 o/ z; I1 Q; `! {% ]# y6 m, v3 {
7 B+ j8 w6 R* X: [$ u8 Q9 f
　　左移位  y/ x$ r7 ~2 L6 p3 U

　　双目操作符
  b+ K5 n9 V4 ^' u
　　>>5 Y- H+ t$ w& T' Y9 J' k0 K4 {

　　右移位
% t6 T, }, W  C/ J& d4 f
　　双目操作符1 v2 d( _% [! c, @* y5 |! V

　　小于- s# M* _9 k/ X* h0 ^6 D% h% [# J/ b

　　双目操作符
8 J$ ]! t* a3 I7 V* ]- ?
　　>1 [; P8 T: k. R) F

　　大于, {) z, `7 q9 v; b6 i; M

　　双目操作符
: P- Z) l0 V2 s  ^- }  a# |7 X
　　==9 b: o2 i  G; d& u# o; e
9 x8 p4 F. C0 d1 t2 l* D( u3 P
　　等于/ M+ z+ x% I. h- p. P) o3 m5 x! ~
+ Z2 u$ w: b" }7 w+ [
　　双目操作符
9 f! U3 w+ |  V$ e; n. H& v
　　!=! a9 y' [2 P! ^. ^0 i0 X
1 }  V- m7 o* `
　　不等于
' [5 H" e2 f! E" [
　　双目操作符
# C1 T4 t( U/ W( k" v
　　^+ K# |( e8 h, W! G

　　位‘异或’4 ]  @. u3 @. t
# [( b# l0 j- {5 b+ B& F
　　双目操作符* a+ G! k8 x0 t" o+ ~& R7 l$ _' x
1 W0 f, u. o8 k: V/ r5 i
　　+=0 F" Y- _! B7 q! y

　　和赋值' ?  U: r0 L0 R' l0 [& y3 C" F
- _. w$ }" u0 H0 _2 a
　　双目操作符) M# u' T$ B0 X0 p

　　-=7 \1 w3 M5 h  `5 K: c) t8 Y
5 H; L! _" U7 y, O8 t
　　差赋值: H; ]1 D) m. Y  k% M

　　双目操作符

　　*=
8 H  U* Y% P6 d( W
　　乘赋值2 B' g2 y; N  K% J  v: P. {9 L

　　双目操作符  D/ y# E! H1 ~% E) V
, l% e( E6 T9 i# |( t
　　/=

　　商赋值
/ w! X$ k* m) W8 K! V# W
　　双目操作符
4 ~* p4 _$ z: q2 p  p8 k& c$ R
　　左移赋值. M) b# }, }) o& f- I
9 y1 p( D* Z" A7 S9 k2 s) b& Q
　　双目操作符" J7 D* e2 R; u

　　>>=

　　右移赋值

　　双目操作符
6 U' ?) w8 z/ C# D
　　&=$ s# N# A# q, _: i: c3 \/ O. ~
9 G& X  [  C5 {- b3 P0 y# k3 r
　　按位‘与’赋值, R" Q; X& r( i5 X6 f- R7 \1 ?
2 `5 G" a6 P1 |& J( p- b' y5 c
　　双目操作符. h% |  U' F' l1 C! ^

　　^=

　　按位异或赋值
  Z+ Q  T+ p; O# F" X) D
　　双目操作符

　　|=- B: h! M; ]/ _: V, l+ {7 ^2 @
; P8 {* Z% d8 ~8 ~* ]: _3 D. P
　　按位或赋值0 H( J7 ?: U) T( x4 h0 o/ V. V

　　双目操作符( P, I8 V1 U9 e  {
4 g6 F0 I; ]: o
　　%=
! ]. i; @) @. K7 A' ^
　　模赋值) w+ i3 s( _* q; s) M
: o; k% F, b% Z) ~& K% L* h
　　双目操作符
; v  r8 S3 S' {1 g& M1 N/ }
　　=* d& |" t8 F- n% Y5 o0 I

　　赋值' c: |# h. y: F0 w" b1 U$ H

　　双目操作符: W& ?, Z1 k$ b
; x8 d9 O$ Y5 x, o
　　?:6 m4 L! c& j: z* Q6 j

　　按条件取值
1 s8 `* t2 ]1 n' v8 N( `5 ~
　　双目操作符" a! m  v) j  P

　　,, q) \  W( B- w0 r. |
, a/ Y3 O3 y. j& ?4 H
　　间隔符5 k0 }* E' ^. J# P2 p

　　标点符号8 u/ p* ~7 M' a8 R* B( z

　　#) g( {6 C9 I- {/ ^' q$ d0 S7 Z

　　预处理符号

　　标点符号

　　##
+ i7 {! e, D3 [: B% f* t
　　预处理符号1 @, R6 Y: S& S' A. x4 N: a
  y& K, H2 @$ U  ~: j
　　标点符号. T& Y9 p: Z( _2 d" w  w

　　sizeof
0 j! c, q5 M7 y4 D
　　求字节数3 I3 u$ B5 G  i0 v& p1 f; N

　　~  U* R/ ^, u8 L3 y
+ T0 l( z6 A# w4 d  K
　　按位求反
7 w3 q' K. F3 Z6 _/ j8 k. N! _
　　|
$ ?& c5 b( I8 E, D3 M
　　位‘或’9 K0 t. E+ R- P* x. S* b* \

　　：
/ g  a3 \" X; X# M, e( Y
　　间隔符

　　；

　　间隔符' E4 U) m- h5 _) t8 v7 A# B

　　...# F" g8 s( \. E4 p9 j4 T6 I

　　间隔符( C' j' ^# N9 S* \

　　要把表中的运算符仔细的分类是不容易的，因为同一个运算符，在不同的地方其含义是不同的。如＊运算符，当作为乘运算时是双目操作符（所谓双目操作符，即运算时需要二个操作数），如3＊6，那么3与6总共是二个操作数。当作为取值运算时就是单目操作符（所谓单目操作符是只需要一个操作数）如对一个数求反：!a，这里只有一个操作数a。

　　要记住运算符的二个特点，一个是运算符的操作对象，另一个就是运算符的优先级别。其中运算符的优先级别是最不容易搞清楚和最容易出错的地方。

　　在讲运算符之前讲一下“表达式”的概念：所谓表达式，就是用运算符把各个操作数连接成符合C语法规则的进行运算的式子。这里说的“符合C语法的规则”也很重要。如 a+b+5就是一个用算术运算符连接起来的表达式。- W; N4 T8 h- x0 D
' L% B2 D  O- C2 A4 |& D  [8 c7 E
　　1、算术运算符：＋、－、＊、/、%- R+ L4 B# D( o
# y, P( R4 e* |7 d. f" b5 C
　　1）＋、－、＊、/　分别是相加、相减、相乘、相除
- i# Z+ O# G" `" D0 o& N/ C2 V1 I- }
　　2）%　　求二个数运算的模。所谓求模就是求二个数相除后的余数。例：25/3的余数是1，可以说25%3的模是1。要注意的是求模运算时二个操作数必须是整数。如果求25.3/3.1这样是不能运算的。2 D+ _3 \% v1 ~2 f
- G+ R7 w7 {. [4 s4 j
　　下面写一个例子：

　　#include /*程序中要用到输入输出库函数，所以包含了stdio.h*/& @& u$ D3 n9 J4 b

　　void main()
  T4 [0 O9 r4 M! Y) ]9 N$ z0 V
　　{

　　int a=10,b=20,c=30; /*定义了3个整型变量，并同时进行了初始化赋值*/
! D# V, p  F( P8 T/ Q3 {+ P
　　a=a*b+c;             /*a*b+c组成了一个算术表达式，运算后的结果为230并把值*/

　　/*赋给变量a*/

　　printf("%d",a);       /*以整型格式输出变量a的值。这里输出230*/2 j2 x; O! y3 o; i5 v1 U. i

　　a=a%b;                /*进行求模运算。因为没有余数，最后的模为0*/
. K% f2 _' N. y( B$ W: w
　　printf("%d",a);       /*输出变量a的值。这里输出0*/

　　}( y/ \) l: D& O8 q7 [5 V* g8 Z" ^

　　下面是一个要考虑运算符优先级的例子：
. n, v2 v$ t, t
　　#include

　　void main()* j' ]8 k. c* R. `* X8 P
& M: N8 V# H. v) T
　　{
& E4 P; B# w+ y, j7 S5 r1 U! C4 U
　　int a=10,b=20,c=30;! I5 V% m* V- x' ^  T1 q

　　a=c-a*b;             /*这里就要考虑运算符优先级，＊运算符的优先级比－运算符*/, s  p# E5 N1 E+ _9 S

　　/*的高，所以先进行乘运算。这里最后结果为-170*/

　　}
0 N+ z4 W( K6 C
　　由上面这个例子看到，在一个有多个运算符连接起来的表达式中需要考虑运算符的优先级，这个例子很简单。关于运算符优先级的概念其实在小学生的算术运算中就有这样的概念了，只不过这里的运算符多了一些，要考虑的情况也就复杂了。
9 r) h+ c  m* @+ n# r
　　如果这个式子改写一下，写成：a=(c-a)*b;在运算时就以括号中的运算优先。8 ^; P. l/ H: O# u+ j/ ~! h+ y

　　几个简化的运算表达式：2 o) ?5 K- x( A) A9 N6 k% v

　　在C语言的程序中，经常看到这样的运算,如：i++;或者k--;这是运算符号的简化写法。
0 x: ~% t& q3 D5 d8 f
　　1、加1运算的简写1 R& j: |+ S# t5 J7 l; B/ S

　　当一个变量进行加1运算时，如a=a+1;这是变量自身加1，简写为a++;) ]* D; t2 S  w) J, e

　　2、减1运算的简写% O" }! g7 H, @  p* a
# H3 o/ t2 T5 u$ q3 J
　　当一个变量进行减1运算时，如a=a-1;这是变量自身减1，简写为a--;

　　3、加1个常量运算的简写7 F6 H. j$ _" a2 V# T

　　当一个变量与一个常量相加时，如a=a+5;这是变量自身加5，简写为a+=5;1 u6 {  x) N9 {

　　4、减一个常量运算的简写

　　当一个变量与一个常量相减时，如a=a-5;这是变量自身减5，简写为a-=5;

　　5、乘一个常量运算的简写# B5 ^1 H5 V) H2 v5 Q$ Z2 ]

　　当一个变量与一个常量相乘时，如a=a*5，这是变量自身乘5，简写为a*=5;) p; t4 B  M" H8 N

　　6、除一个常量运算的简写

　　当一个变量与一个常量相除时，如a=a/5;这是变量自身除5，简写为a/=5;

　　运算符的结合性（或称作关联性）" u# x7 O/ i- p) V4 k
) [8 Q5 [7 [5 E: X
　　在一个复杂的表达式中，常常有许多运算符和变量，这时就要判断优先级和结合性这二个因素。
& R1 k2 x3 Z  s, m! x. t
　　例：-5+7;　这样的一个表达式用结合性来判断，因为运算符'-'和'+'相对于运算的数来说是‘左’结合的，所以就有'-5'和'+7'所以运算的结果为 2。/ ?( s3 q: ?$ j8 W5 g) `5 V' r' j
2 h7 e8 R% i8 y6 b7 r$ O* o- u- A+ [
　　通过这个例子要知道什么是“左结合性”和“右结合性”

　　左结合性－－变量（或常量）与左边的运算符结合

　　右结合性－－变量（或常量）与右边的运算符结合) _7 O. R  Q4 Y! B! z! D% _

　　运算符的优先级和结合性表
6 i* {$ _& ~8 J+ A- y! h' r
　　优先级

　　运算符（高　－－－－－－→低）
' Z/ M5 y. ]3 ~; X7 w3 |3 S
　　结合率
. r' X1 N: e* l, @! W
　　运算符类型
: t( @9 ^$ B, S7 m" A: T
　　高

　　( ) [ ] -> .　　　　6 R" I2 G5 m9 a9 g# _' }8 b
$ q6 O& o" i: R
　　从左至右. @3 n6 O/ f1 w  w) T
* Y( Y2 D1 r2 Q& l' f
　　双目运算符

　　! ~ ++ -- （类型） sizeof　　+ - * &   [9 I7 n, K( s( P
1 R( ~8 t9 o: u9 Y: b; P
　　从右至左

　　单目运算符# u, r& j% ^8 K1 ^6 [5 n& c0 q' H9 o

　　* / %) E4 a  @, t# i; y7 g/ ?# C* l

　　从左至右0 ~; g# s! K. I1 D
; D- C& P, N- q3 @. u% M
　　双目运算符5 H6 \' p2 b1 _* _2 ]1 ^
9 i* N$ M( B8 }3 Z
　　+  -
9 D9 @3 i9 r. \+ I, V5 \: l- |
　　从左至右0 [" a& D8 o2 s; T0 O9 V
. r7 j0 j( y( a
　　双目运算符( N  e( D4 z- s, P( ]4 @% e1 ^
: S+ S" x% Y, {( c0 i) B* x
　　>
7 B! p+ p$ M) v" G  N- l) _) v) r- Z! T
　　从左至右
4 j  l' u9 C& q, u
　　双目运算符

　　>=( K7 M: U/ t' u9 |4 V1 X
0 k1 u$ w' ?7 N7 l1 Z+ p
　　从左至右- ]% X: Z) ?2 E% W, o

　　双目运算符

　　== !=/ ?, U- B2 I8 S' y, }' w# k

　　从左至右# @9 I- b2 r* r4 N) V% Q/ \" p7 |
# u, W2 I. n; j( ]
　　双目运算符0 C- a) S( o; a( f% A

　　&
# y( `/ p: ^6 g: `) D
　　从左至右3 F$ x+ O/ e# t" a7 t$ `( k
% b0 k! S. s% F/ f1 J! D
　　双目运算符
% V) d* p8 ^/ J4 ~
　　^

　　从左至右
2 v* T0 h- s& A0 f
　　双目运算符) j5 Y2 l$ }; |
) U# S4 D: S' C
　　|- W& K! I, m5 _) u

　　从左至右  I: m- N( _# E/ o" ~# m! V

　　双目运算符- Y* u  \3 x1 D, ~  Z
1 `1 Y' ~: V+ i: ~2 ~8 J
　　&&& f+ E, v# V% N. Z; @" E  A

　　从左至右, O1 g6 T. _; U9 I% Y
. X8 M8 Q4 x' Q8 W! S* M
　　双目运算符
' o, k3 _6 s8 z
　　||- i! `. {4 e8 ~0 M- b

　　从左至右8 O6 r' j3 }1 X5 M& l& K. S

　　双目运算符
5 o7 D  x/ _' w8 K6 A- G
　　?:) e/ a4 C3 \4 |( u" J

　　从右至左. O! z% c  M1 M' \7 n

　　三目运算符! ?# Z/ R" S. X; X+ \1 T2 c# z+ g  w
0 L% ]6 G( t* f' E9 x
　　低1 W7 p, T; \0 U3 |8 `

　　= += -= *= /= %= &= ^= |= >=! H7 }7 m5 h# D( ~" V* H! s& \( M; R
8 S( O1 J7 \0 p/ ~
　　从左至右# R0 G* G' i* q% P0 c

　　双目运算符8 H; @- I5 k. f" j2 H) n
, R* |. B; @) j2 C
　　高　　－－－－－－－－－－－－－→　低

　　从表中可以看出一个规律，凡是单目运算符都是“右结合”的，凡是双目运算符都是“左结合”的。其中有一个?:运算符是三目运算符是右结合的，记住了这个规律，运算符的结合性也就掌握了。2 K- |% r( X1 Q' w- u% f. {
  j: y2 N6 h/ h. ^5 t
　　如果代码行中的运算符比较多，用括号确定表达式的操作顺序，避免使用默认的优先级。% K3 z+ _4 ^3 v& Y

　　由于将表熟记是比较困难的，为了防止产生歧义并提高可读性，应当用括号确定表达式的操作顺序。例如：

　　d = (high % ^. G1 k0 J4 S5 J) G  Y: p/ N
% ]- _# I% Q4 ]1 F
　　void main()
7 \# J9 C. O! k( D+ B- C
　　{
3 e  H+ x0 M9 ]1 f3 s7 g) l) e! u$ _
　　int a=2;
; `) T% f& s" ~3 n9 _# i
　　a%=4-1;$ R# f) D5 m9 m. R, O: e+ G

　　printf("%d",a);
0 t: l9 h3 T) S3 O; V8 _  c
　　a+=a*=a-=a*=3;

　　printf("\n%d",a);$ G- }( U/ O. A0 H& }4 K4 A

　　}3 W% [' G- a5 q7 C% R; v

　　A. 2,0          B. 1,0
% |3 R* x. E* y# H
　　C. -1,12       D. 2,12! Y- N  ?; d7 O
1 m, u6 l4 u4 ?2 i1 \" L
　　分析：由于%＝运算符的优先级别低于－运算，a%=4-1即是a%=3，等价于a=a%3即a=2%3=2，所以选项B和C是错误的。表达式a+=a*=a-=a*=3，计算时注意赋值类表达式的值和变量的值随时被更新，计算表达式的值，开始时a=2，表达式赋值是从左至右进行的，表达a*=3使得a=6，此表达式的值也为6，于是表达式a-=a*=3相当于a-=6=6-6=0，a的值为0，后面的计算就不用做了，所以a的值最终为0。( a2 p2 F  {, o9 P
) _0 Q% U4 D, m+ |5 {* x
　　答：A

　　下列语句中错误的是) O: a# [# V- ]: D4 A

　　A.x=sizeof int;9 n/ m7 H3 P" y9 U; ~

　　B.x=sizeof 3.14: X) B6 A4 f& J: y6 @& d4 u$ |$ S
8 P2 {8 k0 A. H) I$ M1 T
　　C.printf("%d",a=a+1,b--,c+1);! p1 w3 [% B3 q/ C9 D: u

　　D.printf("%d",++x,x++);+ M; ?! Y- k1 I  d0 V

　　分析：此题的选项A的作用是测试int类型所占内存的字节数，因为类型符要用括号括起来，这时缺少括号是错误的。) F/ @1 b+ x& h: M, m, A8 Q

　　选项B是正确的。! |8 U4 G. M' e5 ^3 ]( M

　　选项C从表面上看似乎复杂一些，但其中的a=a+1,b--,c+1是一个逗号表达式，C语言允许使用这种表达式所以D也是正确的。
* K% f3 P5 b- ^8 @
　　答案：A
8 v, r4 l( t3 w( h
　　下面的语句中，符合C语言语法的赋值语句是$ }7 p. m4 d7 p9 d* V
  e5 t  G# X' r( m$ _3 P" B
　　A.a=7+b+c=a+7;             B.a=7+b++=a+7;
- [* i! r' V7 n* z0 R
　　C.a=7+b,b++,a+7;             D.a=7+b;c=a+7;
* P4 h/ ]- y- x; |+ @* y8 G1 S$ r) l6 F
　　分析：一般情况下，表达式不能放在赋值号的左边，所以A和B选项是错误的。+ F# N3 M! Q# i
1 Z  ~2 h3 Q8 Y* P# A9 ~8 D
　　选项C不是一个C语言的语句，因为它不是以分号作为结束标志的。+ l/ l; t( T* L( K  h

　　答：D

TOP

‹‹ 上一主题 | 下一主题 ››