全国高等学校计算机等级考试（二级C语言）选择题试题库
答案
试题
C
 1.  在C语言源程序中，以下叙述正确的是（C ）。
 A. main函数必须位于文件的开头   
 B. 每行只能写一条语句   
 C. 程序中的一个语句可以写成多行
 D. 每个语句的最后必须有点号
C
 2.  关于C语言的源程序的叙述中，错误的是（ C ）。
 A. C语言的源程序由函数构成
 B. main函数可以书写在自定义函数之后     
 C. 必须包含有输入语句
 D. 一行可以书写多个语句　
C
 3.  关于C语言数据类型的叙述，正确的是（  ）。
 A. 枚举类型不是基本类型
 B. 数组不是构造类型
 C. 变量必须先定义后使用
 D. 不允许使用空类型
C
 4.  C程序中main函数的位置（C ）。
 A. 必须在最开始
 B. 必须在系统库函数后面
 C. 可以在自定义函数后面
 D. 必须在最后
B
 5.  C语言的函数体由（ B）括起来。
 A. （ ）
 B.  { }
 C.  [ ]
 D.  /* */
D
 6.  关于C语言的叙述中，不正确的是（ D）。
 A. C程序可由一个或多个函数组成
 B. C程序必须包含一个main()函数
 C. C程序的基本组成单位是函数
 D. 注释说明只能位于一条语句的后面
D
 7.  以下叙述不正确的是（D  ）。
 A. C程序的执行总是从main函数开始
 B. 一个C源程序必须包含一个main函数
 C. C语言程序的基本组成单位是函数
 D. 在编译C程序源程序时，可发现注释中的拼写错误
C
 8.  结构化程序设计的三种基本结构是（ C ）。
 A. 函数结构、分支结构、判断结构
 B. 函数结构、嵌套结构、平行结构
 C. 顺序结构、分支结构、循环结构
 D. 分支结构、循环结构、嵌套结构
C
 9.  对于C语言源程序，以下叙述错误的是（ C ）。
 A. 可以有空语句
 B. 函数之间是平等的，在一个函数内部不能定义其它函数
 C. 程序调试时如果没有提示错误，就能得到正确结果
 D. 注释可以出现在语句的前面
D
 10.  下面关于C语言用户标识符的描述，正确的是（  ）。
 A. 不区分大小写
 B. 用户标识符不能描述常量
 C. 类型名也是用户标识符
 D. 用户标识符可以作为变量名
D
 11.  以下（ D ）是正确的变量名。
 A. 5f
 B. if
 C. f.5
 D. _f5
D
 12.  以下（D  ）是正确的常量。
 A. E-5
 B. 1E5.1
C. 'a12'//字符串用双引号
 D. 32766L
D
 13.  以下（  D）是正确的变量名。
 A. a.bee
 B. -p11
 C. int
 D. p_11
C
 14.  以下（  C）是正确的字符常量。单引号括起来
 A. "c"
 B. '\\''
 C. 'W'
 D. "\32a"
A
 15.  以下（  A）是不正确的字符串常量。双引号括起来
 A. 'abc'
 B. "12'12"
 C. "0"
 D. " "
B
 16.  以下（  B）是错误的整型常量。
 A. -0xcdf
 B. 018      //八进制数不能超过8
 C. 0xe
 D. 011
B
 17.  以下（B  ）是正确的浮点数。
 A. e3        //e前面必须有数字，指数必须为整数
 B. .62
 C. 2e4.5
 D. 123
A
 18.  若有说明语句：char c='\95'; 则变量c包含（  ）个字符。
 A. 1  \ddd :表示1到3位八进制数所代表的字符（ASCII码值）
 B. 2  \xhh表示 1到2位十六进制数所代表的字符
 C. 3
 D. 语法错误
A
 19.  若有定义：int a=2; 则正确的赋值表达式是（  ）。
 A. a-=(a*3)//a=a-(a*3)
 B. double(-a)  //(double)(-a)
 C. a*3
 D. a*4=3
C
 20.  语句x=(a=3,b=++a);运行后，x、a、b的值依次为（c  ）。
 A. 3,3,4    //逗号运算符及逗号表达式
 B. 4,4,3
 C. 4,4,4
 D. 3,4,3
B
 21.  语句a=(3/4)+3%2;运行后，a的值为（b  ）。
 A. 0
 B. 1  //注意除号/ 两边均为整型时，结果为整数（不含小数点）
 C. 2
 D. 3
A
 22.  char型变量存放的是（ A）。//考查变量类型
 A. ASCII代码值
 B. 字符本身
 C. 十进制代码值
 D. 十六进制代码值
C
 23.  若有定义：int x,a;则语句x=(a=3,a+1);运行后，x、a的值依次为（C ）。
 A. 3,3  //考查逗号表达式及逗号运算符
 B. 4,4
 C. 4,3
 D. 3,4
B
 24.  若有定义：int a; 则语句a=(3 * 4)+ 2 % 3;运行后，a的值为（ bB）。
 A. 12///////%取余
 B. 14
 C. 11
 D. 17
A
 25.  若有定义：int a,b; double x，则以下不符合C语言语法的表达式是（  Aa）。
 A. x%(-3) //%两侧均应为整型数据
 B. a+=-2
 C. a=b=2
 D. x=a+b
B
 26.  若有定义：int x=2,y=3;float i;，则以下符合C语言语法的表达式是（ B ）。
 A. x=x*3=2  //x*3不是一个变量名
 B. x=(y==1)
 C. i=float(x)  //应改为i=(float)x
 D. i%(-3)  //%两侧均应为整型数据
C
 27.  设double型变量a,b,c,e均有值;对代数式(3ae)/(bc)，不正确的C语言表达式是（ C ）。
 A. a/b/c*e*3
 B. 3*a*e/b/c
 C. 3*a*e/b*c //改为3*a*e/b/c
 D. a*e/c/b*3
B
 28.  下面叙述正确的是（ b ）。
 A. 2/3 与 2.0/3.0  等价
 B. (int)2.0/3 与 2/3 等价//强制类型转换将2.0转换成2
 C. ++5 与 6 等价  //单独写++5是错误的，可以写成a=++5
 D. 'A'与"A"等价
A
 29.  下面叙述中，错误的是（ A ）。
 A. 其算术运算对象不包含函数
 B. %(模运算符)的运算对象只能为整型量
 C. 算术运算符的结合方向是"自左至右"
 D. 自加和自减运算符的结合方向是"自右至左"
A
 30.  下面叙述正确的是（A）。　//++ --只能用于变量，而不能用于常量或表达式
 A. 强制类型转换运算的优先级高于算术运算
 B. 若a和b是整型变量,(a+b)++是合法的
 C. 'A'*'B' 是不合法的
 D. "A"+"B"是合法的
B
 31.  若有定义：int k,i=2,j=4; 则表达式 k=(++i)*(j--) 的值是（B ）。
 A. 8
 B. 12  //注意前缀 后缀的区别
 C. 6
 D. 9
C
 32.  设整型变量a为5，使b不为2的表达式是（C ）。
 A. b=(++a)/3
 B. b=6-(--a)
 C. b=a%2  //结果为1
 D. b=a/2 //QUZHENG
C
 33.  若有定义：int a=1,b=2,c=3; 则语句 ++a||++b&&++c;运行后b的值为（ ）。
 A. 1
 B. 0
 C. 2  //注意运算的不完全性
 D. 3
B
 34.  若有定义：int i,j;则表达式(i=2,j=5,i++,i+j++)的值是（ B ）。
 A. 7
 B. 8
 C. 9
 D. 10
B
 35.  若有定义：int a,b;则表达式(a=2,b=5,a*2,b++,a+b)的值是（b  ）。
 A. 7////a没有被赋值成为4，所以a=2
 B. 8
 C. 9
 D. 10
B
 36.  若有定义：int m=5,n=3;则表达式(m+1,n+1,(--m)+(n--))的值是（B  ）。
 A. 6///与上一题同理，mn没有被赋值
 B. 7
 C. 8
 D. 9
B
 37.  已知 int a;使用scanf()函数输入一个整数给变量a,正确的函数调用是（ b ）。
 A. scanf("%d",a);
 B. scanf("%d",&a);
 C. scanf("%f",&a);
 D. scanf("%lf",&a);
D
 38.  已知 double a;使用scanf()函数输入一个数值给变量a,正确的函数调用是（  d）。
 A. scanf("%ld",&a);
 B. scanf("%d",&a);
 C. scanf("%7.2f",&a); //输入数据时不能规定精度
 D. scanf("%lf",&a);
B
 39.  已知 char a;使用scanf()函数输入一个字符给变量a,不正确的函数调用是（ B ）。
 A. scanf("%d",&a);
 B. scanf("%lf",&a);  //字符型变量与整型等价，但不与浮点型等价
 C. scanf("%c",&a);
 D. scanf("%u",&a);
B
 40.  putchar()函数的功能是向终端输出（B ）。// char *str0;….;puts( str0);
 A. 多个字符//puts()才是输出多个字符
 B. 一个字符
 C. 一个实型变量值
 D. 一个整型变量表达式
D
 41.  getchar()函数的功能是从终端输入（D ）。
 A. 一个整型变量值
 B. 一个实型变量值
 C. 多个字符
 D. 一个字符
D
 42.  若有定义:int x=1234,y=123,z=12;则语句printf("%4d+%3d+%2d", x, y, z);运行后的输出结果为（D ）。
 A. 123412312
 B. 12341234123412341231231231212
 C. 1234+1234+1234
 D. 1234+123+12
A
 43.  已有如下定义和输入语句，
int a; char c1,c2;
scanf("%d%c%c",&a,&c1,&c2);
若要求a、c1、c2的值分别为10、A和B，正确的数据输入是（A  ）。
 A. 10AB //输入数据时，遇空格、回车、TAB、及非法输入 或按规定的宽度结束
 B. 10  A  B
 C. 10A  B
 D. 10  AB
B
 44.  已有如下定义和输入语句：
int a,b;
scanf("%d,%d",&a,&b); //“格式控制”字符串中除了格式说明还有其他字符，则输入//时应在相应位置输入
若要求a、b的值分别为10和20，正确的数据输入是（B  ）。
 A. 10  20
 B. 10,20
 C. a=10,b=20
 D. 10;20
D
 45.  以下程序的运行结果是（  D）。
void main()
{
  int a=65;
  char c='A';
  printf("%x,%d",a,c);
}
 A. 65,a
 B. 41,a
 C. 65,65
 D. 41,65
A
 46.  下面叙述中，（A  ）不是结构化程序设计中的三种基本结构之一。
 A. 数据结构
 B. 选择结构 
 C. 循环结构
 D. 顺序结构
A
 47.  下面叙述中,（A  ）不是结构化程序设计三种基本结构的共同特点。
 A. 先判断后执行
 B. 单入口，单出口
 C. 程序中没有执行不到的语句
 D. 无死循环
A
 48.  结构化程序设计不包括（ A ）。
 A. 最优化
 B. 自顶而下，逐步细化
 C. 模块化设计
 D. 结构化编码
D
 49.  以下运算符中优先级最高的是（D ）。
 A. >
 B. ||
 C. &&
 D. + //初等运算符（）[]  单目  算术 关系 逻辑（不含!） 赋值 逗号
A
 50.  若有定义:int x=3,y=4;则表达式 !x||y 的值为（ A）
 A. 1////0//非零=1
 B. O
 C. 3
 D. 4
A
 51.  若有定义:int i=7,j=8;则表达式 i>=j||i<j 的值为（ A）。
 A. 1
 B. 变量i的值
 C. 0
 D. 变量j的值
C
 52.  若希望当a的值为奇数时,表达式的值为"真",a的值为偶数时,表达式的值为"假"。则不能满足要求的表达式是（  C）。
 A. a%2==1
 B. !(a%2==0)
 C. !(a%2)//偶数时为1.奇数时为0
 D. a%2
D
 53.  若有定义：int x=3,y=4,z=5;则值为0的表达式是（D  ）。
 A. 'x'&&'y'//120&&121=1
 B. x<=y//1
 C. x||y+z&&y-z//////3//9&&-1
 D. !((x<y)&&!z||1) //考查运算符优先级
A
 54.  若有定义：int a=5,b=2,c=1;则表达式a-b<c||b==c的值是（A  ）。
 A. 0
 B. 1
 C. 2
 D. -1
A
 55.  已知double a=5.2; 则正确的赋值表达式是（a  ）。
 A. a+=a-=(a=4)*(a=3)
 B. a=a*3=2///a*3不是变量
 C. a%3////%两边都要是整形变量
 D. a=double(-3) 、、、（double）(-3)
A
 56.  已知char a='R'; 则正确的赋值表达式是（A  ）。
 A. a=(a++)%4
 B. a+2=3
 C. a+=256--
 D. a='\078'
A
 57.  已知int a='R'; 则正确的表达式是（A  ）。
 A. a%10///A=82
 B. a=int(3e2)
 C. 2*a=a++
 D. a=a+a=a+3  与C 同属一类错误
A
 58.  设单精度型变量f、g的值均为2.0，使f为4.0的表达式是（ A）。
 A. f+=g
 B. f-=g+2
 C. f*=g-6
 D. f/=g*10
B
 59.  若有定义：float x=3.5;int z=8;则表达式 x+z%3/4 的值为（ B）。
 A. 3.75
 B. 3.5
 C. 3
 D. 4
A
 60.  若有定义:int a=1,b=2,c=3,d=4,x=5,y=6;则表达式 (x=a>b)&&(y=c>d) 的值为（A ）。
 A. 0
 B. 1
 C. 5
 D. 6
A
 61.  若有定义：int a=2,b=3; float x=3.5,y=2.5;则表达式(float)(a+b)/2+(int)x%(int)y的值是（  A）。 //(float)(a+b)/2=2.5
 A. 3.5
 B. 3.0
 C. 2.5
 D. 2.0
C
 62.  若有定义：int b=7; float a=2.5,c=4.7;则表达式a+(b/2*(int)(a+c)/2)%4的值是（C）。
 A. 2.5 //(b/2*(int)(a+c)/2)=10 注意运算顺序
 B. 3.5
 C. 4.5
 D. 5.5
C
 63.  若有定义：int a=6,b=2;char c1='a',c2='b';则表达式a+b%5+c2-c1的值是（C）。
 A. 7
 B. 8
 C. 9
 D. 表达式错误
B
 64.  以下的if语句中，x的值一定被重新赋值的是（  ）。
 A. if(x==y) x+=y;
 B. if(x>y && x!=y );  //注意if语句后的空语句;
   x+=y;
 C. if(x!=y) 
   scanf("%d",&x); 
 else 
   scanf("%d",&y); 
 D. if(x<y) 
 { x++;y++; }
B
 65.  C语言对if嵌套语句的规定：else总是与（  B）配对。
 A. 第一个if
 B. 之前最近的且尚未配对的if
 C. 缩进位置相同的if
 D. 之前最近的if
B
 66.  对于整型变量x，下述if语句（B  ）与赋值语句：
     x=x%2==0?1:0;
不等价。
 A. if (x%2!=0) x=0; else x=1;
 B. if (x%2) x=1; else x=0;
 C. if (x%2==0) x=1; else x=0;
 D. if (x%2==1) x=0; else x=1;
B
 67.  若有定义:int x=1,y=2,z=4;则以下程序段运行后z的值为（ B）。
if(x>y) z=x+y;
else z=x-y;
 A. 3
 B. -1
 C. 4
 D. 不确定 
D
 68.  若有定义:int a=1,b=2,c=3;则执行以下程序段后a,b,c的值分别为（D ）。
if (a<b) 
{c=a;a=b;b=c;}
 A. a=1,b=2,c=3
 B. a=2,b=3,c=1
 C. a=2,b=3,c=3
 D. a=2,b=1,c=1
D
 69.  以下程序段运行后变量a的值为（ ）。
int x=6,y=5;
int a;
a=(--x==y++)?x:y+1;//X
已经被赋值为5了
 A. 0
 B. 1
 C. 6
 D. 5 、、、、、、、//2013-05-27.晚上21.13
C以下()是不正确的字符串常量
 70.  以下程序的运行结果是（  ）。//注意分支中有无break的区别
void main()
{
  int n='e';
  switch(n--)
  {
    default: printf("error "); 
    case 'a':
    case 'b': printf("good "); break;//break.跳出
    case 'c': printf("pass ");
    case 'd': printf("warn ");
  }
}
 A. error
 B. good
 C. error good
 D. warn
C
 71.  以下程序的运行结果是（ C ）。
void main()
{
  int n='c';
  switch(n++)
  {
    default: printf("error "); break;
    case 'a':
    case 'b': printf("good "); break;
    case 'c': printf("pass ");
    case 'd': printf("warn ");
  }
}
 A. pass
 B. warn
 C. pass warn
 D. error
D
 72.  以下程序的运行结果是（  ）。
void main( )
{ int n=5;
  if(n++>=6)先取值后运算n=6
    printf("%d\n",n);
  else
    printf("%d\n",++n);先运算后取值n=7
}
 A. 4
 B. 5
 C. 6
 D. 7
B
 73.  设有整型变量x,下述语句（B  ）不会出现死循环。
 A. for(;;x+=1);
 B. for(;(x=getchar())!='\n';);
 C. while(1) {x++;}
 D. for(x=10;;x--);
B
 74.  对于整型变量x,与while(!x)等价的是（ B ）。
 A. while(x!=0)
 B. while(x==0)
 C. while(x!=1)
 D. while(~x)
A
 75.  对于整型变量x和y，语句
    for(x=0,y=0;(y!=123)&&(x<4);x++) y++;
  中的“y++；”被执行（A  ）。
 A. 4次
 B. 0次
 C. 123次
 D. 3次
B
 76.  在c语言中while循环和do--while循环的主要区别是（B）。
 A. do--while循环体内可以使用break语句，while循环体内不能使用break语句
 B. do--while的循环体至少无条件执行一次，while的循环体不是
 C. do--while循环体内可以使用continue语句，while循环体内不能使用continue语句
 D. while的循环体至少无条件执行一次，do--while的循环体不是
B
 77.  以下程序段运行后，循环体运行的次数为（ BB）。
int i=10,x;
for (;i<10;i++) x=x+i;
 A. 10
 B. 0
 C. 1
 D. 无限
D
 78.  以下程序段运行后变量n的值为（ D）。
int i=1,n=1;
for (;i<3;i++)
   {continue;n=n+i;}//continue语句结束本次循环，转而进行下一次同层的循环过程
 A. 4
 B. 3
 C. 2
 D. 1
B
 79.  以下程序的运行结果是（  ）。
void main()
{
  int sum = 0, item = 0;
  while(item < 5)
  {
    item++;
    sum += item;
    if(sum==5)
      break;
  }
  printf("%d\n",sum);//sum不可能等于5
}
 A. 10
 B. 15
 C. 5
 D. 6
C
 80.  以下程序的运行结果是（C  ）。
void main()
{
  int sum = 0, item = 0;
  while(item < 5)
  {
    item++;
    sum += item;
    if(sum>=6)
      break;
  }
  printf("%d\n",sum);
}
 A. 10
 B. 15
 C. 6
 D. 7
B
 81.  以下程序的运行结果是（ B ）。
void main()
{
  int sum = 0, item = 0;
  while(item < 5)
  {
    item++;
    if(item == 2)
      continue;
    sum += item;
  }
  printf("%d\n",sum);//1+3+4+5=13
}
 A. 10
 B. 13
 C. 15
 D. 1
A
 82.  下列数组定义中，正确的是（A  ）。
 A. int a[5]={0};
 B. int a[]={0 1 2}; // int a[]={0 , 1,2}; 注意元素与元素之间加逗号
 C. int a[5]=0; // int a[5]={0};
 D. int a[]; //必须指明数组大小
A
 83.  下列数组定义中，正确的是（A  ）。
 A. int a[10];
 B. int n=10,a[n]; //下标必须是常量表达式
 C. int N=10;int a[N];
 D. int n;scanf("%d",&n); int a[n];
A
 84.  已知 int  a[10];  则对a数组元素引用不正确的是（ A ）。 
 A. a[10]  //10个元素的数组下标范围从0到9 ，故此题越界
 B. a[3+5]
 C. a[10-10] //引用数组元素时，下标可以是整型常量或整型表达式
 D. a[5]
B
 85.  若有定义:int a[3]={0,1,2};则a[1]的值为（B ）。
 A. 0
 B. 1
 C. 2
 D. 3
A
 86.  若有定义:int a[5]={1,2,3,4,5};则语句a[1]=a[3]+a[2+2]-a[3-1];运行后a[1]的值为（ A）。
 A. 6
 B. 5
 C. 1
 D. 2
D
 87.  以下能对一维数组a进行正确初始化的语句是（ D）。
 A. int a[5]=(0,0,0,0,0);
 B. int a[5]=[0]; //注意使用大括号
 C. int a[5]={1,2,3,4,5,6,7};//多余2个
 D. int a[]={0}; //定义一个只有一个元素的一维数组，指为0
D
 88.  下面程序段的运行结果是（  ）。
int i=0,a[]={3,4,5,4,3};
do{ 
 a[i]++;
 }while(a[++i]<5);//若为假则不执行循环直接跳出。。所以i=4,5不执行
for(i=0;i<5;i++)
  printf("%d ",a[i]);
 A. 4 5 6 5 4
 B. 3 4 5 4 3
 C. 4 5 5 5 4
 D. 4 5 5 4 3 
C
 89.  下面程序段的运行结果是（  ）。
int i=0,a[]={7,5,7,3,8,3};
do{
 a[i]+=2;
 }while(a[++i]>5);
for(i=0;i<6;i++)
  printf("%d ",a[i]);//与上题同理
 A. 9 7 9 5 10 5
 B. 9 5 9 3 10 3
 C. 9 5 7 3  8 3
 D. 7 5 7 3  8 3 
A
 90.  下面程序段的运行结果是（ A ）。
int i=0,a[]={1,2,3,4,5};
do{ 
  a[i]+=10;
  }while(a[++i]>2);
for(i=0;i<5;i++)
  printf("%d ",a[i]);
 A. 11  2  3  4  5
 B. 1   2  3  4  5
 C. 11 12 13 14 15
 D. 11 12  3  4  5 
C
 91.  设有如下程序段：
int a[3][3]={1,0,2,1,0,2,1,0,1},i,j,s=0;
for(i=0;i<3;i++)
  for(j=0;j<i;j++)
     s=s+a[i][j];
则执行该程序段后,s的值是（  c）。//a[1][0]+a[2][0]+a[2][1]
 A. 0
 B. 1
 C. 2
 D. 3
B
 92.  有如下定义
    int a[][3]={1，2，3，4，5，6，7，8}; //考查二维数组的初始化
则数组a的行数是（ b）。
 A. 2
 B. 3
 C. 4
 D. 无法确定的
D
 93.  以下数组定义中，正确的是（ d ）。
 A. int a[2][3]={1,2,3,4,5,6,7};//多余1个
 B. int a[][]={{1,2,3},{4,5,6},{7,8,9}}; //第二维长度不能省
 C. int a[2][]= {1,2,3,4,5,6};
 D. int a[][4]= {6};
A
 94.  若有定义:int a[3][4]={{1,2},{0},{1,2,3}};则a[1][1]的值为（ a）。
 A. 0
 B. {1,2}
 C. 1
 D. 3
A
 95.  若有定义:int a[3][3];则表达式&a[2][1]-a的值为（ ）。
 A. 7  //&a[2][1]-a 代表两者之间的元素个数，类似指向同种类型的指针相减
 B. 8
 C. 6
 D. 9
C
 96.  若有定义:int i=0,x=0;int a[3][3]={1,2,3,4,5,6,7,8,9};则以下程序段运行后x的值为（ c）。
for (;i<3;i++) x+=a[i][2-i];
 A. 0
 B. 12
 C. 15
 D. 18
D
 97.  若有定义int a[2][3];则对数组元素的非法引用是（ D ）。
 A. a[0][1/2]
 B. a[1][1]
 C. a[4-4][0]
 D. a[0][3]
C
 98.  以下数组定义中，正确的是（C  ）。
 A. int a[2][]={1,2,3,4,5}; //二维数组第二维长度不能省
 B. int a[][2]={{0},{}};
 C. int a[2][2]={{1,2},{3}};
 D. int a[][]={1,2,3,4};
D
 99.  若有定义int a[][3]={1,2,3,4,5,6,7,8,9};则表达式sizeof(a)/sizeof(a[0])
的值为（ D ）。
 A. 3
 B. 4
 C. 5
 D. 9
A
 100.  设有以下变量定义：
   char str1[]="string",str2[8],*str3,*str4="string";
（  ）是正确的。
 A. strcpy(str1,"China");
 B. str2="China";
 C. strcpy(*str3,"China");
 D. strcpy(str4[0],"China");
D
 101.  有如下定义：
   char str[6]={ 'a','b','\0','d','e','f'};
则语句:
   printf("%s",str);
的输出结果是（D  ）。
 A. ab\
 B. abdef
 C. ab\0
 D. ab
C
 102.  设有如下数组定义：
   char str[8]={ "FuJian"};
则分配给数组str的存储空间是（C  ）个字节。
 A. 6
 B. 7
 C. 8
 D. 9
B
 103.  若有定义:char a[]="abcdef";char b[]="xyz";则以下程序段运行后屏幕输出为（ B）。
strcpy(a,b);
printf("%c",a[2]);//strcpy字符串复制
 A. c
 B. z
 C. \0
 D. d
C
 104.  以下程序段运行后屏幕输出为（C）。
char a[]="abc\0mis";/\\\\\\\\\\\\\\\0字符串结束标志strlen作为计算字符串的长度
printf("%d",strlen(a));
 A. 5
 B. 8
 C. 3
 D. 4
B
 105.  若有定义:int a=2;则语句a=strcmp("miss","miss");运行后a的值为（ B）。
 A. 1  //相等返回0 ，字符串1>字符串2,返回一个正整数，否则返回负整数
 B. 0  //strcmp(str1,str2)
 C. -1
 D. 2
B
 106.  以下程序段运行后屏幕输出为（B  ）。
    char str[]="ab\\cd";    注意\\代表一个反斜杠字符
    printf("%d",strlen(str));
 A. 4
 B. 5
 C. 6
 D. 7
A
 107.  以下程序段运行后屏幕输出为（A  ）。
char str[80];strcpy(str,"hello");printf("%d",strlen(str));
 A. 5//strcpy 复制字符串。。strlen计算字符串的大小
 B. 6
 C. 7
 D. 80
B
 108.  若有定义：char str1[6]="abcdm",*ps,*str2="abcdef";（B）是正确的。
 A. strcpy(str1,str2); 
 B. 表达式strcmp(str1,str2)的值大于0
 C. str1=str2;
 D. 表达式strlen(str1)的值为6
A
 109.  设有如下函数定义：
int fun(char *str)
{ char *p=str;
  while ( *p != '\0') p++; 
  return (p-str);
}
则以下语句执行后的输出结果是（  ）。//返回字符串个数
printf("%d\n",fun("Student"));
 A. 7
 B. 8
 C. 9
 D. 10
A
 110.  以下程序的运行结果是（  ）。
int fun(int array[4][4])
{ int j;
  for(j=0;j<4;j++) printf("%2d",array[2][j]);
  printf("\n");
}
main()
{ int a[4][4]={0,1,2,0,1,0,0,4,2,0,0,5,0,4,5,0};
  fun(a);
}
 A. 2 0 0 5
 B. 1 0 0 4
 C. 0 1 2 0
 D. 0 4 5 0
C
 111.  如下fun函数的类型是（  ）。
fun(float x)
{double y; int z ;
 y=x * x ;
 z=(int)y ; 
 return(z); 
}
 A. void
 B. double
 C. int
 D. float
B
 112.  以下程序运行后屏幕输出为（ ）。
#include<stdio.h>
int f(int x,int y)
{
  return(x+y);
}
main()
{
  int a=2,b=3,c;
  c=f(a,b);
  printf("%d+%d=%d\n",a,b,c);
}
 A. 0
 B. 2+3=5
 C. 2+3=0
 D. 3+2=5
D
 113.  以下程序运行后屏幕输出为（ ）。 //考查全局变量与局部变量的区别及范围
#include<stdio.h>
int a=2,b=3;
int max(int a,int b)
{
  int c;
          c=a>b?a:b;
  return(c);
}
main()
{
  int a=4;
  printf("%d",max(a,b));
}
 A. 2,3
 B. 2
 C. 3
 D. 4
B
 114.  以下程序运行后屏幕输出为（ ）。
#include<stdio.h>
void f(int i)    //两个函数中的a不一样
{
  int a=2;
  a=i++;
  printf("%d,",a);
}
main()
{
  int a=1,c=3;
  f(c);
  a=c++;
  printf("%d",a);
}
 A. 4,3
 B. 3,3
 C. 4,5
 D. 3,5
D
 115.  若有如下函数定义： //注意静态变量的使用
int fun()
{
 static int k=0;
 return ++k;
}
以下程序段运行后屏幕输出为（  ）。
int i;
for(i=1;i<=5;i++) fun();
printf("%d",fun());
 A. 0
 B. 1
 C. 5
 D. 6
D
 116.  下面程序的输出结果是（  ）。
#include <stdio.h>
int global=100;
fun()
{
int global=5;
return ++global;
}
void main()
{
 printf("%d\n",fun());
}
 A. 100
 B. 101
 C. 5
 D. 6
B
 117.  下列关于C语言函数的描述中，正确的是（  ）。
 A. 函数的定义可以嵌套，但函数的调用不可以嵌套
 B. 函数的定义不可以嵌套，但函数的调用可以嵌套
 C. 函数的定义和函数的调用都可以嵌套
 D. 函数的定义和函数的调用都不可以嵌套
D
 118.  若有以下宏定义，
#define MOD(x,y) x%y
则执行以下程序段后，z的值是（  ）。
int z,a=15,b=100;
z=MOD(b,a);
 A. 100
 B. 15
 C. 11
 D. 10
B
 119.  以下叙述中，正确的是（B  ）。
 A. “#define PRICE=30”定义了与30等价的符号常量PRICE
 B. 预编译处理命令行都必须以“#”开头
 C. 宏名只能包含大写字母和数字字符 //可以包括小写字母
 D. 在程序的一行上可以书写几个有效的宏定义
A
 120.  Z以下叙述中，正确的是（ A）。
 A. 宏展开不占用运行时间，只占用编译时间
 B. 预编译处理命令行必须以分号结束
 C. 一个源程序只能有一个预编译处理命令行
 D. 使用带参数的宏定义时，应该说明每个参数的数据类型
C
 121.  以下的叙述中不正确的是（）。
 A. 宏展开不占用运行时间，只占用编译时间
 B. 宏名无类型
 C. 宏名必须用大写字母表示
 D. 预处理命令行都必须以#号开始
A
 122.  若有定义:#define PI 3,则表达式PI*2*2的值为（ ）。
 A. 12
 B. 4
 C. 3
 D. 不确定
C
 123.  以下程序运行后,屏幕输出为（ ）。
#define MIN(a,b) ((a)<(b)?(a):(b))
main()
{int x=2,y=3,z;
     z=2*MIN(x,y);
     printf("%d",z);
}
 A. 2
 B. 3
 C. 4
 D. 6
A
124.  下面程序的输出结果是（ ）。
#include <stdio.h>
#define SQR(x) (x*x)
void main()
{
  int a,b=3;
  a=SQR(b+2);
  printf("\n%d",a);//3+2*3+2
}
 A. 11
 B. 25
 C. 不定值
 D. 产生错误
C
 125.  下面程序的输出结果是（C ）。
#include <stdio.h>
#define ONE 1
#define TWO ONE+1
#define THREE TWO+1
void main()
{
  printf("%d\n",THREE-ONE);
}
 A. 产生错误
 B. 1
 C. 2
 D. 3
B
 126.  以下叙述中正确的是（ ）。
 A. 预处理命令行必须位于C源程序的起始位置
 B. 在C语言中，预处理命令行都以"#"开头
 C. 每个C程序必须在开头包含预处理命令行：#include<stdio.h>
 D. C语言的预处理不能实现宏定义和条件编译的功能
D
 127.  设有以下语句，则（  ）是对a数组元素的不正确引用，其中0≤i＜10。
    int a[10]={0,1,2,3,4,5,6,7,8,9}, *p=a;
 A. a[p-a]
 B. *(&a[i])
 C. p[i]
 D. *(*(a+i))
C
 128.  对于基类型相同的两个指针变量之间，不能进行的运算是（  ）。
 A. <
 B. =
 C. +//地址之间不能相加。可以相减
 D. -
B
 129.  执行以下程序段的输出结果是（  ）。
    int a=10,*p=&a;
    printf("%d",++*p);//*p为内容。。p才是指针变量
 A. 10
 B. 11
 C. 变量a的地址
 D. 变量a的地址 + 1
A
 130.  以下程序段运行后*(p+3)的值为（ ）。
char a[]="good";
char *p;
p=a;
 A. 'd'////数组名可以当做指针
 B. '\0'
 C. 存放'd'的地址
 D. 'o'
C
 131.  以下程序段运行后*(++p)的值为（ ）。
char a[5]="work";
char *p;
p=a;
 A. 'w'
 B. 存放'w'的地址
 C. 'o'
 D. 存放'o'的地址
B
 132.  若有定义:int *p,a=4; p=&a;则以下均代表地址的是（ ）。
 A. a,p
 B. &a,p //&取出地址，，p已经定义为指针变量
 C. &a,*p
 D. a,*p
D
 133.  若有说明语句：double *p,a;则能通过scanf语句正确给输入项读入数据的程序段是（ ）。
 A. *p=&a;scanf("%lf",p);
 B. *p=&a;scanf("%lf",*p);
 C. p=&a;scanf("%lf",*p);
 D. p=&a;scanf("%lf",p); //p已经定义为指针
A
 134.  在16位编译系统上，若有定义int a[]={10,20,30},*p=&a;当执行p++;后下列叙述错误的是（ ）。
 A. p向高地址移了一个字节//数组的元素移位一般都是两个字节
 B. p与a+1等价
 C. 语句printf("%d",*p);输出20
 D. p指向数组元素a[1]
B
 135.  下面语句正确的是（ ）。
 A. int *p; *p=20; 
 B. char *s="abcdef"; printf("%s\n",s);////指针指向字符串，书上内容
 C. char str[]="abcd"; str++;//数组名不能改变
 D. char str[]={'a','b','c'};printf("%s",str);  //%s输出字符串，必须以’\0’结束
D
 136.  若有以下程序段，且0≤i＜4，0≤j＜3，则不能正确访问a数组元素的是（  ）。
int i,j,(*p)[3];
int a[][3]={1,2,3,4,5,6,7,8,9,10,11,12};
p = a;
 A. *(*(a+i)+j)
 B. p[i][j]
 C. (*(p+i))[j]
 D. p[i]+j
B
137.  若函数fun的函数头为：
   int fun(int i, int j)
且函数指针变量p定义如下：
   int(*p)(int i, int j);
则要使指针p指向函数fun的赋值语句是（  ）。
 A. p=*fun;
 B. p=fun;
 C. p=fun(i,j);
 D. p=&fun;
D
 138.  设有如下变量定义：
    char aa[2][3]={'a','b','c','d','e','f'};
    char (*p)[3]=aa;
则以下程序段的运行结果是（  ）。
    p++;
    printf("%c",**p);
 A. a
 B. b
 C. c
 D. d
D
 139.  以下程序段运行后x的值为（ ）。
int a[]={1,2,3,4,5,6,7,8};
int i,x,*p;
x=1;
p=&a[2];
for(i=0;i<3;i++)
x*=*(p+i);
 A. 不确定
 B. 24
 C. 120
 D. 60
B
 140.  以下程序段运行后x的值为（ ）。
  int a[]={1,2,3},b[]={4,2,5};
int *p,*q;
int i,x;
p=a; q=b;
for(i=0;i<3;i++)
if(*(p+i)==*(q+i))
x=*(p+i)*2;
 A. 2
 B. 4
 C. 6
 D. 不确定
C
 141.  以下程序段运行后x的值为（ ）。
  int a[9]={1,2,3,4,5,6,3,8,9};
int *p,*q;
int i,x;
p=&a[0]; 
q=&a[8];
for(i=0;i<3;i++)
if(*(p+i)==*(q-i))
x=*(p+i)*2;
 A. 2
 B. 4
 C. 6
 D. 不确定
A
 142.  下面程序的输出结果是（ ）。
#include<stdio.h>
void main()
{
 int i;
 char *s="abc";
 for(i=0;i<3;i++)
   printf("%s\n",s+i);
}
 A. abc
 bc
 c
 B. c
 bc
 abc
 C. abc
 c
 bc
 D. a
 ab
 abc
A
 143.  下面程序的输出结果是（ ）。
#include <stdio.h>
void main()
{ 
 char *str="12345",*ps=str+4;
 printf("%c\n",ps[-4]);
}
 A. 1
 B. 2
 C. 3
 D. 错误
A
 144.  以下程序执行时，输入1  2  3  4  5<回车>，输出为：
#include <stdio.h>
#define N 5
void main()
{
int a[N];
int *p=a;
while(p<a+N)
  scanf("%d",p++);
while(p>a)
  printf("%d ",*(--p));
}
 A. 5 4 3 2 1
 B. 1 2 3 4 5
 C. 2 3 4 5 1
 D. 4 3 2 1 5
C
 145.  设有以下定义语句：
struct student
{ int num;
  char name[10];
  float score;
} wang,zhang;
则不正确的叙述是（  ）。
 A. struct是结构体类型的关键字
 B. zhang是结构体变量名
 C. wang是结构体类型名
 D. num，name，score都是结构体类型student的成员名
B
 146.  设有以下定义语句：
struct student
{ int num;
  char name[10];
  float score;
} wang,zhang;
则变量wang所占的内存字节数是（  ）。
 A. 14
 B. 16
 C. 18
 D. 20
B
 147.  设有如下定义语句：
union u_type
  { int i; //二个字节
    double x; //八个字节
    float f; //四个字节
  };
struct str_type
  { char str[100];
    union u_type u[2];
  };
则语句“printf("%d", sizeof(struct str_type));”的输出结果是（  ）。
 A. 100
 B. 116
 C. 120
 D. 200
C
 148.  若有定义:
struct teacher
{int num;
 char name[10];
 char sex;
 int age;
 float score;
}teacher1;
则变量teacher1所占用的内存字节数是（ ）。
 A. 5
 B. 14
 C. 19
 D. 20
C
 149.  下列对结构体类型变量定义不正确的是（ ）。
 A. struct teacher
{int num;
 int age;
}teach1; 
 B. struct 
{int num;
 int age;
}teach1,teach2;
 C. struct
{int num;
 int age;
}teacher;
   struct teacher teach1;
 D. struct teacher 
{int num;
 int age;
};
   struct teacher teach1;
D
 150.  若有定义:
struct teacher
{int num;
 char sex;
 int age;
}teacher1;
则下列叙述不正确的是（ ）。
 A. struct是结构体类型的关键字
 B. struct teacher是用户定义的结构体类型
 C. num,sex,age都是结构体变量teacher1的成员
 D. teacher1是结构体类型名
D
 151.  以下程序的运行结果是（ ）。
#include <stdio.h>
union Utype{
  int i;
  float f;
}u[2];
void main()
{
 printf("sizeof(u):%d\n",sizeof(u));
}
 A. 2
 B. 4
 C. 6
 D. 8
D
 152.  以下程序的运行结果是（ ）。
#include <stdio.h>
union Utype{
  int i;
  float f;
};
struct{
char ch[2];
int i;
union Utype u;
}a;
void main()
{
  printf("sizeof(a):%d\n",sizeof(a));
}
 A. 5
 B. 6
 C. 7
 D. 8
D
 153.  以下C语言共用体类型数据的描述中，不正确的是（ ）。
 A. 共用体变量占的内存大小等于所需内存最大的成员所占的内存
 B. 共用体类型可以出现在结构体类型定义中
 C. 在定义共用体变量的同时允许对第一个成员的值进行初始化
 D. 同一共用体中各成员的首地址不相同
A
 154.  若有以下定义：
struct link
{ int data;
   struct link *next;
}  *head, *p;
并已建立如下图所示的链表结构：
              ┌──┬──┐    ┌──┬──┐            ┌──┬──┐
    head →│data│next┼→│data│next┼→...─→│data│NULL│
              └──┴──┘    └──┴──┘            └──┴──┘
指针p指向如下结点:
      ┌──┬──┐
  p →│data│next│
      └──┴──┘           
则能够把p所指结点插入到链表中成为链表第2个结点的程序段是（  ）。
 A. p->next = head->next;  head->next = p; 
 B. head->next = p;  p->next = head->next;
 C.& =&;   = p;       
 D. (*head).next = p;  (*p).next = (*head).next;
D
 155.  若有以下定义：
struct link
{ int data;
   struct link *next;
}  a,b,c, *head, *p;
其中,指针head指向变量a, p指向变量c，a.next指向变量b，链表结构如下图所示：
               a               b                       c
         ┌──┬──┐  ┌──┬──┐          ┌──┬──┐
  head →│data│next┼→│data│NULL│      p →│data│next│
         └──┴──┘  └──┴──┘          └──┴──┘
则能够把c插入到a和b之间并形成新链表的程序段是（  ）。
 A.& = c;& = b;
 B.& = p;& =&;
 C. head->next = &c; p->next = head->next;
 D. (*head).next = p; (*p).next = &b;
A
 156.  若有以下定义：
struct link
{ int data;
   struct link *next;
}  *head, *p;
并已建立如下图所示的链表结构:
                            p 
                            ↓       
       ┌──┬──┐  ┌──┬──┐         ┌──┬──┐
head →│data│next┼→│data│next┼→...─→│data│NULL│
       └──┴──┘  └──┴──┘         └──┴──┘
则能保留链表其它结点，而删除p所指向结点的程序段是（  ）。
 A. head->next = p->next; free(p);
 B. head->next = p; p->next = head->next; free(p);
 C. free(p); head->next = p; p->next = head->next; 
 D. free(p); head->next = p->next; 
A
 157.  若有定义:
struct node
{ int data;
  struct node *next;
};
及函数：
void fun(struct node *head) 
{ struct node *p=head;
  while(p)
  { struct node *q=p->next;
    free(p);
    p=q;
  }
}
调用时head是指向链表首结点的指针，整个链表的结构如下图：
         ┌─┬─┐  ┌─┬─┐        ┌─┬─┐
  head →│2 │  ┼→│15│  ┼→ … →│27│  ┼→NULL
         └─┴─┘  └─┴─┘        └─┴─┘ 
则函数fun()的功能是（ ）。
 A. 删除整个单向链表
 B. 删除单向链表中的一个结点
 C. 显示单向链表中的所有数据
 D. 创建单向链表
C
 158.  若有定义：
struct node
{ int data;
  struct node *next;
};
及函数：
 void fun(struct node * head) 
 { struct node * p = head;
   while(p)
   {
    printf("%d  ", p->data );
    p = p->next;
    break;
   }
 }
调用时head是指向链表首结点的指针，整个链表的结构如下图：
         ┌─┬─┐  ┌─┬─┐        ┌─┬─┐
  head →│5 │  ┼→│17│  ┼→ … →│38│  ┼→NULL
         └─┴─┘  └─┴─┘        └─┴─┘ 
则函数fun()的功能是（ ）。
 A. 删除单向链表
 B. 显示单向链表中的所有数据
 C. 显示单向链表中的第一个数据
 D. 创建单向链表
B
 159.  若有定义：
struct node
{ int data;
  struct node *next;
};
及函数：
 void fun(struct node * head) 
 { struct node * p = head;
   while(p)
   {
    printf("%d  ", p->data );
    p = p->next;
   }
 }
调用时head是指向链表首结点的指针，整个链表的结构如下图：
                  ┌─┬─┐  ┌─┬─┐          ┌─┬─┐
        head →│25│  ┼→│47│  ┼→ … →│13│  ┼→NULL
                  └─┴─┘  └─┴─┘          └─┴─┘ 
则函数fun()的功能是（ ）。
 A. 删除单向链表
 B. 显示单向链表中的所有数据
 C. 显示单向链表中的第一个数据
 D. 创建单向链表
B
 160.  若有如下定义，函数fun的功能是（ ）。其中head指向链表首结点，整个链表结构如下图：
        ┌──┬─┐  ┌──┬─┐        ┌──┬──┐
 head →│data│  ┼→│data│  ┼→ … →│data│NULL│
        └──┴─┘  └──┴─┘        └──┴──┘ 
struct node{
   int data;
   struct node *next;
};
int fun(struct node* head)
{
  int n=0;
  struct node* t=head;
  while(t!=NULL)
  {
   n++;
   t=t->next;
  }
return n;
}
 A. 删除链表head中的所有结点
 B. 计算链表head中结点的个数
 C. 插入一个元素到链表head中
 D. 创建一个链表head
A
 161.  若有如下定义，函数fun的功能是（ ）。其中head指向链表首结点，整个链表结构如下图：
        ┌──┬─┐  ┌──┬─┐        ┌──┬──┐
 head →│data│  ┼→│data│  ┼→ … →│data│NULL│
        └──┴─┘  └──┴─┘        └──┴──┘
struct node{
   int data;
   struct node *next;
};
void fun(struct node* head)
{
 struct node* t=head;
 while(t!=NULL)
  {
   if(t->data%2==0)
        printf("%d ",t->data);
   t=t->next;
  }
}
 A. 遍历链表head,输出表中值为偶数的元素
 B. 建立一个只有表头结点的链表head
 C. 删除链表head中的第一个结点
 D. 插入一个元素到链表head中 
A
 162.  下面程序的输出结果是（ ）。
#include <stdio.h>
#include <stdlib.h>
typedef struct node{
   int data;
   struct node *next;
}Node;
Node list[3]={{1,&list[1]},{2,&list[2]},{3,0}};
void print(Node* head)
{
 Node* t=head;
 while(t!=NULL)
  {
   printf("%d ",t->data);
   t=t->next;
  }
}
void main()
{
 print(list); 
}
 A. 1 2 3
 B. 0 1 2
 C. 0 1 3
 D. 2 3 0 
A
 163.  对枚举类型进行定义，不正确的是（  ）。
 A. enum b{1, 2, 3}; //用户定义的标识符不能以数字开头
 B. enum a{A, B, C};
 C. enum c{D=3, E, F};
 D. enum d{X=0, Y=5, Z=9};
C
 164.  假定已有如下变量说明和枚举定义：
   char ch ;
   int j, k ;
   enum day{sun, mon, tue, wed, thu, fri, sat} ;
   int a[sat];
判断下列语句是否符合语法规则，结果是（  ）。
   char a ;                   /* 语句1 */
   j + k = j ;                /* 语句2 */
   if(a[mon]>0) j ++ ;        /* 语句3 */
 A. 语句2错误，其它正确
 B. 语句1正确，其它错误
 C. 语句3正确，其它错误
 D. 语句1错误，其它正确
C
 165.  设有如下定义：
typedef int *INTEGER;
INTEGER p,*q;
则（  ）是正确的叙述。
 A. p是int型变量             
 B. q是基类型为int的指针变量
 C. p是基类型为int的指针变量                     
 D. 程序中可用INTEGER代替int类型名
A
 166.  在对于无符号数的位运算中，操作数右移一位相当于（ ）。
 A. 操作数除以2
 B. 操作数乘以2
 C. 操作数除以4
 D. 操作数乘以4
C
 167.  若有定义:int a=20,b=28,c;则执行语句c=(a^b)<<2;后c的值为（ ）。
 A. 2
 B. 5
 C. 32
 D. 92
A
 168.  若有定义:int a=20,b=28,c;则执行语句c=(a&b)>>2;后c的值为（ ）。
 A. 5
 B. 7
 C. 80
 D. 112
B
 169.  下面程序的输出结果为（ ）。
#include <stdio.h>
void main()
{
 enum Weekday{sun=7,mon=1,tue,wed,thu,fri,sat};
 enum Weekday day=sat;
 printf("%d\n",day);
}
 A. 7
 B. 6
 C. 5
 D. 4 
C
 170.  若有以下类型说明，叙述正确的是（ ）。
typedef struct   
{
 int num;
 char *name;
 int score;
}STU,*PSTU;
 A. STU是变量名 
 B. PSTU是变量名   
 C. PSTU是指向结构体类型STU的指针类型名
 D. 类型说明语句有错误
C
 171.  下面程序段的运行结果是（ ）。
int a=5,b=6;
printf("%d",a|b);
 A. 5
 B. 6
 C. 7
 D. 8
C
 172.  以下程序的功能是（  ）。
#include <stdio.h>
main()
{ FILE *fp;
  long int n;
  fp=fopen("wj.txt","rb");
  fseek(fp,0,SEEK_END);
  n=ftell(fp);
  fclose(fp);
  printf("%ld",n);
}
 A. 计算文件wj.txt的起始地址
 B. 计算文件wj.txt的终止地址
 C. 计算文件wj.txt内容的字节数
 D. 将文件指针定位到文件末尾
B
 173.  标准函数fgets(s, n, f)的功能是（  ）。
 A. 从文件f中读取长度为n的字符串存入指针s所指的内存
 B. 从文件f中读取长度不超过n-1的字符串存入指针s所指的内存
 C. 从文件f中读取n个字符串存入指针s所指的内存
 D. 从文件f中读取长度为n-1的字符串存入指针s所指的内存
A
 174.  以下程序的可执行文件名是。
   main(int argc,char * argv[])
   { int i;
     for(i=2;i<argc;i++)
     printf("%s%c",argv[i],(i<argc-1)?' ':'\n');
   }
在DOS命令行输入：file My C Language and Programming<回车>，其输出结果是（  ）。
 A. C Language and Programming
 B. My C Language and Programming
 C. MyCLanguageandProgramming
 D. file My C Language and Programming
C
 175.  以下程序的可执行文件名为tt.exe，若程序运行后屏幕显示：3, We are，则在DOS提示符下输入的命令是（ ）。
void main(int argc, char * argv[])
{
  int i;
  printf("%d,",argc);
  for(i=1;i<argc;i++)
     printf("%s ",argv[i]);
}
 A. tt 
 B. tt We 
 C. tt We are 
 D. tt We are happy! 
D
 176.  以下程序运行后，屏幕显示write ok!，下列说法正确的是（ ）。
#include <stdio.h>
main()
{ FILE *fp;
  fp=fopen("", "wt");
  if(fp!=NULL)
  { fprintf(fp,"%s\n", "File write successed!\n");
    fclose(fp);
    printf("write ok!\n");
  }
}
 A. 当前工作目录下存在文件,其中的内容是"write ok!"
 B. fclose(fp);语句的功能是打开文件
 C. 当前工作目录下一定不存在文件
 D. 当前工作目录下一定存在文件
C
 177.  以下程序运行后，屏幕显示File open error!，则可能的原因是（ ）。
#include <stdio.h>
main()
{
  FILE *fp;
  char str[256];
  fp = fopen("", "rt");
  if(fp==NULL) 
  { printf("File open error!");
    return;
  }
  fscanf(fp,"%s",str);
  fclose(fp);
}
 A. 当前工作目录下有文件,但文件太小
 B.&文件不能关闭
 C. 当前工作目录下没有文件
 D. 当前工作目录下有文件,但文件太大
B
 178.  以下程序的可执行文件名为。
#include <stdio.h>
#include <stdlib.h>
void main(int argc,char *argv[])
{
 if(argc!=2)
 {
  printf("You forgot to type your name or you typed more parameters\n");
  exit(1);
 }
 printf("Hello %s\n",argv[1]);
}
在DOS命令行输入：cmdline harry<回车>,则输出结果是（ ）。
 A. You forgot to type your name or you typed more parameters
 B. Hello harry
 C. Hello cmdline
 D. hello
C
 179.  对下面程序正确的描述是（ ）。
#include <stdio.h>
#include <stdlib.h>
void main()
{
 FILE *in,*out;
 if((in=fopen("","r"))==NULL)
  {
   printf("cannot open infile\n");
   exit(0);
  }
 if((out=fopen("","w"))==NULL)
  {
   printf("cannot open outfile\n");
   exit(0);
  }
 while(!feof(in))
     fputc(fgetc(in),out);
 fclose(in);
 fclose(out);
}
 A. 程序实现在屏幕上显示磁盘文件的内容
 B. 程序实现将两个磁盘文件和的内容合二为一
 C. 程序实现将磁盘文件复制到磁盘文件
 D. 程序实现将两个磁盘文件合并并在屏幕上输出
D
 180.  以下叙述中正确的是（ ）。
 A. C语言中的文件是流式文件，因此只能顺序存取数据
 B. 打开一个已存在的文件进行了写操作后，原有文件中的全部数据必定被覆盖
 C. 在一个程序中当对文件进行了写操作后，必须先关闭该文件然后再打开，才能读到第1个数据
 D. 当对文件的写操作完成之后，必须将它关闭，否则可能导致数据丢失

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。