C语言案例教程 - 第三章 数 据 运 算

第3章：数 据 运 算

【例3-1】

加1和减1运算。

1. 
   
2. 
   
3.     main()
   
4.      { int a=100;
   
5.        printf("%d\\n",a);
   
6.        printf("%d\\n",++a);
   
7.        printf("%d\\n",a--);
   
8.        printf("%d\\n",a);
   
9.      }

复制代码

程序运行结果如下：

100

101

101

100

【例3-2】

算术表达式计算中的优先级和结合性规则。

1. 
   
2. 
   
3.     main()
   
4.      { int a=3,b=5,c=15,d=2;
   
5.        printf("%d\\n",6-a*b/c%d);
   
6.        printf("%d\\n",++a-++a);
   
7.      }

复制代码

在第一个printf()语句中，由于乘、除和求模的优先级高于减法，因此先计算a*b/c%d，同时根据从左到右的原则依次进行乘、除和求模的运算，得到中间结果1，然后再计算6–1，结果为5。在第二个printf()语句中，由于++优先于–，因此先进行第一个++a的运算，得a=4作为被减数，再进行第二个++a运算，得a=5作为减数，最后进行“–”运算，结果为–1。

【例3-3】

混合运算的自动类型转换求值规则。

1. 
   
2. 
   
3. main()
   
4. { char ch=\'a\';
   
5. int i=5;
   
6. unsigned int j=6;
   
7. long int k=12;
   
8. float f=3.0;
   
9. double d=6.0;
   
10. printf(%lf\\n",ch/i+i*k-(j+k)*(f*d)/(f+i));
    
11.      }

复制代码

表达式ch/i+i*k–(j+k)*(f*d)/(f+i)中含有多种类型的变量，根据优先级和结合性规则及自动类型转换规则进行计算，计算过程如图3-1所示。图中凡标有类型关键字的，表示对应的数据进行了自动类型转换。

【例3-4】

强制类型转换。

1. 
   
2. 
   
3.   main()
   
4.     { int a=7,x=3,y=2;
   
5.       float b=2.5,c=4.7,z=3.5;
   
6.       printf("%f\\n",b+a%3*(int)(b+c)%2/4);
   
7.       printf("%d\\n",(x+y)%2+(int)b/(int)z);
   
8.     }

复制代码

程序运行时，在第一个printf()语句中，b+c的值为7.2，强制转换成int型后变成7。整个表达式变成2.5+7%3*7%2/4，最后计算结果为2.5，float型，因此要用\"%f\"控制输出；第二个printf()语句中，变量b和z的值分别被强制转换成int型的2和3。整个表达式变成(3+2)%2+2/3，最后计算结果为1（注意，在计算2/3时，其值是0而不是0.67），int型，因此要用\"%d\"控制输出。

【例3-5】

赋值表达式中的高精度类型转换成低精度类型。

1. 
   
2. 
   
3. main()
   
4. { int a; char b; float c;
   
5.      c=2.5;
   
6.      b=c;
   
7.      a=b;
   
8.      printf("%d,%d,%.1f",a,b,c);
   
9.    }

复制代码

在计算数值型的赋值表达式时，要将赋值号右边的表达式转换成与左边变量或数组元素相同的类型。这种转换既可能将高精度类型转换成低精度类型，也可能相反。特别是不同类型整数的相互转换，实际数值可能会发生变化。在本例中，计算赋值表达式c=2.5时，先要将双精度型常数2.5转换成float型，再赋给变量c；在计算赋值表达式b=c时，先要将c中的float型数转换成char型，然后赋给变量b；在计算赋值表达式a=b时，先要将b中的char型值转换成int型，然后赋给变量a。前两个赋值要将高精度转换成低精度，第三个赋值则要将低精度转换为高精度。程序运行结果为：a=2，b=2，c=2.5。

【例3-6】

赋值表达式中的低精度类型转换成高精度类型。

1. 
   
2. 
   
3.     main()
   
4.       { int a=-1;
   
5.         unsigned int b;
   
6.         b=a;
   
7.         printf("%d   %u\\n",a,b);
   
8.       }

复制代码

在Turbo C中，数值是按补码形式存储的，int型的–1的二进制存储格式为16个“1”。在进行b=a的赋值时，要将–1转换成unsigned int型，这时，最高位的符号位也被视为数值位，16个“1”代表的数值是65 535。因此，程序输出为：

–1
65535

【例3-7】

复合赋值运算符和变量的连续赋值。

1. 
   
2. 
   
3. main()
   
4. { int a=12;
   
5. a+=a-=a*a;
   
6. printf("%d\\n",a);
   
7. }

复制代码

在计算赋值表达式a+=a– =a*a时，按从右到左的顺序先计算a*a，得144；然后进行a– =144的赋值运算，得到a=12–144= –132；该值作为赋值表达式a– =a*a的值，参加下一个赋值表达式的计算，得a=a+(–132)= –264。因此，当同一变量被连续赋值时，要注意其值在不断变化。本例程序的运行结果为：

–264

【例3-8】

逗号运算符及逗号表达式。

1. 
   
2. 
   
3.     main()
   
4.       { int c=5;
   
5.          printf("%d,%d,%d\\n",c+=c++,c+8,++c);
   
6.          c=5;
   
7.          printf("%d\\n",(c+=c++,c+8,++c));
   
8.          c=5;
   
9.          printf("%d\\n",c+=c++,c+8,++c);
   
10.        }

复制代码

程序中第一个printf()中的3个格式转换说明符对应3个输出项。执行时，根据Turbo C的规定(当printf()函数中出现多个表达式输出项时，先按从右到左的顺序计算各表达式的值，然后再显示结果，而不是从左到右计算，也不是每计算一个表达式就输出结果)，先计算最右边的++c，得c=6；然后计算c+8，得14；最后计算c+=c++。此时，先取出c的值6，然后将它的值加1，使c的值变成7，c+=c++表示的是c=c+c++，即c=7+6=13。第二个printf()中只有1个格式转换说明符，因此输出项被解释为一个逗号表达式，按从左到右的顺序计算。计算第一项时，先取出c的值5，然后将c加1，得c=6，再计算c=6+5=11；第二项为11+8=19；第三项为11+1=12。第三个printf()中只有1个格式转换说明符，但有3个输出项，根据Turbo C的规定，先从右到左计算3个输出项的值，依次为6、14和13，然后输出第一个输出项的值13，因此程序的运行结果为：

13,14,6

12

13

二楼还有

上一章：C语言案例教程 - 第二章 基本数据类型

下一章：C语言案例教程 - 第四章 程序流程控制

【例3-9】

关系表达式的计算。

1. 
   
2. 
   
3.     main()
   
4.       { int x=8,y,z;
   
5.         y=z=x++;
   
6.         printf("%d  ",(x>y)==(z=x-1));
   
7.         x=y==z;
   
8.         printf("%d  ",x);
   
9.         printf("%d\n",x++>=++y-z--);
   
10.       }

复制代码

程序执行赋值语句y=z=x++后，得到z=8，y=8，x=9。第一个printf()输出的是关系表达式(x>y)==(z=x–1)的值。该表达式中x>y的计算结果是1，z=x–1的计算结果8（注意z=x–1是赋值表达式），经过1==8的比较后可知该关系表达式的值是0。执行赋值语句x=y==z时，由于“==”的优先级高于“=”，故先进行y==z比较，然后将比较的结果赋给变量x。由于y和z的值均为8，故y==z的值为1，从而得到x=1。第三个printf()中的输出项是关系表达式x++>++y–z– –，即比较1>=9–8，得到结果为1。程序运行后输出为：0
1
1

【例3-10】

逻辑表达式的计算。

1. 
   
2. 
   
3. #define EOF 1
   
4. main()
   
5.    { int a=3,b=4,c=5;
   
6.      printf("%d\n",3*(a+b)>c&&a++||c!=0&&!EOF);
   
7. }

复制代码

该逻辑表达式包含多种运算符，其计算过程如图3-2所示。图3-2中方框内的数字是各步计算的结果，圆圈内的数字是计算的顺序编号。程序运行结果为：1。

【例3-11】

1. 
   
2. 
   
3.     main()
   
4.       { int a=1,b=2,c=3,d=4,m=2,n=2;
   
5.         (m=a>b)&&(n=c>d);
   
6.         printf("%d  %d\n",m,n);
   
7.       }

复制代码

程序将逻辑表达式(m=a>b)&&(n=c>d)作为一条语句。在执行该语句时，先计算m=a>b，由于“>”的优先级高于“=”，这是一个赋值表达式，计算结果为m=0。对于逻辑与来说，只要有一个运算量为0，整个逻辑表达式的值即为0，因此表达式n=c>d将不被计算。这样，变量n并未被赋值，其值仍为2，而不是0。程序输出的结果为：

0
2

【例3-12】

设x为int型变量，请写出与关系表达式x==0等价的最简单的逻辑表达式及能表示x为正奇数的逻辑表达式。

关系表达式x==0表示的含义是：当x=0时，取逻辑真；否则，取逻辑假。与之等价的逻辑表达式是!x。因为对!x而言，若x=0，则!x为非0，即逻辑真；若x≠0，则!x为0，即逻辑假。不难看出，与x==0等价的逻辑表达式是!x。

为了判断x是不是奇数，相当于判断x能否被2整除，可以用x%2!=0或x%2==1来判断。因此，表示正奇数的逻辑表达式是x>0&&x%2!=0，也可以写成x>0&&x % 2、!(x<=0)&&!(x%2==0)等多种形式。

【例3-13】

用sizeof测试Turbo C中各种数据类型的长度。

1. 
   
2. 
   
3.          main()
   
4.            { char ch;
   
5.              float a=1.28,b=3000.0;
   
6.              printf("char:%d\n",sizeof(char));
   
7.              printf("short int:%d    int:%d    long int:%d\n",
   
8.                sizeof(short int),sizeof(int),sizeof(long int));
   
9.              printf("float:%d\n",sizeof(a));
   
10.              printf("double:%d    long double:%d\n",
    
11. sizeof(double),sizeof(long double));
    
12.              printf("float express:%d\n",sizeof(a+b));
    
13.              printf("character express:%d\n",sizeof('a'-'0'));
    
14.            }

复制代码

程序运行结果如下：

char:1

short int:2
int:2

long int:4

float:4

double:8
long double:10

float express:8

character express:2

【例3-14】

位操作及由位操作运算符组成的复合赋值运算符。

1. 
   
2. 
   
3.     main()
   
4.           { int a=10,b=11,c1,c2,n=1;
   
5.             c1=a,c2=b;
   
6.             a&=b;
   
7.             b|=a;
   
8.             printf("a=%d&%d=%d,b=%d|%d=%d\n",c1,c2,a,c2,c1,b);
   
9.             a=c1,b=c2;
   
10.             a>>=n+1;
    
11.              b<<=n+1;
    
12.              printf("a=%d>>%d=%d,b=%d<<%d=%d\n",c1,n+1,a,c2,n+1,b);
    
13.              a=c1,b=c2;
    
14.              a=～a;
    
15.              b^=a;
    
16.              printf("a=~%d=%d,b=%d^%d=%d",c1,a,c2,c1,b);
    
17.           }

复制代码

复合赋值运算符的概念已在3.2节介绍过了，不再赘述。本程序的运行结果为：

a=10&11=10,
b=11|10=11

a=10>>2=2,
b=11<<2=44

a=～10=-11,
b=11^10=-2

【例3-15】

将任意整数x的后6位全部置0，其余各位不变。例如，当x=95时，其二进制表示为0000000001011111，要使它的后6位全部置0，而其余各位保持不变，应该得到的二进制数是0000000001000000，即整数64（八进制100）。

要将x的后6位置0，只要找到一个数y，它的后6位全为0而其他各位全为1。再将x和y进行按位与(&)运算就可得到所需结果。只要对八进制整数077按位取反，就得到符合要求的y，即y=～077，这样，对任何整数x，x=x&y都能使x的后6位置0而其余位保持不变。程序如下：

1. 
   
2. 
   
3.     main()
   
4.       { int x;
   
5.         scanf("%d",&x);
   
6.         x&=～077;
   
7.         printf("x=%o\n",x);
   
8.       }

复制代码

程序运行时，若从键盘输入95，则输出为100（八进制表示）。

三楼继续

【例3-16】

从一个整数x的右端第p位开始向右取n位，构成一个新的数。例如，当x=712时，其二进制表示为0000001011001000，从右边第8位开始向右取6位，应得到110010，即八进制数62。

为了解决这个问题，可设计如下步骤：

① 将x右移p–n位，使指定的n位移到最右端；

② 取y=～0，使y为全1，将y左移n位，使其右端的n位为0而其余各位全为1；

③ 对移位后的y按位取反，这就使y最右端的n位全为1而其余各位全为0；

④ 将x和y按位与(&)，结果即为所求的数。

1. 
   
2. 
   
3.     main()
   
4.       { int x,y,x1,p,n;
   
5.         printf("请输入整数x:");
   
6.         scanf("%d",&x);
   
7.         x1=x;
   
8.         printf("请输入起始位置p:");
   
9.         scanf("%d",&p);
   
10.         printf("请输入位数n:");
    
11.         scanf("%d",&n);
    
12.         x>>=p-n;
    
13.         y=(～0<<n);
    
14.         y=～y;
    
15.         x&=y;
    
16.         printf("x=%d,p=%d,n=%d,result=%o\n",x1,p,n,x);
    
17.       }

复制代码

程序运行情况为：

请输入整数x:712↙

请输入起始位置p:8↙

请输入位数n:6↙

x=712,p=8,n=6,result=62

【例3-17】

编制一个能将一个整数a循环右移n位的程序。

所谓循环右移，就是将a最右端的n位顺序移到a的最左端，而将a中原左端的各位顺序右移到最右端，即如下图所示：

例如，二进制数1111111111111110循环右移1位后，新的二进制数为0111111111111111。可以按以下步骤操作(假设a是2字节的整型变量)：

① 将a左移16–n位，存入变量b中，这样，b中最右端的16–n位全部为0，而最左端的n位就是原a中最右端的n位；

② 将a右移n位，存入变量c中，这样，c中最左端的n位全部为0，而最右端的16–n位就是原a中最左端的16–n位(对无符号数而言)；

③ 取a=b|c，这样就把b中最左端的n位和c中最右端的16–n位同时复制到a中，从而实现了循环右移n位。程序如下：

1. 
   
2. 
   
3.     main()
   
4.       { unsigned int a,b,c;
   
5.         int n;
   
6.         printf("请输入a的值:");
   
7.         scanf("%d",&a);
   
8.         printf("请输入要循环右移的位数:");
   
9.         scanf("%d",&n);
   
10.         b=a<<16-n;
    
11.         c=a>>n;
    
12.         printf("a=%d      ",a);
    
13.         a=b|c;
    
14.         printf("After right shifting:a=%o\n",a);
    
15.       }

复制代码

程序运行时，若从键盘输入a的值为24，n的值为3，则输出为：

a=24
After right shifting: a=3

【例3-18】

求cos(30°)的值

1. 
   
2. 
   
3.     #include <math.h>
   
4.     main()
   
5.       { double x,y;
   
6.         x=30.0;
   
7.         y=cos(x/180*3.14159);
   
8.         printf("%f\n",y);
   
9.       }

复制代码

程序运行结果为：

0.866026

【例3-19】

求65.2值。

1. 
   
2. 
   
3.     #include <math.h>
   
4.     main()
   
5.       { double x;
   
6.         x=pow(6.0,5.2);
   
7.         printf("x=%.3f\n",x);
   
8.       }

复制代码

程序运行结果为：

x=11 127.216

【例3-20】

求e3.214 568 9的值

1. 
   
2. 
   
3.     #include <math.h>
   
4.     main()
   
5.       { double x;
   
6.         x=exp(3.2145689);
   
7.         printf("x=%.7lf\n",x);
   
8.       }

复制代码

程序运行结果为：

x=24.8925584