提示:内容已经过期谨慎付费，点击上方查看最新答案
C语言程序设计（西安工程大学）
- 若有说明:int *p,m=5,n;以下正确的程序段是( )
若int a=0，x=4；则执行语句if (a=0) x++；else x--；后x值是（ ）
有以下程序
#include <stdio.h>
void fun(int p)
{ int d=2;
p=d++; printf("%d",p);}
void main()
{ int p=1;
fun(p); printf("%d\n",p);}
程序运行后的输出结果是( )
- 若有说明：int a[10]，*p = a；不能正确表示a[2]地址的是（ ）
如果有下面的定义和赋值，则使用（）不能输出n中data的值。
struct SNode {
unsigned id;
int data; } n,*p;
p=&n;
- 有语句：int a[10],;则（ ）是对指针变量p的正确定义和初始化。
- 以下语句或语句组中,能正确进行字符串赋值的是 （ ）
设有以下函数：
#include <stdio.h>
int f(int a)
{ int b=0;
static c=3;
b++ ; c++;
return (a+b+c); }
如果在下面的程序中调用该函数，则输出结果是（ ）
void main()
{ int a=2,i;
for(i=0;i<3;i++) printf("%d\n",f(a)); }
设有以下定义和语句
char str[20]=”Program”,*p;
p=str;
则以下叙述中正确的是 ( )
下面的程序执行后，文件test.t中的内容是 （ ） 。
#include <stdio.h>
void fun(char *fname,char *st)
{ FILE *myf;
int i;
myf=fopen(fname,"w");
for(i=0;i<strlen(st);i++) fputc(st[i],myf);
fclose(myf);}
void main()
{ fun("test.t","new world");
fun("test.t","hello,");
}
- 在C程序中，可以将整型数以二进制形式存放到文件中的函数是( )
有程序：
#include "string.h"
#include "stdio.h"
void main()
{
char p[]={'a','b','c'},q[10]={'a','b','c'};
printf("%d %d\n", strlen(p), strlen(q));
}
以下叙述中正确的是( )
若有定义int x=3,y=2和float a=2.5,b=3.5,则表达式:(x+y)%2+(int)a/(int)b的值是（ ）
以下程序段执行后m的值是（ ）
int k=2，m=3； do { m+=k；} while ( k<2 ) ；
表达式：(int)((double)9/2)-9%2的值是（ ）
以下程序的输出结果是（ ） 。
#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); }
设有以下程序段
struct MP3
{char name[20];
char color;
float price;
}std,*ptr;
ptr=& std;
若要引用结构体变量std中的color成员，写法错误的是( )
下面程序的输出是（ ）
#include <stdio.h>
int m=13;
int fun2(int x, int y)
{ int m=3;
return(x*y-m);
}
void main()
{ int a=7, b=5;
printf("%d\n",fun2(a,b)/m);
}
以下变量x、y、z均为double类型且已正确赋值，不能正确表示数学式子：(x)/(y×z)的c语言表达式是（）。
- 以下各选项欲说明一种新的类型名，其中正确的是 （ ）。
假定建立了以下链表结构，指针p和q分别指向如图所示的结点，则以下可以将q所从链表中删除并释放该结点的语句组是 （ ） 。
- 设有如下定义：
struck sk { int a;
float b; }data; int *p;
若要使p指向data中的a域，正确的赋值语句是( )。 已知 struct student {char ﹡name; int student_n; char grade; };
struct student temp,*p=&temp; temp.name=”chou”;
则下面说法不正确的是（ ）。
有以下程序
#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,则正确的输入是 ( )
- 若有说明：char *pc[ ]={"aaa", "bbb", "ccc", "ddd"};，则以下叙述正确的是( )
若num、a、b和c都是int型变量，则执行表达式num=(a=4,b=16,c=32);后num的值为（）。
执行下面程序中的输出语句后,输出结果是（ ）
#include<stdio.h>
void main()
{int a;
printf("%d\n",(a=3*5,a*4,a+5));
}
在C语言程序中，表达式5%2的结果是（ ）。
若已定义int a,则表达式a=10,a+10,a++的值是（ ）
有定义char *s=”\t\‟Name \\Address\n”; ，则指针s的指字符串的长度为（ ）
- 已知有声明"int a[10]={1,2,3,4,5,6,7,8},*p=&a[5];",则*(p-3)的值是( )
以下程序的输出结果是（ ）。
#include <stdio.h>
#include <string.h>
void main()
{ char st[20]="hello\0\t\?\\";
printf("%d %d\n",strlen(st),sizeof(st)); }
- 用fopen()函数打开一个新的二进制文件，该文件可以读也可以写，则文件的入打开方式是( )
语句y+=i; 的执行次数是（ ）。
int y，i；
for(i=0；i<20；i++) { if(i%2==0) continue; y+=i; }
下列数据中，为字符串常量的是（ ） 。
- 设有以下说明语句：struct ex { int x；float y； char z；}example；则下面的叙述中不正确的是 （ ） 。
设x、y、z和k都是int型变量，则执行下列表达式后，变量x的值为（ ）
x=(y=4,z=16,k=32);
以下程序段的运行结果为 （）。
int num[]={1,2,3,4,5,6,7,8,9},*pnum=&num[2];
pnum++;
++pnum;
printf("%d",*pnum);
定义如下变量和数组:
int i;
int x[4][4]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
则下面语句的输出结果是( )
for(i=0;i<4;i++) printf("%3d",x[i][3-i]);
以下程序段输出的结果是 ( )
int a =1234;
printf (“%2d\n”,a);
- C语言标准输出操作中,putchar() 函数可以输出显示一个字符串。（）
- C语言标准格式输入函数scanf() 的参数表中要使用变量的地址值。（）
- 函数的实参可以是常量，变量或表达式 。（）
- C语言程序只能有一个文件。（）
- 凡在函数中未指定存储类别的局部变量，其默认的存储类别为static。（）
- 结构体变量可以作数组元素。（）
- C语言允许用字符串对数组初始化。（）
- 在对数组全部元素赋初值时，不可以省略行数，但能省略列数。（）
- 结构体名在定义结构体时不可省略。（）
- 下划线是标识符中的合法字符。（）
- 在C语言程序中，凡是没有出现存储类别说明符的变量都是自动类的。（）
- break 只可用于循环体中。（）
- 任何表达式语句都是表达式加分号组成的。（）
- 用字符串方式赋值比用字符逐个赋值要多占一个字节，用于存放字符串结束标志“0'。（）
- 在switch语句中，每一个的case常量表达式的值可以相同。（）
- 以“a”方式打开一个文件时，文件位置标记指向文件首。（）
- C语言规定:定义符号常量时必须用大写字母。（）
- 以“r”方式打开一个文件时，文件指针指向文件首。（）
- break 是结束整个循环过程，不再判断执行循环的条件是否成立。（）
- 表达式语句和表达式没有什么区别。（）
下列一组初始化语句中，不正确的是( )
以下选项中，正确的C语言字符型常量是（）。
对字符数组进行初始化，以下哪种形式是正确的（）
以下定义语句中，正确的是( )
如果在一个函数中的复合语句中定义了一个变量，则以下不正确的说法是( )。
以下不能正确读入字符串的程序段是（ ）
以下可以对二维数组a进行正确初始化的语句是 ( )
下述对C语言字符数组的描述中正确的是（ ）
以下叙述正确的是（）
设整型变量 a=2，则执行下列语句后，浮点型变量b的值是0.5的是（ ）。
在C语言中，如果缺省函数类型，此时函数隐含类型是void 。
若有定义：char s[ ] =”TurboC++”；则数组s的长度是9。
一个函数返回值的类型是由调用该函数的函数的类型决定的。
若有定义语句：char s[10]="1234567\0\0"；，则strlen(s)的值是7。
若有定义int (*p)[4]，则标识符p是一个指向由4个元素组成的整型一维数组的指针变量。
A:p=scanf("%d",*p) B:p=scanf("%d",&p); C:p=*p=m; D:scanf("%d",&n);*p=n;
答案:p= *p=m;
A:4 B:3 C:0 D:5
答案:3
A:12 B:21 C:32 D:22
答案:4,7,5
A:p[2] B:a+2 C:p+2 D:&a[ 2 ]
答案:for(p=a; p
A:(*p).data B:p->data C:n.data D:p.data
答案:p.data
A:int *p= B:int p= C:int p=*a; D:int *p=a;
A:char s[10];*s="right!"; B:char *sp="right!"; C:char s[10];s="right!"; D:char *sp;*sp="right!";
A:789 B:777 C:7911 D:71013
A:*p与str[0]中的值相等 B:str数组长度和p所指向的字符串长度相等 C:str与p的类型完全相同 D:数组str中存放的内容和指针变量p中存放的内容相同
A:new,worldhello B:new,world C:hello， D:hello,rld
AI参考:执行程序后，文件test.t中的内容是选项B：new,world。程序中的fun函数用于将字符串st的内容写入到指定的文件中。在main函数中，两次调用了fun函数，第一次将字符串"new world"写入到test.t文件中，第二次将字符串"hello,"写入到test.t文件中。由于在调用fun函数时使用了相同的文件名，所以第二次调用fun函数时，原来的文件内容会被覆盖，所以最后文件中只有"new world"这一行内容。因此，正确答案是new,world。'
A:fputc() B:fread() C:fprintf() D:fwrite()
A:由于p数组中没有字符串结束符，长度不能确定；但q数组中字符串长度为3 B:由于q数组中没有字符串结束符，长度不能确定；但p数组中字符串长度为3 C:在给p和q数组置初值时，系统会自动添加字符串结束符，故输出的长度都为3 D:由于p和q数组中都没有字符串结束符，故长度都不能确定
AI参考:选项C是正确的。 程序中给p和q数组赋值的代码是`char p[]={a, b, c}, q[10]={a, b, c}`。这两段代码都创建了字符串数组，但是并没有在字符串末尾添加字符串结束符（ ）。因此，这两个数组的长度都不能确定，因为它们可能包含了额外的字符。 然而，printf函数使用strlen函数来获取字符串的长度，而strlen函数在处理字符串时会找到字符串结束符（ ）并停止计数。因此，无论是p还是q，当使用strlen函数时，都会输出正确的长度（即3）。 所以，答案为C：在给p和q数组置初值时，系统会自动添加字符串结束符，故输出的长度都为3。"
A:1.5 B:1 C:0 D:2
A:死循环 B:2 C:3 D:5
AI参考:执行后的值是D:5。程序段中，首先定义了一个整数变量k并赋值为2，另一个整数变量m赋值为3。然后执行do-while循环，循环体中的语句是m += k，表示将k的值加到m上。由于k的初始值为2，所以循环体中的语句会将m的值增加2。在循环条件中，k的值小于2，所以循环会一直执行下去，直到k的值不再小于2为止。因此，最终m的值会变为5。因此，答案为D:5。'
A:0 B:4 C:3 D:5
A:4 B:101 C:6 D:5
AI参考:程序的输出结果是：D:5。程序的主要逻辑是使用一个循环，从1开始，每次迭代检查b的值。如果b大于等于10，则跳出循环。如果b除以3的余数为1，则将b增加3并继续下一次循环。循环结束后，输出a的值，即剩余的迭代次数。在这个程序中，当b等于3时，循环会跳出，此时a的值是5，所以输出结果是5。因此，正确答案是D。'
A:ptr-> color B:std.color C:std-> color D:(*ptr) .color
A:2 B:7 C:10 D:1
A:x*(1/(y*z)) B:x/y*z C:x/y/z D:x/y*1/z
A:typedef vl int; B:typedef v4：int; C:typedef int v3; D:typedef v2=int;
A:q=q->next; p->next=q; p=p->next; free(p); B:free(q);p->next=q->next; C:q=（*q）.next;（*p）.next=q; free(q); D:(*p).next=(*q).next; free(q);
A:*p=data.a; B:p= C:p=data.a; D:p=&data.a;
AI参考:正确选项是D：p=&data.a;解释：在C语言中，p是一个指向int类型的指针，data是一个结构体类型的数据，其中包含一个int类型的域a。要将p指向data中的a域，需要将p指向data.a，即使用&符号取a的地址，然后将该地址赋值给p。因此，正确的赋值语句是p=&data.a;。选项A和C中没有使用&符号，选项B则完全未提及p和data的关系，所以都不正确。'
A:p->name的值为“chou” B:(*p)->name+2的值为‘h’ C:*p->name+2的值为‘e’ D:*(p->name+2)的值为‘o’
A:m=123,n=456,p=789 B:123 456 789 C:m=123n=456p=789 D:m=123；n=456；p=789
A:32 B:4 C:52 D:16
A:15 B:20 C:65 D:10
A:2 B:3 C:2.5 D:1
A:10 B:11 C:21 D:20
A:-12 B:18 C:19 D:15
AI参考:正确选项是 C:19解释：* `char *s = "Name \\Address";` 这行代码定义了一个指向字符串的指针 `s`，该字符串包含空格、反斜杠、双引号等字符。* 字符串中的反斜杠是一个转义字符，它表示一个特殊的字符序列。例如，`\\` 表示一个反斜杠字符，`` 表示换行符。* 在该字符串中，反斜杠后面跟着一个双引号，这表示字符串的结束。所以，该字符串实际上包含了19个字符（包括终止字符）。* 指针 `s` 指向该字符串，因此 `s` 的长度也是19。所以，答案为 C:19。'
A:3 B:2 C:1 D:6
A:9 9 B:5 20 C:20 20 D:13 20
AI参考:程序输出的结果是选项D：13 20。程序中，变量st的定义为char st[20]="hello\x00\t?\\";，字符串中包含了空格、制表符和反斜杠等非打印字符，因此strlen(st)的计算会考虑这些特殊字符的长度，结果为13。而sizeof(st)则是计算整个数组st所占用的内存大小，即包括数组长度20以及所有元素的类型大小（对于char来说通常是1字节），结果为20。因此，输出结果是strlen(st) 20，即13 20。'
A:"ab" B:"rb+" C:"wb+" D:"ab+"
A:10 B:20 C:19 D:9
AI参考:正确选项是：D:9该语句的执行过程是一个循环，循环变量i从0开始，每次循环i的值加1，直到i小于20为止。在循环中，当i的值是偶数时，程序会跳过当前循环，继续下一次循环，即使用continue关键字。所以当i从0到19时，只有当i是奇数时才会执行y+=i这条语句。因此，语句的执行次数为19次。最终，变量y的值将是9。所以正确选项是D：9。'
A:$abc’ B:”house” C:How do you do． D:‘A’
A:example是结构体类型名 B:struct是结构体类型的关键字 C:struct ex是结构体类型名 D:x,y,z都是结构体成员名
A:4 B:52 C:16 D:32
A:6 B:3 C:4 D:5
AI参考:答案为D：5。程序段首先定义了一个整型数组num并初始化了其中的元素，然后通过指针pnum指向数组中的第三个元素（即num[2]）的位置。接着，程序段执行了两次pnum的递增操作，即pnum++和++pnum，这两次操作会使pnum指向数组中的第四个元素（即num[3]）的位置。最后，程序段使用printf函数输出*pnum的值，即第四个元素的值。由于数组是从0开始计数的，所以num[3]的值是5，因此程序段的运行结果为5。'
A:1 5 9 13 B:1 6 11 16 C:4 8 12 16 D:4 7 10 13
A:12 B:34 C:1234 D:提示出错，无结果
AI参考:正确选项是C:1234。程序段中首先定义了一个整型变量a，赋值为1234。然后使用printf函数输出该变量的值，使用格式化字符串"%2d"，表示输出的整数左对齐，并在左侧填充空格，直到达到指定的宽度（这里是2位）。由于变量a的值为1234，所以输出结果为"1234"。因此，选项C是正确的。'
A:对 B:错
A:错 B:对
A:对 B:错
A:错 B:对
A:对 B:错
A:错 B:对
A:对 B:错
A:错 B:对
A:错 B:对
A:对 B:错
A:对 B:错
A:错 B:对
A:对 B:错
A:错 B:对
A:对 B:错
A:对 B:错
A:错 B:对
A:对 B:错
A:对 B:错
A:错 B:对
A:int a[7]=7*6; B:int a[9]={0,7,0,4,8}; C:int a[5]={9,5,7,4,0,2}; D:int a[8]={ };
AI参考:正确选项是： A) a B) 1 C) D) B 解释： * 在C语言中，字符型常量由单引号()括起来的单个字符组成。所以选项A) a，D) B是正确的。 * 选项B) 1 不是一个字符，它是一个数字字符，它的大小写映射是1。 * 选项C) 是一个空格字符，不是一个字符型常量。 所以，正确选项为ABD。"
AI参考:正确选项是： B. C. D. 解析： A. char str[] = hello; // 不正确，字符串常量需要用引号括起来。 B. char str[] = {h, e, l, l, o}; // 正确，字符数组初始化时可以直接给每个元素赋值。 C. char str[] = {(char) 65, (char) 66, (char) 67}; // 正确，可以使用强制类型转换给字符数组赋值。 D. char str[] = {0}; // 正确，字符数组的最后一个元素通常被赋值为0，表示字符串的结束。 所以，以上三种形式都是对字符数组进行正确初始化的形式。"
AI参考:对于这个问题，由于没有给出具体的定义语句，我无法判断哪个选项是正确的。如果您能提供具体的定义语句，我将很乐意帮助您判断其是否正确。'
A:该变量在本程序范围内均有效 B:该变量为非法变量 C:该变量只在该复合语句中有效 D:该变量在该函数中有效
A:char *p;scanf("%s", p); B:char str[10], *p;p=str; scanf("%s", p); C:char str[10];scanf("%s", &str) D:char str[10], *p=str;scanf("%s", p[1]);
A:int a[2][3]={{1,2},{3,4},{5,6}}; B:int a[][3]={1,2,3,4,5,6}; C:int a[2][3]={0}; D:int a[][3]={{1,2},{0}};
A:不可以用关系运算符对字符数组中的字符串进行比较 B:字符数组中的字符串可以整体输入、输出 C:字符数组可以存放字符串 D:可以在赋值语句中通过赋值运算符"="对字符数组整体赋值
A:C程序在书写时，有严格的缩进要求，否则不能编译通过 B:一个C程序只能有一个主函数 C:C程序的主函数必须用main作为函数名 D:一个C程序可以包含多个不同名的函数
AI参考:正确选项是【BD】A. C程序在书写时，虽然有严格的缩进要求，但并非不能编译通过的必要条件。在C语言中，如果缩进错误或不符合语法规则，编译器可能会报错，但不是不能编译通过的必要条件。B. 一个C程序只能有一个主函数，这是C语言的基本规则。主函数是程序的入口，也是程序执行的起点。C. 在C语言中，main函数是程序的入口点，但不是必须用main作为函数名。实际上，C语言允许使用任何合法的标识符作为函数名，只要符合语法规则即可。D. 一个C程序可以包含多个不同名的函数，这是正确的。在C语言中，函数名只是标识符，用于区分不同的函数，而函数的内容是独立的，可以放在不同的文件中。因此，一个C程序可以包含多个不同名的函数，每个函数都有自己的作用域和生命周期。'
A:b=(float)(1/a) B:b=1/(a*1.0) C:b=1/(float)a D:b=1.0/a
A:对 B:错
A:错 B:对
AI参考:答案：B:对。 解释：题目中给出了一个char数组s，并初始化为TurboC++，因此数组s的长度应该等于字符串的长度，即9。因此，选项B是正确的。选项A是错误的，因为数组s的长度应该是9而不是7。"
A:错 B:对
AI参考:B:对。一个函数返回值的类型是由其定义的类型决定的，而不是由调用该函数的函数的类型决定。因此，这个说法是正确的。'
A:错 B:对
A:对 B:错
