结构化编程基础
第 2 章 结构化编程基础
2.1 常用数据类型
实例1. 数值型常量的表示与使用
include <stdio.h>
void main()
{
printf("八进制整型：\n");
printf("%o,%d\n",015,015);
printf("%o,%d\n",0101,0101);
printf("%o,%d\n",0177777,0177777);
printf("十六进制整型：\n");
printf("%x,%d\n",0x2A,0x2A);
printf("%X,%d\n",0XA0,0XA0);
printf("%x,%d\n",0XFFFF,0XFFFF);
printf("%x,%d\n",0X124,0X124);
printf("八进制长整型：\n");
printf("%Lo,%d\n",077L,077L);
printf("%Lo,%ld\n",0200000L,0200000);
printf("%0x,%d\n",0X124,0X124);
printf("十六进制长整型：\n");
printf("%lx,%d\n",0X15L,0X15L);
printf("%LX,%d\n",0XA5L,0XA5L);
printf("%Lx,%d\n",0x10000L,0x10000L);
printf("%lx,%d\n",0X124,0X124);
printf("%Lx\n",0X456987L);
printf("实数常量的表示与输出：\n");
printf("%f\n",356.);
printf("%f\n",356);
printf("%f\n",356f);
printf("数字字符与其 ASCII 值的表示与输出：\n");
printf("'5'=%c,'5'=%d,'5'+5=%d\n",'5','5','5'+5);
}
请读者自行运行程序并分析运行结果。
十进制表示的长整型常数，在数值后面加字母 L 或 l。如：
65124L、12L、-567L、158L、35800L
八进制表示的长整型常数。如：
012L 、077L、0200000L
十六进制表示的长整型常数。如：
0X15L、0XA5L、0X10000L、0X456987L。
长整数 158L 和基本整常数 158 在数值上并无区别。但对 158L，因为是长整型量，Ｃ编译系统将为它分
配 4 个字节存储空间。而对 158，因为是基本整型，只分配 2 个字节的存储空间。因此在运算和输出格式上
要予以注意，避免出错。
实例2. 转义字符的使用与转义字符的 ASCII 测试输出
include <stdio.h>
void main()
{
int a=5,b=6,c=7; //定义三个整型变量并初始化
printf("a=%d\tb=%d\tc=%d\tde\rf\n",a,b,c); // 测试转义字符\t \r \n 的作用
printf("'=%d;\=%d;"=%d\n",''','\','"'); //测试转义字符',\,"的 ASCII 值
printf("\v=%d;\n=%d;\r=%d\n",'\v','\n','\r'); //测试转义字符\v,\n,\r
}
程序运行结果为：
f=5 b=6 c=7 de
'=39; =92; ”=34
\v=11; \n=10; \r=13
【程序解析】
⑴输出函数 printf("a=%d\tb=%d\tc=%d\tde\rf\n",a,b,c)中，执行 a=%d\tb=%d\tc=%d\tde 时，输出本应该为：
a=5 b=6 c=7 de
但执行到\rf 时，由于\r 的作用是执行回车，该操作将光标置于行的开始出，再输出 f，则输出字符的字母
f 把最先输出的字符 a 给覆盖了，结果显示为 a=5。实质上输出的 a=5，但后来输出的字母 f 把最先输出的字
母 a 覆盖了。所以最开始显示为 f=5。
⑵输出函数 printf("'=%d;\=%d;"=%d\n",''','\','"')中，'=%d;\=%d;"=%d 的作用是分别输出单引号字符、
反斜杠字符、双引号本身及其 ASCII 的值。
实例3. 符号常量、变量的使用
define PI 3.1415926 //定义了符号常量 PI
include <stdio.h>
void main()
{
int r=10; //定义一个整型变量并初始化
double area; //定义一个双精度变量
int a=3,b=32735,c='A'; //定义变量并初始化
int x,y,z; //定义变量未初始化
long d;
unsigned u;
x=y=z=123; //赋值运算的嵌套，从右到左依次赋值
printf("a=%d,b=%d,c=%d\n",a,b,c);
u=c+a;
d=b+c;
printf("a+c=%d,b+c=%ld\n",u,d);
printf("x+y+z=%u\n",x=y+z);
}
【说明】
符号常量与变量不同，它的值在其作用域内不能改变，也不能再被赋值。
使用符号常量的好处是：含义清楚；能做到“一改全改”。
符号常量的有效范围是从定义点到本程序结束或者遇上定义撤销命令。
C 语言中定义变量时不允许连续初始化（赋值），如 int x=y=z=123 是不合法的。x=y=z=123 作为赋值
语句是合法的，实质是赋值运算的嵌套。
x, y 是长整型变量，a, b 是基本整型变量。它们之间允许进行混合运算，运算结果为长整型。但 c，
d 被定义为基本整型，因此最后结果为基本整型。
不同类型的量可以参与运算并相互赋值。其中的类型转换是由编译系统自动完成的。有关类型转换
的规则将在以后介绍。
实例4. 测试数据类型占用的存储空间及其实数的精度
include <stdio.h>
include <float.h>
void main()
{
int x=3; //定义整型变量
short y=3; //定义短整型变量
long z=3; //定义长整型变量
unsigned int ux=3; //定义无符号整型变量
unsigned short yu=3; //定义无符号短整型变量
unsigned long zu=3; //定义无符号长整型变量
printf("sizeof(int):%d\n",sizeof(x));
printf("sizeof(short):%d\n",sizeof(y));
printf("sizeof(long):%d\n",sizeof(z));
printf("sizeof(unsigned int):%d\n",sizeof(xu));
printf("sizeof(unsigned short):%d\n",sizeof(yu));
printf("sizeof(unsigned long):%d\n",sizeof(zu));
float a=3.12345678901234567890; //定义单精度浮点数变量
//定义双精度浮点数变量
double x=1.791234567890123456789E+308,y=1.791234567890123456789E-308;
//定义长双精度浮点数变量
long double m=1.791234567890123456789E+308,n=1.791234567890123456789E-308;
printf("float a=%f\n", a);
printf("double MAX=%.19e\n", x);
printf("double MIN=%.19e\n", y);
printf("long double MAX=%.19le\n", m);
printf("long double MIN=%.19Le\n", n);
printf("sizeof(float):%d\n",sizeof(float));
printf("sizeof(double):%d\n",sizeof(double));
printf("sizeof(long double):%d\n",sizeof(long double));
float b;
double y;
b=1234.567890E5f;
y=3333.55555555555;
printf("b=%f\ny=%lf\n",b,y);
}
自己分析程序运行结果。
实例5. 字符型变量赋以整数实例
include <stdio.h>
void main()
{
char a,b;
a=120;
b=121;
printf("%c,%c\n",a,b);
printf("%d,%d\n",a,b);
a=a-32;
b=b-32;
printf("%c,%c\n%d,%d\n",a,b,a,b);
}
程序运行结果为：
x,y
120,121
X,Y
88,89
【程序解析】
⑴定义 a，b 为字符型，在赋值语句中赋以整型值。从程序运行结果看，a，b 值的输出形式取决于 printf
函数格式串中的格式控制符，当格式符为"%c"时，变量对应的输出为字符形式，当格式控制符为"%d"时，变量
值对应的输出为整数（字符的 ASCII 值本身）。
⑵Ｃ语言允许字符变量参与数值运算，即用字符的 ASCII 值参与运算。同一个英文字母其大小写的 ASCII
值相差 32，因此运算后把小写字母换成大写字母。然后分别以整型和字符型输出。
2.2 运算符与表达式
实例6. 算术运算符运算规则实例解析
include <stdio.h>
void main()
{
printf("-20/7=%d ，20/7=%d ， 20/-7=%d\n",-20/7,20/7,20/-7);
printf("20.0/7=%.2f ， -20.0/7=%.2f\n",20.0/7,-20.0/7);
printf("100%%3=%d ， 3%%100=%d\n",100%3,3%100);
printf("5.0/2=%.2f ， 5/2.0=%0.2f ，5.0/2.0=%.2f\n",5.0/2,5/2.0,5.0/2.0);
printf("2.0/5=%0.2f ，2/5.0=%.2f ，2.0/5.0=%.2f\n",2.0/5,2/5.0,2.0/5.0);
}
程序运行结果：
-20/7=-2 ，20/7=2 ， 20/-7=-2
20.0/7=2.86 ， -20.0/7=-2.86
100%3=1 ， 3%100=3
5.0/2=2.50 ， 5/2.0=2.50 ，5.0/2.0=2.50
2.0/5=0.40 ，2/5.0=0.40 ，2.0/5.0=0.40
【程序解析】
⑴本例中，为了便于对照理解，输出了各“运算表达式”本身。如。100%%3 是为了输出 100%3 这个表达
式，“%%”输出%本身。格式控制符“%.2f”中的.2 表示输出时保留两位小数。
⑵-20/7，20/7，20/-7 的结果均为整型，求整商值（小数被裁去）。
⑶20.0/7 和-20.0/7 由于有实数参与运算，结果为实型。
⑷求余运算符%：双目运算，具有左结合性。要求参与运算的量均为整型。运算结果等于两数相除后的余
数。计算方法：被除数-(商*除数)，当被除数小于除数时，商为 0，余数为被除数本身。比如本例中，3%100，
商为 0，余数为 3。而 100%3，商为 33，余数为 1。
⑸本例中涉及到算术的混合运算，要发生类型的自动转化，整数转化为实型。
实例7. 复合赋值运算规则实例。
分析每个输出语句的输出结果。运行以下程序验证分析结果。掌握复合赋值运算的运算规则。
include "stdio.h"
void main()
{
int a=13;
float b=2.;
printf("a=%d\n",a); //输出 a 变量的值
a/=35;
printf("a/=35 结果为：a=%d\n",a); //输出运算表达式及其运算结果，便于对照分析
a=13;
printf("a=%d\n",a);
a=a/35;
printf("a=a/35 结果为：a=%d\n",a);
printf("b=%.2f\n",b);
b/=35.;
printf("b/=35. 结果为：b=%8.4f\n",b);
b=2.f;
printf("b=%.2f\n",b);
b=b/35.0f;
printf("b=b/35.0f 结果为：b=%8.4f\n",b);
}
分析以下复合赋值运算的结果，上机测试
include "stdio.h"
void main()
{
int a=5,b=9;
printf("运算表达式：a+=b+=a=a+(b=a+(b%%=a))\n"); //输出运算表达式本身
a+=b+=a=a+(b=a+(b%=a));
printf("计算结果：a=%d b=%d\n",a,b);
}
程序运行结果：
运算表达式：a+=b+=a=a+(b=a+(b%=a))
计算结果：a=446 b=241
【程序解析】
表达式：a+=b+=a=a+(b=a+(b%=a))
等价于：a=a+(b=b+(a=a(a+(b=b(a+(b=b%a))))))
等价于：a=a+(b=b+(a=a(a+(b=b(a+(b=9%5)))))) //b=4
等价于：a=a+(b=b+(a=a(a+(b=4(5+4))))) // b=4*(5+4)，b=36 a=5
小括号的优先级是最高的，从内到外依次计算小括号中表达式的值，层层展开计算。
实例8. 数据类型转化及其规则实例
本实例主要验证数据类型的几种转化情况及其转化规则。阅读并分析程序的运行结果，输入程序源程序，
验证分析结果。
include "stdio.h"
void main()
{
float x=6.6,y=9,z,w ;
int a=7,b=8;
z=x+a%3*(int)(x+y)%2/4; //不同类型的数据之间的运算转化
printf("z=%.3f \n",z); //.3f 表示输出时保留 3 位精度
w=(float)(a+b)/2+(int)x%(int)y; // 强制性数据类型转化
printf("w=%.3f\n",w); //.3f 表示输出时保留 3 位精度
x=(int)x; //此语句执行后 x 的类型是什么？
printf("x=%.3f\n",x); //.3f 表示输出时保留 3 位精度
}
程序运行显示结果：
z=6.600
w=13.500
x=6.000
读者自行分析结果
实例9. 利用条件运算符及其嵌套输出三个数的最大和最小值
1、算法之一：利用条件运算符输出三个数的最大和最小值算法。两两先后比较，最后得到最大值。
源代码如下：
include "stdio.h"
void main()
{
int a,b,c,max,min;
printf("输入三个正整数，用空格间隔输入的数：");
scanf(" %d %d %d",&a,&b,&c); //输入函数的使用
max=a>b?a:b; //得到 a、b 的最大值，条件运算符的使用
max=max>c?max:c; //得到 a、b、c 的最大值
min=a>b?b:a; //得到 a、b 的最小值
min=min>c?c:min; //得到 a、b、c 的最小值
printf("最大值：%d\t 最小值：%d\n",max,min);
}
思考题：几个赋值语句“=”的先后顺序可以交换吗？
算法之二：利用条件运算符的嵌套输出三个数的最大值
include "stdio.h"
void main()
{
int a,b,c,m;
printf("输入三个整数[用空格间隔输入的数]：");
scanf(" %d %d %d",&a,&b,&c);
m=a>b? (a>c? a : c) : (b>c? b : c); // 条件运算符的嵌套，注意运算的结合方向
printf("条件运算符的嵌套运用，求三个数的最大值.\n");
printf("三个数(%d ，%d ，%d)的最大值：%d\n",a,b,c,m);
}
运行时输入：65 98 12↙
程序运行结果为：
条件运算符的嵌套运用，求三个数的最大值.
三个数(65，98，12)的最大值：98
【程序解析】
本例中，应用了条件运算符的嵌套，特别注意三个条件运算中条件的建立是关键。a>b，a>c， b>c 三个
条件表达式，其实是三个关系表达式。
实例10. 逻辑运算 a && b && c 的特殊规则
读者先结合理论，静态分析程序的运行结果，再上机运行程序验证并分析运行结果。
include "stdio.h"
void main()
{
int a=0,b=19,c=1,d=0; //定义变量并初始化
printf("a=%d b=%d c=%d d=%d\n",a,b,c,d); //输出变量的初始值
++a && b++ % c++ && ++d; //执行逻辑与运算
printf("++a && b++%%c++ && ++d;\n"); //输出运算表达式本身
printf("a=%d b=%d c=%d d=%d\n",a,b,c,d); //输出运行结果
a=0,b=19,c=1,d=0; //重新初始化变量
printf("\na=0,b=19,c=1,d=0\n"); //输出赋值后的变量值
++a && b++ % ++c && ++d;
printf("++a && b++ % ++c && ++d;\n"); //输出运算表达式本身
printf("a=%d b=%d c=%d d=%d\n",a,b,c,d); //输出执行表达式语句之后各变量的值
}
程序运行结果：
a=0 b=19 c=1 d=0
++a && b++%c++ && ++d;
a=1 b=20 c=2 d=0
a=0,b=19,c=1,d=0
++a && b++ % ++c && ++d;
a=1 b=20 c=2 d=1
【程序解析】
⑴表达式++a&&b++%c++&&++d 中，++a 相当于格式“a&&b&&c”中的 a，++a 为前缀运算，则整个表
达式++a 的结果值为 1，变量 a 的值变为 1。b++%c++相当于格式“a&&b&&c”中的 b，将被计算。b++为后
缀，但 b 的值仍变为 20，c++也是后缀，则表达式 b++%c++等价于 b%c，b++，c++。运算 b%c 的结果值为 0，
相当于格式“a&&b&&c”中的 b 为 0。则++d 不被计算，因此 d 的值不变化。++d 相当于格式“a&&b&&c”
中的 c。因此++a&&b++%c++&&++d 计算之后，变量 a、b、c 的值分别为：1、20、2、0，验证了形如格式
a&&b&&c 的逻辑运算的特殊规则。
⑵表达式 a++ && b++ % ++c && ++d 中，a++相当于格式“a&&b&&c”中的 a，表示式 a++的结果为 0，
因为++是后缀运算，先引用 a 的值为 0，a 再自加。特别注意是表达式本身的运算结果为 0，变量的值自加之
后为 1。根据运算规则，表达式 b++ % ++c 和++d 将不再计算。结果为 a=1，b=20，c=2，d=0。
⑶函数 printf 中的“%%”，用于输出%本身。
实例11. 逻辑运算 a || b || c 运算的特殊规则
a||b||c，运算规则：只有当“表达式 a”的值为假（0 值）时才计算“表达式 b”；只有当“表达式 a”和
“表达式 b”的值均为假（0）时才计算“表达式 c”。先结合理论，静态分析程序运行结果，再上机运行程序
验证并分析结果。
include "stdio.h"
include "stdlib.h" //引用 system()
void main()
{
int a=0,b=19,c=1,d=0;
system("cls"); //清屏幕
printf("a=0,b=19,c=1,d=0\n"); //输出初始值
a++ || b++ % c++ || ++d;
printf("a++ || b++ %% c++ || ++d;\n"); //输出表达式本身
printf("a=%d b=%d c=%d d=%d\n\n",a,b,c,d); //输出运算之后各变量的值
a=0,b=19,c=1,d=0; //修改变量的值，以作之后验证之用
printf("a=0,b=19,c=1,d=0;\n");
++a || b++ % c++ || ++d;
printf("++a || b++ %% c++ || ++d;\n"); //输出表达式本身，%%用于输出%本身
printf("a=%d b=%d c=%d d=%d\n",a,b,c,d); //输出运算之后各变量的值
}
程序运行结果：
a=0,b=19,c=1,d=0
a++ || b++ % c++ || ++d;
a=1 b=20 c=2 d=1
a=0,b=19,c=1,d=0;
++a || b++ % c++ || ++d;
a=1 b=19 c=1 d=0
【程序解析】
⑴表达式 a++ || b++ % c++ || ++d 中，++a 相当于格式“a||b||c”中的 a。a++为后缀运算，a 的初始值为 0，
则整个表达式 a++的结果值为 0，而变量 a 的值变为 1。b++%c++相当于格式“a||b||c”中的 b，将被计算。b++
为后缀，但 b 的值仍变为 20，c++也是后缀，但 c 值本身要变为 2。表达式 b++%c++等价于 b%c，b++，c++。
运算 b%c 的结果值为 0，相当于格式“a||b||c”中的 b 为 0。则++d 将被计算，因此 d 的值变为 1。++d 相当于
格式“a||b||c”中的 c。因此 a++||b++%c++||++d 计算之后，变量 a、b、c、d 的值分别为：1、20、2、1，验证
了形如格式 a||b||c 的逻辑运算的特殊规则。
⑵表达式“++a|| b++ % ++c || ++d”中，++a 相当于格式“a&&b&&c”中的 a，++a 中是++前缀运算，则
表示式“++a”的结果为 1，变量 a 的值也变为 1。则表达式“b++ % ++c”、表达式“++d”都不被执行。根
据运算规则，则结果为 a=1，b=19，c=1，d=0。
实例12. 逻辑运算 a || b && c 的特殊规则
a || b && c，运算规则：当表达式 a 的值为假（0 值）时才计算表达式 b；只有当表达式 a 的值为假（0、
0.0、'\0'、NULL）和表达式 b 的值为非 0 时才计算表达式 c。先结合理论，静态分析程序的运行结果，再上机
运行程序验证并分析结果。
include "stdio.h"
include "stdlib.h" //引用 system()
void main()
{
int a=0,b=19,c=1,d=0;
a++ || b++%++c && ++d;
printf("a=0,b=19,c=1,d=0 => "); //输出变量的原始值
printf("a++||b++ %% ++c&&++d\n"); //输出表达式本身及变量的原始值
printf("a=%d b=%d c=%d d=%d\n\n",a,b,c,d); //输出表达式执行之后各变量的值
a=0,b=19,c=1,d=0;
a++ || ++b % ++c && ++d;
printf("a=0,b=19,c=1,d=0 => "); //输出变量的原始值
printf("a++||++b %% ++c&&++d\n"); //输出运算表达式本身
printf("a=%d b=%d c=%d d=%d\n\n",a,b,c,d); //输出表达式执行之后各变量的值
a=0,b=19,c=1,d=0;
++a || ++b % ++c && ++d;
printf("a=0,b=19,c=1,d=0 => "); //输出变量原始值
printf("++a||++b %% ++c && ++d\n"); //输出运算表达式本身
printf("a=%d b=%d c=%d d=%d\n",a,b,c,d); //输出表达式执行之后各变量的值
}
程序运行结果：
a=0,b=19,c=1,d=0 => a++||b++ % ++c&&++d
a=1 b=20 c=2 d=1
a=0,b=19,c=1,d=0 => a++||++b % ++c&&++d
a=1 b=20 c=2 d=0
a=0,b=19,c=1,d=0 => ++a||++b % ++c && ++d
a=1 b=19 c=1 d=0
读者自行分析各表达式的计算结果，与运行结果进行比较分析。
实例13. 逻辑运算 a && b || c 的特殊规则
a && b || c，运算规则：当表达式 a 的值为非 0 时才计算表达式 b；当表达式 a&&b 运算后的值为假（0、
0.0、'\0'、NULL 其中之一）时才计算表达式 c。结合理论，先静态分析程序的运行结果，再上机运行验证分
析结果。
include "stdio.h"
void main()
{
int a=0,b=19,c=1,d=0;
printf("a=0,b=19,c=1,d=0; \n"); //输出变量各初始值
a++ && b++ % ++c || ++d;
printf("a++ && b++ %% ++c || ++d;\n"); //输出运算表达式本身
printf("a=%d b=%d c=%d d=%d\n",a,b,c,d); //输出运算之后的结果
a=0,b=19,c=1,d=0;
printf("\na=0,b=19,c=1,d=0;\n"); //输出各变量初始值
++a && b++ % c++ || ++d;
printf("++a && b++ %% c++ || ++d;\n"); //输出运算表达式本身
printf("a=%d b=%d c=%d d=%d\n\n",a,b,c,d); //输出运算之后各变量的值
a=0,b=19,c=1,d=0;
printf("a=0,b=19,c=1,d=0;\n"); //输出变量各初始值
++a && b++ % ++c || ++d;
printf("++a && b++ %% ++c || ++d;\n"); //输出运算表达式本身
printf("a=%d b=%d c=%d d=%d\n",a,b,c,d);
}
读者自行分析各个逻辑运算表达式的计算结果，并上机验证、分析运行结果。
以上几个例题，验证了几种特殊逻辑运算的规则，不遵循运算符的一般性优先级。
实例14. ++、--运算符实例解析（++、--运算符的前缀、后缀问题）
include "stdio.h"
void main()
{
int i=5;
printf("i=%d\n",i);
printf("++i=%d\n",++i); //i 值先增加 1，再输出 i 的值，++i 中++是前置运算
printf("--i=%d\n",--i); //i 值先减少 1，再输出 i 的值，--i 中--是前置运算
printf("i++=%d\n",i++); //先输出 i 的值，i 值再增加 1，i++中++是后置运算
printf("i--=%d\n",i--); //先输出 i 的值，i 值再减少 1，i--中--是后置运算
printf("-i++=%d\n",-i++); //先输出负数的 i 值，i 值再增加 1，i++中++是后置运算
printf("-i--=%d\n",-i--); //先输出负数的 i 值，i 值在减少 1，i--中--是后置运算
}
程序运行结果为：
i=5
++i=6
--i=5
i++=5
i--=6
-i++=-5
-i--=-6
实例15. 逗号运算符应用实例解析
include "stdio.h"
int max(int a,int b,int c,int d) //不是逗号表达式，逗号只是起间隔各参数项的作用
{ int t=a;
a+=12,b*=b+a,c=a+b,d%=3; //此处的逗号是运算符，逗号表达式语句
return a+b+c+d;
}
void main()
{
int a,b,c,d,x,y,m; //此处的逗号不是运算符，逗号只是起间隔作用
scanf(" %d %d %d",&b,&c,&d); //此处逗号不是运算符，逗号只是起间隔作用
a=(b=3,c=4,d=b+c); //此处逗号是运算符，小括号中的就是逗号表达式
printf("a=%d ，b=%d ，c=%d ，d=%d\n",a,b,c,d); //此处逗号不是运算符，只是起间隔作用
y=(x=a+b),(b+c); //此处逗号是运算符，此处是一个逗号表达式语句
printf("y=%d,x=%d",y,x); //此处逗号不是运算符，逗号只是起间隔作用
m=max(a,b,c,d); //此处逗号不是运算符，逗号只是起间隔作用
}
实例16. 赋值产生的类型转化导致的副作用
include "stdio.h"
void main()
{
float PI=3.14159;
int s,r=5;
s=rrPI;
printf("s=%d\n",s);
}
本例程序中，PI 为实型，s，r 为整型。在执行 s=rrPI 语句时，r 和 PI 都转换成 double 型计算，结果也
为 double 型。但由于 s 为整型，故赋值结果仍为整型，舍去了小数部分，结果不正确。
要使运算能够得到正确的结果，读者自行分析程序应该如何修改？
实例17. 类型自动转化和强制转化实例
include "stdio.h"
define PI 3.1415926
void main()
{
int r=5;
double s,f=9.76;
s=rrPI; //要发生类型自动转化
printf("s=%.2f\n",s);
printf("(int)f=%d,f=%f\n",(int)f,f);
}
本例表明，f 虽强制转为 int 型，但只在运算中起作用，f 本身的类型并不改变。因此，(int)f 的值为 9(删
去了小数)，f 的值仍为 9.76。
