提示:内容已经过期谨慎付费，点击上方查看最新答案
C语言程序设计（青岛职业技术学院）
有以下程序
#include <stdio.h>void fun(int *a,int *b)
{int *c;
c=a;a=b;b=c;
}
main()
{int x=3,y=5,*p=&x,*q=&y;
fun(p,q);printf("%d,%d,",*p,*q);
fun(&x,&y);printf("%d,%d ",*p,*q);
}
程序运行后的输出结果是( )假定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的值是_______.
- sizeof( double ) 是（ ）
- 一个栈的初始状态为空。现将元素1、2、3、4、5、A、B、C、D、E 依次入栈，然后再依次出栈，则元素出栈的顺序是（ ）。
- 设整型变量a，b的值分别为1，0，那么a && b的结果是（ ）。
- 以下叙述正确的是
设有定义：char *c;，以下选项中能够使字符型指针c正确指向一个字符串的是( )
- 设有宏定义：#include
IsDIV（k,n） （（k%n==1）?1:0且变量m已正确定义并赋值，则宏调用：IsDIV（m,5）&& IsDIV（m,7）为真时所要表达的是 - 有以下程序
#include
#define PT 3.5;
#define S（x） PT*x*x;
mian（）
{ int a=1, b=2; printf（“%4.1f ”,S（a+b））;}
程序运行后输出的结果是 - 设有定义:
struct complex
{ int real,unreal;} data1={1,8},data2;
则以下赋值语句中错误的是 - 变量a中的数据用二进制表示的形式是01011101，变量b中的数据用二进制表示的形式是11110000。若要求将a的高4位取反，低4位不变，所要执行的运算是
在一个C语言程序中，下列说法正确的是( )。
在定义int a[5][4];之后，对数组元素的引用正确的是
- 设有变量说明：float x = 4.0 , y = 4.0，下面使x为10.0的表达式是（ ）
在C语言中，引用数组元素时，其数组下标的数据类型允许是
以下叙述中正确的是（）。
- 若有以下定义
int x[10],*pt=x;
则对x数组元素的正确应用是 以下选项中不是C语句的是（ ）。
已知指针p的指向如图所示的a[1]，则表达式*++p的值是（ ）。
a[0] a[1] a[2] a[3] a[4]
10
20
30
40
50
- 设整型变量a，b的值分别为1，0，那么a || (b++)的结果是（ ）。
- 以下选项中合法的 C 语言赋值语句是（ ）
- 设有定义语句int(*f)(int);,则以下叙述正确的是
下列语句组中，正确的是（ ）
对以下说明语句，理解正确的是（ ）。
int a[10]={6,7,8,9,10};
若要求在if后一对圆括号中表示a不等于0的关系,则能正确表示这一关系的表达式为（ ）。
已知char *p，*q；下面语句正确的是（ ）。
- 设整型变量a，b的值分别为1，0，那么a != b的结果是（ ）。
- 以下选项中叙述正确的是（ ）
已有定义：char a[]="xyz",b[]={''x'',''y'',''z''};,以下叙述中正确的是 （ ）。
对数组各元素的存取完全可以不用下标变量而用指针来代替。
- 有以下程序
#include
void fun(int p)
{ int d=2;
p=d++; printf(“%d”,p);}
main()
{ int a=1;
fun(a); printf(“%d ”,a);}
程序运行后的输出结果是 - 在C语言中，所有算术运算符的优先级都相同。（ ）
- 执行以下程序段后，w 的值为（ ）。
int w='A', x=14, y=15;
w=((x || y)&&(w<'a')); - 在数据管理技术发展的三个阶段中，数据共享最好的是（ ）。
以下叙述中不正确的是( )。
- 有以下程序
#include
int fun()
{ static int x=1;
x*2; return x;
}
main()
{int i,s=1，
for(i=1;i<=2;i++) s=fun();
printf("%d ",s);
｝
程序运行后的输出结果是 已知char s[10],*p=s;,则在下列语句中，错误的语句是（ ）。
- 有定义语句：char s[10];，若要从终端给s输入5个字符，错误的输入语句是
&&运算符，如果参与运算的第一个表达式为真，第二个不再计算其值了。
有以下程序
#include
#define SUB(a) (a)-(a)
main()
{ int a=2,b=3,c=5,d;
d=SUB(a+b)*c;
printf("%d ",d);
}
程序运行后的输出结果是_______
- 下列语句组中，正确的是
下列关于运算符优先顺序的描述中正确的是( )。
1、数组名能与其它变量名相同。数组名后是用方括号括起来的常量表达式，不能用圆括号。
有如下程序
int main( )
{ float x=2.0,y;
if(x<0) y=0.0;
else if(x<10.0) y=1.0/x;
else y=1.0;
printf(“%f ”,y);return 0;
}
该程序的输出结果是（ ）。0x173是正确的十六进制常数。
- 有以下程序
#include <stdio.h>
main()
{
int a=2, c=5;
printf(“a=%%d,b=%%d\n”, a, c );
}
程序运行后的输出结果是（ ） - 下列排序方法中，最坏情况下比较次数最少的是
- 有以下程序
#include
main()
{ int a=2,b=2,c=2;
printf("%d ",a/b&c);
}
程序运行后的输出结果是 - 在软件开发中，需求分析阶段产生的主要文档是
- 有以下程序
#include <stdio.h>
#include <math.h>
main()
{
int a=1, b=4, c=2;
double x=10.5, y=4.0, z;
z = ( a+b )/c + sqrt( y ) * 1.2 / c + x;
printf("%f\n", z);
}
程序运行后的输出结果是（ ） 有如下函数定义：
#include <stdio.h>
int fun( int k )
{ if (k<1) return 0；
else if (k＝＝1) return 1；
else return fun(k－1)＋1；
}
若执行调用语句：n＝fun(3)；，则函数fun总共被调用的次数是( )。
- 耦合性和内聚性是对模块独立性度量的两个标准。下列叙述中正确的是
有如下定义：
struct person { char name[9];int age;};
struct person class[10]={"John",17, "Paul",19, "Mary",18, "Jack",19};
根据上述定义，能输出字母M的语句是（ ）
- 算法的特点之一是无穷性。（ ）
- 若有以下程序段
int r=8;
printf(“%d ”,r>>1);
输出结果是 以下对一维数组a进行不正确初始化的是
C语言程序中,当调用函数时实参和形参各占一个独立的存储单元。
以下用户标识符中，合法的是_______。
- 选出下列标识符中不是合法的标识符的是（ ）
A:5,3,3,5 B:5,3,5,3 C:3,5,3,5 D:3,5,5,3
答案:3,5,3,5AI参考:程序运行后的输出结果是选项C：3,5,3,5。程序中首先定义了一个函数fun，该函数接收两个指向整型变量的指针，并将其中一个指针的值赋给另一个指针，再将其中一个指针的值赋给原变量。然后在main函数中分别调用了fun函数两次，将变量x和y的地址分别传给fun函数，同时将fun函数返回的结果分别赋值给变量p和q。第一次调用fun函数后，变量p指向x的地址，q指向y的地址，此时x的值为3，y的值为5。fun函数执行完后，p指向的x的值变为y的值，即5，此时输出的结果是5,3。第二次调用fun函数后，变量p仍然指向x的地址，q指向y的地址，此时x的值仍然为5，但y的值变成了3。fun函数执行完后，变量p指向的值仍然是x的值，即5，此时输出的结果是3,5。因此，程序运行后的输出结果是3,5,3,5。'
A:2 B:4 C:3 D:1
答案:1AI参考:答案：D解析：程序段执行过程为：1. m=(w
A:不合法的表达形式 B:一个双精度表达式 C:一个整型表达式 D:一个函数调用
答案:一个整型表达式AI参考:正确选项是B:一个双精度表达式。sizeof是C/C++中的一个运算符，用于获取指定类型在内存中的大小（以字节为单位）。double是一个双精度浮点数类型，因此sizeof(double)是一个双精度表达式。选项A、C、D都是不合法的。'
A:12345ABCDE B:ABCDE12345 C:54321EDCBA D:EDCBA54321
答案:B_EDCBA54321AI参考:正确答案是D：EDCBA54321。因为栈是后进先出（LIFO）的数据结构，所以元素出栈的顺序应该是最后一个进栈的元素最先出栈，即EDCBA54321。'
A:2 B:都不对 C:1 D:0
答案:0AI参考:正确答案是D:0。这是一个逻辑与运算，如果a和b都是真（即非零），则结果为真，否则为假。在这个问题中，a的值是1，这是一个非零的真值，而b的值是0，这是一个零的假值，因此a && b的结果是0。所以正确答案是D。'
A:C语言函数可以嵌套调用，例如：fun(fun(x)) B:C语言程序是由过程和函数组成的 C:C语言函数不可以单独编译 D:C语言中除了main函数，其他函数不可作为单独文件形式存在
AI参考:正确选项是B:C语言程序是由过程和函数组成的。解释：A选项中，C语言函数可以嵌套调用，但是fun(fun(x))这样的调用方式并不符合C语言的语法规则，因此这个选项是错误的。C选项中，C语言函数是可以单独编译的，但通常情况下我们会在一个C语言源文件中包含多个函数，这样的方式可以使代码更清晰，便于管理和维护。因此，选项C是错误的。D选项中，C语言中的函数是作为独立的代码块存在的，可以在单独的文件中定义和实现，也可以在主程序中调用。因此，选项D也是错误的。而B选项中，C语言程序是由过程和函数组成的，这是正确的。在C语言中，函数是程序的基本组成部分之一，它们可以被定义、调用、实现和测试。因此，B选项是正确的。'
A:c=getchar(); B:char str[ ]=”string”;c=str; C:scanf(“%s”,c); D:*c=”string”;
AI参考:正确选项是B: char str[] = "string"; c = str;解释如下：A. c = getchar(); 会从输入中读取一个字符，赋值给指针c，而不是指向一个字符串。C. scanf("%s", c); 是用于从输入中读取一个字符串，并将它存储在c指向的位置。但这不会让c正确指向一个字符串。D. *c = "string"; 是将字符串"string"的内存地址赋值给指针c，而不是让c指向一个字符串。只有选项B是正确的，因为char str[] = "string"; 会创建一个字符串并存储在str中，然后将str的地址赋值给c，这样c就正确指向了一个字符串。所以选项B是正确的。'
A:判断m被5和7整除是否余1 B:判断m被5或者7整除是否余1 C:判断m是否能被5或者7整除 D:判断m是否能被5和7整除
AI参考:答案选D：判断m是否能被5和7整除。解析：在宏定义中，`IsDIV（k,n）`宏的作用是对k是否能被n整除进行判断并返回一个值。而在宏调用中，宏定义的上下文仍然存在，且后跟&&连接两个宏调用，那么就是这两个宏判断的结果为真时整个表达式的值为真。即当`IsDIV（m,5）&& IsDIV（m,7）`为真时，需要表达的是m是否能被5和7整除。因此，选项D为正确答案。注意：在C语言中，&&运算符的优先级低于逻辑与运算符&&，所以需要用括号来明确表达式的运算顺序。因此，正确的宏调用应该是`(IsDIV(m,5) && IsDIV(m,7))`。'
A:7.5 B:31.5 C:程序有错无输出结果 D:4.0
AI参考:选项B:31.5是正确答案。程序中的宏定义PT被定义为3.5，S（x）表示PT乘以x的平方。在主函数中，变量a和b被初始化为1和2，调用S（a+b）即求3.5乘以3的平方，结果为31.5。在printf函数中，输出的格式为%4.1f，即输出一个浮点数，左对齐，至少保留一位小数，因此输出结果为31.5。'
A:data2.real=data1.unreal; B:data2=(2,6); C:data2=data1; D:data2.real=data1.real;
AI参考:错误的是B: data2=(2,6);。在C++中，括号内的2和6必须为表达式或者有效的标量值。这里只提供了数字和逗号的组合，无法作为一个合法的复合表达式或者值进行赋值，因此会导致错误。选项A、C和D都是正确的赋值语句，其中A和D使用了复合赋值运算符。选项C直接将data1的值赋给了data2，这也是正确的。所以，正确的选项是B: data2=(2,6)。'
A:a|b B:a^b C:a D:a&b
AI参考:正确选项是B:a^b。解释：在二进制中，按位取反操作符“^”表示对每一位进行按位取反，即如果某一位为1，则取反后该位为0，如果某一位为0，则取反后该位仍为0。因此，要求将变量a的高4位取反，低4位不变，需要将变量a和变量b进行按位异或操作。异或运算的特点是：相同位上的数相异或结果为0，不同位上的数相异或结果为1。因此，选项B a^b满足要求。选项A表示按位或运算，选项C表示不执行任何操作，选项D表示按位与运算，都不符合要求。'
A:main函数必须出现在所有函数之后 B:main函数必须出现在所有函数之前 C:main函数必须出在固定位置 D:main函数可以出现在其它函数之外的任何位置
AI参考:正确选项是 D:main函数可以出现在其它函数之外的任何位置。在C语言中，main函数是程序的入口点，必须放在程序的开始部分，通常位于其它函数之前。但是，main函数可以出现在其它函数之外的任何位置，只要它位于程序的开始部分即可。这是因为main函数是程序的入口点，需要首先执行，而其它函数可以在需要时被调用。因此，选项D是正确的。选项A、B和C都是错误的，因为main函数不能必须出现在所有函数之后、之前或固定位置。'
A: a[5][0] B:a[0][0] C:a[2][4] D:a[0，0]
AI参考:正确答案是B: `a[0][0]`。在C++中，数组可以通过索引访问，每个索引都有一个对应的位置，且使用二维数组的引用方式访问数组元素时，应按照先左后右的原则。即第一个元素用`a[0][0]`来访问，第二个元素用`a[1][0]`，以此类推。选项A、C和D都是错误的，因为它们的索引超出了数组的范围。所以，正确的选项是B。'
A:x *= y-6 B:x /= y+9 C:x -= y*2.5 D:x += y+2
AI参考:正确选项是【D:x += y+2】。解释：在C语言中，float类型的变量可以进行加法和减法运算。选项A中，y-6的结果是一个double类型，不能直接赋值给float类型的x，所以错误。选项B中，y+9的结果是一个double类型，不能直接赋值给float类型的x，所以错误。选项C中，y*2.5的结果是一个double类型，不能直接赋值给float类型的x，而且表达式中存在除法运算符，而除法运算符只能应用于整数类型，所以这个选项也错误。只有选项D中的表达式x += y+2是将y+2的结果赋值给x，所以是正确的。因为浮点数的加法运算中会进行隐式类型转换，将float类型的x和double类型的y进行加法运算后，得到的结果会以float类型存储，符合题目要求。因此选项D是正确的。'
A:整型表达式或整型常量 B:任何类型 的表达式 C: 整型常量 D:实型常量
AI参考:正确选项是【A:整型表达式或整型常量】。在C语言中，引用数组元素时，其数组下标的数据类型允许是整型表达式或整型常量。这是因为数组下标通常用于指定数组中的元素位置，而数组下标通常需要一个整数类型的值来表示位置。其他选项如实型常量或任何类型的表达式都不符合C语言的语法规则。'
A:在C语言的函数内部，可以定义局部嵌套函数 B:不同函数的形式参数不能使用相同名称的标识符 C:用户自己定义的函数只能调用库函数 D:C语言源程序总是由一个或多个函数组成
AI参考:在C语言的函数内部，可以定义局部嵌套函数，这是正确的。B选项中，形式参数可以使用相同名称的标识符，只要它们在同一个作用域内。C选项中，用户自己定义的函数不仅可以调用库函数，也可以调用其他用户自己定义的函数。D选项也是正确的，因为C语言源程序通常由一个或多个函数组成，每个函数都有自己的作用域和生命周期。因此，正确答案是A。注：在C语言中，函数是程序的基本构造单元，每个程序至少有一个主函数main()。主函数是程序执行的入口，程序从这里开始执行。其他函数可以嵌套在主函数中，也可以在主函数外部定义。所以D选项也是正确的。'
A:*（pt+10） B:*（x+3） C:*&x[10] D:pt+3
AI参考:正确选项是 C: `:*&x[10]`。首先，数组x的第一个元素地址被赋值给了指针pt，所以pt实际上指向了数组x的第一个元素。其次，pt+10表示指针pt向后移动了10个元素的位置，这超过了数组x的长度，因此C选项中的`:*&x[10]`是对的，它表示的是对数组x中第10个元素的解引用操作。B选项和D选项中的`:*（x+3）`和`pt+3`都是错误的，因为它们都超出了数组x的范围。而A选项中的`:*（pt+10）`虽然看起来正确，但实际上它指向了数组之外的内存空间，这是不安全的。所以正确答案是C。'
A:++t B:{a/=b=1;b=a%2;} C:k=i=j; D:;
AI参考:正确答案是D:;。这是一个空语句，没有执行任何操作。其他选项中，A选项是自增操作，B选项是赋值语句，C选项是赋值语句和变量初始化语句。因此，选项D不是C语句。'
A:30 B:21 C:20 D:31
AI参考:答案：C解析：因为表达式中用到了前++，前++表示先取值再自增，所以表达式*++p的值是a[1]的值，即30。'
A:都不对 B:1 C:2 D:0
AI参考:答案：D解析：a的值是1，b的值是0，a||(b++)表示逻辑或运算，结果取决于a的值，a的值是1，所以结果是1||0=0。所以答案是D。注意：在C/C++中，++运算符有两种使用方式，一种是后置加法运算，一种是前置加法运算。前置++是在使用变量前先自增，后置++是在赋值后再自增。在表达式中，如果++在操作数之前，那么它是前置++运算符；如果++在操作数之后，那么它是后置++运算符。所以在这个问题中，b++是后置加法运算。'
A:k=int( a+b ); B:a=b=34 C:a=3,b=9 D:++i;
AI参考:正确选项是B:a=b=34。选项A中，int(a+b)会先将a和b相加，然后再将结果转换为整数，这可能会得到不正确的结果。选项C中，a=3,b=9应该是一个逗号表达式，但这里只有一个变量a，所以它不是一个有效的赋值语句。选项D中，++i;是一个有效的赋值语句，但这里只是简单地将变量i的值增加1，并没有将其赋值给其他变量。选项B中，a=b=34是一个有效的赋值语句，它将b的值赋给a，然后将a的值赋给b。在这种情况下，b的值被设置为34，而a的值也被设置为34，并且没有违反任何语法规则。因此，选项B是正确的选项。'
A:f是指向函数的指针变量，该函数具有一个int类型的形参 B:f是函数名，该函数的返回值是基类型为int类型的地址 C:f是基类型为int的指针变量 D:f是指向int类型一维数组的指针变量
AI参考:答案：A解析：解释：这道题是考察指针的基础概念。题目中的语句int(*f)(int)定义了一个指向函数的指针变量f，该函数具有一个int类型的形参。这里f是一个指针变量，它存储的是函数地址，所以它指向的是一个函数，而不是数组。所以选项B和D是错误的。选项C的说法也是不准确的，因为f的基类型是int*，而不是int。所以，正确答案是A：f是指向函数的指针变量，该函数具有一个int类型的形参。'
A:char *s;s={"Olympic"｝; B:char *s;s="Olympic"; C:char s[7];s="Olympic"; D:char s[7];s={"Olympic"｝;
A: 将5个初值依次赋给a[0]到a[4] B: 因为数组长度与初值的个数不相同，所以此语句不正确 C: 将5个初值依次赋给a[1]到a[5] D:将5个初值依次赋给a[6]到a[10]
AI参考:正确选项是：A: 将5个初值依次赋给a[0]到a[4]。解释：根据题目中的说明语句“int a[10]={6,7,8,9,10};”，我们可以知道这是一个定义了一个长度为10的整型数组a并初始化了它的值。在这个初始化过程中，我们将其中的五个元素的值依次赋给了数组的元素a[0]到a[4]，所以选项A是正确的。选项B、C、D都是不正确的理解，因为题目中已经说明了初始化的顺序是按照数组的顺序从a[0]到a[9]，而不是从a[1]到a[10]或者a[6]到a[10]。'
A:!a B:a<>0 C:a D:a=0
AI参考:正确选项是：B:a<>0。题目要求在if语句后一对圆括号中表示a不等于0的关系，因此需要使用逻辑运算符“不等于”来表示a不等于0。选项B中的“a<>0”符合要求，表示a不等于0。选项A中的“!”符号表示逻辑非，不符合题目要求；选项C、D中的表达式不正确，无法表示a不等于0的关系。因此，正确答案是B。'
A:p+=q; B:p+=3; C:p/=q; D:p*=3;
AI参考:正确答案是D:p*=3; 。选项D中的p*=3;是一个复合赋值运算符，表示将指针p指向的地址中的内容乘以3，并将结果存回指针p所指向的地址中。因此，选项D是正确的。选项A中的p+=q;表示将指针p指向的地址加上指针q所指向的地址，这在C语言中是不合法的，因为指针q并未被初始化。选项B中的p+=3;表示将指针p指向的地址向后移动三个字节，这在C语言中也是不合法的，因为指针p并未被初始化。选项C中的p/=q;表示将指针p指向的地址除以指针q所指向的地址，这在C语言中也是不合法的，因为指针q并未被初始化。因此，选项D是正确的。'
A:0 B:2 C:都不对 D:1
AI参考:答案：C推理过程：a!=b的结果取决于a和b是否不相等。题目中给出的a=1，b=0，显然a不等于b，所以a!=b的结果是“真”，即“对”。而“真”在计算机中通常用1表示，“假”用0表示。所以，a!=b的结果是1。因此，正确选项是D。但是，由于本题是单选题，所以只能选择一个选项，因此正确答案是C。'
A:C 语言的标识符可分为运算符、用户标识符和关键字三类 B:C 语言的标识符可分为关键字、预定义标识符和用户标识符三类 C:C 语言的标识符可分为函数名、变量和预定义标识符三类 D:C 语言的标识符可分为语句、变量和关键字三类
AI参考:正确选项是【B:C 语言的标识符可分为关键字、预定义标识符和用户标识符三类】。C语言中的标识符可分为关键字、预定义标识符和用户标识符三类，其中关键字是由C语言规定的，不可再定义的标识符；预定义标识符是由C语言提供的库函数或宏定义的标识符；用户标识符则是用户根据需要定义的标识符。因此选项B是正确的。选项A、C、D都存在错误，不符合C语言标识符的分类。'
A:a数组长度小于b数组长度 B:数组a和b的长度相同 C:上述说法都不对 D: a数组长度大于b数组长度
A:对 B:错
AI参考:正确答案是B：错。在编程中，数组元素的存取通常需要使用下标变量来指定元素的索引位置，以便进行访问和操作。而指针通常用于指向内存地址，而不是用于访问数组元素。因此，直接使用指针来代替下标变量来访问数组元素是不正确的。在编程中，下标变量是常用的数组元素访问方式，它能够方便地指定元素的索引位置，并提供了对数组元素进行操作的控制和灵活性。'
A:32 B:12 C:21 D:22
AI参考:正确答案是A。程序中的函数fun(int p)将p赋值为d的值，也就是2，并且执行了d的自增操作，所以p的值变为3。在main函数中，调用fun函数并传入a的值，a的值变为3。因此，程序运行后的输出结果是32。解释一下代码中的一些细节：* 在fun函数中，d=2是局部变量，只在fun函数内部有效。* p=d++;是先给p赋值为d的值（即2），然后再将d自增1。因此，在fun函数执行完毕后，p的值变为3。* printf(“%d”,p);打印的是p的值，也就是3。* main函数中，调用fun函数后，a的值变为3，但在main函数中并未对a进行任何操作，所以最终输出的结果为3。希望这个解释能帮到你！'
A:错 B:对
AI参考:答案是A：错。在C语言中，算术运算符的优先级并不完全相同。有些运算符的优先级较高，如乘法和除法，而有些运算符的优先级较低，如加法和减法。因此，在执行算术运算时，需要使用括号来明确运算顺序。所以这个说法是错误的。'
A:NULL B:l C:0 D:-1
AI参考:执行以下程序段后，w 的值为（C:0）。 程序段解释： 1. 定义了变量w、x和y，并分别赋值为A、14和15。 2. 执行w=((x || y)&&(w
A:三个阶段相同 B:数据库系统阶段 C:文件系统阶段 D:人工管理阶段
AI参考:在数据管理技术发展的三个阶段中，数据共享最好的是**数据库系统阶段**。数据管理技术的发展阶段包括人工管理阶段、文件系统阶段和数据库系统阶段。在数据库系统阶段，数据被有组织地存储在数据库系统中，这使得数据共享变得更好，同时减少了数据的冗余。此外，通过数据库管理系统，数据的管理和查询变得更加方便高效。因此，数据库系统阶段是数据管理技术发展中的最佳阶段。'
A:在C语言中，整数可以以十进制、八进制或十六进制的形式输出 B:使用putchar函数可以不要输出项 C:调用printf函数时，必须要有输出项 D:使用putchar函数时，必须在之前包含头文件stdio.h
AI参考:选项C是错误的。在C语言中，printf函数是用于格式化输出的函数，需要指定输出项，包括格式化字符串和要输出的变量等。而putchar函数则是用于输出单个字符的函数，通常不需要输出项，但是也需要包含stdio.h头文件。选项A、B和D都是正确的。因此，正确选项是C:调用printf函数时，必须要有输出项。'
A:1 B:4 C:0 D:8
AI参考:程序的输出结果是：D:8。解释：在fun函数中，使用了静态变量x，第一次调用fun函数时，x的值为1，函数内部将其乘以2并返回。由于static关键字的作用，x在fun函数内部被存储在静态存储区，只在fun函数内部有效，因此下一次调用fun函数时，x的值不会改变。因此，fun函数被调用了两次，即x的值被乘以2两次，最终返回值为8。在main函数中，s被初始化为1，然后调用fun函数两次并将结果赋值给s，因此最终输出结果为8。'
A:p=s+5; B:s=p+s; C:s[2]=p[4] D:*p=s[0]
AI参考:在C语言中，数组名s是一个指向数组第一个元素的指针，即p=s;是一个有效的赋值语句。选项A:p=s+5;是正确的，因为p是一个指向数组元素的指针，s+5会得到指向数组的第6个元素的指针。选项B:s=p+s;是错误的，因为这将把s指向一个新的位置，而不是改变数组s的内容。选项C:s[2]=p[4]是正确的，因为s和p都指向同一个数组，所以可以使用数组索引进行赋值。选项D:*p=s[0]是正确的，因为*p解引用p指向的元素，也就是数组s的第一个元素。因此，只有选项B是错误的。'
A:scanf(“%s”,s[1]); B:scanf(“%s”,s+1); C:gets(&s[0]); D:gets(s);
A:对 B:错
AI参考:答案是B：错。在C++中，&&运算符是逻辑与运算符，如果第一个表达式为真，则整个表达式为真，必须计算第二个表达式的值。只有当第一个表达式为假时，第二个表达式才会被跳过。所以这个说法是错误的。'
A:-12 B:-20 C:10 D:0
AI参考:程序运行后的输出结果是选项 B: -20。程序中的宏定义 SUB(a) 是一个递归函数，它将参数 a 减去自身。在主函数中，d 的值是 (a+b)-(a+b)*c，即 -2*(5)，结果为 -10。然后使用 printf 函数输出 d 的值，所以输出结果为 -20。'
A:char s[7];s="Olympic"; B:char *s;s="Olympic"; C:char s[7];s={"Olympic"｝; D:char *s;s={"Olympic"｝;
AI参考:正确选项是【C:char s[7];s={"Olympic"｝;】。解释：选项A中，变量s被声明为char类型数组，但其后面没有对数组赋值就直接赋值了一个字符串，这是错误的。选项B中，变量s被声明为char指针类型，但其后面直接赋值了一个字符串，也是错误的。选项D中，变量s被声明为char指针类型数组，但是它后面并没有给数组的每个元素赋值，就给数组整体赋值了一个字符串，这是错误的。选项C中，正确地使用了字符数组初始化方式，即使用大括号{}来给数组的每个元素赋值。因此选项C是正确的。所以正确选项是C:char s[7];s={"Olympic"｝;。'
A:赋值运算符< 逻辑与运算符< 关系运算符< 算术运算符 B:算术运算符< 关系运算符< 赋值运算符< 逻辑与运算符 C:逻辑运算符< 关系运算符< 算术运算符< 赋值运算符 D:关系运算符< 算术运算符< 赋值运算符< 逻辑与运算符
AI参考:答案：B解析：选项A逻辑与运算符是逻辑运算符；选项C逻辑运算符是优先级最高的，且逻辑运算符不能与其他类型运算符一起使用；选项D算术运算符优先于关系运算符，但关系运算符优先于赋值运算符。根据优先级顺序，正确答案是B。其中算术运算符优先级高于关系运算符，关系运算符优先级高于赋值运算符，而赋值运算符优先于逻辑与运算符。故本题答案为B。'
A:错 B:对
AI参考:答案：A解释：数组名不能与其他变量名相同，因此选项B错误。数组名后面应该用方括号括起来的常量表达式，但是可以包含变量和常量，也可以使用圆括号。因此选项A错误。正确答案是A。'
A:0.500000 B:0.250000 C:0.000000 D:1.000000
AI参考:正确答案是D:1.000000。程序首先检查x是否小于0，如果是，则y被设置为0.0。否则，程序检查x是否小于10.0，如果是，则y被设置为1.0/x的值，这是一个除法运算，所以结果是x的值分之一，因此y=1/x=1/2=0.5。因此程序最后输出的是y的值，即0.5，然后返回0表示程序正常结束。综上所述，程序的输出结果为D选项，即1.0。'
A:错 B:对
AI参考:正确答案是B：对。\r0x173是正确的十六进制常数。'
A:a=%2,b=%5 B:a=%d,b=%d C:a=2,b=5 D:a=%%d,b=%%d
AI参考:程序的输出结果应该是C：a=2,b=5。解释如下：在程序中，printf函数用来输出变量的值，但printf函数中的%d被%替代了，这是因为在C语言中，%%是一个特殊的字符，它代表的是%符号本身，而不是%d。因此程序输出结果是变量a的值，即2，变量c的值，即5。另外，输出格式是"a=%%d,b=%%d"，这实际上并没有被执行，因为%%在printf函数中已经被替换为%符号了。所以程序的输出结果并不会包含%%d。因此，正确选项是C：a=2,b=5。'
A:直接插入排序 B:简单选择排序 C:堆排序 D:冒泡排序
AI参考:正确选项是 C:堆排序。堆排序是一种基于比较的排序算法，它通过构建一个最大堆或最小堆，然后交换堆顶元素和最后一个元素，再调整堆结构，直到所有元素都排序完成。在堆排序中，最坏情况下的比较次数取决于最大堆或最小堆的构建过程。在构建最大堆时，需要将新元素与当前最大元素进行比较，并交换它们的位置，这个过程需要遍历整个数组。因此，在最坏情况下，堆排序需要进行n*(n-1)/2次比较，其中n是数组的大小。而在其他排序方法中，如直接插入排序、简单选择排序和冒泡排序，它们的比较次数会随着数组长度的增加而增加，但在堆排序中，比较次数在最坏情况下是最少的。'
A:0 B:1 C:3 D:2
AI参考:程序的输出结果是选项B:1。程序中，变量a、b和c都被初始化为2，因此它们的值都是2。在C语言中，整数除法是向下取整的，所以a/b的结果是1，而a/b&c的结果是a和c的较低位同时取反后的结果，即1&(2^0)=1。因此，程序输出的结果是1。'
A:概要设计说明书 B:可行性分析报告 C:集成测试计划 D:软件需求规格说明书
AI参考:正确选项是【D】软件需求规格说明书。在软件开发中，需求分析阶段的主要任务是深入理解用户的需求，并转化为计算机系统可以理解的语言。在这个阶段，会产生各种需求分析文档，其中最主要的是软件需求规格说明书。该文档详细描述了软件的功能、性能、界面、约束条件等需求，是软件设计、开发、测试的重要依据。其他选项中，概要设计说明书是在系统设计阶段产生的，可行性分析报告是在项目前期进行评估时使用的，集成测试计划则是测试阶段使用的。所以，在这些选项中，只有D选项——软件需求规格说明书，是需求分析阶段产生的最主要文档。'
A:14.900000 B:15.400000 C:14.000000 D:13.700000
AI参考:选项B是正确的答案。程序中的代码首先将变量a、b、c和x、y的值代入表达式，计算出z的值。然后使用printf函数将结果输出到屏幕上。程序中的sqrt函数用于计算y的平方根，但需要注意的是，该程序中并没有包含头文件
A:3 B:5 C:2 D:1
AI参考:答案：C解析：第一次调用：k=3，满足第一个if条件，返回0第二次调用：k=2，不满足条件，执行else，递归调用fun(2-1)=fun(1)，返回1第三次调用：递归调用fun(1-1)=fun(0)=0+1=1总共被调用的次数是2次。'
A:耦合性是指一个模块内部各个元素间彼此结合的紧密程度 B:降低耦合性提高内聚性有利于提高模块的独立性 C:内聚性是指模块间互相连接的紧密程度 D:提高耦合性降低内聚性有利于提高模块的独立性
AI参考:答案：B解析：耦合性和内聚性是软件工程中的两个概念，它们是度量模块独立性的两个标准。选项A中，耦合性是指模块之间相互连接的紧密程度，而内聚性是指模块内的各个元素间彼此结合的紧密程度，这两个概念描述的对象不同，表述也不准确。选项C中，内聚性是指模块间互相连接的紧密程度，这个叙述是正确的，但这不是耦合性和内聚性的定义。选项D中，提高耦合性和降低内聚性都会降低模块的独立性。只有选项B中，降低耦合性提高内聚性有利于提高模块的独立性，这是耦合性和内聚性的定义，也是提高模块独立性的正确方法。因此，正确答案是B。'
A:printf("%c ",class[3].name[1]); B:printf("%c ",class[3].name); C:printf("%c ",class[2].name[0]); D:printf("%c ",class[2].name[1]);
AI参考:答案为C，代码的含义是定义了一个结构体数组class，数组中的每个元素都是一个person结构体，每个person结构体包含一个姓名（字符数组）和一个年龄。现在需要输出数组中第三个元素（下标为3）的姓名，也就是字母M。选项A和D中，直接输出class[3].name[1]或class[2].name[1]，会输出下标超出范围的错误信息。选项B中，直接输出class[3].name，会输出整个姓名字符串，而不是单个字符。选项C中，printf("%c", class[2].name[0])，会输出第三个元素（下标为2）的姓名中的第一个字母M。因此，正确答案是C。'
A:对 B:错
AI参考:答案是B：错。算法的特点之一是有限性，即算法必须在有限时间内完成，不能是无穷的。因此，选项B是正确的。'
A:2 B:8 C:16 D:4
AI参考:正确答案是D:4。程序段中r的值是8，使用右移运算符">>"将r的值右移一位，相当于除以2，所以输出结果为4。'
A:int a[10]＝{}; B:int a[]＝{0}; C:int a[10]＝{10*2}; D:int a[10]＝(0,0,0,0);
AI参考:正确选项是：D:int a[10]＝(0,0,0,0);在C++中，数组初始化可以使用大括号{}来一次性初始化所有元素。选项A、B和C都是正确的数组初始化方式，分别初始化为空、只初始化为0或初始化为一个数值序列。然而，选项D中的初始化方式是不正确的，因为它使用了逗号分隔的多个值，这在C++中不会被视为初始化数组的元素，而是会分别赋值为每个逗号分隔的值。因此，D选项会导致错误。'
A:错 B:对
AI参考:正确答案是B：对。在C语言中，当调用函数时，实参和形参各占一个独立的存储单元。实参是实际传递给函数的参数，而形参是函数定义中的参数。实参和形参在内存中是独立的存储单元，它们在函数执行期间可以进行数据的传递和交换。'
A:a+b B:int C:123 D:nit
AI参考:在C++中，用户标识符需要满足一定的规则。选项A、C明显不符合标识符的要求，因为它们包含数字。选项B是合法的，因为它是一个具体的类型名（在C++中，int是一个常见的整数类型）。而选项D中的"nit"不是一个合法的标识符，因为它不是一个有效的单词或者缩写。所以，正确答案是B:int。'
A:hot_do B:cat@113 C:INT D:_2ab
AI参考:正确答案是C：INT。标识符是用来标识变量、函数、类等程序的名称。标识符可以是字母、数字、下划线，但第一个字符必须是字母或下划线。A选项的“hot_do”符合标识符命名规则；B选项的“cat@113”是合法的标识符，其中@在此处是一个分隔符，用来将字母“c”和数字“at”分开；D选项的“_2ab”也符合标识符命名规则，其中下划线可以作为标识符的间隔符。因此，只有C选项中的“INT”不是合法的标识符，因为它以数字开头。'
温馨提示支付 ￥2.65 元后可查看付费内容,请先翻页预览!
