20160201.CCPP体系详解(0011天)

内容概要:C语言基本数据类型及运算题库(含答案)

第二章 基本数据类型及运算
一、选择题
1. 若以下选项中的变量已正确定义，则正确的赋值语句是【C】。
A) x1=26.8%3;        B) 1+2=x2;      C) x3=0x12;        D) x4=1+2=3;
2. 设变量x为float型且已经赋值，则以下语句中能够将x中的数值保留到小数点后面两位，并将第三位四舍五入的是【C】。
A) x=x*100+0.5/100.0                      B) x=(x*100+0.5)/100.0
C) x=(int)(x*100+0.5)/100.0               D) x=(x/100+0.5)* 100.0

3. 下列C语言中运算对象必须是整型的运算符是【A】。
A) %=        B) /      C) =        D) *=
4. 若有以下程序段：int c1=1,c2=2,c3; c3=1.0/c2*c1;则执行后，c3中的值是【A】。
A) 0        B) 0.5      C) 1        D) 2

5. 设x和y均为int型变量，则以下语句：x+=y; y=x-y; x-=y; 的功能是【D】。
A) 把x和y按从大到小排列     B) 把x和y按从小到大排列
C) 无确定结果                 D) 交换x和y中的值

6. 下列变量定义中合法的是【A】。
A）short _a=1-1.1e-1;               B）double b=1+5e2.5;
C）long do=0xfdaL;              D）float 2_and=1-e-3;

7. 以下4个选项中，不能被看作是一条语句的是【D】。
A) {；}                              B) a=0,b=0,c=0;
C) if (a>0);                         D) if (b==0)m=1;n=2;

8. 设x=1,y=-1，下列表达式中解为8的是【D】。
    X 0001 1110
    Y 1111
A）x&y      B）~x│x      C）x＾x      D）x<<=3
  答:位运算可以提高乘法和除法的运算效率(但是必须是2的整数次方运算才行)
9. 在C语言中不合法的整数是【C】。
A）20      B）0x4001      C）08      D）0x12ed

10. 以下选项中不正确的实型常量是【B】。
A）2.607E-1     B)0.8103e0.2     C)-77.77     D)456e–2
11.若变量已正确定义并赋值，符合C语言语法的表达式是【A,B】。
A）a=a+7                       B）a=7+b+c,a++区分逗号表达式和赋值语句.
C）int(12.3%4)                 D）a=a+7=c+b
12. 以下十六进制数中不合法的是【A,D】。
A）oxff      B）0Xabc    C）0x11     D）0x1G
13. 设int i=2,j=3,k=4,a=4,b=5,c=3;,则执行表达式（a=i<j）&&(b=j>k)&&(c=i,j,k)后，c值是【D】。
A）0      B）1      C）2     D）3

14. 下列程序的运行结果是【C】。
# include “stdio.h”
void main( )
{  int i=23;
   do{++i;}
   while(i);
   printf(“%d”,i);
}
A）23      B）24      C）死循环    D）无任何结果

15.设int a=3,b=4,c=5;,下列表达式的值不为1的是【A】。
A）a+b>c&&b==c                           B）a||b+c&&b-c-->a||(b+c&&b-c)
C）!(a>b)&&!c||1-->(!(a>b)&&!c)||1      D）!(a+b)+c-1&&b+c/2

16.下列不合法的常量是:【(2),(4),(6),(9),(10),(14),(16)】
（1）’?’  （2）’abc’  （3）”Turbo c”  （4）’\0x32’  （5）’\123’
（6）’’’’  （7）”△”　（8）’△’　　　  （9）”\\\”   （10）’’a’’’
（11）’\\’ （12）’\0123’（13）’\xaf’     （14）’王’   （15）”李为民”
（16）”\xaif”

17. 下列运算符中，结合方向为自左向右的是【B】。
（A）？：  （B），  （C）+ =  （D）++

18. 若有float x;则sizeof (x)和sizeof (float)两种描述【A】。
（A）都正确  （B）都不正确  （C）前者正确 （D）后者正确

19. 有整型变量x，单精度变量y=5.5，表达式x=(float)(y*3+((int)y)%4)执行后，x的值为【A】。过程：（int）y=5 -> 5%4=1 ->5.5*3+1=17.5 ->(float)(17.5)=17.500000 -> (int)17.500000 -> 17
（A）17  （B）17.500000  （C）17.5 （D）16
     赋值号会自动进行数据类型转换，小数部分会被舍弃（只会有取整操作）
20. 若给定条件表达式（M）?(a++):(a--)，则其中表达式(M）【C】。
A．和(M==0)等价               B．和(M==1)等价
C．和(M!=0)等价               D．和(M!=1)等价

21. 已知float x=1,y;则y=++x*++x的结果是【A】。
A．y=9        B．y=6      C．y=1       D．表达式是错误的
解析过程:
1.  当一个表达式当中同时出现对一个变量的自变运算符的时候
2.  取最后一次累计的结果作为一个整体进行替换运算操作
3.  统一内存数据读取操作的特点

22. 以下程序的输出结果是【D】。2^16=65536
short i=65535; printf ("%d\n",i);
A．65535                                       B．0
C．语法错误，无输出结果           D．-1
解析过程:
1.  如果printf();函数当中的格式控制符与所需打印的数据的数据类型不匹配的时候
2.  就会涉及到尝试的自动数据类型转换操作(建立在同一类型不同长度的情况之下)
3.  先判断是否有符号,如果有符号,就会考虑到符号位进行数据类型转换,如果没有符号,则不然(决定是否补上符号位)

23.有变量说明语句int a,b ,c;，顺序执行下面语句：
   a=b=c=1；
   ++a||++b&&++c;-->++a||(++b&&++c);
那么，变量b的值应是【B】。
A．2    B．1    C．0    D．3
答：这道题优先级是++  &&  ||，b的值是1，这里先算++a=2，++b=2，++c=2，再算b&&c，这里  逻辑且如果左边的值是非零，后面就跳过，不会执行了，而且&&返回的是1或0，这时b为非零，所以不执行后面的，返回非零就是1

24. 有变量说明int a=3;,则表达式a<1&&--a>1的运算结果和a的值应该是【B】。
A．0和2    B．0和3    C．1和2    D．1和3
答：优先级：-- <  >  &&,--a=2，a<1=0,2>1=1,0&&1=0,整个表达式的结果是0，a<1=0不赋值，所以a=3
25. 以下程序的输出为【C】。
#include<stdio.h>
void main( )
{
  double x=213.82631;
  printf("%-6.2e\n",x);
}
A．213.82        B．21.38e+01      C．2.14e+02       D．-2.14e2
答：-代表左对齐，所以排除D，A不是以指数形式，指数形式一般会留小数点前一位B也不对,对于指数形式的实数打印方式,没有正负号的区分,但是又小数位的区分

26. 下列关于单目运算符+ +、- -的叙述中正确的是【D】。
A）它们的运算对象可以是任何变量和常量
B）它们的运算对象可以是char型变量和int型变量，但不能是float型变量
C）它们的运算对象可以是int型变量，但不能是double型变量和float型变量
D）它们的运算对象可以是char型变量、int型变量和float型变量
27. 有以下程序：
#include <stdio.h>
void main ( )
{
    char a,b,c,*d;
    a='\';b='\xbc';
    c='\0xab';d="\0127";
    printf ("%c%c%c%c\n",a,b,c,*d);
}
编译时出现错误，以下叙述中正确的是【D】。
A）程序中只有“a='\'；”语句不正确
B）“b='\xbc';”语句不正确
C）“d="\0127";”语句不正确
D）“a='\'；”和“c='\0xab';”语句都不正确
解析过程:
给字符变量赋值只能赋一个字符，包括转义字符，语句“a='\'”是错误的，因为“\”是转义字符，应该用“\\”来表示，语句“B='\xbc'；”是正确的，它是将一个用十六进制表示的转义字符赋给一个字符型变量，故选项B不为所选；语句“c=\0xab；”是错误的，反斜线后的十六进制只可由小写x开头， 不能用Ox。语句“d="\0127"；”是正确的，可以给字符型指针变量赋一个字符串，其作用是让该指针变量指向该字符串，故选项C不正确。所以，D选项为所选。

28. 有以下程序：
#include <stdio.h>
void main ( )
{
    int a=1,b=2,m=0,n=0,k;
    k=(n=b>a)||(m=a<b);
    printf ("%d,%d\n",k,m);
}
程序运行后的输出结果是【C】。
A）0，0      B）0，1      C）1，0      D）1，1
29. 已定义ch为字符型变量，下列赋值语句中错误的是【A】。
A）ch='\';      B）ch=62+3;      C）ch=NULL;      D）ch='\xaa';
30. 以下4个选项中，不能看作一条语句的是【D】。
A）{；}                    B）a=0,b=0,c=0;
C）if (a>0);                  D）if (b= =0)m=1;n=2;
答：D
A．是块语句，B.一条语句中有多个表达式可以用逗号隔开C.if的条件语句D以个分号代表一条语句的结束

31. 假定有以下变量定义，则能使值为3的表达式是【D】。
int k=7,x=12;
A）x%=(k%=5)  =0          B）x%=(k-k%5)  =2
C）x%=k-k%5   =2          D）(x%=k)-(k%=5)  =3

32. 以下程序的输出结果是        。
#include <stdio.h>
void main( )
{
    int x=3,y=2,z=1;
    printf ("%s=%d\n", "x/y&z",x/y&z);
    printf ("%s=%d\n", "x^y&~z", x^y&~z);
}
=
A）x/y&z=0            B）x/y&z=1
   x^y&~z =0             x^y&~z =0
C）s=x/y&z=0          D）x/y&z=1
   s=x^y&~z =1           x^y&~z =1
 解析过程:
x->0000 0011 y->0000 0010  z->0000 0001
x^y->0000 0001 ~z->0000 0000=>x^y&~z
    整数1的反码就是0
33. 设有“int x=11;”则表达式（x++*1/3）的值是【A】。
A）3     B）4     C）11     D）12

34. 若有语句scanf（”%d %c%f”,&a,&b,&c）,假设输入序列为2223a123o.12,a、b、c的值为【D】。
A）无值                   B）2223,a,123o.12
C）2223,a,无               D）2223，a，123
35. 下列描述中，正确的一条是【A】。
A）C语言的整型变量可以分为int 、short、long、unsigned int、unsigned short、unsigned long等几种类型，因此整型常量也可以分为这几种类型
B）C语言的字符数据与整型数据可以互相赋值-->在一定的范围内
C）若对字符型变量的定义为：“char c;”可使用语句c=“a”对变量c赋值
D）已知x为float型，执行语句（int）x后，x为int型
解析过程:
    B选项,在char类型所能描述的整型数据范围之内
    C选项,区分字符变量和字符指针变量
    D选项,数据类型转换,不会影响到原有数据类型的变化
36. 设“int x=1,y=1;”,表达式（！x‖y--）的值是【B】。
 A）0    B）1     C）2    D）-1
37. 执行x=5>1+2&&2||2*4<4-!0后，x的值为【C】。
 A）-1    B）0     C）1    D）5
38. 语句“printf ("%d ", (a=2)&&(b=-2));”的输出结果是【D】。
 A）无输出    B）结果不确定     C）-1    D）1
39. 设a=2、b=3、c=4，则表达式a+b>c&&b= =c&&a||b+c&&b+c的值为【D】。
 A）5    B）8     C）0    D）1
解析过程:逻辑与经常用于将各种操作数绑定在一起进行运算
((a+b>c&&b==c)&&a)||(b+c&&b+c)
40. 执行语句scanf (“%c%c%c”,&c1,&c2,&c3)，输入abc时, 变量c1、c2、c3的值分别为【A】。
A）＇a＇, ＇b＇, ＇c＇   B）＇a＇,＇b＇, ＇＇
C）＇a＇, ＇＇, ＇b＇     D）＇a＇,＇＇,＇c＇

41. 若有以下定义：
int a=10,b=9,c=8;
顺序执行下列语句后，变量b中的值是【C】。
c=(a -= (b-5));
c=(a%11)+(b=3);
 A）3    B）8     C）9    D）10
42. 有以下程序段：
int m=0,n=0;char c='a';
scanf("%d%c%d"，&m,&c,&n);
printf("%d,%c,%d\n",m,c,n);
若从键盘上输入：10A10<回车键>，则输出结果是【A】。
A）10，A，10        B）10，a，10      C）10，a，0        D）10，A，0

43. 已定义c为字符型变量，则下列语句中正确的是【C】。
A）c=＇97 ＇      B）c=“97 “    C）c=97        D）c=“a”

44. 若有以下变量说明和数据的输入方式，则正确的输入语句为【B】。
    变量说明：float x1,x2;
    输入方式：4.52<回车>
              3.5<回车>
A）scanf (“%f,%f”,&x1,&x2);
B）scnaf (“%f%f”,&x1,&x2);
C）scanf (“%3.2f %2.1f”,&x1,&x2);
D）scnaf (“%3.2f%2.1f”,&x1,&x2);

45. 若有程序段：【D】.
for (m=1;m<=100;m++)
{
    scanf("%d",&y);
    if(y<0) continue;
    printf("%3d",m);
}
正确的描述是（   ）。
A）当y<0时整个循环结束       B）y>=0时什么也不输出
C）printf函数永远也不执行      D）最多允许输出100个非负整数

46. 下面程序的运行结果是【A】。
#include <stdio.h>
#define DATA  20+7
void main( )
{
    printf("DATA=%d",DATA/3);
}
A）DATA=22       B）DATA=21
C）DATA=9        D）以上都不对

47. sizeof(float)是【B】。
A）一个双精度型表达式       B）一个整型表达式
C）一种函数调用             D）一个不合法的表达式

48. 设有语句
    int a=5,b=6,c=7,d=8,x=2,y=2,n;
    n=(x=a<b)&&(y=(++c>d&&b>c));
则执行完上述语句后n的值为【D】。
A）1       B）2     C）3     D）0

49. 设c1,c2均是字符型变量，则以下不正确的函数调用为【D】。
A）scanf(“c1=%cc2=%c”,&c1,&c2);       B）c1=getchar( );
C）putchar(c2);                          D）putchar(c1,c2);

50. 有定义如下：【D】。
    char str1[50],str2[20],ch;
则下列语句中正确的是（   ）。
A）str1={“Crazy”};              B）str1={“Crazy”};
   str2=str1;                          str2={“English”};
                                     strcpy(str1,str2);
C）ch=“xy”; ch是一个字符                   D）ch=＇x＇;

51. 有以下定义语句：
    double a,b;   int w;   long c;
若各变量已正确赋值，则下列选项中正确的表达式是【C,D】
A）a=a+b=b++     a+b是右值    B）w%((int)a+b)
C）(c+w)%(int)a               D）w=a=b

52. 有以下程序：【D】。
#include <stdio.h>
void main( )
{
    int i=0,s=0;
    for(; ;)
    {
        if(i==3||i==5)continue;
        if(i==6)  break;
        i++;
        s+=i;
    };
    printf("%d\n",s);
}
程序运行后的输出结果是（   ）。
A）10                B）13            C）21      D）程序进入死循环

53. 以下选项中可以作为C语言中合法整数的是【C】。
（A）10110B      （B）0386 八进制不能有8（C）0Xffa      （D）x2a2
54．以下选项中可作为C语言合法常量的是【B】。
（A）-80. Double型转换为int会丢失数据（B）-080（C）-8e1.0 指数不能为小数（D）-80.0e
解析过程:
    A选项,小数点儿后面必须跟有数字
    B选项,八进制的数据可以添加正负号
    C选项,实数的指数形式,其中指数不能为小数
    D选项,实数的指数形式,指数不能不写
55．若a为整型变量，则以下语句【B】。
a=-2L;printf(“%d\n”,a);//高位阶段,不补上符号位,再以有符号类型进行解析操作
（A）赋值不合法   （B）输出值为-2    （C）输出为不确定值    （D）输出值为2
56．若有以下程序：
#include <stdio.h>
void main( )
{  int k=2,i=2,m;
   m=(k+=i*=k);
   printf(" %d,%d\n ",m,i);
}
    执行后的输出结果是【C】。
（A）8, 6   （B）8 ,3    （C）6, 4    （D）7, 4
57. 以下非法的赋值语句是【C】。
（A）n=(i+2,i++);      （B）j++;      （C）++(i+1);      （D）x=j>0
58. 有以下程序
#include <stdio.h>
void main( )
{  int x=102,y=012;
   printf(“%2d,%2d\n”,x,y);
}
执行后输出结果是【C】。
（A）10，01      （B）02，12      （C）102，10      （D）02，10
   X=102是十进制，y=012是八进制，而%d是按照十进制打印，所以它会把012换算成十进制，就是10

59. 以下程序输出的结果是【D】。
#include <stdio.h>
void main( )
{
    printf("\n*a=%15s,","chinazhongguo");
    printf("\n*b=%-5s*", "chi");
}
（A）*a=chinazhongguo*              （B）*a=chinazhongguo*
      b=**chi*                            *b=chi *
（C）*a=*  chinabeijing*             （D）*a= chinazhongguo*
      *b=chi*                             *b=chi *
%15s表示输出十五位，而字符串里只有13位，而默认是右对齐的，所以会在左边补两个空格 %-5s*，-表示左对齐，5表示输出5位，所以会在右边补两个空格
60. 若整型变量a、b、c、d中的值依次为：1、4、3、2。则条件表达式a<b?a:c<d?c:d的值是【A】。
（A）1       （B）2       （C）3      （D）4
三目运算符的就和方向是自右向左先算后面一个c<d不成立取d的值为2，再算前面的a<b成立取a的值 所以结果为1
61. 设有定义：int x=1,y=-1;。则语句“printf(“%d\n”,(x--&&++y);”的输出结果是【B】。
（A）1       （B）0       （C）-1      （D）2
   x--先取值再执行--，就是1  ++y先执行后取值就是0  1&&0就是0

62. 若变量a是int类型，并执行了语句  = ' A ' +1.6；，则正确的叙述是【D】。
（A）a的值是字符C                 （B）a的值是浮点型
（C）不允许字符型和浮点型相加      （D）a的值是字符＇A＇的ASCII值加上1
   赋值运算符会自动进行数据类型转换，它会把右边表达式的值的数据类型自动转换成左边的数据类型，字符A用到这里会按照A的ASCII码值进行运算，然后会把整个表达式的数据类型转化成int类型，小数部分会被舍弃，所以就是66  选D
63. 有一下程序
#include <stdio.h>
void main()
{
    int x=3,y=2,z=1;
    printf("%d\n",x/y&~z);
}
程序运行后的输出结果是【D】。
（A）3     （B）2    （C）-1     （D）0
   按照运算符优先级先对z取反，z就是0  0&任何数都为0，所以x/y不用计算
64. 表达式x<b||~c&d的运算顺序是【D】。
（A）~，&,<,||          （B）~，||,—，>
（C）~，&,|| , <          （D）~，<,&,||
65. 整型变量x和y的值相等，且均为非0值，则以下选项中，结果为0的表达式是【D】。
（A）x||y          （B）x|y         （C）x & y          （D）x＾y
66. 在下列符号中，不属于转义字符的是【A】。
（A）\   （B）\x12   （C）\013     （D）\05
   B是按16进制输出整数C和D是按八进制输出整数,转义字符有整体的意义,单独的\只能表示转义的作用,但并不是用于表示所谓的转义字符本身
67. 若有以下定义：intx,y;char a,b,c;并有以下输入数据（此处代表空格）：
12
ABC
则能给x赋整数1，给y赋整数2，给a赋字符A，给b赋字符B，给c赋字符C的正确程序段是【D】。
（A）scanf ("x=%dy=%d",&x,&y);a=getchar( );b=getchar( );c=getchar( );
（B）scanf ("%d %d",&x,&y);a=getchar();b=getchar( );c=getchar( );
（C）scanf ("%d%d%c%c%c ",&x,&y,&a,&b,&c);
（D）scanf ("%d%d%c%c%c %c%c%c",&x,&y,&a,&a,&b,&b,&c,&c);
   这里输入顺序是1<空格<2<回车<A<空格<B<空格<C字符录入能够识别不可见字符
只有在进行字符串,数字录入的时候,才会自动的以空格,Tab键,回车作为字符串扫描的结束标识,作为字符扫描的时候不会将空格,Tab键，回车给忽略掉
68. 语句：printf("%03d,%-3d\n",4,5);的输出为【A】。
（A）004,5          （B）004，5
（C）4,5                      （D）4，5
   %03d表示场宽为3位左边补充为0，%-3d表示场宽为3位左对齐

69. 若有以下程序段：【B】。
int a=0,b=0,c=0;
c=(a-=a-5),(a=b,b+3);
printf("%d，%d，%d\n",a, b, c);
其输出结果是
A）3，0，-10     B）0，0，5
C）-10，3，-10   D）3，0，3

70. 若有以下程序段：
#include <stdio.h>
void main()
{
    int a=2,b=5;
    printf("a=%%d,b=%%d\n",a,b);
}
其输出结果是【D】。
A）a=%2,b=%5                     B)a=2,b=5
C）a=%%d,b=%%d                   D)a=%d,b=%d
   两个%代表输出一个%  所以这里的d起不到作用

71. 若变量c定义为float类型，当从终端输入283.1900<CR> (<CR>代表回车键)，能给变量c赋以283.19的输入语句是【C】。
A）scanf(“%f”,c);              B）scanf(“%8.4f”,＆c);
C）scanf(“%6.2f”,＆c);          D）scanf(“%8f”,＆c);
   ）
72. 下列运算符中优先级最高的是【A】。
A）！     B）%     C）- =     D）&&
73. 设a、b和c都是int型变量，且 a=3，b=4，c=5；则以下的表达式中，值为0的表达
式是【D】。
A）a&&b     B）a<=b     C）a||b+c&&b-c     D）!((a<b)＆＆!c||1)
74. C语言中不合法的字符常量是【A】。
A）'\0xff '      B）'\65 '      C）'& '      D）'\028 '
75. 以下的程序：
#include <stdio.h>
void main()
{
    char x=040;
    printf("%d\n",x=x<<1);
}

其输出是【D】。
A）100      B）160      C）120      D）64
左移*2右移/2  这里按8进制赋值按10进制打印，所以要把x先换算成十进制再左移1为就是*2就是64

76. 以下定义语句中正确的是【C】.
A）char a=＇A＇b=＇B＇;        B）float a=b=10.0;
C）int  a=10,*b=＆a;           D）float *a, b=＆a;
   A中定义多个变量要用逗号隔开，C中，*b指向的本来就是一个内存地址C同B一样
77. 以下所列的C语言常量中，错误的是【B】。
A）0xFF      B）1.2e0.5      C）2L      D）＇\72＇
   指数不能为小数

78. 有以下程序
#include <stdio.h>
void main()
{
    int m=0256,n=256;
    printf("%o %o\n",m,n);
}
程序运行后的输出结果是【C】。2004年9月）
A）0256  0400      B）0256  256      C）256  400      D）400  400
   %o代表按照八进制输出  定义m=0256是代表八进制，n=256代表十进制，所以都按照八进制打印要把n换算成八进制就是400而这里没有按照%#o所以前面不会加0

79. 已经定义ch为字符型变量，以下赋值语句中错误的是【A】。
A）ch= '\’;      B）ch=62+3      C）ch=NULL      D）ch= '\xaa';
80. 有以下程序
#include <stdio.h>
void main()
{
    int m=3,n=4,x;
    x=-m++;
    x=x+8/++n;
    printf("%d\n",x);
}
程序运行后的输出结果是【D】。
A）3     B）5      C）-1      D）-2

81. 下列程序的输出结果是【C】。
#include <stdio.h>
void main()
{
    double d=3.2;
    int x,y;
    x=1.2;y=(x+3.8)/5.0;
    printf("%d\n",d*y);
}
A）3     B）3.2     C）0      D）3.07
这里按照运算顺序结果=3.2，但是是按照%d来打印，所以打印小数会解析失败，所以会打印0
82. 设有如下程序段
int x=2002,y=2003;
printf("%d\n",(x,y));
则以下叙述中正确的是【D】。
A）输出语句中格式说明符的个数少于输出项的个数，不能正确输出
B）运行时产生出错信息
C）输出值为2002
D）输出值为2003
   这里是输出一个逗号表达式的结果，所以会输出2003

83. 有以下程序
#include <stdio.h>
void main()
{
    unsigned char a,b; //0000 0100
    a=4|3;             //0000 0011
    b=4&3;
    printf("%d %d\n",a,b);
}
执行后输出结果是【A】。
A）7 0    B）0  7     C）1  1     D）43  0
   这里打印的不是逻辑的值0与非零，在这里是要把4和3换算成2进制运算，然后再换算成十进制打印

84. 设a和b均为double型变量，且a=5.5、b=2.5,则表达式（int）a+b/b的值是【D】。
A）6.500000    B）6     C）5.500000    D）6000000
   这里（int）是只把a转换为int类型，不是把整个表达式的结果转换成int类型
(int)5.5+2.5/2.5 -> 5+1.000000 -> 6.000000
85. 已有定义：int x=3,y=4,z=5;则表达式!(x+y)+z-1&&y+z/2的值是【D】。
A）6     B）0     C）2     D）1
   按照优先级运算（）>！>/>+-   结果为1
    (!(x+y)+z-1)&&(y+z/2)B
86. 设int x=1,y=1;表达式(!x||y--))的值是【B】。
A）0     B）1     C）2     D）-1
87. 若x和y代表整型数，以下表达式中不能正确表示数学关系|x-y|<10的是【C】。
A）abs(x-y)<10   B）x-y>-10&&x-y<10   C）!(x-y)<-10||!(y-x)>10  D）(x-y)*(x-y)<100
88. 在下列选项中，不正确的赋值语句是【D】。
A）++t;      B）n1=(n2=(n3=0));      C）k=i= =j;      D）b+c=1;
89. 若x=2,y=3，则x&y的结果是【B】。
A）0     B）2      C）3      D）5   1
90. 下面程序的输出结果是【A】。
main( )
{ unsigned a=32768;
printf(“a=%d\n”,a);
}
A）a=32768      B）a=32767      C）a=-32767      D）a=-1
   这里按照无符号定义，按无符号十进制解析，没有超出数据极限，所以可以正常打印

91. 以下程序的输出结果是【B】
#include <stdio.h>
void main( )
{
    int i=010,j=10;
    printf("%d,%d\n",++i, j--);
}
A）11,10      B）9,10      C）010,9      D）10,9
   %d是按照十进制解析，所以需要把i先转换为十进制  然后执行++就是9
92. 以下程序的输出结果是【B】。
#include <stdio.h>
void main( )
{
    int a,b,d=241;
    a=d/100%9;
    b=(-1)&&(-1);
    printf("%d,%d\n",a,b);
}
A)6,1      B)2,1      C)6,0      D)2,0
93. 如果在用户的程序中使用C语言库函数中的sqrt函数，应在该源文件中使用的include命令是【B】。
A）# include <string.h>    B）# include <math.h>
C）# include <ctype.h>    D）# include <stdio.h>
   求完全平方

94. 下面程序的输出结果是【9a,ffffff65】。
#include <stdio.h>
void main( )
{
    unsigned int a,b;
    a=0x9a;10+9*16=154
    1001 1010->0110 0101
    b= ~a;
    printf("%x, %x\n",a,b);
}
 ：9a,ff65(TC2.0)或9a,ffffff65(Visual C++6.0)
A=十六进制的9a换算成二进制就是10011010，再把a取反就是01100101赋值给b，换算成十六进制就是65  按十六进制显示就是ffffff65
95. sizeof(double)是【C】。
A）一种函数调用      B）一个双精度型表达式
C）一个整型表达式    D）一个不合法的表达式
   Sizeof返回的是字节数，所以它是一个整型表达式
96. 下面的程序【D】。
#include <stdio.h>
void main( )
{
    int x=3,y=0,z=0;
    if(x=y+z)
        printf("* * * *");
    else
        printf("# # # #");
}
A）有语法错误不能通过编译
B）输出 * * * *
C）可以通过编译，但是无法连接，因而不能运行
D）输出# # # #

97. 已知i、j、k为 int型变量，若从键盘输入：1，2，3<回车>，使i的值为1、j的值为2、k的值为3，以下选项中正确的输入语句是【C】。（2002年9月）
A）scanf("%2d%2d%2d", &i, &j, &k);
B）scanf("%d  %d  %d", &i, &j, &k);
C）scanf("%d,%d,%d", &i, &j, &k);
D）scanf("i=%d,j=%d,k=%d", &i, &j, &k);
98. 设有以下语句：
char x=3,y=6,z; 0000 0011
z=x^y<<2;       0000 0110->0000 0101->0001 0100
则z的二进制值是【A】。
A．00010100      B．00011011      C．00011100      D．00011000
   先把y左移两位
99. putchar 函数可以向终端输出一个【D】。
A）整型变量表达式的值           B）实型变量的值
C）字符串                       D）字符或字符型变量的值
100. 已知ch是字符型变量，下面不正确的赋值表达式是【A】。
A）ch='a+b'   B）ch='\0'    C）ch='7'+'9'    D）ch=5+9
101.以下常量中，合法的是【C】。
A）5e2.5          B）e8           C）’\\’             D）’BASIC’
解析过程:e这个必须得有指数,而且必须有系数
102. C语言提供的合法的数据类型关键字是【B】。
A）DOUBLE      B）short         C）integer          D）Character
103. 下列不正确的转义字符是【D】。
A）’\\’            B）’\0’          C）’\’’             D）’057’
104．C语言中，合法的长整型常数是【A】。
A）1L            B）5074369      C）225D           D）326581&
105．以下类型中属于C语言的数据类型是【D】。
A）逻辑型        B）纯小数型     C）复数型         D）双精度型
106．C语言中，运算对象必须是整形数的运算符是【B】。
A）*             B）%            C）+             D）/
107．表达式10<20的值是【D】。
A）10            B）20            C）0             D）1
108．表示关系x≤20或x≥50，应使用C语言表达式是【A】。
A）x<=20 || x>=50                    B）x<=20 or x>=50
C）x≤20 or x≥50                    D）x≤20 || x≥50
109．已知int  t = 1;  t+ = 9;  y = t++; 则y =【B】。
A）11            B）10            C）9             D）1
110．已知char a; int b; float c; double d; 则表达式a+b * c-d的结果为【D】型。
A）char           B）int            C）float          D）double
   数据类型转换规则是从低到高
111. 若x 为int型变量，则执行语句x=10;  x+ = x— = x — x后，x的值为【C】。
A）0             B）10            C）20            D）30
112. 若x、a、b、c均 为int型变量，则执行表达式x= (a = 4, b = 8, c = 12)后，x的值为【C】。
A）4             B）8             C）12            D）24
   逗号表达式的值就是最后一个逗号后面的表达式的值
113. 在C程序中，x + y是_______、x + y；是_______。
A）表达式、语句                   B）表达式、表达式
C）语句、语句                     D）语句、表达式
    解析过程:表达式和语句的区别,表达式末尾没有分号,语句后面含有分号
114．已知int x = 23;  则printf(“%d \n”,x++*1/3)的输出结果为【D】。
A）8            B）7.66            C）7.33          D）7
   这里++是后++所以本语句中部执行  类型是int型  所以是7

115．若a、b、c为int型变量，且值均为5;  则以下表达式正确的是【C】。
A）17.6%a                         B）a = a+7 = b+c
C）c = b = a * 5 + 6                  D）a: = c + b
   %运算符只能作用于整数   a+7是左值
116. 设 int b=2;表达式(b>>2)/(b>>1)的值是【A】。
A) 0                  B) 2                C) 4                D) 8
    0000 0010 >> 2 -> 0000 0000 -> 0（移丢失的位就被舍弃掉了）
0000 0010 >> 1 -> 0000 0001 -> 1
117. 以下程序的功能是进行位运算
#include <stdio.h>
void main()
{
    unsigned char a, b;    0111  0100->1011
    a=7^3; b= ~4 & 3;      0011        0011
    printf("%d %d\n",a,b);
}
程序运行后的输出结果是【A】。
A）4 3           B）7 3           C）7 0           D）4 0
118. 以下程序的输出结果是【D】。
#include <stdio.h>
void main()
{
    int a=-1, b=4, k;
    k = ( ++a < 0) && ( b += 5);
    printf ("%d%d%d \n", k, a, b );
}
A）104          B）103          C）003            D）004
   按优先级运算  ++a=0  0<0=0  后面无意义  k=0  a=0  b=4

119. 若有以下定义和语句：
char c1 = 'b', c2 = 'e';
printf ( "%d, %c \n", c2 - c1, c2 - 'a' + 'A' );
则输出的结果是【A】。
A）3，E         B）3，D        C）2，D           D）2，E
   //这里会按照ascii来进行运算然后会按照相应的打印方式打印
120. 已知，x是int型变量，y是float型变量，用下列语句给这两个变量赋值时，为了把100和75.3分别赋给x和y，则正确的输入为【B】。
scanf ( “ x = %d, y = %f ”, &x, &y );
A）100<空格>75.3<回车>               B）x = 100，y = 75.3<回车>
C）100<回车>75.3<回车>               D）x = 100<回车>y = 75.3<回车>
121. 以下对于scanf函数叙述正确的是【B】。
A）输入项可以是一个实型常量，如scanf ( “ %f ”, 7.3 );
B）当输入数据时，必须指明变量地址，如scanf ( “ %f ”, &a );
C）当输入一个实型数据时，可以规定小数点后位数，如scanf ( “ %5.3f ”, &a );
D）只有格式控制，没有输入项也能正确输入数据，如scanf ( “ x = %d, y = %f ” );
123. 语句printf ( “%d”, ( a = 2)&&(b = -2));的输出结果是【A】。
A）1            B）0         C）提示语法错误     D）结果不确定
124. 若有以下定义和语句：int x = ‘f’;
printf ( “ %c \n”, ‘A’ + ( x – ‘a’ + 2));
则输出的结果是【A】。
A）H         B）h         C）G         D）I
  // 65+（102-97+2）=72
125. 下列程序运行的结果是【B】。
#include <stdio.h>
void main()
{
    int a = 9, b = 7;
    printf ("a = %d, b = %d \n", a, b);
}
A）a = %9, b  = %7           B）a = 9, b  = 7
C）a = %d, b  = %d           D）9, 7
126. 语句printf ( “a\bcd\’ef\’g\\\bij\n”);的输出结果是【C】。
A）a\bcd\’ef\’g\\\bij\n          B）acd’ef’gbij\n
C）cd’ef’gij                     D）以上均不正确
127. 执行下列程序片断后c的值是【A】。
int a = 1, b = 2, c;
c = 1.0/b*a;
A）0         B）0.5       C）1         D）2
128. 已知x、y、z被定义为int型变量，若从键盘对其输入数据，正确的是【C】。
A）INPUT  x, y, z;                   B）read ( “%d%d%d”, &x, &y, &z);
C）scanf ( “%d%d%d”, &x, &y, &z);    D）scan ( “%d%d%d”, &x, &y, &z);
129. 执行下列程序后的输出结果是【C】。
#include <stdio.h>
void main()
{
    int x = 11;
    printf ("x = %d, x = %o, x = %x \n", x, x, x);
}
A）x = 11, x = o13, x = oxb      B）x = 11, x = 13, x = 11
C）x = 11, x =13, x = b          D）x = 11, x = o13, x = ox11
130. 分析以下程序，其输出结果是【D】。
# include "stdio.h "
void main ( )
{
int a, b, c = 210;
a = c/100%9;
b = (-1) && (-1);
printf (" %d, %d \n ", a, b);
}
A）210, -1           B）210,          C）2, -1             D）2, 1
131.已定义str为字符型变量，则以下赋值语句中错误的是【A】。
A）str="\";                B）str=NULL;
C）str=55+8;              D）str=‘\xbb’;
   //“”表示字符串=
132. 已定义c为字符型变量，则下列语句中正确的是【C】。
A）c=‘98’;    B）c="98";      C）c=98;        D） c="b";
133. 有以下程序
#include <stdio.h>
void main()
{
    printf("%d\n", NULL);
}
程序运行后的输出结果是【A】
A）0             B）1             C） -1           D） NULL没有定义，出错
134. 下列程序执行后的输出结果是【A】
#include <stdio.h>
void main()
{
    int x= 'f';
    printf("%c ", 'A'+(x-'a'+1));
}
A） G      B） H      C） I       D） J
135. 若变量c为char类型，能正确判断出c为数字的表达式是【D】。
A）  '0'<=c<= '9'                       B）  (c>= '0')||(c<= '9')
C）  ('0'<=c) and ('9'>=c)                D）  (c>= '0')&&(c<= '9')
136. 若有定义  char c=’\010’；则该变量中包含的字符个数是【B】。
A）  非法定义                        B）  1个
C）  3个                            D） 4个
137. 下列函数中能够向终端输出一个字符或字符型变量值的是【D】。
A） gets      B） puts      C） getchar       D） putchar
138. 若有下列语句
char c=’A’；
printf(“%d”,c);
则输出的结果是【C】。
A） A     B） c      C） 65       D） 错误的语句
139. 下列程序输入’a’字母后，执行程序后输出的结果【B】。
#include <stdio.h>
void main( )
{
    char c;
    c=getchar();
    c=c-32;
    printf("%c\n",c);
}
A）65     B） A      C） 97       D） a
140.以下不能正确计算代数式值的C语言表达式是【A】。
A）1/3*sin(1/2)*sin(1/2)先除   B）sin(0.5)*sin(0.5)/3
C）pow(sin(0.5),2)/3  D）1/3.0*pow(sin(1.0/2),2)
141.以下能正确定义且赋初值的语句是【B】。
A）int n1=n2=10;  B）char c=32;
C）float f=f+1.1;     D）double x=12.3E2.5;
142.设有定义：int k=1,m=2; float f=7;，则以下选项中错误的表达式【A】。
A）k=k>=     B）-k++     C）k%int(f)     D）k>=f>=m
143.设有定义：int a=2,b=3,c=4;，则以下选项中值为0的表达式是【A】。
A）(!a==1)&&(!b==0)   B）(a<B)&& !c||1
C）a && b     D）a||(b+b)&&(c-a)
144.以下选项中可作为C语言合法常量的是【B】。
A）-80.   B）-080  C）-8e1.0    D）-80.0e
145.以下不能定义为用户标识符的是【D】。
A）Main   B）_0    C）_int  D）sizeof
146.以下选项中不能作为合法常量的是【B】。
A）1.234e04   B）1.234e0.4     C）1.234e+4  D）1.234e0
147.有以下程序：
#include <stdio.h>
void main( )
{
    int m=12,n=34;
    printf("%d%d",m++,++n);12 35 35 14
    printf("%d%d\n",n++,++m);
}
程序运行后的输出结果是【A】。
A）12353514   B）12353513  C）12343514  D）12343513
148.有以下程序：
#include <stdio.h>
void main( )
{
    int a,b,d=25;
    a=d/10%9;
    b=a&&(-1);
    printf("%d,%d\n",a,b);
}
程序运行后的输出结果是【B】。
A）6,1    B）2,1   C）6,0   D）2,0
149.以下叙述中正确的是【B】。
A）调用printf函数时，必须要有输出项
B）使用putchar函数时，必须在之前包含头文件stdio.h
C）在C语言中，整数可以以十二进制、八进制或十六进制的形式输出
D）调用getchar函数读入字符时，可以从键盘上输入字符所对应的ASCII码
150.以下程序的功能是：给r输入数据后计算半径为r的圆面积s。程序在编译时出错。
#include <stdio.h>
void main()
{
    int r;
    float s;
    scanf("%d",&r);
    s=p*r*r;
    printf("s=%f\n",s);
}
出错的原因是【D】。
A）注释语句书写位置错误
B）存放圆半径的变量r不应该定义为整型
C）输出语句中格式描述符非法
D）计算圆面积的赋值语句中使用了非法变量
151.数字字符0的ASCII值为48，若有以下程序
#include <stdio.h>
void main()
{
    char a='1',b='2';
    printf("%c,",b++);
    printf("%d\n",b-a);
}
程序运行后的输出结果是【C】。
A）3,2    B）50,2  C）2,2  D）2,50

152.有定义语句：int b;char c[10];,则正确的输入语句是【B】。
A）scanf("%d%s",&b,&c);   B）scanf("%d%s",&b, c);
C）scanf("%d%s",b, c);    D）scanf("%d%s",b,&c);
153.有以下程序
#include <stdio.h>
void main()
{
    int m,n,p;
    scanf("m=%dn=%dp=%d",&m,&n,&p);
    printf("%d%d%d\n",m,n,p);
}
若想从键盘上输入数据，使变量m中的值为123，n中的值为456，p中的值为789，则正确的输入是【A】。
A）m=123n=456p=789    B）m=123 n=456 p=789
C）m=123,n=456,p=789  D）123 456 789
154.有以下程序
#include <stdio.h>
void main()
{
    char c1='1',c2='2';
    c1=getchar(); c2=getchar(); putchar(c1); putchar(c2);
}
当运行时输入a<回车> 后，以下叙述正确的是【A】。
A）变量c1被赋予字符a，c2被赋予回车符
B）程序将等待用户输入第2个字符
C）变量c1被赋予字符a，c2中仍是原有字符2
D）变量c1被赋予字符a，c2中将无确定值
155.以下程序的功能是进行位运算
#include <stdio.h>
void main()
{
    unsigned char a, b;      0111  0100
    a=7^3; b= ~4 & 3;        0011  1011
    printf("%d %d\n",b,a);   0100   0011
}
程序运行后的输出结果是【A】。
A）4 3    B）7 3   C）7 0   D）4 0
156. 有以下程序
#include <stdio.h>
void main()
{
    int c=35;
    printf("%d\n",c&c);
}
程序运行后的输出结果【C】。
A）0    B）70    C）35    D）1
157.设有定义语句  char c1=92,c2=92;,则以下表达式中值为零的是【A】。
A)c1^c2         B)c1&c2         C)~c2          D)c1|c2
158． 有定义语句：int  a,b;， 若要通过scanf("%d,%d",&a,&b);语句使变量a得到数值30，变量b得到数值40， 则下面四组输入形式中，错误的输入形式是【A】。
A）30  40<回车＞                    B）30，40＜回车＞
C）30,40＜回车＞                 D＝30,＜回车＞40＜回车＞
159． 若有说明语句  char ch=’65’；则变量ch【C】。
A）包含3个字符                    B）包含2个字符
C）包含1个字符                        D）说明不合法，变量值不确定
160． 已知字母a的ASCII码为十进制的97，ch1为字符型变量，则执行语句ch1='a'+'7'-'5'；后，ch1中的值为【D】
A） 99         B）不确定的值    C） b         D） c
161． 假设变量a是整型，b是实型，c是双精度型，则表达式30+a+c*b的值的数据类型是【C】。
A） int        B） float        C） double    D） 不确定
162．若变量c为char类型，能正确判断出c为大写字母的表达式是【D】。
A）  'A'<=c<= 'Z'             B）  (c>= 'A')||(c<= 'Z')
C）  ('A'<=c) and ('Z'>=c)    D）  (c>= 'A')&&(c<= 'Z')
163． 若有定义：int a＝7；f1oat x＝2.5，y＝4.7；则表达式x+a％3*(int)(x+y)％2／4的值是【A】。
A） 2.5          B） 2.7           C） 3.5             D） 4.7
164．下列程序执行后的输出结果是【G】。
#include <stdio.h>
void main()x
{
    int x= 'f';
    printf("%c",'A'+(x-'a'+1));
}
A） G            B） H             C） I               D） J
165． 在C语言中（以TC编译系统为例），5种基本数据类型的存储空间长度的排列顺序为【A】。
A） char<int<long int<=float<double     B） char=int<long int<=float<double
C） char<int<long int=float=double      D） char=int=long int<=float<double
166. 在c语言中，非char型数据在内存中的存储形式是【A】。
A） 补码       B） 反码        C） 原码        D） ASCII码
167. 在c语言中，char型数据在内存中的存储形式是【D】。
A） 补码       B） 反码        C） 原码        D） ASCII码
二、填空题
1. printf库函数的第一个参数中的格式串是指明输出数据格式，各种数据类型对应的基本格式串是：
short、int  %hd&%hu %d&%u  ,      long     %ld&%lu  ,
float   %f  、  %e  ,   double   %lf  、  %le  ,
char   %c  、 %hd&%d&%ld  ,   字符串  %s  。
2. scanf库函数格式串和输入项之间的关系是  一一对应:格式控制字符串当中的格式控制
符与输入项的顺序要一致,类型要匹配,个数要对应   。
3. 阅读下述程序功能：将三位整数n的十位数的数字变为0。例如，输入三位整数为738，输出为708。请将正确 写在横线处。
# include<stdio.h>
void main( )
{
 int n=0,d2=0,d0=0  ;
printf (“输入一个三位整数：”)；
scanf (“%d”,&n);
d2=   n/100  ;   /* 取出百位数的数字 */
d0=   n%10  ;   /* 取出个位数的数字 */
printf (“输出三位整数：%d\n”,   d2*100+d0  );
}
5. 若x为单精度型变量，y为字符型变量，z为整型变量，执行如下的输入语句：
scanf (“%f %c%d”,&x,&y,&z);后，从键盘输入12.77A79A86。此时，变量x、y、z的值分别为  12.770000   、   A    、  79   。
6. 表达式8/4*(int)2.5/(int)(1.25*(3.7+2.3))的值是      0    。
7. 已知char c= 'A'；int i=1,j;执行语句j=!c&& i++后，i和j的值分别是  1   和
   0   。
8. 执行下面的程序
#include <stdio.h>
void main( )
{
  int a=0100,b=100;
  printf("x=%d,y=%d\n",--a,b++);
}
则输出结果是 x=63,y=100
9. 如果要通过以下语句给a、b、c、d分别输入字符A、B、C、D，给w、x、y、z分别输入10、20、30、40，正确的输入形式是  10A20[]30BC30D    ，请用<CR>表示回车键。
scanf ("%d%c%d%d%c%c%d%c",&w,&a,&x,&y,&b,&c,&z,&d);
解：输入格式“%c”表示输入任意一个字符，包括按回车、空格和Tab键等。因此在输入整数10、30、40后不能输入空格而要直接输入字母；同理，字母B和C之间也不能输入空格。同时在20和30之间必须输入空格进行两个整数的区分。所以本题 为：10A20□30BC40D<CR>（其中，“□”表示一个空格）。
10. 有以下程序：
#include <stdio.h>
void main ( )
{
    char ch1,ch2;int n1,n2;
    ch1=getchar ( );ch2=getchar ( );
    n1=ch1-'0';n2=n1*10+(ch2-'0');
    printf ("%d\n",n2);
}
程序运行时输入：12<回车>，执行后输出结果是  12    。（2004年4月）
11.程序的运行结果为   aabb    cc     。
#include <stdio.h>
void main( )
{
    char c1='a',c2='b',c3='c';
    printf ("a%cb%c\tc%c\n",c1,c2,c3);
}
12. 请在空白处填上适当的语句，使以下程序的输出结果是16.00，。
#include <stdio.h>
void main ( )
{
int a=9,b=2;
float x=   6.6    ,y=1.1,z;
z=a/2+b*x/y+1/2;
printf (“%5.2f\n”,z);
}
13. 有如下程序：
#include <stdio.h>
void main( )
{
    int y=3,x=3,z=1;
    printf("%d %d\n",(++x,y++),z+2);
}
运行该程序的输出结果是【D】。
A）3 4       B）4 2     C）4 3        D）3 3
14. 以下程序段中与语句k=a>b?(b>c?1:0):0;功能等价的是【A】。
A）if((a>b&&(b>c))k=1;        B) if((a>b)‖(b>c))k=1;
   else  k=0;                       else  k=0;
C）if(a<=b)  k=0;            D)  if(a>b)  k=1;
   else if(b<=c) k=1;               else if(b>c) k=1;
                                else  k=0;
15. 已知大写字母A的ASCII码值是65，小写字母a的ASCII码是97，则用八进制表示的字符常量是＇\101＇是    A   。
16. 下面程序的运行结果是        。
#include <stdio.h>
#define STR "a C program"
void main( )
{
    printf("No.1：This is a STR!\n");
    printf("No.2：This is %s!",STR);
}
 ：  No.1:This is a STR!
    No.2:This is a C program!

17. 若有以下程序：
   main( )
  {
int i=4;
printf(“%d”,-++i);//负号只是对变量的一种修饰形式而已,不是变量自身组成
   }
该程序执行后的输出结果以及i的值分别是   -5   、   5   。
18. 以下程序运行时若从键盘输入：10 20 30<回车>。输出结果是   10300    。
#include <stdio.h>
void main( )
{
    int i=0,j=0,k=0;
    scanf("%d%*d%d",&i,&j,&k);
    printf("%d%d%d\n",i,j,k);
}
19. 以下程序的执行结果是    c=3,a=2,b=3     。
#include <stdio.h>
void main( )
{
    int a,b,c;
    c=(a=3,b=a--);
    printf("c=%d, a=%d, b=%d\n",c,a,b);
}
20. 已知x=7.5,y=2,z=3.6,则表达式x>y&&z>x<y&&!z>y的值是 0 。
 ：0 解析方式:(x>y&&z>x<y)&&(!z>y)
21. 以下程序运行的结果是   1,1      。
#include <stdio.h>
void main( )
{
    int a,b,c;
    a=1;b=2;c=3;a=b--<=a||a+b!=c;//a=(b--<=a)||(a+b!=c)
    printf("%d,%d",a,b);
}
22. 输入“12345,xyz”，下列程序输出的结果是  123,4     。
main( )
{  int x;char y;
   scanf (“%3d%3c”,&x,&y);
   printf (“%d,%c”,x,y);}
23. 以下的程序执行时，先输入a  ;后输入b  。最后显示的结果是    b,    。
#include <stdio.h>
void main( )
{
    int x,y;
    printf("Enter a character：");
    x=getchar( ); y=getchar( );
    printf("Enter a character,again：");
    x=getchar( ); y=getchar( );
    printf("%c,%c\n",x,y);
}
24. 读程序段：//位运算运算的是内存存储形式补码
int a=-5;a=a|0337;  printf("%d,%o\n",a,a);
0101
-5原码:1000 0000 0000 0000 0000 0000 0000 0101
-5反码:1111 1111 1111 1111 1111 1111 1111 1010
-5补码:1111 1111 1111 1111 1111 1111 1111 1011
0337补码:0000 0000 0000 0000 0000 0000 1101 1111
补码结果:1111 1111 1111 1111 1111 1111 1111 1111
11 111 111 111 111 111 111 111 111 111 111
以上程序段输出结果是   -1,37777777    。
//八进制的数据没有符号的概念(从低二进制位到高二进制位数三位),位运算的运算对象是补码(位运算的实质就是操作内存当中的数据实际存储形式)
25. 设有二进制数a的值为11001101，若通过a&b运算使a中的低4位不变，高4位清零，则b的二进制数是    00001111      。
26. 设a是一个整数（两个字节），若要通过a|b使a的低八位为1，高八位不变，则b的八进制数是   0377     。
27. 变量i、j、k已定义为int类型并有初值0，用以下语句进行输入
     scanf("%d",&i); scanf("%d",&j); scanf("%d",&k);
当执行以上输入语句，从键盘输入（<CR>代表Enter键）：
    12.3<CR>//当遇到非格式控制符的数据扫描时,不能正常扫描数据
//不能正确扫描的数据,就保持原样的数据形式
则变量i、j、k、的值分别是   12    、   0    、    0     。
28. 有以下语句段
int n1=10,n2=20;
printf("  n1=%d\nn2=%d\n    ",n1,n2);
要求按以下格式输出n1和n2的值，每个输出行从第一列开始，请填空。
n1=10
n2=20
29. 把int型变量low中的低字节及变量high中的高字节放入变量s中的表达式是
low&0x0000ffff | high&0xffff0000     。
此题结果与编译环境有关，上面结果为Visual C++6.0环境下的表达式。
30. 以下语句的输出结果为    ASCII of ‘x’ec=120,oct=170,hex=78,character=x      。
    char c= 'x';
    printf ("ASCII of 'x'  ec=%d,oct=%o,hex=%x,character=%c\n",c,c,c,c);
31.表示关系x≤y≤z，应使用C语言表达式是_x<=y&&y<=z_；表示数学式 的C语言表达式是_a/(b*c)_。
32.已知  har a; int b; float c; double d;则表达式a*b + c-d的结果为_double_型。
33.执行了以下程序片断后，x = _11_；y = _11_。
int  x = 10 , y = 10;
x++;  ++y;
34.若a、b、x、y均为int变量，且a=b= 6, x=y=7则执行表达式(x = a > b) && (y = 2)后x的值为_0_；y的值为 7__。
35.若int  x = 3，则执行表达式x* = x+ = x - 1后x的值为_25_。
36.已知：int  x = 256，执行语句printf( “%x”, x )的结果是_100_。
37. 已知：int x = 97，执行语句printf( “%c”, x )的结果是_a_；执行语句printf ( “%d”, x )的结果是_97_。
38．在C语言中所提供的数据结构是以数据类型形式出现的，其中的基本类型包括int 型 即_整型__、float型即_单精度性__、double型即_双精度型__、char型即_字符型__等。
39.表达式3 * 7 % 2 + 7 % 2 * 5的值为_6__；表达式8.0*(1/2)的值为  0.0  __。
40. C语言中的赋值运算是_=__，表示相等的关系运算符是_==__。
41. C语言本身不提供输入输出语句，输入和输出操作是由_函数__实现的，如格式输出函数_printf();__和格式输入函数_scanf();__。
42. putchar ( )函数的作用是_向终端输出一个字符__，getchar ( )函数的作用是_从终端
获取一个字符__和。
43. 在printf ( )函数的格式说明中，%d表示_以有符号十进制形式输出__，%o表示 _以
八进制整数形式进行输出__，%f表示_输出单精度浮点型__，%s表示 _输出一个字符串__，%ld表示以长整型形式输出整数　。
44. 若想通过以下输入语句给x赋１，给y赋２，则输入数据的形式应是_x = 1, y =2__。
int a, b;
scanf( “x = %d, y = %d”, &x, &y);
……
45. 若想通过以下输入语句使a = 5.0, b = 4, c = 3则输入数据的形式应该是_5.0, 4, c
= 3__。
46. 语句：printf(“%d”,x++);  printf(“%d”,++x); x+=1; x=1+x; x=x+1中，执行后能使变量x的值增1的有__；语句; 的输出结果是否相等
_不相等_；语句; ; 是否完全等效_完全等效_。
47. C程序中的字符常量是用_单引号_括起来的一个字符；除此之外，还允许用一种特殊形式的字符常量，是以_\_开头，被称为转义字符。
48. 转义字符\n的功能是_换行_；\b的功能是_退格_；\\的功能是_输出反斜杠字符\_。
49. 将一个字符常量放到一个字符变量中，实际上并不是把该字符放到内存单元中去，而是将该字符的相应_ASCII码_放到存储单元中，其存储形式与_整数_的存储形式相类似，所以可以以_整数_形式输出。
50. 字符串常量是一对_双引号_括起来的字符序列，且以_\0__结束；则字符串china的长度是_6_个字符。
51. C语言中没有专门的字符串变量，如需要存放在变量中，则以_字符数组_形式来存放。
52. 执行以下程序段后，输出的结果是_a__。
char c= 'z';
printf("%c",c-25);
53. 若想通过以下输入语句使a中存放字符串1234，b中存放字符5，则输入数据的形式应该是__a=1234,b=5_。
char a[10],b;
scanf("a=%s,b=%c",a,&b);
54.通过使用关键字_const_，可以将一个变量定义为一个常量。
55.常量是指在程序执行过程中其值_不能_改变的量。
56.变量是指在程序执行过程中其值_可以_改变的量。
57.在C程序中，大写字母和小写字母是无区别的，此说法正确吗？_不正确_。
58.以0开头的整数是_八进制整数_。
59.以0x开头的整数是_十六进制整数_。
60.在一个整数后面加一个字母_lorL_，则认为是long int型常量。
61.C整型变量可分为：基本型、_短整型_、_长整型_和无符号型四种。
62.C实型变量分为_单精度型_和_双精度型_两类。
63.C的字符常量是用_单引号_括起来的一个字符。
64._转义字符_字符的意思是将反斜杠(\)后面的字符转变成另外的意义。
65.转义字符'\n'表示_换行_符，使光标移到屏幕上下一行开头。
66.一个字符变量在内存中占_一个_字节。
67.一个字符数据既可以以字符形式输出，也可以以_整数_形式输出。
68.字符串常量是用_双引号_括起来的字符序列。
69.C规定以字符_’\0’_作为字符串结束标志。
70.在进行运算时，不同类型的数据必须_先转换为统一类型_，然后进行运算。
71.可以利用_强制类型转换_运算符将一个表达式的值转换成指定的类型。
72.有两种类型转换，一种是在运算时不必用户指定，系统自动进行类型转换；另一种是_
强制类型转换_。
73.两个整数相除的结果是_整_数。
74.取余运算符（%）只能用于_整数_操作数。
75.算术运算符*、/、%、+、- 的优先级相同。此说法正确吗？_不正确_。
76.所有运算符中级别最低的是_逗号_运算符。
77.自增运算符（++）和自减运算符（--）只能用于变量，而不能用于_常量或表达式_。
78.自增运算符（++）和自减运算符（--）的结合性是_右结合性(自右向左)_。
79.赋值运算符的作用是将一个数据或表达式的值赋给一个_变量_。
80.sizeof( double )表示的含义是一个double型数据占用内存的_字节_数。
81.一个表达式的最后加上一个_分号_就成了一个语句。
82.结构化程序设计中有三种基本结构：顺序结构、_分支结构_、_循环结构_。
83.在C中，赋值语句和赋值表达式是相同的概念，此说法对吗？_不正确_。
84.C语言本身不提供输入输出语句，输入和输出操作是由_函数_来实现的。
85.printf函数的作用是_向终端输出若干个任意类型的数据_。
86.putchar函数的作用是_向终端输出一个字符_。
87.scanf函数的作用是_从终端输入若干个任意类型的数据_。
88.getchar函数的作用是_从终端获取一个字符_。
89.scanf函数中应当是变量_地址_，而不应是变量名。
90.程序执行时，注释语句使计算机在屏幕上打印//之后的文本。此说法对吗？_不正确_。
99.所有变量都应先声明后使用。此说法对吗？_正确_。
100.C中变量number和NuMbEr是相同的。此说法对吗？_不相同_。
101．C语言既具有高级语言的特点，又具有低级语言的功能，因而具有广泛的用途和很强的生命力。其指针运算和_位_运算就很适合于系统软件设计的需要。
102．位运算是指进行_二进制位_的运算。

103．一个字节一般由_8_个二进位组成，每一个二进位的值是_0or1_。
104．原码只将最高位作符号位（以_0_代表正，_1_代表负），其余个位代表数值本身的绝对
值（以二进制表示）。
105．_正整数_的补码同其原码相同，_负数_的补码为：最高位是1，其余各位为原码的相应位取反，然后对整个数加1。
106．_0_的补码是唯一的，其值为_0_。
107．用补码进行运算，减法可以用_加法_法来实现。
108．计算机是以_补码_码形式存放数的。
109．按位与运算的特殊用途：_清零_、取一个数中某些指定位、保留一个数中的某一位。
110．按位或运算常用来对一个数据的某些位定值为_1_。
111．按位异或运算的特殊用途：使特定位_翻转_、交换两个值，不用_临时变量_。
112．同一个数与本身相_异或_运算，结果必为0。
113．取反运算符的优先级别比算术运算符、关系运算符、逻辑运算符和其它位运算符都_
高_。
114．左移比乘法运算快得多，乘2运算可用左移_1_位来实现。
115．右移一位相当于除以_2_。
116. 以下程序的运行结果是 9,10,9,9 。
#include <stdio.h>
void main()
{
    int i=8,j=9,m,n;
    m=++i;
    n=j++;
    printf("%d,%d,%d,%d\n",i,j,m,n);
}
117．以下程序的运行结果是 2,1,2  。
#include <stdio.h>
void main()
{
    int a,b,c;
    a=b=c=1;
    if (a++||++b) c++;
    printf("%d,%d,%d\n",a,b,c);
}
118． 以下程序的输出结果是 1,2,0 。
#include <stdio.h>
void main()
{
    int k, i=0, j=2;
    k = i++&&j++;
    printf ("%d,%d,%d\n", i, j, k);
}
119．下列程序的输出结果是 2 。
#include <stdio.h>
void main()
{
    int a = 3, b = 4 , c = 5;
    printf( " %d \n ", a++ - c++ + b );
}
120．下列程序的输出结果是 66 。
#include <stdio.h>
void main()
{
    int a = 3 , b = 14 , c = 5 ;
    c = c + a *a + b % 5 * 10 ;
    printf("%o\n" , c ) ;
}
121．有以下程序, 若从键盘输入：247<回车>，则程序的输出结果是 6689 。
#include <stdio.h>
void main()
{
    int c;
    while ((c=getchar())!='\n')
    {
        switch (c-'2')
        {
            case 0:
            case 1: putchar(c+4);
            case 2: putchar(c+4);break;
            case 3: putchar(c+3);
            default:putchar(c+2);break;
        }
    }
}
三、问答题
1. 字符型常量和字符串常量有什么区别？
解：字符型常量与字符串常量的书写方式不同，用单引号括起来的的单个字符是字符型常量，用双引号括起来的字符序列是字符串常量。字符串常量与字符型常量的存储方式不同，C编译程序在存储字符串常量时，自动采用\0作为字符串常量的结束标志。C编译器在存储字符型常量的时候,通常是存储该字符所对应的ASCII码值,这一点和整数的存储原理相似。
2. 已知int i=5,j=5;试问表达式或函数输出的值：
（1）i++  - ++j   -1                （2）++i  - j++   1
（3）printf (“%d\n”,++i+(++j));  12 （4）printf (“%d\n”,i++ +j); 10
//后++是先取值后执行  前++是先执行后取值
3. 程序改错：
    #include <stdio.h>
void main( )
{   float f=7.12;
    char c=“c”; //字符常量应用‘’
    printf(“%d\n”,int(f%3));//%运算的操作数必须都是整数
    printf("%c",c);
}
解：正确程序如下。
#include <stdio.h>
void main( )
{
    float f=7.12;
    char c='c';                     /*修改  */
    printf("%d\n",(int)f%3);        /*修改  */
    printf("%c",c);
}
4. 请指出以下程序段中的错误:
#include <stdio.h>
void main ( )
{
short j,i,k;
char a,b,c;
float x, y, z;    //short类型的整数极限值是32767~-32768
i=30000;
j=30000;
a= '9';
b= '5';
k=a*i+b*j;     //short类型的整数极限值是32767~-32768
//已经超出了数据极限
z=x*x+y*y;//x和y未赋初始值
}
答：错误的地方如下：
（1）变量k的值溢出，不能得到正确结果。
（2）变量x和y未赋初值。
5. 以下程序的输出是什么?
#include <stdio.h>
void main ( )
{
    int i;
    unsigned int j;
    i= ~0;
//解析过程:
//  1.默认的0就是-0,该-0的反码为1111 1111 1111 1111
//  2.那么,此时的内存数据就是1111 1111 1111 1111
//  3.只要存储的二进制内存数据一致,那么解析一致,效果一致
//      解析不一致,效果不一致
//有符号解析:
//  内存数据:1111 1111 1111 1111 1111 1111 1111 1111
//  补码数据:1111 1111 1111 1111 1111 1111 1111 1111
//  反码数据:1111 1111 1111 1111 1111 1111 1111 1110
//  原码数据:1000 0000 0000 0000 0000 0000 0000 0001->-1
//无符号解析:
//  内存数据:1111 1111 1111 1111 1111 1111 1111 1111
//  全是数据:0xffffffff->4294967295
//  有符解析:-1s
    j= ~0;
    printf ("i=%d  j=%d\n",i,j);
}答：-1,-1
6. 使用运算符++可以把以下3个语句写成一个语句。请设法写出这个语句，并编程上机验证结果。
y=y+1;   //这里表示给y先自增1
z=x+y;   //这里表示给z赋x+y的值
x=x+1;   //这里表示给x后自增1
答：z=(x++)+(++y)
7. 假定输入的数据流如下：
23.456789 12.23 567 hello F 34.32
为了把第二个数赋给变量second，把第三个数赋给变量third，把字符’F’赋给变量
ch。问scanf( )函数的表示形式是什么？
解: scanf("%*f%f%d%*s%*c%c",&second,&third,&ch);
//字符格式控制符不能指定长度
8. 找出并更正以下程序中的错误。
    #include <stdio.h>
void main ( )
{
    double pound;
    double kilograms;
    scanf (“%f”,pound); //双精度小数应该用%lf进行控制台录入
    kilogram=pound/2.2;
    printf (“%d pounds equals %d  kilograms\n”,pounds,kilograms);
}//双精度小数运算结果这里是除以2.2  所以也是double类型
答：
正确的程序如下：
#include <stdio.h>
void main ( )
{
    double pound;
    double kilograms;
    scanf ("%lf",&pound );  /* 输入输出double型数，要使用格式符%lf */
    kilograms=pound/2.2;
    printf ("%lf pounds equals %lf kilograms\n",pound , kilograms);
}

9. 语句printf("a\bRe\'CH\'y\\\bou\n");的输出结果是  Re’CH’you  。
10. 说明下面程序的输出结果：
#include <stdio.h>
void main()
{
    int x='f';
    printf("%c\n", 'A'+(x-'a'+1));
}//这里会按照ascii码值进行运算120-97+1+65=71  ascii码71对应大写字母G
答：输出大写字母G。因为x-’a’是字符常量’f’的ASCII码值减去字符常量’a’的ASCII码值。结果是5，加1后为6。于是’A’+6得到的是大写字母G的ASCII码值。按格式“%c”输出，即是字母G。
11. 分析下面程序的输出结果。
#include<stdio.h>
void main( )
{
    int x,m,n,a,b;
    m=n=a=b=8;
    x=(m=a>b)&&(n=a>b);
    printf("x=%d,m=%d,n=%d\n",x,m,n);//x=9,m=0,n=8
}
//这里把a>b的逻辑值赋值给m  这里不成立表示0，而&&运算符左边为0就不考虑右边的值，就直接把左边的逻辑值赋值给x，所以x=0,m=0而n是刚才&&没有运算的值  也就是初始值，
【解】输出结果是：
x=0,m=0,n=8
这里，变量m、n、a、b初始值都是8。语句
x=(m=a>b)&&(n=a>b);
把逻辑表达式(m=a>b) &&(n=a>b)的值赋给变量x。逻辑运算符&&左右两边都是赋值表达式：左边是把关系表达式a>b的值赋给变量m；右边是把关系表达式a>b的值赋给变量n.
    在计算这个逻辑表达式取值时，左边的关系表达式a>b不成立，因此取值为0。也就是说，变量m的值为0，所以&&左边的条件取值为假。于是，C语言不再去计算这个逻辑表达式右边的条件，而直接把逻辑值0赋给变量x。正因为没有去计算右边表达式的取值，所以并没有做把关系表达式的a>b的值赋给变量n的操作。因此变量n仍保持它原有的值8。
12. 执行下面的程序后，变量b里的值是什么？
#include <stdio.h>
void main( )
{
    int x =35;
    char c='A';
    int b;
        10 0011
        00 1111
        00 0011
    b=((x&15)&&(c<'a'));
    printf("%d\n",b);//1
}
【解】这里是要把逻辑表达式（x&15）&&(c<‘a’)的值赋给变量b。该逻辑表达式进行的是逻辑与（“&&”）运算。它的左边是一个位逻辑表达式，右边是一个关系表达式。
先来看左边的x&15。从图3- 4看出，运算结果是3，即是逻辑真，取值为1。
//这里0&任何数都得0，1&任何数都得其本身
再来看右边的关系表达式c<‘a’。由于变量c里存放的是’A’，它的ASCII码值（65）小于’a’的ASCII码值（97）。因此，该关系成立，运算结果为1。
所以，整个逻辑表达式的结果是1。因此，程序执行后，变量b里的值是1。
13. 以下程序的执行结果是什么？为什么？
#include <stdio.h>
main ( )
{
    long a=32767;
    long b;
    b=a+1;
    printf ("a=%ld,b=%ld\n",a,b);
}
解：这里都是长整型数，存储一个数的位数是32，故直接相加即可。
所以，本程序的执行结果为  =32767,b=32768
//这里a和b都是长整型数，所以直接相加
14. 执行以下程序时输入：
1234567
请写出程序运行结果。
#include <stdio.h>
void main( )
{
    int x,y;
    scanf("%2d%*2s%1d",&x,&y);
    printf("x=%d,y=%d\n",x,y);
}
解：scanf ( )函数中第一个格式说明为“%2d”，表示接受两个数字即12赋给x；第二个格式说明为“%*2s”，表示接受两个数字不赋给任何变量，即跳过34；第三个格式说明为“%1d”，表示接受一个数字即5赋给y。所以程序输出为：
x=12,y=5
15. 阅读程序，并按给定的输出格式将程序运行结果写在“运行结果：”之后
#include <stdio.h>
void main()
{
    int i;
    float f;
    char c;
    scanf("%d %c %f", &i ,&c, &f);
    printf ("i= %d, c=%c, f=%f \n", i, c, f);
}
当输入100a1.563时，程序的运行结果是：i=100,c=a,1.563000
当输入1.23456时，程序的运行结果是：i=1,c=,f=23456.000000
//这里会按照各自数据类型去解析，100a1.563，%d会解析到数字结束位置为止然后到%c，它会解析一个字符，最后一个%f会解析一个实数类型的数据
16. 阅读程序，并按给定的输出格式将程序运行结果写在“运行结果：”之后
#include <stdio.h>
void main()
{
    int i = 010, j = 10, k = 0x10;
    printf ("i=%d, j=%d, k=%d \n", i, j, k);
}
运行结果是:i=8,j=10,k=16
//这里定义分别是按八进制十进制十六进制定义，而打印时按照十进制打印，所以会自动把八进制和十六进制转换成十进制
17. 阅读程序，并按给定的输出格式将程序运行结果写在“运行结果：”之后
#include <stdio.h>
void main()
{
    int a = 7, b = 9;
    a = a + b;  b = a - b;  a = a - b;
    printf ("a=%d, b=%d \n", a,b);
}
运行结果是：a=9,b=7
//典型的不用第三方变量进行数据交换，不适用于较大数据，否则会有溢出风险
18. 阅读程序，并按给定的输出格式将程序运行结果写在“运行结果：”之后
#include <stdio.h>
void main()
{
    int a, b, c;
    a = (b = (c = 3) * 5)*5;
    printf ("a=%d, b=%d, c=%d \n", a, b, c);
}
运行结果是：a=75,b=15,c=3
19. 阅读程序，并按给定的输出格式将程序运行结果写在“运行结果：”之后
#include <stdio.h>
void main()
{
    int a = 16, b, x = 6, y, z;
    b = a+++1;   //++优先级会高于+，所以是（a++）+1，b=17，a=16
    printf ("b=%d \n", b);//b=17
    x *= a = b;//赋值运算符的结合性是自右向左，所以会先把b的值赋值给a
    printf ("x=%d \n", x);//102
    x = 1;  y = 2;  z = 3;
    x += y += z;//x=6，y=5，z=3
    printf ("%d \n",z+=x>y?x++:y++);//9
}
运行结果是:条件运算符的优先级大于赋值运算符条件运算符是具有返回值的
 ：运行结果是：
b=17
x=102
9
//这里需要注意的是复合运算符优先级低于三目运算符，所以先执行索娜姆运算符，最后执行复合运算
20. 阅读程序，并按给定的输出格式将程序运行结果写在“运行结果：”之后
#include <stdio.h>
void main( )
{
    printf("  ab c\t de\rf\tg\n");
    printf("h\ti\b\bj   k");
}
：运行结果是：\r表示回车,回到当前行的首部进行下一次输入,原先存在的依然保留,注意后输入的数据具有覆盖效果,覆盖不完的部分依然进行显示
f       gde
h      j   k
21. 阅读程序，并按给定的输出格式将程序运行结果写在“运行结果：”之后
#include <stdio.h>
void main( )
{
    char c1, c2;
    int n1, n2;
    c1 = getchar();  c2 = getchar();
    n1= c1 - '0';  n2 = n1*10 + (c2 - '0'); //字符0的ascii码是48，这里的getchar是等待输入一个字符，会把48拆解开当作两个字符解析，4的ascii码是52，8的ascii码是56，c2-‘0’就是8，n1*10就是40，加8 就是48，按照十进制整数打印就是48
    printf ("%d\n", n2);
}
若输入48，则运行结果是：48
22.阅读程序，并按给定的输出格式将程序运行结果写在“运行结果：”之后
#include <stdio.h>
void main( )
{
    char c;
    int n=100;
    float f=10;
    double x;
    x=f*=n/=(c=50);
    printf("%d %f\n",n,x);2,20.000000
}
运行结果：
 ：
2 20.000000
//n是int类型，x是double类型，赋值号回自动进行类型转换
23.阅读程序，并按给定的输出格式将程序运行结果写在“运行结果：”之后
#include <stdio.h>
void main( )
{
    int a,b,c;
    a=10; b=20; c=(a%b<1)||(a/b>1);
    printf("%d %d %d\n",a,b,c);
}//按优先级运算，%<  左边不成立为0，再看右边/>也不成立都是0就返回0，这里没有对a和b进行赋值，所以还是初始值
运行结果：10 20 0
24.阅读程序，并按给定的输出格式将程序运行结果写在“运行结果：”之后
#include <stdio.h>
void main()
{
    int x=0210; //定义变量赋值八进制0210
//010001000
//1000 1000
//88
    printf("%X\n",x);//按十六进制解析就是88
}
运行结果：88
25.阅读程序，并按给定的输出格式将程序运行结果写在“运行结果：”之后
已知字母A的ASCII码为65。以下程序运行后的输出结果是______。
#include <stdio.h>
void main()
{
    char a, b;
    a='A'+'5'-'3'; b=a+'6'-'2';
    printf("%d %c\n", a, b);//67 G
}

//运算结果a=67，b=71，这里按照十进制整数打印a就是67按字符打印b就是G
运行结果：67 G
26.阅读程序，并按给定的输出格式将程序运行结果写在“运行结果：”之后
已知字符A的ASCII代码值为65，以下程序运行时若从键盘输入  33<回车>，则输出结果是______。
#include <stdio.h>
void main()
{
    char a,b;
    a=getchar();
    scanf("%d",&b);
    a=a-'A'+'0';b=b*2;//’A’=65   ‘0’=48 ‘3’51
    printf("%c %c\n",a,b);//ASCII34,6对应的字符
}
四、编程题:
1. 编写程序，读入3个双精度数，求它们的平均值并保留此平均值小数点后一位数，对小数点后第二位数进行四舍五入，最后输出结果。
【分析与解答】
（1）定义4个双精度变量a、b、c和ave,变量a、b、c分别存放读入的3个双精度数，ave存放它们的平均值。
（2）设计输入语句，以及在此之前用于提示输入的（printf）语句。
（3）设计求平均值的算法，把所求得平均值放入变量ave中。
（4）设计把变量ave中的数，从小数点后第二位数进行四舍五入的算法。现举例说明：若ave中的数为123.4644，为了保留此值小数点后一位，可用表达式：（int）（123.4644*10）/10.0;依次推算，为了保留此值小数点后二位，可用表达式：（int）（123.4644*100）/100.0;其他依次类推。
（5）若要求对小数点后第二位数进行四舍五入，则可对原数加0.05后再进行以上运算。如要求保留123.4644小数点后一位且对第二位数进行四舍五入，可用表达式：（int）（（123.467+0.05）*10）/10.0。注意：分母一定要用实数10.0而不能用整数10，否则就变成整除了；若要求保留123.4644小数点后两位且对第三位数进行四舍五入，可用表达式：（int）（（123.467+0.005）*100）/100.0;其他依此类推。
（6）设计输出语句。输出a、b、c和ave。
（7）把以上内容放在主函数的一对花括号中。
（8）编写程序如下：
#include <stdio.h>
void main()
{
    double a,b,c,ave;
    printf("Enter a,b,c：");
    scanf("%1f %1f %1f", &a,&b,&c);
    ave=(a+b+c)/3;
    printf("ave=%f\n",ave);     /*用以比较四舍五入前后的数据*/
    ave=(int)((ave+0.05)*10)/10.0;
    printf("a=%f,b=%f,c=%f,ave=%f\n",a,b,c,ave);
 }

2. 编写一个简单的C程序，输出以下信息：
* * * * * * * * * * * * *
C program!
* * * * * * * * * * * * *
#include <stdio.h>
void main ( )
{
    printf("* * * * * * * * * * * * * \n");
    printf("     C program! \n");
    printf("* * * * * * * * * * * * * \n");
}
3. 编写一个程序，输入一个弧度值，并将其换算成角度值（度、分、秒的形式）输出。
提示：设x为弧度，则对应的角度为180*x/∏,其整数部分为度数，余下的部分乘60，其整数部分为分数，再将余下的部分乘60，其整数部分为秒数。
#define pi 3.14159
#include <stdio.h>
void main()
{
    float x,a,a1;
    int d,f ,m;
    printf("请输入弧度:");
    scanf("%f",&x);
    a=x*(180/pi);
    d=(int)a;
    a1=(a-d)*60;
    f=(int)a1;
    m=(int)((a1-f)*60+0.5);
    printf("%g弧度  <=>  %d度%d分%d秒\n",x,d,f,m);
}
4. 编写一个程序，输入一个摄氏温度，输出其对应的华氏温度。
提示：摄氏温度与华氏温度之间的转换公式为：华氏温度=9*摄氏温度/5+32。
#include <stdio.h>
void main()
{
    double s, h;
    printf("请输入摄氏温度:");
    scanf("%lf", &s);
    h = 9 * s / 5 + 32;
    printf("摄氏%lf温度所对应的华氏温度是%lf \n", s , h);
}
5. 编写一个程序，输入半径，输出其圆周长、圆面积、及圆球体积。
#define pi 3.14159
#include <stdio.h>
void main()

{
    double r = 0.0, c = 0.0, s = 0.0, v = 0.0;
    scanf("%lf", &r);
    c = 2 * PI*r;
    s = PI *r * r;
    v = PI*r * r * 4 / 3 * r;
    printf(" c = %lf, s = %lf, v = %lf \n");
}
6. 输入一个字符，分别输出其前导字符、该字符、后续字符。
#include <stdio.h>
void main()
{
    char chr = '\0';
    chr = getchar();
    printf("qchr = %c, chr = %c, hchr = %C \n", chr - 1, chr, chr + 1);

    system("pause");
}

7.对任意输入的一个字符进行加密，然后解密，输出加密解密的结果。
【解】设一个常量d为加密码，利用异或运算对字符c进行加密，解密过程则是再一次利用异或运算。程序如下：
#include<stdio.h>
void main( )
{
    char dcode = '\0', code = '\0', rcode = '\0';
    int pass = 1234;
    scanf("%c", &dcode);
    printf("dcode = %c \n", dcode);
    code = dcode ^ pass;
    printf("code = %c \n", code);
    rcode = code ^ pass;
    printf("rcode = %c \n", rcode);
}
8. 输入三个整数，按从小到大的顺序进行输出。
#include<stdio.h>
#include <stdio.h>
void main()
{
    int a = 0, b = 0, c = 0;
    scanf("%d %d %d", &a, &b, &c);
    if (a > b)
    {
        a = a^b;
        b = a^b;
        a = a^b;
    }
    if (a > c)
    {
        a = a^b;
        b = a^b;
        a = a^b;
    }
    if (b > c)
    {
        b = b ^c;
        c = b ^c;
        b = b ^c;
    }
    printf("a = %d , b = %d , c = %d \n", a, b, c);

    system("pause");
}