超星高级语言_4课后答案(学习通2023完整答案)

分类： 历年真题库发布于：2024-06-02 17:12:15ė74259次浏览642条评论

超星高级语言_4课后答案(学习通2023完整答案)

第一章C语言基础

第一章单元测试

1、超星在一个C程序中（ ）。高级 A) main函数必须出现在所有函数之前 B) main函数可以在任何地方出现 C) main函数必须出现在所有函数之后 D) main函数必须出现在固定位置
A、课后C语言中main函数的答案位置不固定
B、C语言中main函数的学习位置不固定
C、C语言中main函数的通完位置不固定
D、C语言中main函数的整答位置不固定

2、以下选项中合法的超星用户标识符是（ ）。 A) long B) _2Test C) 3Dmax D) A.dat
A、高级标识符不能是课后关键字
B、符合标符的答案定义
C、标示符不能用数字开头
D、学习标识符中不能有除下划线以外的通完其他特殊字符

3、以下选项中不属于C语言的整答类型的是（ ）。 A) integer B)float C) int D) char
A、超星integer不是C语言中的类型关键字
B、float是C语言中的浮点类型关键字
C、int是C语言中的整型关键字
D、char是C语言中的字符类型关键字

4、以下变量x.、y、z均为double类型且已正确赋值，不能正确表示数学式子的C语言表达式是（ ）。 A) x/y*z B) x*(1/(y*z)) C) x/y*1/z D) x/y/z
A、该答案表示的是
B、符合要求
C、符合要求
D、符合要求

5、C语言中运算对象必须是整型的运算符是（ ）。 A) % B) / C) = D) <=
A、%是求余运算，运算对象只能是整型数据
B、/是除法运算符，运算对象可以是实型数据
C、=是赋值运算符，运算对象可以是其它类型
D、<=是关系运算符，运算对象可以是其它类型

6、设有 int x=11; 则表达式(x++ * 1/3) 的值是（ ）。 A) 3 B) 4 C) 11 D) 12
A、表达式x++ * 1/3运算过程中，先使用x的值参于运算，等同于11/3，由于运算对象均为整型，故得整数商3，当该表达式运算结束后，x的值自增为12
B、不符合运算规则
C、不符合运算规则
D、不符合运算规则

7、以下选项中，非法的字符常量是（ ）。 A) ‘\t’ B) ‘\17’ C）“n” D) ‘\xaa’
A、是转义字符
B、是转义字符
C、是字符串，不是字符
D、是转义字符

8、若有定义：int a=8，b=5，c；，执行语句c=a/b+0.4;后，c的值为（ ）。 A) 1.4 B) 1 C) 2.0 D) 2
A、不符合运算规则
B、a/b的结果是1，1加上0.4是1.4，由于c是整型变量，进行强制类型转换，故c的值是1
C、不符合运算规则
D、不符合运算规则

9、以下程序的输出结果是（ ）。 #include <stdio.h> void main() { char c=’z’; printf(“%c”,c-25); } A) a B) Z C) z-25 D) y
A、字符‘z’的ASCII码值是122，122-25=97，97是字符‘a’的ASCII码值，按%c格式输出为字符'a'。
B、计算错误
C、表示错误
D、计算错误

10、以下选项中，与k=n++完全等价的表达式是（ ）。 A) k=n,n=n+1 B) n=n+1,k=n C) k=++n D) k+=n+1
A、k=n++的含义是先将n的值赋给变量k，然后n自加1，故等价于逗号表达式k=n,n=n+1
B、不符合k=n++的含义
C、不符合k=n++的含义
D、不符合k=n++的含义

第二章 C语言控制语句

第二章单元测试

1、能正确表示逻辑关系：“a≥=10或a≤0”的C语言表达式是( )。 A) a>=10 or a<=0 B) a>=0||a<=10 C) a>=10 &&a<=0 D) a>=10||a<=0
A、解析错误
B、解析错误
C、解析错误
D、表达式“a≥=10或a≤0”是指a大于等于10或者小于等于0，故只有该答案正确。

2、设 a、b、c、d、m、n均为 int型变量，且 a=5、b=6、c=7、d=8、m=2、n=2，则逻辑表达式(m=a>b)&&(n=c>d)运算后，n的值应为（ ）。 A) 0 B) 1 C)2 D) 3
A、理解错误
B、理解错误
C、表达式(m=a>b)&&(n=c>d)运算时，由于m=a>b的值是0，故&&运算不再继续运算，产生运算短路，n=c>d不再执行，故c的值不变
D、理解错误

3、假定w、x、y、z、m均为int型变量，有如下程序段： w=1; x=2; y=3; z=4; m=(w<x)?w: x; m=(m<y)?m:y; m=(m<z)?m:z; 则该程序运行后，m的值是( ) A) 4 B) 3 C) 2 D) 1
A、运算错误
B、运算错误
C、运算错误
D、本题主要考查条件运算的运算规则，执行m=(w<x)?w: x;以后m的值是1，再执行 m=(m<y)?m:y; m=(m<z)?m:z;以后，m的值仍然是1。

4、若执行以下程序时从键盘上输入9，则输出结果是（ ） #include <stdio.h> void main() { int n; scanf(“%d”,&n); if(n++<10) printf(“%d\n”,n); else printf(“%d\n”,n--); } A) 11 B) 10 C) 9 D) 8
A、解析错误
B、语句if(n++<10) printf(“%d\n”,n);执行时，先计算表达式“n++<10”，由于n的值是9，故表达式“n++<10”值为真，此时n自加为10，故 printf(“%d\n”,n);语句输出10。
C、解析错误
D、解析错误

5、若有定义: float w; int a, b; 则合法的switch语句是（ ）。 A) switch(w) B) switch(a) { case 1.0: printf("*\n"); { case 1 printf("*\n"); case 2.0: printf("**\n"); case 2 printf("**\n"); } } C) switch(b) D) switch(a+b); { case 1: printf("*\n"); { case 1: printf("*\n"); default: printf("\n"); case 2: printf("**\n"); case 2: printf("**\n"); default: printf("\n"); } }
A、case后的常量是实数，不符合规则
B、case后面无冒号
C、符合switch语句的构造规则
D、switch后面多了分号

6、程序 #include <stdio.h> void main() { int n=9; while(n>6) { n--;printf(“%d”,n);} } 的输出结果是( ) A)987 B) 876 C) 8765 D)9876
A、输出结果不对
B、循环体执行三次，第一次输出8，第二次输出7，第三次输出6。
C、输出结果和输出次数都不对
D、输出结果和输出次数都不对

7、以下程序段的输出结果是（ ）。 int x=3; do { printf("%3d,",x-=2); }while(!(--x)); A)1 B) 0 C)死循环 D) 1,-2,
A、分析错误
B、分析错误
C、分析错误
D、do...while是一个先执行循环体再判断的循环语句，初始x=3，执行printf("%3d,",x-=2);输出1，此时x=1; while(!(--x))中的循环条件是先让x自减1，x=0，!(x)为真，继续执行循环体，printf("%3d,",x-=2);输出-2，再判断!(--x)的值，此时!(--x)为假，结束循环。

8、设i、j、k均为int型变量,则执行完下面的for循环后，k的值为( )。 for(i=0,j=10;i<=j;i++,j--)k=i+j; A)12 B) 10 C) 11 D) 9
A、分析错误
B、循环体共执行了6次，每一次k的值均等于i+j，结果为10.
C、分析错误
D、分析错误

9、以下程序的输出结果是( )。 #include <stdio.h> void main() { int a, b; for(a=1, b=1; a<=100; a++) { if(b>=10) break; if(b%3==1) { b+=3; continue; } } printf(“%d\n”,a); } A)101 B) 6 C) 5 D) 4
A、分析错误
B、分析错误
C、分析错误
D、注意continue和break的使用，循环体共执行了4次

10、以下程序的输出结果是( )。 #include <stdio.h> void main() { int a=0,i; for(i=1;i<5;i++) { switch(i) { case 0: case 3:a+=2; case 1: case 2:a+=3; default:a+=5; } } printf("%d\n",a); } A)31 B)13 C)10 D)20
A、循环共执行了4次，由于switch语句中没有使用break语句，当i=1时执行了a+=3;a+=5;结果是a=8；当i=2时执行了a+=3;a+=5;结果是a=16；当i=3时执行了a+=2;a+=3;a+=5;结果是a=26；当i=4时执行了a+=5;结果是a=31
B、分析错误
C、分析错误
D、分析错误

第三章 数组

第三章单元测试

1、假定int类型变量占用两个字节，定义：int x[10]={ 0,2,4};，则数组x在内存中所占字节数是（ ） A) 3 B) 6 C) 10 D) 20
A、理解错误
B、理解错误
C、理解错误
D、int x[10]={ 0,2,4}实际上定义一个具有10个int型元素的一维数组，每个元素占2字节，故共占20个字节

2、执行下面的程序段后,变量k中的值为（ ）。 int k=3, s[2]; s[0]=k; k=s[1]*10; A)不定值 B) 33 C) 30 D) 10
A、int k=3,s[2];定义了一个一维数组s[2],s[2]中有两个元素s[0]和s[1]，后面的语句使s[0]=3，但s[1]没有确定的值，故执行语句k=s[1]*10后，k的值不确定
B、理解错误
C、理解错误
D、理解错误

3、若有说明“int x[3][4]；”，则对x数组元素的正确引用是（ ）。 A) x[2][4]; B) x[1,3] C) x[4-2][0] D) x[3][0]
A、x[2][4]中的第二个下标越界
B、x[1,3]不符合C语言的语法规则
C、int x[3][4]共定义了12个数组元素，分别是x[0][0]，x[0][1]，x[0][2]，x[0][3]，x[1][0]，x[1][1]，x[1][2]，x[1][3]，x[2][0]，x[2][1]，x[2][2]，x[2][3]。x[4-2][0] 指的是x[2][0] 。
D、x[3][0]中的第一个下标越界

4、若的以下语句，则下面（ ）是正确的描述。 char x[]=”12345”; char y[]={ ‘1’,’2’,’3’,’4’,’5’}; A)x数组和y数组的长度相同 B) x数组的长度大于y数组的长度 C) x数组的长度小于y数组的长度 D) x数组等价于y数组
A、理解错误
B、由于字符串”12345”隐含着一个字符串结束标志'\0',故char x[]=”12345”定义的数组x的长度是6; 而char y[]={ ‘1’,’2’,’3’,’4’,’5’};定义的y数组长度是5。
C、理解错误
D、理解错误

5、程序 #include <stdio.h> void main() { int n[5]={ 0,0,0},i,k=2; for(i=0;i<k;i++) n[i]=n[i]+1; printf(“%d\n”,n[k]); } 输出结果是（ ）。 A) 不确定的值 B) 2 C) 1 D) 0
A、理解错误
B、执行过程分析错误
C、执行过程分析错误
D、循环体执行了2次，使得n[0]=1，n[1]=1，n[2]并没有被循环所赋值，故n[2]=0。

6、程序 #include <stdio.h> void 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];i++;} printf("%d\n",k); } 执行后输出结果是（ ）。 A) 58 B) 56 C) 45 D) 24
A、循环条件分析错误
B、循环条件分析错误
C、循环条件分析错误
D、当表达式i<7&&p[i]%2值为真时执行循环体，故该程序的循环体只执行了两次，k的值是24。

7、以下程序的输出结果是（ ）。 #include <stdio.h> void main() { int i, a[10]; for(i=9;i>=0;i--) a[i]=10-i; printf(“%d%d%d”,a[2],a[5],a[8]); } A) 258 B) 741 C) 852 D) 369
A、分析方法错误
B、分析方法错误
C、该程序的循环语句使得：a[9]=1，a[8]=2，a[7]=3，a[6]=4，a[5]=5，a[4]=6，a[3]=7，a[2]=8，a[1]=9，a[0]=10，printf(“%d%d%d”,a[2],a[5],a[8]);的输出结果852
D、分析方法错误

8、以下程序的输出结果是（ ） #include <stdio.h> void main() { int b[3][3]={ 0,1,2,0,1,2,0,1,2},i,j,t=1; for(i=0;i<3;i++) for(j=i;j<=i;j++) t=t+b[i][b[j][j]]; printf("%d\n",t); } A) 3 B) 4 C) 1 D) 9
A、循环分析错误
B、本题考查是的数组的下标变化，注意内循环的循环条件是j<=i，输出结果是4。
C、循环分析错误
D、循环分析错误

9、程序 #include <stdio.h> #include <string.h> void main() { char s[]="\n123\\"; printf("%d,%d\n",strlen(s),sizeof(s)); } 执行后输出结果是（ ）。 A) 赋初值的字符串有错 B) 6,7 C) 5,6 D) 6,6
A、不理解字符串初始化
B、对字符串和字符数组分析错误
C、char s[]="\n123\\"中‘、'\n'是转义字符换行，'\\'是转义字符表示'\'，故字符串的长度是5，为数组s开辟了6个字节的内存空间。
D、对字符串和字符数组分析错误

10、程序执行后的输出结果是（ ）。 #include <stdio.h> #include <string.h> void main() { char arr[2][4]; strcpy(arr[0],"you"); strcpy(arr[1],"me"); arr[0][3]='&'; printf("%s \n",arr); } A) you&me B) you C) me D) err
A、二维数组的在内存的存储方式是行主序存储，char arr[2][4]定义了8个数组元素，它们以 arr[0][0],arr[0][1],arr[0][2],arr[0][3],arr[1][0],arr[1][1],arr[1][2],arr[1][3]顺序在内存开辟空间， 语句strcpy(arr[0],"you") 使arr[0][0]=‘y’,arr[0][1]=‘o’,arr[0][2]=‘u’,arr[0][3]=‘\0’。语句strcpy(arr[1],"me");使arr[1][0]=‘m’,arr[1][1]]=‘e’,arr[1][2]]=‘\0’。arr[0][3]='&'使arr[0][3]重新赋值为'&'。printf("%s \n",arr)以字符串格式输出，arr为首地址，故输出结果为you&me。
B、字符串结束标志分析的不对
C、字符串起始地址分析的不对
D、理解错误

第四章函数

第四章单元测试

1、以下函数值的类型是( )。 fun( float x ) { float y; y= 3*x-4; return y; } A) int B) 不确定 C) void D) float
A、没有指定函数类型时，系统默认函数的类型是int类型。
B、没有指定函数类型时，系统默认函数的类型是int类型。
C、没有指定函数类型时，系统默认函数的类型是int类型。
D、没有指定函数类型时，系统默认函数的类型是int类型。

2、有如下函数调用语句 func(rec1,rec2+rec3,(rec4,rec5)); 该函数调用语句中，含有的实参个数是( )。 A) 3 B) 4 C) 5 D) 不确定
A、func(rec1,rec2+rec3,(rec4,rec5))函数有rec1,rec2+rec3,(rec4,rec5)三个实在参数。
B、func(rec1,rec2+rec3,(rec4,rec5))函数有rec1,rec2+rec3,(rec4,rec5)三个实在参数。
C、func(rec1,rec2+rec3,(rec4,rec5))函数有rec1,rec2+rec3,(rec4,rec5)三个实在参数。
D、func(rec1,rec2+rec3,(rec4,rec5))函数有rec1,rec2+rec3,(rec4,rec5)三个实在参数。

3、以下程序的输出结果是( )。 #include <stdio.h> fun(int x, int y, int z) { z=x*x+y*y; } void main() { int a=31; fun(5,2,a); printf(“%d\n”,a); } A) 0 B) 29 C) 31 D) 无定值
A、理解错误
B、x值不能回传
C、变量a是主函数中的变量，作为实在参数通过fun(5,2,a)实现函数调用，只能将a的值传递给形参x，但x值不能回传给a，故a的值仍然是31。
D、无效选项

4、程序 #include <stdio.h> int func(int a,int b) { return(a+b);} void main() { int x=2,y=5,z=8,r; r=func(func(x,y),z); printf("%d\n",r); } 输出的结果是( )。 A) 12 B) 13 C) 14 D) 15
A、理解错误
B、理解错误
C、理解错误
D、r=func(func(x,y),z)运用了函数的嵌套调用，func(x,y)的值是7，func(func(x,y),z)相当于func(7,8)，其值为15，故r=15。

5、程序 #include <stdio.h> long fib(int n) { if(n>2) return(fib(n-1)+fib(n-2)); else return(2); } void main() { printf("%d\n",fib(3));} 输出结果是( )。 A) 2 B) 4 C) 6 D) 8
A、理解错误
B、该程序实现了函数的递归调用，欲求fib(3)，在fib函数中由于实参3大于2，故需计算fib(2)+fib(1)，在fib(2)+fib(1)中需调用fib(2)和fib(1)，由于此时实参均不大于2，fib(2)和fib(1)的函数值都是2，然后回溯求得fib(3)的值等于4。
C、理解错误
D、理解错误

6、程序 #include <stdio.h> void f(int x,int y) { int t; if(x<y){ t=x;x=y;y=t;} } void main() { int a=4,b=3,c=5; f(a,b); f(a,c); f(b,c); printf("%d,%d,%dn",a,b,c);} 执行后输出结果是( )。 A) 3,4,5 B) 5,3,4 C) 5,4,3 D) 4,3,5
A、不理解形参、实参的传递方式，不理解局部变量的作用域
B、不理解形参、实参的传递方式，不理解局部变量的作用域
C、不理解形参、实参的传递方式，不理解局部变量的作用域
D、变量a=4,b=3,c=5是主函数中的局部变量，作为实参调用f函数，f函数中只交换了形参x,y的值，并为回传给实参，故a=4,b=3,c=5不变。

7、程序 #include <stdio.h> int f1(int x,int y) { return x>y?x:y; } int f2(int x,int y) { return x>y?y:x; } void main() { int a=4,b=3,c=5,d,e,f; d=f1(a,b); d=f1(d,c); e=f2(a,b); e=f2(e,c); f=a+b+c-d-e; printf("%d,%d,%d\n",d,f,e); } 执行后输出结果是( )。 A) 3,4,5 B) 5,3,4 C) 5,4,3 D) 3,5,4
A、理解错误
B、理解错误
C、函数f1是求两数中的最大值，函数f2是求两数中的最小值，经过连续的函数调用，d获得了a,b,c中的最大值，e获得了a,b,c中的最小值，又执行f=a+b+c-d-e;f获得了三个数中的中间值。
D、理解错误

8、以下程序的输出结果是( )。 #include <stdio.h> int a,b; void fun() { a=100;b=200;} void main() { int a=5,b=7; fun(); printf("%d%d\n",a,b); } A) 100200 B) 57 C) 200100 D) 75
A、对全局变量和局部变量理解错误
B、全局变量的作用范围不包括同名局部变量所在的函数，fun()函数中的a,b是全局变量，main()函数中的a,b是局部变量，故输出结果是57。
C、对全局变量和局部变量理解错误
D、对全局变量和局部变量理解错误

9、程序 #include <stdio.h> int a=3; void main() { int s=0; { int a=5; s+=a++; } s+=a++; printf("%d\n",s); } 运行后的输出结果是( )。 A) 8 B) 10 C) 7 D) 11
A、{ int a=5; s+=a++; } 中的a是局部变量，此时执行 s+=a++，s的值是5。其后的 s+=a++中的a是全局变量，执行该语句后，s的值是8。
B、理解错误
C、理解错误
D、理解错误

10、以下程序的输出结果是( )。 #include <stdio.h> int x=3; void incre() { static int x=1; x*=x+1; printf(" %d",x); } void main() { int i; for(i=1;i<x;i++) incre(); } A) 3 3 B) 2 2 C) 2 6 D) 2 5
A、全局变量、局部变量，静态变量、自动变量理解错误
B、干扰项
C、主函数中的x是全局变量，故循环语句中的循环执行了两次，incre()函数中的x是静态的局部变量，主函数第一次循环时，调用incre()函数，执行 x*=x+1后，x的值是2， printf(" %d",x)输出2；主函数第二次循环时，调用incre()函数，由于x静态变量，故x中保留的是上次执行后值，x=2，再执行 x*=x+1后，x的值是6， printf(" %d",x)输出6。
D、全局变量、局部变量，静态变量、自动变量理解错误

第五章指针

第五章单元测试

1、若有说明：int n=2,*p=&n,*q=p;，则以下非法的赋值语句是（ ）． A) p=q; B) *p=*q; C) n=*q; D) p=n;
A、p和q是同类型的指针变量
B、把q所指向空间中的值赋给p所指向空间中
C、n可以获得q所指向空间中的值
D、int n=2,*p=&n,*q=p;中已定义p是指针变量且已获得变量n的地址，而p=n是让p获得n的值，这是无意义的。

2、对于基类型相同的两个指针变量之间，不能进行的运算是（ ）． A) < B) = C) + D) -
A、两个指针变量比较大小，可以区分所指向的地址不同位置
B、基类型相同的两个指针变量之间可以赋值
C、两个指针变量相加没意义
D、基类型相同的两个指针变量之间相减可以表明所指向地址的距离

3、请选出正确的程序段（ ）． A) int *p; B) int *s, k; scanf("%d",p); *s=100; … … C) int *s, k; D) int *s, k; char *p, c; char *p, e; s=&k; s=&k; p=&c; p=&c; *p='a'; s=p; … *s=1; …
A、p是指针变量，在未获得值之前不能使用，scanf("%d",p); 无意义。
B、s是指针变量，在未获得值之前不能使用，此时使用*s无意义。
C、定义与使用均没问题
D、指针变量s和指针变量p基类型不同， s=p无意义

4、下面程序的输出结果是（ ）． #include <stdio.h> void main() { int a[ ]={ 1,2,3,4,5,6,7,8,9,0,},*p; p=a; printf(“%d\n”,*p+9); } A) 0 B) 1 C) 10 D) 9
A、分析错误
B、分析错误
C、p=a使得指针变量p指向了数组a的起始地址，*p的值是1，故输出结果为10
D、分析错误

5、程序 #include <stdio.h> void main() { int x[8]={ 8,7,6,5,0,0},*s; s=x+3 printf("%d\n",s[2]); } 输出结果是（ ）． A) 随机值 B) 0 C) 5 D) 6
A、不理解指针与数组
B、s=x+3使指针变量s指向了数组元素x[3]的地址，等价于s=&x[3]。此时用s访问，则s[0]=5,s[1]=0,s[2]=0
C、分析错误
D、分析错误

6、有如下说明 int a[10]={ 1,2,3,4,5,6,7,8,9,10},*p=a; 则数值为9的表达式是（ ）． A) *P+9 B) *(P+8) C) *P+=9 D) P+8
A、*P+9等于10
B、*(P+8) 相当于a][8]，其值为9
C、*P+=9相当于*P=*P+9，其值为10
D、p+8是a[8]的地址

7、.以下程序调用findmax函数返回数组中的最大值 #include <stdio.h> int findmax(int *a,int n) { int *p,*s; for(p=a,s=a; p-a<n; p++) if( ) s=p; return(*s); } void main() { int x[5]={ 12,21,13,6,18}; printf("%d\n",findmax(x,5)); } 在下划线处应填入的是（ ）． A) p>s B) *p>*s C) a[p]>a[s] D) p-a>p-s
A、p>s中比较的是地址
B、在findmax函数中的循环语句中，比较式*p>*s的*p和*s其实就是数组中的元素，循环处理的的过程中，总是让s指向数组中最大元素的地址，返回*s就是求出了最大值。
C、a[p]>a[s] 中p和s不能作为下标
D、p-a>p-s中比较的是地址的偏移量

8、程序 void fun(int *a,int i,int j) { int t; if(i<j) { t=a[i];a[i]=a[j];a[j]=t; fun(a,++i,--j); } } #include <stdio.h> void main() { int a[]={ 1,2,3,4,5,6},i; fun(a,0,5) for(i=0;i<6;i++) printf("%d",a[i]); } 输出结果是（ ）． A) 6 5 4 3 2 1 B) 4 3 2 1 5 6 C) 4 5 6 1 2 3 D) 1 2 3 4 5 6
A、fun函数是递归函数，实现了数组就地逆序存放
B、分析错误
C、分析错误
D、没考虑数组的变化

9、以下程序中函数sort的功能是对a所指数组中的数据进行由大到小的排序 #include <stdio.h> void sort(int a[],int n) { int i,j,t; for(i=0;i<n-1;i++) for(j=i+1;j<n;j++) if(a[i]<a[j]) { t=a[i];a[i]=a[j];a[j]=t;} } void main() { int aa[10]={ 1,2,3,4,5,6,7,8,9,10},i; sort(&aa[3],5); for(i=0;i<10;i++) printf(“%d,”,aa[i]); printf(“\n”); } 程序运行后的输出结果是（ ）． A)1,2,3,4,5,6,7,8,9,10 B) 10,9,8,7,6,5,4,3,2,1, C) 1,2,3,8,7.6.5.4.9,10 D) 1,2,10,9,8,7,6,5,4,3
A、分析错误
B、分析错误
C、sort(&aa[3],5);是对从aa[3]开始的5个元素从大到小排序，对数组中的其它元素并未处理
D、分析错误

10、以下函数的功能是：通过键盘输入数据，为数组中的所有元素赋值。 #define N 10 void arrin(int x[N]) { int i=0; while(i<N) scanf("%d", ); } 在下划线处应填入的是（ ）． A) x+i B）&x[i+1] C）x+(i++) D）&x[++i]
A、i没有发生变化
B、i没有发生变化
C、x+(i++) 是x数组中元素的地址，每次循环时让i发生了变化
D、先让发生变化，没有访问到x[0]

第六章 自定义数据类型

第六章单元测试

1、设有以下定义，叙述（ ）是错误的。 struct ex { int x; float y; char z; }example; A) struct是结构体类型的保留字 B) example是结构体类型名 C) x、y、z是结构体类型成员名 D) ex是结构体类型名
A、表述正确
B、example是结构体类型的变量名
C、表述正确
D、表述正确

2、若有定义语句: struct { int a1;int a2;}a3;以下赋值语句正确的是（ ）。 A)a.a1=4; B)a2=-4; C)a3={ 4,5}; D) a3.a2=5;
A、a不是结构体变量名
B、不能对成员名进行赋值
C、a3={ 4,5};在定义结构体变量时，可以用a3={ 4,5};进行初始化。但不允许作为一个独立的语句。
D、a3是结构体类型的变量，a2是结构体的成员名，a3.a2符合结构体变量的引用格式

3、设有以下结构体定义及初始化，表达式p->score的结果是（ ）。 struct node { int num; float score; }stu[2]={ 101,91.5,102,92.5},*p=stu; A)101 B)91.5 C)102 D)92.5
A、分析错误
B、该定义使stu[0].num=101，stu[0].score=91.5，stu[1].num=102，stu[0].score=92.5，p指向数组stu的首地址，p->score的值是stu[0].score。
C、分析错误
D、分析错误

4、程序 #include <stdio.h> struct STU { char num[10]; float score[3]; }; void main() { struct STU s[3]={ { "20021",90,95,85},{ "20022",95,80,75},{ "20023",100,95,90}},*p=s; int i; float sum=0; for(i=0;i<3;i++) sum=sum+p->score[i]; printf("%6.2f\n",sum); } 输出结果是( )。 A) 260.00 B) 270.00 C) 280.00 D) 285.00
A、解析错误
B、所定义数组s各元素的值是s[0].num="20021"，s[0].score[0]=90，s[0].score[1]=95，s[0].score[2]=85，s[1].num="20022"，s[1].score[0]=95，s[1].score[1]=80，s[1].score[2]=75，s[2].num="20023"，s[2].score[0]=100，s[2].score[1]=95，s[2].score[2]=90，指针变量p指向数组的首地址，循环完成了s[0].score[0]=90，s[0].score[1]=95，s[0].score[2]=85三个数的相加。
C、解析错误
D、解析错误

5、设有如下定义： struck sk { int a;float b;}data; int *p; 若要使p指向data中的a域，正确的赋值语句是( )。 A) p=&a; B) p=data.a; C) p=&data.a; D) *p=data.a;
A、不能直接访问成员名
B、没有取地址运算
C、合法引用
D、*p得到了data.a的值，p未必指向data中a域

6、以下程序的输出结果是( )。 #include <stdio.h> struct HAR { int x, y; struct HAR *p;}h[2]; void main() { h[0].x=1; h[0].y=2; h[1].x=3; h[1].y=4; h[0].p=&h[1]; h[1].p=h; printf("%d %d \n",(h[0].p)->x,(h[1].p)->y); } A) 12 B) 23 C) 14 D) 32
A、解析错误
B、解析错误
C、解析错误
D、该结构体有三个域，其中两个数据域x,y，一个指针域p，程序中h[0].p指向h[1]，h[1].p又指向了h[0]，故h[0].p)->x的值是h[1].x，h[1].p)->y的值是h[0].y，输出结果为32

7、程序 #include <stdio.h> #include <stdlib.h> struct NODE { int num; struct NODE *next; }; void main() { struct NODE *p,*q,*r; p=(struct NODE*)malloc(sizeof(struct NODE)); q=(struct NODE*)malloc(sizeof(struct NODE)); r=(struct NODE*)malloc(sizeof(struct NODE)); p->num=10; q->num=20; r->num=30; p->next=q;q->next=r; printf(“%d\n”,p->num+q->next->num); } 输出结果是( )。 A) 10 B) 20 C) 30 D) 40
A、解析错误
B、解析错误
C、解析错误
D、p->num=10，q->next->num其实是r->num，即q->next->num的值是30，输出结果为40。

8、假定建立了以下链表结构，指针p、q分别指向如图所示的结点，则以下可以将q所指结点从链表中删除并释放该结点的语句组是( )。 A) free(q); p->next=q->next; B)(*p).next=(*q).next; free(q); C) q=(*q).next;(*p).next=q; free(q); D) q=q->next; p->next=q; p=p->next; free(p);
A、删除了q以后的所有结点
B、正确
C、未释放当前的q结点
D、释放了当前q结点以后所有结点

9、假设int类型占2个字节，long类型占4个字节，char类型占1个字节，有如下定义，则变量a所占内存字节数是( )。 union U { char st[4]; int i; long l; }; struct A { int c; union U u; }a; A) 4 B) 5 C) 6 D) 8
A、解析错误
B、解析错误
C、union U定义了一个共用体，为该类型分配的空间是最大的那个域所占的空间，故该共用体占4个字节，struct A定义了一个结构体，该类型变量所占的空间为各分量所占空间的和。因为a.c占2个字节，a.u占4个字节，所以变量a占据了6个字节的内存空间。
D、解析错误

10、设有枚举类型定义： enum color{ red=3,yellow,blue=10,white,black}; 则枚举量black的值是（ ）。 A)7 B)15 C)12 D)14
A、枚举元素常量值反映定方式不对
B、枚举元素常量值反映定方式不对
C、枚举元素作为常量是有值的，因为blue=10，则white的值是11,black的值是12
D、枚举元素常量值反映定方式不对

高级语言期末考试

高级语言期末考试

1、下面合法的C语言标识符是： 。 A、3xy B、XY.2 C、a_2 D、？xyz
A、3xy
B、XY.2
C、a_2
D、？xyz

2、若有定义 int a=8，b=5,c; 执行语句 c=a/b+0.4后，c的值是 。 A、1.4 B、1 C、2.0 D、2
A、1.4
B、1
C、2.0
D、2

3、以下有关注释的说法中，错误的是： 。 A、注释可以出现在程序的任何位置 B、程序编译时，不对注释做任何处理 C、程序编译时，要对注释做处理 D、注释的作用是提示或解释程序的含义，帮助提高程序的可读性
A、注释可以出现在程序的任何位置
B、程序编译时，不对注释做任何处理
C、程序编译时，要对注释做处理
D、注释的作用是提示或解释程序的含义，帮助提高程序的可读性

4、已知各变量的类型说明如下： int k,a,b,w; float x=1.4; 则以下不符合 C 语言语法的表达式是________。 A、x%3 B、w+=-2 C、k=(a=2,b=3,a+b) D、a>=5
A、x%3
B、w+=-2
C、k=(a=2,b=3,a+b)
D、a>=5

5、下列定义变量的语句错误的是 。 A、int _int B、double int_ C、char For D、float US$
A、int _int
B、double int_
C、char For
D、float US$

6、以下能正确地定义整型变量a，b和c并为它们都赋初值为5的语句是 。 A、int a=b=c=5； B、int a,b,c=5； C、int a=5,b=5,c=5； D、int a,c=b=5；
A、int a=b=c=5；
B、int a,b,c=5；
C、int a=5,b=5,c=5；
D、int a,c=b=5；

7、以下程序执行后输出结果是 。 main(){ int a=5，b=4，c=3，d=2； if(a＞b＞C) printf("%d\n",d) ； else if((c-1＞＝d) ＝＝1) printf("%d\n",d+1)； else printf("%d\n"，d+2)； } A、2 B、3 C、4 D、编译时有错，无结果
A、2
B、3
C、4
D、编译时有错，无结果

8、已知字母A的ASCII码是65，以下程序的执行结果是 。 #include<stdio.h> main(){ char c1=’A’,c2=’Y’; printf(“%d,%d\n”,c1,c2); } A、A,Y B、65，65 C、65，89 D、65，90
A、A,Y
B、65，65
C、65，89
D、65，90

9、下列四种运算中，优先级最高的运算符是 。 A、&& B、>= C、= = D、++
A、&&
B、>=
C、==
D、++

10、以下不正确的if语句形式是 。 A、if(x>y&&x!=y); B、if(x==y) x+=y; C、if(x!=y) scanf("%d",&x) else scanf("%d",&y); D、if(x<y){ x++;y++;}
A、if(x>y&&x!=y);
B、if(x==y) x+=y;
C、if(x!=y) scanf("%d",&x) else scanf("%d",&y);
D、if(x<y){ x++;y++;}

11、已知有：scanf(“a=%d,b=%d,c=%d”,&a,&b,&c);则正确的输入形式是 。 A、a=12 b=24 c=36 B、12,24,36 C、a=12,b=24,c=36 D、12 24 36
A、a=12 b=24 c=36
B、12,24,36
C、a=12,b=24,c=36
D、12 24 36

12、if（表达式）语句中的“表达式” 。 A、必须是逻辑表达式 B、必须是关系表达式 C、必须是逻辑表达式或关系表达式 D、可以是任意合法的表达式
A、必须是逻辑表达式
B、必须是关系表达式
C、必须是逻辑表达式或关系表达式
D、可以是任意合法的表达式

13、C语言规定，简单变量做实参时，它和对应形参之间的数据传递方式为 。 A、地址传递 B、单向值传递 C、由实参传给形参，再由形参传回给实参 D、由用户指定传递方式
A、地址传递
B、单向值传递
C、由实参传给形参，再由形参传回给实参
D、由用户指定传递方式

14、下列程序输出的结果是 。 fun(int a ,int b ,int c){ c = a*b; } void main(){ int c ; fun(2,3,c); printf(“%d\n”,c); } A、0 B、1 C、6 D、无法确定
A、0
B、1
C、6
D、无法确定

15、下述对C语言字符数组的描述中错误的是 。 A、字符数组可以存放字符串 B、字符数组中的字符串可以整体输入、输出 C、可以在赋值语句中通过赋值运算符“=”对字符数组整体赋值 D、不可以用关系运算符对字符数组中的字符串进行比较
A、字符数组可以存放字符串
B、字符数组中的字符串可以整体输入、输出
C、可以在赋值语句中通过赋值运算符“=”对字符数组整体赋值
D、不可以用关系运算符对字符数组中的字符串进行比较

16、若有说明：int a[3][4]=;则下面正确的叙述是 。 A、数组a中各元素都可得到初值0 B、此语句说明不正确 C、数组a中各元素都可得到初值，但其值不一定为0 D、只有元素a[0][0]的初值为0
A、数组a中各元素都可得到初值0
B、此语句说明不正确
C、数组a中各元素都可得到初值，但其值不一定为0
D、只有元素a[0][0]的初值为0

17、有以下函数定义： void fun(int n,double x){ ……} 若以下选项中的变量都已正确定义并赋值，则对函数fun正确调用语句是 。 A、fun(int y,double m)； B、fun(4,3.5)； C、k=fun(10,12.5)； D、void fun(n，x)；
A、fun(int y,double m)；
B、fun(4,3.5)；
C、k=fun(10,12.5)；
D、void fun(n，x)；

18、有一个二维数组a[3][4],第2行第3列元素的正确表示方法为 。 A、&a[2][3] B、a[2]+3 C、*(a+2)+3 D、*(a[2]+3)
A、&a[2][3
B、a[2]+3
C、*(a+2)+3
D、*(a[2]+3)

19、已设p1和p2为指针变量，且已指向一个整型数组中的元素，a是一个整型变量，以下不能正确执行的语句是 。 A、a=*p B、a=*p1+*p2 C、a=p1-p2 D、p1=a-p2
A、a=*p
B、a=*p1+*p2
C、a=p1-p2
D、p1=a-p2

20、设有以下语句： Typedef struct S { int g;char h;} T; 则下面叙述正确的是 。 A、可用S定义结构体变量 B、可用T定义结构体变量 C、S是struct类型的变量 D、T是struct S类型的变量
A、可用S定义结构体变量
B、可用T定义结构体变量
C、S是struct类型的变量
D、T是struct S类型的变量

高级语言期末考试试卷

1、结构化程序设计采用顺序结构、选择结构和 等三种基本结构编写程序。

2、有定义：int a[]={ 3,5,7,9,11,13};*p=a;则*（p+1）的值是_________，*（a+5）的值是________。

3、表达式26/3的结果是__________，表达式26%3的结果是_______________。

4、当a=6,b=4,c=3时，表达式a>b!=c的值是 。

5、在C语言中的实型变量分为是double、long double和 三种类型。

6、C语言描述“x和y都大于或等于z”的表达式是： 。

7、下列程序输出结果是： 。 #include<stdio.h> main(){ int a[3][3] = { 1,3,5,7,9,11,13,15,17}; int sum = 0,i,j; for(i=0;i<3;i++) for(j=0;j<3;j++) if(i==j) sum = sum+a[i][j]; printf(“sum=%d\n”,sum); }

8、下列程序输出的结果是 。 #include<stdio.h> int f(int x ){ static y = 1; y++; x+ = y; return x; } main(){ int k; k =f(3); printf(“%d %d\n”,k,f(k)); }

9、利用循环结构编写程序，输出以下图形。 * *** ***** 中国大学mooc网课答案

*

10、输入10个整数，判断它们是否为素数。要求：编写一个函数int prime(int m)来判断形参变量m是否为素数，如果是素数则返回1，否则返回0。主函数调用prime完成素数的判断，并完成数据的输入与输出。

11、对一个有10个整型数据元素一维数组按照从大到小进行排序，要求对数组排序过程写成函数形式，并在主函数中调用。

学习通高级语言_4

在学习通高级语言_4模块中，我们将深入学习高级语言的各个方面，包括函数、类、模块、异常处理、文件操作等等内容。

函数

函数是一段被命名的代码，可被重复利用。使用函数可使代码更具可读性和模块化。

函数的定义形式如下：

def function_name(arguments):    statements    return value

arguments是函数的参数，可有多个。statements是函数的主体代码，可以是任意语句。return value是函数的返回值，可以省略。

类

类是面向对象编程中的重要概念。类是由属性和方法组成的封装体，可用于创建对象。

类的定义形式如下：

class class_name:    def __init__(self, arguments):        statements    def method_name(self, arguments):        statements

__init__()是类的初始化方法，用于设置类的属性。method_name()是类的方法，可被类的对象调用。

模块

模块是Python代码的组织方式，用于封装可重用的代码。模块可以包含变量、函数、类等内容。

模块的引入形式如下：

import module_name

也可使用from-import语句导入模块的特定成员。如：

from module_name import member_name

异常处理

异常处理是程序在运行过程中遇到错误时的处理方式，可防止程序崩溃。

异常处理的语法形式如下：

try:    statementsexcept ExceptionType:    statements

try中包含可能会抛出异常的代码，如果异常发生，则进入except。ExceptionType是异常类型，可以是特定的异常，也可以是通用的异常类型。

文件操作

文件操作是Python中常用的操作之一，可用于读取和写入文件。

文件的读取形式如下：

with open(file_path, 'r') as f:    content = f.read()

file_path是文件路径，r表示以只读方式打开文件。with语句用于自动关闭文件，read()方法用于读取文件内容。

文件的写入形式如下：

with open(file_path, 'w') as f:    f.write(content)

w表示以写入方式打开文件，write()方法用于写入文件内容。

以上为学习通高级语言_4模块的核心内容，通过深入学习这些知识点，我们可以编写出高质量的Python程序。



Ɣ回顶部