C程序设计

第3章 数据类型、运算符与表达式 3.1 Ｃ语言的数据类型 第3章 数据类型、运算符与表达式 3.1 Ｃ语言的数据类型 算法处理的对象是数据，而数据是以某种特定的形式存在的（例如整数、实数、字符等形式）。不同的数据之间往往还存在某些联系（例如由若干个整数组成一个整数数组）。所谓数据结构指的是数据的组织形式。例如，数组就是一种数据结构。处理同一类问题，如果数据结构不同，算法也会不同。例如，对10个整数排序和对由10个整数构成的数组排序的算法是不同的。因此，在考虑算法时，必须注意数据结构。实际上，应当综合考虑算法和数据结构，选择最佳的数据结构和算法。 C语言的数据结构是以数据类型形式出现的。

C的数据类型如下：

C语言中数据有常量与变量之分，它们分别属于以上这些类型。由以上这些数据类型还可以构成更复杂的数据结构。例如利用指针和结构体类型可以构成表、树、栈等复杂的数据结构。 在程序中对用到的所有数据都必须指定其数据类型。

3.2 常量与变量 3.2.1 常量和符号常量 在程序运行过程中，其值不能被改变的量称为常量。常量区分为不同的类型，如12、0、-3为整型常量，4.6、-1.23为实型常量，’a’、’d’为字符常量。常量一般从其字面形式即可判别。这种常量称为字面常量或直接常量。 也可以用一个标识符代表一个常量，该标识符称为符号常量，即标识符形式的常量。 常量是以二进制的形式存储在计算机中 整数 是以补码的形式转化为二进制代码存储在计算机中的 实数 是以IEEE754标准转化为二进制代码存储在计算机中的。 字符的本质实际也是与整数的存储方式相同。 举例： //printf("%d %d %d\n", 12, 0, -3); //printf("%f %f %f\n", 4.6, -1.23, 0.0); //printf("%c %c %c\n", 'a', 'b', 'd');

[例3.1]符号常量的使用 #define PRICE 30 main() { int num, total; num=10; total=num* PRICE; printf(“total=%d”, total); }

符号常量不同于变量，它的值在其作用域（本例中为主函数）内不能改变，也不能再被赋值。 习惯上，符号常量名用大写，变量名用小写，以示区别。使用符号常量的好处是： （1）含义清楚 （2）在需要改变一个常量时能做到“一改全改”。

3.2.2 变量 其值可以改变的量称为变量。一个变量应该有一个名字，在内存中占据一定的存储单元。在该存储单元中存放变量的值。变量名实际上是一个符号地址，在对程序编译连接时由系统给每一个变量名分配一个内存地址。在程序中从变量中取值，实际上是通过变量名到相应的内存地址，从其存储单元中读取数据。 程序演示： 1、什么是变量？ 2、变量为什么要初始化； 3、变量赋值必须符合相应数据类型；

用来标识变量名、符号常量名、函数名、数组名、类型名、文件名的有效字符序列称为标识符(identifier)。 C语言规定标识符只能由字母、数字和下划线三种字符组成，且第一个字母必须为字母或下划线。 合法的标识符，也是合法的变量名： sum, average, _total, Class, day, month, Student_name, tan, lotus_1_2_3, BASIC, x_h_b 不合法的标识符和变量名： M.D.John, ￥123, #33, 3D64, a>b 注意，大写字母和小写字母被认为是两个不同的字符。因此，sum和SUM，Class和class是两个不同的变量名。一般，变量名用小写字母表示，与人们日常习惯一致，以增加可读性。

在C语言中，要求对所有用到的变量作强制定义，也就是“先定义，后使用”。这样做的目的是： (1)凡未被事先定义的，不作为变量名，这就能保证程序中变量名使用得正确。 (2)每一个变量被指定为一确定类型，在编译时就能为其分配相应的存储单元。 (3)指定每一变量属于一个类型，这就便于在编译时，据此检查该变量所进行的运算是否合法。 举例： (1) int student; student=10; printf(“%d”,stuent); //在这里stuent打错了，如果声明了变量，就知道这错误了。 (3) //float a, b; //a=10; //b=3; //printf(“%d”, a%b); //在这就知道a%b是错的，因为a和b都是float类型，而 %运算只能是整型。 //printf("%d", sizeof('a'));

3.3 整型数据 3.3.1 整型常量的表示方法 整型常量即整常数。C整常数可用以下三种形式表示： (1)十进制整数。如123，-456，0。 (2)八进制整数。以数字0开头的数是八进制数。如0123表示八进制数123，-011表示八进制数-11。 (3)十六进制整数。以0x开头的数是十六进制数。如0x123代表十六进制数123，-0x12等于十六进制数-12。 程序演示： 1、不同进制的表示； //printf("%d %d %d\n", 123, -456, 0); //printf("%d %d\n", 0123, -011); //printf("%d %d\n", 0x123, -0x12);

3.3.2 整型变量 1、整型数据在内存中的存放形式 数据在内存中是以二进制形式存放的。 int i; i=10; 原码、反码、补码的表示 原码： 也叫符号绝对值码。最高位0表示正，1表示负，其余二进制位是数字的绝对值的二进制位。 原码简单易懂，加减运算负责，存在加减乘除四种运算，增加了CPU运算的复杂度； 反码： 反码运算不便，也没有在计算机中应用； 补码： 已知十进制求二进制 求正整数的二进制 除2取余，直至商为零，余数倒序排序； 求负数的二进制 先求与该负数相对应的正整数的二进制代码，然后将所有位取反，末尾加1，不够位数时，左边补1。 求零的二进制 全是零 已知二进制求十进制 如果首位是0，则表明是正整数，按普通方法求； 如果首位是1，则表明是负整数 将所有位取反，末尾加1，所得的数字就是该负数的绝对值

int i; i=-10;

2、整型变量的分类 整型变量的基本类型符为int。可以根据数值的范围将变量定义为基本整型、短整型或长整型。在int之前可以根据需要分别加上修饰符：short(短型)或long(长型)。因此有以下三种整型变量： （1）基本整型，以int表示。 （2）短整型，以short int表示，或以short表示。 （3）长整型，以long int表示，或以long表示。 为了充分利用变量的表数范围，可以将变量定义为“无符号”类型。对以上三种都可以加上修饰符unsigned，以指定是“无符号数”。如果加上修饰符signed，则指定是“有符号数”。如果既不指定为signed，也不指定为unsigned，则隐含为有符号。

归纳起来，可以用以下6种整型变量。即： 有符号基本整型 [signed] int 无符号基本整型 unsigned [int] 有符号短整型 [signed] short [int] 无符号短整型 unsigned short [int] 有符号长整型 [signed] long [int] 无符号长整型 unsigned long [int]

表3.1 ANSI标准定义的整数类型 类型 比特数 最小取值范围 [signed] int 16 -32768~32767(-215~215-1) unsigned [int] 0~65535(0~216-1) [signed] short [int] unsigned short [int] long [int] 32 -2147483648~2147483647 (-231~231-1) unsigned long [int] 0~4294967295(0~232-1)

3、整型变量的定义 [例3.2]整型变量的定义与使用 main() { int a, b, c, d; unsigned u; a=12; b=-24; u=10; c=a+u; d=b+u; printf(“a+u=%d, b+u=%d\n”, c, d); }

4、整型数据的溢出 在Turbo C中一个int型变量的最大允许值为32767，如果再加1，会出现什么情况？ [例3.3]整型数据的溢出 main() { int a, b; a=32767; b=a+1; printf(“%d,%d”, a, b); } VC中执行 #include <stdio.h> int main(void) { int i,j; i=2147483647; //2的31此方-1 j=i+1; printf("%d",j); }

3.3.3 整型常量的类型 在将一个整型常量赋值给上述几种类型的整型变量时如何做到类型匹配？请注意以下几点： (1)一个整数，如果其值在-32768～32767范围内，认为它是int型，它可以赋值给int型和long int型变量。 (2)一个整数，如果其值超过了上述范围，而在-2147483648～2147483647范围内，则认为它是长整型，可以将它赋值给一个long int型变量。 (3)如果某一计算机系统的C版本确定short int与int型数据在内存中占据的长度相同，则它的表数范围与int型相同。因此，一个int型的常量也同时是一个short int型常量，可以赋给int型或short int型变量。 (4)一个整常量后面加一个字母u或U，认为是unsigned int型，如1234u，在内存中按unsigned int规定的方式存放。 (5)在一个整常量后面加一个字母l或L，则认为是long int型常量。

3.4 浮点型数据 3.4.1 浮点型常量的表示方法 浮点数(floating-point number)就是实数(real number)。浮点数有两种表示形式： (1)十进制小数形式。它由数字和小数点组成。0.123、123.、123.0、0.0都是十进制小数形式。 (2)指数形式。如123e3或123E3都代表123×103。注意字母e或E之前必须有数字，且e后面的指数必须为整数，如e3、2.1e3.5、e3、e都不是合法的指数形式。 //printf(“%f %f %f %f”, 0.123, 123., 123.0, 0.0); //float型数据，小数点后6位 //printf("%f %f %f", 123.456e0, 12.3456e1, 1234.56e-1);

3.4.2 浮点型变量 1、浮点型数据在内存中的存放形式

2、浮点型变量的分类 浮点型变量分为单精度(float)型、双精度(double)型和长双精度(long double)型3类。在Turbo C中有关浮点型的数据见下表。 类型 比特数 有效数字 数值范围 float 32 6~7 -3.4×10-38~3.4×1038 double 64 15~16 -1.7×10-308~1.7×10308 long double 128 18~19 -1.2×10-4932~1.2×104932

对每一个实型变量都应在使用前加以定义。如： float x, y; double z; long double t; printf("%f\n", x); printf("%lf\n", z); printf("%lf\n", t);*/

3、浮点型数据的舍入误差 由于浮点型变量是由有限的存储单元存储的，因此能提供的有效数字总是有限的，在有效位以外的数字将被舍去。由此可能会产生一些误差。 [例3.4]实型数据的舍入误差 main() { float a, b; a=123456.789e5; //float型变量有效位数是7位 b=a+20; printf(“%f”, b); }

3.4.3 浮点型常量的类型 C语言编译系统将浮点型常量作为双精度来处理。 f=2.45678*4523.65 如果是在数的后面加字母f和F(如1.65f、654.87F)，这样编译系统就会按单精度处理。 一个浮点型常量可以赋给一个float型、double型或long double变量。根据变量的类型截取浮点型常量中相应的有效位数字。假如a已指定为单精度浮点型变量： float a; a=111111.111; //float f; //double f; //f=2.45678*4523.65; //两个常量先转换为double型计算，正常结果应为11113.612847 //printf(“%lf\n”, f); //f是float型，只能取7位有效数字，所以前7位才是正确的，而后7位不能正确表示，这就是误差 //double a; //a=111111.111; //printf(“%f”, a); //printf("\x3f");

3.5 字符型数据 3.5.1 字符常量 C语言的字符常量是用单撇号括起来的一个字符。如’a’、’x’、’D‘、’?’、‘$’等都是字符常量。 除了以上形式的字符常量外，C还允许用一种特殊形式的字符常量，就是以一个字符“\”开头的字符序列。 常用的以“\”开头的特殊字符见下表。 /*char c1, c2; c1='a'; c2='b'; printf("%c %c\n", c1, c2);*/

转义字符及其作用 字符形式 含义 ASCII代码 \n 换行，将当前位置移到下一行开头 10 \t 水平制表(跳到下一个Tab位置) 9 退格，将当前位置移到前一列 8 \r 回车，将当前位置移到本行开头 13 \f 换页，将当前位置移到下页开头 12 \\ 代表一个反斜杠字符"\" 92 \' 代表一个单引号字符 39 \” 代表一个双引号字符 34 \a 鸣铃 7 \ddd 1到3位八进制数所代表的字符 \xhh 1到2位十六进制数所代表的字符 //printf(“\x3f”); //x3f是用十六进制表示的？字符

[例3.5]转义字符的使用 #include <stdio.h> void main() { printf(“ㄩ abㄩc\tㄩde\rf\tg\n”); printf(“h\ti\b\bjㄩk\n”); }

3.5.2 字符变量 字符变量用来存放字符常量，它只能放一个字符，不要以为在一个字符变量中可以放一个字符串 字符变量的定义形式如下： char c1, c2; c1=‘a’; c2=‘b’; 在所有的编译系统中都规定以一个字节来存放一个字符，或者说一个字符变量在内存中占一个字节

3.5.3 字符数据在内存中的存储形式及其使用方法 将一个字符常量放到一个字符变量中，并不是把该字符本身放到内存单元中去，而是将该字符的相应的ASCII代码放到存储单元中。例如字符’a’的ASCII代码为十进制数97，’b’的ASCII代码为十进制数98，在内存中变量c1、c2的值如下图(a)所示。实际上是以二进制形式存放的，如图(b)所示。 ASCII不是一个值，而是一种规定； ASCII规定了不同的字符时使用哪个整数值去表示，如 ‘A’ 65 ‘B’ 66 ‘a’ 97 ‘b’ 98 ‘0’ 48 补充程序： 1、什么是ASCII.CPP；

在内存中字符数据以ASCII码存储，它的存储形式就与整数的存储形式类似。这样使字符型数据和整型数据之间可以通用。一个字符数据既可以以字符形式输出，也可以以整数形式输出。以字符形式输出时，需要先将存储单元中的ASCII码转换成相应字符，然后输出。以整数形式输出时，直接将ASCII码作为整数输出。也可以对字符数据进行算术运算，此时相当于对它们的ASCII码进行算术运算。

[例3.6]向字符变量赋予整数 #include <stdio.h> void main() { char c1, c2; printf("%c %c\n", c1, c2); printf("%d %d\n", c1, c2); }

[例3.7]大小写字母的转换 #include <stdio.h> void main() { char c1, c2; c1='a'; c2='b'; c1=c1-32; c2=c2-32; printf("%c %c", c1, c2); }

3.5.4 字符串常量 字符常量是由一对单撇号括起来的单个字符。C语言除了允许使用字符常量外，还允许使用字符串常量。字符串常量是一对双撇号括起来的字符序列。例如下面是合法的字符串常量： “How do you do.”，”CHINA”，”a”，”$123.45” 可以输出一个字符串，例如： printf(“How do you do.”); 不要将字符常量与字符串常量混淆。’a’是字符常量，”a”是字符串常量，二者不同。 C规定：在每一个字符串常量的结尾加一个“字符串结束标志”，以便系统据此判断字符串是否结束。C规定以字符’\0’作为字符串结束标志。’\0’是一个ASCII码为0的字符。

“CHINA”在内存中是： Char c; C=“a” //错误，”a”在内存表示为 a \0

3.6 变量赋初值 程序中常需要对一些变量预先设置初值。C语言允许在定义变量的同时使变量初始化。例如： int a=3; float f=3.56; char c=‘a’; 也可以使被定义的变量的一部分赋初值。例如： int a, b, c=5; 如果对几个变量赋予同一个初值，应写成： int a=3, b=3, c=3; 不能写成： int a=b=c=3; //char c1; //c1='a'; //int a=3; //int a; //a=3;

初始化不是在编译阶段完成的（只有在第8章中介绍的静态存储变量和外部变量的初始化是在编译阶段完成），而是在程序运行时执行本函数时赋初值的，相当于一个赋值语句。例如： int a=3; 相当于： int a; a=3; 又如： int a, b, c=5; int a, b, c; c=5;

3.7 各类数值型数据间的混合运算 整型(包括int、short、long)和浮点型(包括float、double)可以混合运算。字符型数据可以与整型通用，因此，整型、浮点型、字符型数据间可以混合运算。例如： 10+’a’+1.5-8765.1234*’b’ 在进行运算时，不同类型的数据要先转换成同一类型，然后进行运算。转换的规则按下图所示。

int i; float f; double d; long e; 10+’a’+i*f-d/e 水平方向：无条件进行转换 垂直方向：运算对象为不同类型时按方向转换 //printf("%lf", 10+'a'+1.5-8765.1234*'b');

3.8 算术运算符和算术表达式 3.8.1 C语言运算符简介 C语言的运算符范围很宽，把除了控制语句和输入输出以外的几乎所有的基本操作都作为运算符处理，例如将赋值符“=”作为赋值运算符、方括号作为下标运算符等。

Ｃ语言的运算符有以下几类： (1)算术运算符 (+ - * / %) (2)关系运算符 (> < == >= <= !=) (3)逻辑运算符 (! && ||) (4)位运算符 (& | ~ ^ << >>) (5)赋值运算符 (=及其扩展赋值运算符) (6)条件运算符 (? :) (7)逗号运算符 (,) (8)指针运算符 (* &) (9)求字节数运算符 (sizeof) (10)强制类型转换运算符 ((类型)) (11)分量运算符 (. ->) (12)下标运算符 ([]) (13)其他 (如函数调用运算符())

3.8.2 算术运算符和算术表达式 1、基本的算术运算符 (1) +(加法运算符，或正值运算符，如3+5、+3) (2) –(减法运算符，或负值运算符，如5-2、-3) (3) *(乘法运算符，如3*5) (4) /(除法运算符，如5/3) (5)%(模运算符，或称求余运算符，%两侧均应为整型数据，如7%4的值为3) （只能用于整形数据运算） //printf("%d\n", 5%2);

2、算术表达式和运算符的优先级和结合性 用算术运算符和括号将运算对象（也称操作数）连接起来的、符合C语法规则的式子，称C算术表达式。运算对象包括常量、变量、函数等。 例如，下面是一个合法的C算术表达式： a*b/c-1.5+’a’

C语言规定了运算符的优先级和结合性。在表达式求值时，先按运算符的优先级别高低次序执行，例如先乘除后加减。如表达式a-b C语言规定了运算符的优先级和结合性。在表达式求值时，先按运算符的优先级别高低次序执行，例如先乘除后加减。如表达式a-b*c，b的左侧为减号，右侧为乘号，而乘号优先于减号，因此，相当于a-(b*c)。如果在一个运算对象两侧的运算符的优先级别相同，如a-b+c，则按规定的“结合方向”处理。

C语言规定了各种运算符的结合方向(结合性)，算术运算符的结合方向为“自左至右”，即先左后右，因此b先与减号结合，执行a-b的运算，再执行加c的运算。“自左至右的结合方向”又称“左结合性”，即运算对象先与左面的运算符结合。以后可以看到有些运算符的结合方向为“自右至左”，即右结合性(例如，赋值运算符)。 如果一个运算符的两侧的数据类型不同，则会按3.7节所述，先自动进行类型转换，使二者具有同一种类型，然后进行运算。

3、强制类型转换运算符 可以利用强制类型转换运算符将一个表达式转换成所需类型。例如： (double)a (int)(x+y) (float)(5%3) 其一般形式为： (类型名)(表达式) 注意，表达式应该用括号括起来。如果写成 (int)x+y 则只将x转换成整型，然后与y相加。 需要说明的是，在强制类型转换时，得到一个所需类型的中间变量，原来变量的类型未发生变化。例如： (int)x 如果已定义x为float型，进行强制类型运算后得到一个int型的中间变量，它的值等于x的整数部分，而x的类型不变。 例题： double(5/2) =2.0 double(5)/2=2.5 注意二者的区别

[例3.8]强制类型转换 #include <stdio.h> void main() { float x; int i; i=(int)x; printf(“x=%f, i=%d\n”, x, i); }

4、自增、自减运算符 作用是使变量的值增1或减1，例如： ++i，--i i++，i-- 粗略地看，++i和i++的作用相当于i=i+1。但++i和i++不同之处在于++i是先执行i=i+1后，再使用i的值；而i++是先使用i的值后，再执行i=i+1。如果i的原值等于3，请分析下面的赋值语句： j=++i; j=i++; 又例如： i=3; printf(“%d”, ++i); 输出“4”。若改为 printf(“%d”, i++); 则输出“3”。 /*int i; i=3; printf("%d\n", -i++); printf("%d\n", i);*/

注意： （1）自增运算符（++）和自减运算符（--）只能用于变量，而不能用于常量或表达式，如5++或(a+b)++都是不合法的。 （2）++和--的结合性是“自右至左”。 （3）自增（减）运算符常用于循环语句中，使循环变量自动加1；也用于指针变量，使指针指向下一个地址。 （1）int I,j; i=3; j=4; (i+j)--; //这是错误的，自增减运算不能用于表达式。 （3）/*int i; printf("%d\n", -i++); printf("%d\n", i);*/ /*or(int i=10; i>=1; i--) { printf("i=%d\n", i); }*/

5、有关表达式使用中的问题说明 (1)C运算符和表达式使用灵活，利用这一点可以巧妙地处理许多在其他语言中难以处理的问题。但是应当注意：ANSI C并没有具体规定表达式中的子表达式的求值顺序，允许各编译系统自己安排。 (2)C语言中有的运算符为一个字符，有的运算符由两个字符组成，在表达式中如何组合呢？ (3)在调用函数时，实参数的求值顺序，C标准并无统一规定。 对（1）的解释 int i=3; printf(“%d%d”,(i++)+(i++)+(i++),i); 不同编译器对这条语句的理解是不同的。有的可以是3+4+5 ，也有的是3+3+3 ，但i的值都应该是6。 对 （2）的解释 i++j 应该是由左向右结合，解释为（i++)+j，应尽量减少这种歧义。 （3）int i=3; printf(“%d%d”,i,i++) //不同的编译器计算的结果可能有不同，看从左至右或是从右至左。在VC中是从左至右，所以结果为3 3

3.9 赋值运算符和赋值表达式 1、赋值运算符 赋值符号“=”就是赋值运算符，它的作用是将一个数据赋给一个变量。如“a=3”的作用是执行一次赋值操作(或称赋值运算)。把常量3赋给变量a。也可以将一个表达式的值赋给一个变量。

2、类型转换 如果赋值运算符两侧的类型不一致，但都是数值型或字符型时，在赋值时要进行类型转换。 (1)将浮点型数据（包括单、双精度）赋给整型变量时，舍弃实数的小数部分。 (2)将整型数据赋给单、双精度变量时，数值不变，但以浮点数形式存储到变量中。 (3)将一个double型数据赋给float变量时，截取其前面7位有效数字，存放到float变量的存储单元(32位)中。但应注意数值范围不能溢出。将一个float型数据赋给double变量时，数值不变，有效位数扩展到16位，在内存中以64位存储。 1、int i; i=3.12; //结果为3 2、float f; double d; f=i; //f为3.000000，7位有效数 d=i; //d为3.000000,16位有效数 sizeof(f) sizeof(d)

(4)字符型数据赋给整型变量时，由于字符只占1个字节，而整型变量为2个字节，因此将字符数据(8位)放到整型变量低8位中。

字符型数据赋给整型变量： 1、如果所用系统将字符处理为无符号的量或对unsigned char型变量赋值，则将字符的8位放到整型变量低8位，高8位补零。 C=‘\376’ 是八进制 对应的十进制数是254 在这如果定义 unsigned char c; 则输出i结果为254 如果定义 char c，则结果为-2，因为char 默认为有符号数。 /*signed char c; c='\376'; int i; i=c; printf("%d", i);*/

2、如果所用系统将字符处理为带符号的（即signed char），若字符最高位为0，则整型变量高8位补0；若字符最高位为1，则高8位全补1。这称为”符号扩展”，这样做的目的是使数值保持不变。

(5)将一个int、short、long型数据赋给一个char型变量时，只将其低8位原封不动地送到char型变量（即截断）。例如： int i=289; char c=‘a’; c=i; /*int i=289; char c=i; printf("%c", c);*/

(6)将带符号的整型数据(int型)赋给long型变量时，要进行符号扩展，将整型数的16位送到long型低16位中，如果int型数据为正值(符号位为0)，则long型变量的高16位补0；如果int型变量为负值(符号位为1)，则long型变量的高16位补1，以保持数值不改变。反之，若将一个long型数据赋给一个int型变量，只将long型数据中低16位原封不动地送到整型变量(即截断)。例如： int a; long b=8; a=b;

(7)将unsigned int型数据赋给long int型变量时，不存在符号扩展问题，只需将高位补0即可。将一个unsigned类型数据赋给一个占字节数相同的整型变量(例如：unsigned int->int，unsigned long->long，unsigned short->short)，将unsigned型变量的内容原样送到非unsigned型变量中，但如果数据范围超过相应整数的范围，则会出现数据错误。如： unsigned int a=65535; int b; b=a;

(8)将非unsigned型数据赋给长度相同的unsigned型变量，也是原样照赋（连原有的符号位也作为数值一起传送）。如： [例3.9]有符号数据传送给无符号变量 main() { unsigned a; int b=-1; a=b; printf(“%d”, a); } /*unsigned int a; signed int b=-1; a=b; printf("%u\n", a);*/

3、复合的赋值运算符 在赋值符“=”之前加上其他运算符，可以构成复合的运算符。例如： a+=3 等价于 a=a+3 x*=y+8 等价于 x=x*(y+8) x%=3 等价于 x=x%3 凡是二元(二目)运算符，都可以与赋值符一起组合成复合赋值符。C语言规定可以使用10种复合赋值运算符。即： += -= *= /= %= <<= >>= &= ^= |=

4、赋值表达式 由赋值运算符将一个变量和一个表达式连接起来的式子称为“赋值表达式”。它的一般形式为： <变量> <赋值运算符> <表达式> 赋值运算符左侧的标识符称为“左值”(left value)。并不是任何对象都可以作为左值的，变量可以作为左值，而表达式a+b就不能作为左值，常变量也不能作为左值，因为常变量不能被赋值。出现在赋值运算符右侧的表达式称为“右值”(right value)。显然左值也可以出现在赋值运算符右侧，因而凡是左值都可以作为右值。

赋值表达式中的“表达式”，又可以是一个赋值表达式。例如： a=(b=5) a=b=c=5 a=5+(c=6) a=(b=4)+(c=6) a=(b=10)/(c=2) a+=a-=a*a 将赋值表达式作为表达式的一种，使赋值操作不仅可以出现在赋值语句中，而且可以以表达式形式出现在其他语句（如输出语句、循环语句等）中，如： printf(“%d”, a=b); //int a; //int b; //int c; //a=1; //b=2; //c=3; //a=(b=5); //a和b都等于5 //a=b=c=5; //a、b、c和表达式的值都为5 //a=(b=4)+(c=6); //表达式的值为10，a的值为10 ，b的值为4，c的值为6 //a=(b=10)/(c=2); // //printf("%d", a=b); //printf("a=%d\n", a); //printf("b=%d\n", b); //printf("c=%d\n", c); a=12 a+=a-=a*a 等价于 (1) a=a-a*a ，结果为-132 (2) a=a+(-132) ，结果为 -264

3.10 逗号运算符和逗号表达式 C语言提供一种特殊的运算符—逗号运算符。用它将两个表达式连接起来。例如： 3+5, 6+8 称为逗号表达式，又称“顺序求值运算符”。逗号表达式的一般形式为： 表达式1, 表达式2 逗号表达式的求解过程是：先求解表达式1，再求解表达式2。整个逗号表达式的值是表达式2的值。 一个逗号表达式又可以与另一个表达式组成一个新的逗号表达式，例如： (a=3*5, a*4), a+5 逗号表达式的一般形式可以扩展为 表达式1, 表达式2, 表达式3, …, 表达式n 1、x=(a=3,6*3) a=3,x=18 2、x=a=3,6*3 a=3 x=3 表达式为18

习题 3.6写出以下程序的运行结果： #include <stdio.h> void main() { char c1=‘a’, c2=‘b’, c3=‘c’, c4=‘\101’, c5=‘\116’; printf(“a%cb%c\tc%c\tabc\n”, c1, c2, c3); printf(“\t\b%c%c\n”, c4, c5); }

3.7要将“China”译成密码，密码规律是：用原来的字母后面第4个字母代替原来的字母。例如，字母“A”后面第4个字母是”E“，用”E“代替”A”。因此，“China”应译为“Glmre”。请编一程序，用赋初值的方法使c1、c2、c3、c4、c5这5个变量的值分别为’C‘、’h‘、’I‘、’n’、‘a’，经过运算，使c1、c2、c3、c4、c5分别变为‘G’、‘l’、‘m’、‘r’、‘e’，并输出。

3.8 例3.6能够改成如下： #include <stdio.h> void main() { int c1, c2; c1=97; c2=98; printf(“%c %c\n”, c1, c2); printf(“%d %d\n”, c1, c2); }

3.9求下面算术表达式的值 (1)x+a%3*(int)(x+y)%2/4 设x=2.5, a=7, y=4.7 (2)(float)(a+b)/2+(int)x%(int)y 设a=2, b=3, x=3.5, y=2.5

3.10写出下面程序的运行结果 #include <stdio.h> void main() { int i, j, m, n; i=8; j=10; m=++i; n=j++; printf(“%d, %d, %d, %d\n”, i, j, m, n); }

3.11写出下面赋值的结果 int 99 42 char ‘d’ unsigned int 76 65535 float 53.65 long int 68

3.12写出下面赋值表达式运算后a的值，设原来a=12: (4)a/=a+a (5)a%=(n%=2), n的值等于5 (6)a+=a-=a*=a