* 4*

3.66700000

* 4*

*4*

*       4*

* 4*

      3

4

*       4*

* 4

*       4*

*       4*

浮点数 3.667 被四舍五入到最接近的整数 4。

由于指定了 .0，小数部分被省略。

整个数字（现在是整数 4）被格式化为至少8个字符宽，但由于数字本身只有1个字符宽，所以在左侧添加了7个空格以达到总宽度8。

数字两侧分别打印了一个星号 *。

*       4*

*       4*

*     4*

*       4

*       4*

*       4*

＊ 4*

*       4*

*       4*

*       3*

*       4*

* 3*

* 4*

*3.6*

* 4*

       3

*       4*

答案：*       （7个空格）4*，c语言中浮点类型遵循四舍五入规则

*       4*

*4*

*       4*

4

*       4*

* 4*

1. void main()

{ 

float y=3.667;

printf("*%8.0f*\n",y);

}

结果：*4*

2.void main()

{ 

int x=1,y=2;

printf("%d,",x>y?y++:x++);

printf("%d,",x<=y?++y:++x);

printf("%d,%d",x,y);

}

结果：1,3,2，3

3.void main()

{ int x=0,y=0,z=0;

do

{

switch(y++)

{

case 1:x++;break;

case 3:x+=3;break;

default:x=x%2;continue;

}

z++;

}

while(y<5);

printf("x=%d,y=%d,z=%d\n",x,y,z);

}

结果：x=0, y=5, z=2

4. 若有定义和语句：double x=34213.6894; printf("*%8.2e*\n", x); 则下列说法真确的是：

A. 输出值为*3.42e+04*B. 输出值为*3.42e+004*

C. 输出值为*34.21e+04*D. 输出格式符宽域不够，不能输出值

答案：B

5.void main()

{int a=2,b=5;

printf("a=%%d,b=%%d\n"); 

}

结果为：

A. a=%2，b=%5B. a=2，b=5

C. a=%%d，b=%%d D. a=%d，b=%d

答案：D

6. 以下叙述中正确的是
　A）用C程序实现的算法必须要有输入和输出操作
　B）用C程序实现的算法可以没有输出但必须要有输入
　C）用C程序实现的算法可以没有输入但必须要有输出
　D）用C程序实现的算法可以既没有输入也没有输出

7. 结构化程序由三种基本结构组成，三种基本结构组成的算法
　A) 可以完成任何复杂的任务B) 只能完成部分复杂的任务
　C) 只能完成符合结构化的任务    D) 只能完成一些简单的任务

8.以下选项中可作为C语言合法常量的是
　A）-80.　B）-080
　C）-8e1.0　D）-80.0e01 

9.在c语言学习书籍中常见十进制转化二进制题目：将十进制数23588转化成二进制：

错：#include <stdio.h>

void main()

{

unsigned long a=23588,n=0;/*数据类型长度可能不够*/

while(a)

{n=10*n+a%2; /*首次a%2可能为0 */ 

a=a/2;

}

while(n)

{printf("%d",n%10);

n=n/10;

}

printf("\n");

}

对：#include <stdio.h>

void main()

{

int a=23588,n=0,b[20];

while(a)

{b[n++]=a%2;

a/=2;

}

for(n--;n>=0;n--)

printf("%d",b[n]);

printf("\n");

}

10.设有如下函数:

func(float a)

{printf(“%d\n”,a*a);

}

则函数的类型是:

A.无法确定B.intC.floatD.void

(在C语言中，若对函数类型未加显示地说明，则函数的隐含类型为int型)

11.宏定义#define E 2.71828中，宏名“E”代替一个 字符串。

12.下面的叙述中，错误的是：

A.#include命令可以包含扩展命名为“.c”的文件

B.#include“test\\test.h”是一个正确的文件包含命令

C.#include<…>中可以包含路径

D.使用#include<…>比#include“…”节约编译时间

（#include命令的包含文件可以带目录，并且目录的书写格式必须符合操作系统的习惯，由于它不是C语言的字符串，不能用“\\”来表示“\”）

13.下列程序的结果是：

#include <stdio.h>

#define PR printf

#define NL "\n"

#define D "%d"

#define D1 D NL

#define D2 D D NL

main()

{int a=1,b=2;

PR(D1,a);

PR(D2,a,b);

} 

A.1B. 1C. 1D.程序错误，值为任意值

121212

14. 下列程序的结果是：

#include <stdio.h>

#define PR(a) printf("%d\t",(int)(a));

#define PRINT(a) PR(a);printf("ok!")

main()

{int i,a=1;

for(i=0;i<3;i++)

PRINT(a+i);

printf("\n");

}

结果为：123ok!

15.以下可以讲char型变量s中的大小写字母进行转化（即大写改小写，小写改大写）的语句是：

A．s=s^32B．s=s&32C．s=s|32D．s=s+32

16.以下程序的输出结果是:

main()

{char a=0xf0,b=03,c;

c=~a&020>>b;

printf("%x\n",c);

}

结果：2（注意运算符优先级高低）

17.若有以下定义和语句:

int *p,i=1;

double *w,a=3.5;

p=&i; w=&a;

在执行了p=(int *)w;语句后，*p的值为：

A.4B．3.5C．3D．一个整数

注意:double类型的数据与int类型数据存放的机制不同，因此无法估计此证书的确切值

18.已知函数说明语句：void *f（）；则它的含义是:

A.函数f的返回值是一个通用型指针

B.函数f的返回值可以是任意的数据类型

C.函数f无返回值

D.指针f指向一个函数，该函数无返回值

19.已知int a[]={1,2,3,4},y,*p=&a[1]; y=(*--p)++;则y的值是

A.1B．2C．3D．4

20．函数的功能是交换变量x和y的值，且通过正确调用返回交换结果，能正确执行此功能的函数是：

A.funa（int *x，int*y）

{int *p；

*p=x；*x=*y；*y=*p；

}

B.funb(int x,int y)

{int t;

t=x；x=y；y=t；

}

C.func（int *x，int *y）

{*x=*x+*y;*y=*x-*y;*x=*x-*y；

}

D.fund（int *x，int *y）

{*x=*y；*y=*x; 

}

21.设有如下定义

struct sk

{int n;

float x;

}data,*p;

若要使p指向data中n域，真确的赋值语句是：

A.p=&data.n;B．*p=data.n; 

C.p=(struct sk *) &data.n;D．p=( struct sk *) data.n; 

22.以下程序的输出结果是 256。

union

{char m[2]; int k;} mk;

main()

{mk.m[0]=0; 

mk.m[1]=1;

printf("%d\n",mk.k);

}

解：char占一个字节，int占两个字节，共用体变量mk的两个成员共占用存储单元，给数组赋值后，存储状况如下图:

23.对于c语言特点有下列叙述中正确的是：

A. C语言中既有逻辑类型也有集合类型

B. C语言中没有逻辑类型但有集合类型

C. C语言中有逻辑类型但没有集合类型

D. C语言中既没有逻辑类型也没有集合类型

24.以下程序的输出结果是：

main()

{int p[7]={11,13,14,15,16,17,18},i=0,k=0;

while(i<7&&p[i]%2) k=k+p[i++];

printf("%d\n",k);

}

A.58B．56C．45D．24

25.以下程序段中，能过通过调用函数fun，使main函数中的指针变量p指向一个合法的整型单元是：

A.int fun(int *p)B.int fun(int **p)

{int s; p=&s;}{int s; *p=&s;}

main()main()

{int *p;{int *p;

fun(p);fun(&p);

}}

C.#include <stdlib.h> D.#include <stdlib.h>

int fun(int **p) int fun(int p)

{*p=(int *)malloc(2);} {p=(int *)malloc(sizeof(int));}

main()main()

{int *p; {int *p;

fun(&p);fun(p);

答案: C

*       4*

3.667000