当前位置：首页 > news >正文

Day03_刷题niuke20251004

news 2025/10/4 5:27:31

试卷01

试卷02

试卷题目

试卷01_题目
单选题
C++
C语言
1.
下列数组定义语句中，不合法的是（）
A
int a[3] = { 0, 1, 2, 3 };
B
int a[] = { 0, 1, 2 };
C
int a[3] = { 0, 1, 2 };
D
int a[3] = { 0 };
正确答案：A
官方解析：
数组的定义语句中，A选项不合法的原因是初始化列表中的元素个数(4个)超过了数组的声明长度(3个)。在C++中,定义数组时如果指定了数组长度,那么初始化列表中的元素个数不能超过数组长度。

分析其他选项:
B选项合法：当数组定义时不指定长度,用初始化列表赋值时,数组的长度会自动设置为初始化列表中元素的个数,此处长度为3。

C选项合法：数组长度为3,初始化列表也包含3个元素,元素个数与数组长度相符。

D选项合法：数组长度为3,初始化列表只有1个元素0,编译器会自动将剩余元素初始化为0,所以数组实际值为{0,0,0}。

总的来说,定义数组时需要注意:
1. 如果指定了数组长度,初始化列表的元素个数不能超过数组长度
2. 初始化列表的元素个数可以少于数组长度,剩余元素会被自动初始化为0
3. 不指定长度时,数组长度由初始化列表的元素个数决定
知识点：C++、C语言
题友讨论(6)
单选题
C语言
2.
若有int a[3][5]={{2，2}，{2，6}，{2，6，2}}，则数组a共有7个元素。
A
正确
B
错误
正确答案：B
官方解析：
二维数组， 15 个元素，缺少的元素用 0 补充，如第 1 行为 2 2 0 0 0
知识点：C语言
题友讨论(9)
单选题
C语言
3.
C语言程序的语句都是以（）结尾。
A
“.”
B
“；”
C
“，”
D
都不是
正确答案：B
官方解析：
【解释】根据C语言的规定，在程序中所有的语句均必须由“；”结尾。所以选择B。
知识点：C语言
题友讨论(12)
单选题
软件工程
C语言
4.
以下正确的叙述有（）
A
在 C 程序中，每行只能写一条语句
B
在 C 程序中，一条语句只写在一行上
C
在 C 程序中，多条语句必须写在多行上
D
在 C 程序中，多条语句可以写在一行上
正确答案：D
官方解析：
C语言对于代码格式非常灵活, D选项正确,因为在C语言中多条语句确实可以写在同一行,只要使用分号(;)分隔即可。比如:a=1; b=2; c=3;这样的写法是完全合法的。

分析其他选项:

A错误:C语言并没有规定每行只能写一条语句。一行可以写多条语句,只需用分号分隔。

B错误:一条语句不一定要局限在一行内。长语句可以跨多行书写,编译器会自动将其视为一个完整语句。

C错误:多条语句不必须写在多行上。C语言的语句之间用分号分隔,与换行无关。

需要注意的是,虽然C语言在语法上允许这种灵活的书写方式,但为了代码的可读性和可维护性,建议:
1. 每行写一条主要语句
2. 相关的语句按逻辑分组
3. 使用适当的缩进和空行
4. 保持代码格式的一致性

这些都是良好的编程习惯,但不是语言强制要求的规则。
知识点：软件工程、C语言
题友讨论(3)
单选题
C++
C语言
5.
程序的基本结构中选择结构又叫分支结构，有单分支与多分支两种。请问这句话的说法是否正确？
A
正确
B
错误
正确答案：A
官方解析：
选择结构(分支结构)确实包含单分支和多分支两种基本形式,因此这句话的说法是正确的。

具体说明如下:
1. 单分支结构:也称为if结构,只有一个判断条件,当条件成立时执行相应的程序段,不成立时继续执行后续语句。形式为:if(条件){语句块}

2. 多分支结构:主要包括两种形式:
- if...else if...else结构:可以处理多个不同的条件判断
- switch...case结构:用于对某个变量的不同取值进行判断和处理

这两种基本分支结构是程序设计中最基础和最常用的控制结构,它们各自适用于不同的场景:
- 单分支适用于只需要判断一个条件的简单情况
- 多分支适用于需要判断多个条件的复杂情况

B选项错误,因为题目中的说法完全符合程序设计的基本原理,准确描述了选择结构的分类方式。
知识点：C++、C语言
题友讨论(11)
单选题
C语言
6.
运行以下程序后，如果从键盘上输入 65 14<回车>，则输出结果为（）
1
2
3
4
5
6
7
8
9
10
11
int main(void) {
    int m, n;
    printf("Enter m,n;");
    scanf("%d%d", &m,&n);
    while (m!=n) {
        while (m>n) m=m-n;
        while (n>m) n=n-m;
    }
    printf("m=%d\n",m);
    return 0;
}
A
m=3
B
m=2
C
m=1
D
m=0
正确答案：C
官方解析：
这道题目考察的是程序的循环迭代和求最大公约数的算法。让我们通过执行过程来分析:

输入 m=65, n=14 后的执行过程:

1) 首轮: m=65>n=14
65-14=51, 所以m=51
51>14继续循环
51-14=37, 所以m=37
37>14继续循环
37-14=23, 所以m=23
23>14继续循环
23-14=9, 所以m=9

2) 此时m=9 切换到n>m的循环
14-9=5, 所以n=5

3) 现在m=9>n=5
9-5=4, 所以m=4

4) n=5>m=4
5-4=1, 所以n=1

5) m=4>n=1
4-1=3, m=3
3-1=2, m=2
2-1=1, m=1

6) 此时m=n=1,循环结束
输出m=1

所以C选项(m=1)是正确答案。这个算法实际上是在计算两个数的最大公约数,通过反复相减的方式实现。

其他选项分析:
A(m=3)错误:这只是计算过程中的某个中间值
B(m=2)错误:同样是中间过程值
D(m=0)错误:由于算法的特性,结果不可能为0

这个程序本质上是用减法实现的辗转相除法(欧几里得算法)的变体,最终会得到输入数字的最大公约数。
知识点：C语言
题友讨论(7)
单选题
C语言
7.
以下程序的输出结果是
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
int a, b;
void fun() {
    a = 100;
    b = 200;
}
int main() {
    int a = 5, b = 7;
    fun();
    printf("%d %d\n", a, b);
    return 0;
}

A
100200
B
57
C
200100
D
75
正确答案：B
官方解析：
这道题目主要考察局部变量和全局变量的作用域概念。

程序中定义了全局变量 a、b 和局部变量 a、b。在 main 函数中定义的 a=5,b=7 是局部变量,而在函数外定义的 a、b 是全局变量。当在 main 函数中通过 fun() 修改变量值时,实际修改的是全局变量,而不是局部变量。因此 main 函数中打印的仍然是局部变量 a=5,b=7。

所以 B 选项(5 7)是正确答案。

分析其他选项:
A选项(100 200)错误:这是误认为修改的是局部变量的值
C选项(200 100)错误:这是对修改的变量顺序理解错误
D选项(7 5)错误:这是对局部变量的初始值理解错误

这个题目的关键是要理解:
1. 同名变量的作用域规则 - 局部变量会屏蔽全局变量
2. 函数对变量的访问规则 - 在没有使用指针的情况下,函数只能修改全局变量,不能修改其他函数的局部变量
知识点：C语言
题友讨论(21)
单选题
C++
C语言
8.
以下叙述中正确的是（）
A
使用typedef定义新类型名后，新类型名与原类型名实际上是等价的
B
结构体类型中的各个成分均不能是数组或指针
C
结构体类型的变量，不能在声明结构体类型组成时一起定义
D
元素为结构体类型的数组，只能在声明过结构体类型之后，单独进行定义
正确答案：A
官方解析：
typedef定义新类型名后，原类型名和新类型名在使用上完全等价，可以互换使用而不会产生任何错误。这是因为typedef本质上只是给现有类型起了一个别名，并不会创建新的数据类型。

分析其他选项的错误原因：

B选项错误：结构体成员可以是任何基本数据类型，也可以包含数组或指针。比如可以在结构体中定义字符数组来存储字符串，或者定义指针成员来实现链表等数据结构。

C选项错误：在声明结构体类型的同时是可以定义变量的。例如：
struct Student {
int id;
char name[20];
} stu1, stu2; //合法的声明方式

D选项错误：元素为结构体类型的数组可以在声明结构体类型的同时定义。例如：
struct Point {
int x, y;
} points[100]; //合法的声明方式

所以A选项描述是准确的，而其他选项都存在错误认识。这个题目主要考察了对结构体声明和定义的基本概念，以及typedef的本质理解。
知识点：C++、C语言
题友讨论(9)
单选题
C语言
9.
以下程序
#include <stdio.h>
void fun(char **p) {
    int i;
    for (i = 0; i < 4; i++)
        printf("%s", p[i]);
}
main() {
    char *s[6] = {"ABCD", "EFGH", "IJKL", "MNOP", "QRST", "UVWX"};
    fun(s);
    printf("\n");
}
程序运行后的输出结果是?
A
ABCDEFGHIJKL
B
ABCD
C
AEIM
D
ABCDEFGHIJKLMNOP
正确答案：D
官方解析：
这道题目考察了字符串指针数组以及指针作为函数参数的知识点。

题目中定义了一个含有6个字符串的指针数组s，每个字符串包含4个字符。在fun函数中通过二级指针p接收这个数组，并使用for循环打印前4个字符串。因此程序会依次输出"ABCD"、"EFGH"、"IJKL"、"MNOP"，最终输出结果为"ABCDEFGHIJKLMNOP"。

分析每个选项：
A错误：输出"ABCDEFGHIJKL"，这只包含了前3个字符串，少了第4个字符串"MNOP"。

B错误：输出"ABCD"，这只包含了第1个字符串，缺少了后面3个字符串。

C错误：输出"AEIM"，这种理解是完全错误的，程序是按完整字符串顺序输出，而不是取每个字符串的首字母。

D正确：程序通过for循环遍历了指针数组的前4个元素(i<4)，每个元素都是一个包含4个字符的字符串，因此完整输出了"ABCDEFGHIJKLMNOP"。虽然原数组s定义了6个字符串，但是fun函数中的循环只访问了前4个。

这道题目的关键是要理解字符串指针数组的结构，以及printf("%s",p[i])是打印完整字符串而不是单个字符。
知识点：C语言
题友讨论(0)
单选题
C语言
10.
下面代码段的运行结果是（）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
void f (int a[], int i, int j) {
    int t;
    if(i<j) {
        t = a[i];
        a[i] = a[j];
        a[j] = t;
        f(a, i+1, j-1);
    }
}
int main() {
    int i, a[5] = {1,2,3,4,5};
    f(a,0,4);
    for (i = 0; i < 5; i++) printf("%d,",a[i]);
}

A
5,4,3,2,1,
B
5,2,3,4,1,
C
1,2,3,4,5,
D
1,4,3,2,5,
正确答案：A
官方解析：
【解释】函数f的功能是：如果数组a的下标i比下标j小，就将a[i]与a[j]交换，然
后进一步判断i+1与j-1的大小，如果i+1比j-1小，再将a[i+1]与a[j-1]交换，直到
前者的下标不小于后者的下标为止。即函数f的功能就是将数组元素a[i]到a[j]之间元素进
行交换。所以函数调用(a，0，4)其结果就是将a[0]与a[4]交换、a[1]与a[3]交换，所以交换
后数组a中的元素为5 4 3 2 1。所以正确答案为A。
知识点：C语言
题友讨论(12)
单选题
C语言
11.
表达式0x13&0x17的值是（）
A
0x17
B
0x13
C
0xf8
D
0xec
正确答案：B
官方解析：
这道题考察位运算中按位与(&)运算符的使用。

要计算0x13 & 0x17的值，我们需要先将它们转换为二进制，然后进行按位与运算：

0x13 = 0001 0011
0x17 = 0001 0111

按位与运算规则是：两个位都为1时结果为1，否则为0。

运算过程：
0001 0011 (0x13)
0001 0111 (0x17)
-----------
0001 0011 (结果)

将结果转回十六进制就是0x13，所以B选项正确。

分析其他选项：
A选项0x17：这是其中一个操作数，而不是运算结果
C选项0xf8：这个值的二进制是1111 1000，明显不是运算结果
D选项0xec：这个值的二进制是1110 1100，也不是运算结果

在按位与运算中，如果某一位任何一个操作数为0，结果必定为0。这就是为什么结果会保留两个操作数中都为1的位，而其他位都变成0。这里的结果刚好等于0x13。
知识点：C语言
题友讨论(8)
单选题
C语言
12.
C语言结构体类型变量在程序执行期间（）
A
所有成员一直驻留在内存中
B
只有一个成员驻留在内存中
C
部分成员驻留在内存中
D
没有成员驻留在内存中
正确答案：A
官方解析：
【解释】结构体变量不管其包含有多少个成员，都应当看成是一个整体。在程序运行
期间，只要在变量的生存期内，所有成员一直驻留在内存中，不可能出现有的成员驻留内
存，有的成员不驻留内存的情况。故选择答案是A。
知识点：C语言
题友讨论(10)
单选题
C++
C语言
13.
当n=6时，下列函数的返回值是（）
1
2
3
4
5
int foo(int n){
    if(n < 2)
        return n;
    return foo(n-1)+foo(n-2);
}
A
5
B
7
C
8
D
10
正确答案：C
官方解析：
这道题考察了递归函数的执行过程。这个函数实际上是在计算斐波那契数列,其中f(n)=f(n-1)+f(n-2)。

让我们通过递归展开计算f(6):
f(6) = f(5) + f(4)
f(5) = f(4) + f(3)
f(4) = f(3) + f(2)
f(3) = f(2) + f(1)
f(2) = f(1) + f(0)
f(1) = 1
f(0) = 0

从底向上计算:
f(2) = f(1) + f(0) = 1 + 0 = 1
f(3) = f(2) + f(1) = 1 + 1 = 2
f(4) = f(3) + f(2) = 2 + 1 = 3
f(5) = f(4) + f(3) = 3 + 2 = 5
f(6) = f(5) + f(4) = 5 + 3 = 8

所以当n=6时,函数返回值为8,C选项正确。

分析其他选项:
A(5)错误:这是f(5)的值,而不是f(6)的值
B(7)错误:计算结果不正确
D(10)错误:计算结果不正确

这个递归函数本质上是在计算斐波那契数列的第n项,每一项都是前两项的和。
知识点：C++、测试工程师、C语言
题友讨论(23)
单选题
C语言
14.
下面程序的执行结果为（）
1
2
3
4
5
6
7
8
9
10
11
12
#include <stdio.h>
int func(int n) {
    if (n < 2)
        return n;
    return func(n - 1) + func(n - 2);
}
int main () {
    printf("%d\n",func(7));
    return 0;
}

A
11
B
13
C
17
D
21
正确答案：B
官方解析：
这道题目考察的是递归函数求解斐波那契数列。函数func(n)实际上就是在计算斐波那契数列的第n项。

让我们分析func(7)的计算过程：
斐波那契数列前几项为：0, 1, 1, 2, 3, 5, 8, 13, ...

当n=7时，func(7)的计算过程如下：
- func(7) = func(6) + func(5)
- func(6) = func(5) + func(4)
- func(5) = func(4) + func(3)
- func(4) = func(3) + func(2)
- func(3) = func(2) + func(1)
- func(2) = func(1) + func(0)
- 当n<2时，直接返回n

所以：
- func(0) = 0
- func(1) = 1
- func(2) = 1
- func(3) = 2
- func(4) = 3
- func(5) = 5
- func(6) = 8
- func(7) = 13

因此，func(7)的结果是13，B选项是正确答案。

其他选项分析：
A(11)错误：比实际结果小
C(17)错误：比实际结果大
D(21)错误：比实际结果大太多

这个递归函数的时间复杂度是O(2^n)，因为每个函数调用会产生两个新的递归调用，直到达到基本情况(n<2)。在实际应用中，通常会使用动态规划或迭代方法来优化斐波那契数列的计算。
知识点：C++工程师、2019、C语言
题友讨论(19)
单选题
C语言
15.
对于下面的代码
1
2
int i = (j = 4, k = 8, l = 16, m = 32);
printf("%d", i);
的输出是（）
A
4
B
8
C
16
D
32
正确答案：D
官方解析：
这道题目考察的是逗号表达式的运算规则。在C语言中,逗号表达式从左到右依次计算,整个表达式的值为最后一个表达式的值。

代码 int i=(j=4,k=8,l=16,m=32) 是一个逗号表达式,它包含了4个赋值操作:
1. j=4 先执行
2. k=8 接着执行
3. l=16 然后执行
4. m=32 最后执行

根据逗号表达式的特性,整个表达式的值等于最后一个表达式 m=32 的值,即32。所以变量i被赋值为32。

因此当执行 printf("%d", i) 时,输出的结果是32。

分析其他选项:
A选项4错误:虽然j确实被赋值为4,但逗号表达式的值取决于最后一个表达式。
B选项8错误:k的值确实是8,但不是整个表达式的最终值。
C选项16错误:l的值是16,但同样不是逗号表达式的最终值。

所以D选项32是正确答案,因为它是逗号表达式中最后一个表达式的值。
知识点：C++工程师、2017、游戏研发工程师、C语言
题友讨论(3)
单选题
C++
C语言
16.
有如下程序，正确的输出结果是（）
1
2
3
4
5
6
7
8
9
10
11
12
int main() {
    int a=15,b=21,m=0；
    switch (a % 3) {
        case 0:m++；break;
        case 1:m++;
            switch (b%2) {
                default:m++;
                case 0:m++；break；
            }
    }
    printf ("%d\n",m)；
}
A
1
B
2
C
3
D
4
正确答案：A
官方解析：
让我们逐步分析这段代码的执行过程：

1. 首先 a = 15，计算 a % 3 = 0，因此进入 case 0
2. case 0 中执行 m++，m 从0变为1
3. 遇到 break 语句，直接跳出 switch 语句
4. 最后输出 m 的值为 1

所以 A 选项（1）是正确答案。

分析其他选项错误的原因：

B选项（2）错误：如果 a % 3 = 1 的情况下才可能得到2，但本题 a = 15，a % 3 = 0，所以不会进入 case 1 的逻辑。

C选项（3）错误：要得到3需要执行三次 m++，而在当前代码中，由于 a % 3 = 0 且有 break 语句，因此只会执行一次 m++。

D选项（4）错误：要得到4需要执行四次 m++，这在当前代码中是不可能的。即使进入内层 switch，最多也只能执行三次 m++。

补充说明：
- 如果 a % 3 = 1，则会进入第一个 case 1，然后根据 b % 2 的值继续执行
- 但在本题中，由于 a % 3 = 0，且 case 0 中有 break 语句，所以内层 switch 不会被执行
- 这也是嵌套 switch 语句中 break 的重要性，它能够防止代码继续向下执行
知识点：C++、C语言
题友讨论(31)
单选题
C语言
17.
以下是C语言的一个struct声明
1
2
3
4
5
6
7
8
9
#pragma pack(4)
typedef struct {
    int a;
    char b;
    int c;
    float e;
    char f;
    float g;
} stru;
问在32bits平台下，sizeof(stru) 为多少？
A
22
B
24
C
28
D
32
正确答案：B
官方解析：
要解答这道题目，我们需要理解结构体内存对齐的规则：

1. #pragma pack(4)表示按4字节对齐
2. 每个成员相对于结构体起始位置的偏移量必须是成员大小与对齐参数中较小值的整数倍
3. 整个结构体的总大小必须是对齐参数的整数倍

让我们分析每个成员的内存布局：
- int a: 占4字节，从0开始
- char b: 占1字节，从4开始
- int c: 占4字节，从8开始（第5位需要填充3字节才能对齐）
- float e: 占4字节，从12开始
- char f: 占1字节，从16开始
- float g: 占4字节，从20开始（第17位需要填充3字节才能对齐）

因此：
4(a) + 1(b) + 3(填充) + 4(c) + 4(e) + 1(f) + 3(填充) + 4(g) = 24字节

B选项24是正确答案。

其他选项分析：
A(22)错误：没有考虑完整的对齐要求
C(28)错误：超出了实际所需空间
D(32)错误：过度估计了填充空间的需求
知识点：C++工程师、2018、C语言
题友讨论(9)
单选题
C++
C语言
18.
下面3段程序代码的效果一样吗？
1
2
3
4
int b;
(1)const int *a = &b;
(2)int const *a = &b;
(3)int *const a = &b;
A
(2)=(3)
B
(1)=(3)
C
(1)=(2)
D
都不一样
E
都一样
正确答案：C
官方解析：
这道题目考察了C++中const关键字修饰指针的不同位置所表达的不同含义。(1)和(2)是完全相同的写法，而(3)的含义不同，所以C选项正确。

让我们详细分析三种写法：

(1) const int *a = &b 和 (2) int const *a = &b
这两种写法是等价的，都表示指针a所指向的内容是常量，不能通过指针a来修改所指向的值，但指针a本身可以指向其他地址。
const/const被放在int之前或之后，修饰的都是int，表达的是相同的意思。

(3) int *const a = &b
这种写法表示指针a本身是一个常量，初始化后a不能再指向其他地址，但可以通过指针a修改所指向的值。

分析其他选项：
A错误：(2)≠(3)，因为它们的const修饰含义完全不同
B错误：(1)≠(3)，原因同上
D错误：因为已经确定(1)=(2)，所以不可能都不一样

记忆要点：
- const在*之前修饰的是指针指向的内容
- const在*之后修饰的是指针本身
- const int *和int const *是等价的
知识点：C++、C语言
题友讨论(42)
单选题
C语言
19.
下列选项，不正确的是
A
for(int a=1;a<=10;a++);
B
int a=1; do { a++; }while(a<=10)
C
int a=1; while(a<=10) { a++; }
D
for(int a=1;a<=10;a++)a++;
正确答案：B
官方解析：
这道题目主要考察了不同循环语句的执行逻辑和结果。B选项是错误的。

分析每个选项的执行过程：

A选项for(int a=1;a<=10;a++); 是正确的循环语句,虽然循环体为空(只有一个分号),但语法和执行逻辑都是正确的,a从1到10递增。

B选项的do-while循环有问题。因为先执行再判断条件,当a=1时,先执行a++使a=2,然后判断2<=10为true继续循环,最终a会增加到11,超出了预期的范围。

C选项while(a<=10)是正确的循环语句,a从1开始,每次循环加1,直到a>10时退出循环。

D选项for(int a=1;a<=10;a++)a++; 虽然每次循环a会增加2(循环体内的a++和循环控制的a++),但语法和执行逻辑是正确的。

总的来说,B选项的do-while循环因为先执行后判断的特性,导致循环次数和最终结果都与预期不符,所以是不正确的选项。其他三个选项虽然写法不同,但都能正确完成循环控制。
知识点：C语言
题友讨论(65)
单选题
C语言
20.
下面代码执行后的结果是（      ）
#include "stdio.h"
int Function(unsigned int n) {
    n = (n & 0x55555555) + ((n >> 1) & 0x55555555);
    n = (n & 0x33333333) + ((n >> 2) & 0x33333333);
    n = (n & 0x0f0f0f0f) + ((n >> 4) & 0x0f0f0f0f);
    n = (n & 0x00ff00ff) + ((n >> 8) & 0x00ff00ff);
    n = (n & 0x0000ffff) + ((n >> 16) & 0x0000ffff);
    return n;
}
void main() {
    printf("%ld\n",Function(197));
}
A
5
B
4
C
3
D
2
正确答案：B
官方解析：
这道题目考察的是一个计算二进制中1的个数的经典算法。Function函数实现了一个并行计算二进制位中1的个数的方法,也被称为"汉明重量(Hamming Weight)"计算。

输入数字197的二进制表示为: 11000101(只写出有效位)
该算法通过5步并行计算得到结果:

1. 第一步: n & 0x55555555 + (n>>1 & 0x55555555)
将相邻的两位分组,每组内的1相加

2. 第二步: n & 0x33333333 + (n>>2 & 0x33333333)
将相邻的两组再次合并相加

3. 第三步: n & 0x0f0f0f0f + (n>>4 & 0x0f0f0f0f)
将4位一组进行合并相加

4. 第四步: n & 0x00ff00ff + (n>>8 & 0x00ff00ff)
将8位一组进行合并相加

5. 第五步: n & 0x0000ffff + (n>>16 & 0x0000ffff)
最后合并得到最终结果

对于输入197,其二进制表示中有4个1,所以最终输出为4,因此B选项正确。

其他选项分析:
A(5): 197的二进制中只有4个1,不可能得到5
C(3): 少统计了一个1
D(2): 严重少统计了两个1

这种算法的优点是通过并行处理,大大减少了循环次数,提高了计算效率。
知识点：C语言
题友讨论(3)
单选题
C语言
21.
二维数组X按行顺序存储，其中每个元素占1个存储单元。若X[4][4]的存储地址为Oxf8b82140,X[9][9]的存储地址为Oxf8b8221c,则X[7][7]的存储地址为()。
A
Oxf8b821c4
B
Oxf8b821a6
C
Oxf8b82198
D
Oxf8b821c0
正确答案：A
官方解析：
让我们来逐步分析解决这个二维数组存储地址的问题。

首先,我们需要找出两个已知地址之间的规律:
1. X[4][4]的地址是0xf8b82140
2. X[9][9]的地址是0xf8b8221c
计算它们的地址差：0xf8b8221c - 0xf8b82140 = 220(十进制)

由于是按行存储,从X[4][4]到X[9][9]共跨越了:
- 从第4行第4列到第9行第9列
- 完整行数=(9-4)=5行
- 当前位置差=(9-4)=5列
所以总共间隔了55个元素(5×10+5=55)

因此可以得知每个元素占4字节(220/55=4)

现在计算X[7][7]的地址:
- 从X[4][4]到X[7][7]需要跨越:
* 完整行数=(7-4)=3行
* 当前位置差=(7-4)=3列
* 总元素数=3×10+3=33个元素
- 地址增量=33×4=132(十六进制是0x84)
- 所以X[7][7]的地址=0xf8b82140+0x84=0xf8b821c4

因此A选项0xf8b821c4是正确答案。

其他选项给出的地址都不符合按行存储时的地址计算规律。
知识点：C语言
题友讨论(85)
单选题
C语言
22.
下列程序段的输出结果为（）
1
2
float k = 0.8567;
printf("%06.1f%%", k*100);

A
0085.6%%
B
0085.7%
C
0085.6%
D
.857
正确答案：B
官方解析：
这道题目考察了printf函数中格式控制符的使用。B选项"0085.7%"是正确答案。

让我们逐步分析格式控制符"%06.1f%%":
1. %f 表示浮点数格式
2. .1 表示保留1位小数
3. 6 表示总宽度为6位
4. 0 表示用0填充空位
5. %% 表示输出一个百分号字符

计算过程：
- k = 0.8567
- k*100 = 85.67
- 保留1位小数后为85.7
- 总宽度为6位，不足的用0填充，所以结果为"0085.7"
- 最后加上%符号，得到"0085.7%"

分析其他选项的错误：
A选项"0085.6%%"：错误保留了两个%符号，且小数部分四舍五入有误
C选项"0085.6%"：小数部分四舍五入有误
D选项".857"：完全没有按照格式控制符的要求输出，既没有补0，也没有百分号，且未进行乘100运算

因此，只有B选项"0085.7%"符合格式控制符的所有要求，是正确答案。
知识点：C语言
题友讨论(30)
单选题
C语言
23.
下面四个类A,B,C,D,在32位机器上sizeof(A),sizeof(B),sizeof(C),sizeof(D)值分别为()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class A{
};
class B{
    char ch;
    int x;
};
class C{
public:
    void Print(void){}
};
class D
{
public:
    virtual void Print(void){}
};
A
0,5,0,0
B
1,8,4,4
C
1,8,1,4
D
1,5,1,4
正确答案：C
官方解析：
让我们逐个分析每个类的大小:

1. 空类A的大小为1字节。
虽然类A没有任何成员变量和函数,但C++规定空类也要占用1个字节,以便区分不同的对象。

2. 类B的大小为8字节。
包含一个char(1字节)和一个int(4字节)。由于字节对齐原则,char后会有3个字节的填充,使得int能够在4的整数倍地址上开始,因此总大小为8字节。

3. 类C的大小为1字节。
虽然类C有一个普通成员函数Print(),但普通成员函数不占用对象的空间。因此C类似于空类,大小为1字节。

4. 类D的大小为4字节。
类D声明了虚函数Print(),编译器会为包含虚函数的类生成虚函数表(vtable),并在对象中添加一个指向虚函数表的指针(vptr)。在32位系统中,指针大小为4字节。

因此选项C(1,8,1,4)是正确答案。

分析其他选项:
A(0,5,0,0)错误:空类也要占1字节,且没有考虑内存对齐。
B(1,8,4,4)错误:类C不需要4字节,因为它没有虚函数。
D(1,5,1,4)错误:类B的大小应为8字节而不是5字节,因为要考虑内存对齐。
知识点：C语言
题友讨论(25)
单选题
C++
C语言
24.
下面选项中关于 " 文件指针 " 概念的叙述正确的是（）
A
文件指针是 FILE 指针类型的变量
B
文件指针就是文件位置指针，表示当前读写数据的位置
C
文件指针指向文件在计算机中的存储位置
D
把文件指针传给 fscanf 函数，就可以向文本文件中写入任意的字符
正确答案：A
官方解析：
文件指针是一个非常重要的C语言文件操作概念。A选项正确，文件指针确实是FILE类型的指针变量，它指向一个包含文件信息的结构体，这个结构体记录了文件的各种信息，如文件名、访问模式、缓冲区等。

分析其他选项的错误之处：

B选项错误：这里混淆了两个概念。文件指针(FILE*)和文件位置指针是不同的概念。文件位置指针是一个整数值，用来标识当前读写位置，而文件指针是指向FILE结构体的指针。

C选项错误：文件指针并不直接指向文件在计算机中的存储位置，而是指向一个包含文件信息的结构体（FILE结构体）。文件的物理存储位置是由操作系统管理的。

D选项错误：fscanf函数是用于从文件中读取数据的，而不是写入数据。写入数据应该使用fprintf函数。此外，即使是fprintf函数也不能直接写入"任意的字符"，它需要按照指定的格式写入数据。

总的来说，理解文件指针的本质是FILE类型的指针变量这一点很重要，这有助于正确使用C语言中的文件操作函数。
知识点：C++、C语言
题友讨论(11)
单选题
C++
C语言
25.
C++是不是类型安全的？
A
是
B
不是
正确答案：B
官方解析：
C++不是完全类型安全的语言,这主要体现在以下几个方面:

1. 指针操作不安全:
- C++允许任意的指针类型转换
- 可能出现悬空指针和野指针
- 指针运算可能越界访问内存

2. 类型转换存在风险:
- 隐式类型转换可能导致精度丢失
- 强制类型转换可能破坏类型系统
- C风格的类型转换缺乏检查机制

3. 数组边界检查:
- 不进行自动的数组边界检查
- 可能发生缓冲区溢出
- 访问越界不会被编译器捕获

4. 内存管理问题:
- 手动内存管理容易出错
- 内存泄漏风险
- delete/delete[]使用不当造成的问题

5. 全局变量:
- 允许使用全局变量
- 变量作用域和生命周期管理复杂
- 可能导致命名污染

这些特性虽然提供了灵活性和高性能,但也带来了类型安全方面的风险。相比之下,Java等现代语言通过更严格的类型检查和自动内存管理提供了更好的类型安全保证。
知识点：C++、C语言
题友讨论(24)
单选题
C语言
26.
计算机工作时，内存储器用来存储（）
A
程序和指令
B
数据和信号
C
程序和数据
D
ASCⅡ码和数据
正确答案：C
官方解析：
【解释】计算机内存按所存信息的类别一般分为两大类，即程序和数据。程序是用来
控制计算机完成某项任务的指令的集合，而数据是程序运行处理的对象。A只说明是程序，
B和D只说明是数据，因为信号和ASCⅡ码均为数据，所以选C。
知识点：C语言
题友讨论(14)
单选题
C语言
27.
有如下程序段：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <stdio.h>
class A {
  public:
    A() { printf("0"); }
    A(int a) { printf("1"); }
    A &operator=(const A &a) {
        printf("2");
        return (*this);
    }
};
int main() {
    A al;
    al = 10;
}
则程序输出是：
A
02
B
012
C
01
D
以上都不对
正确答案：B
官方解析：
这道题目主要考察了C++中构造函数和赋值运算符重载的调用过程。

程序执行过程分析：
1. A al; 调用默认构造函数，输出"0"
2. al=10; 这条语句会有两个步骤：
- 首先会调用A(int a)构造函数创建一个临时对象，输出"1"
- 然后调用赋值运算符operator=将临时对象赋值给al，输出"2"

所以完整的输出序列是"012"，B选项正确。

分析其他选项：
A选项"02"错误：忽略了创建临时对象时调用的带参构造函数
C选项"01"错误：忽略了赋值运算符的调用
D选项"以上都不对"错误：B选项已经是正确答案

补充说明：
这里的al=10;语句实际上包含了隐式类型转换，编译器会先将整数10转换为A类型的临时对象，再进行赋值操作。这是C++中常见的对象赋值过程，涉及到临时对象的创建和赋值运算符的调用。理解这个过程对于掌握C++的对象操作非常重要。
知识点：C语言
题友讨论(33)
单选题
C语言
28.
有如下程序段：
1
2
3
4
5
6
7
#include <stdio.h>
int main() {
    char ch = -1;
    printf(" %02x, %02x", ch, (unsigned char)ch);
    return 0;
}
则输出：
A
-1,-1
B
ff,ff
C
ffffffff,ff
D
ff,ffffffff
正确答案：C
官方解析：
这道题目考察了C语言中字符类型转换和格式化输出的知识点。

关键分析：
1. char ch = -1 中，-1以补码形式存储，一个字节的补码表示为0xff
2. printf中%x格式符用于以16进制形式输出整数
3. 当使用%x输出char类型时，会发生整型提升，将char提升为int类型
4. (unsigned char)的转换不会改变二进制位，只是改变解释方式

具体输出分析：
- 第一个%02x输出ch：char类型的-1会先被提升为int类型的-1，其十六进制表示为0xffffffff
- 第二个%02x输出(unsigned char)ch：将ch转为无符号字符，0xff的二进制不变，输出ff

所以输出结果为：ffffffff, ff

其他选项分析：
A错误：不会直接输出"-1, -1"，因为格式符%x要求十六进制输出
B错误：没有考虑到char到int的整型提升
D错误：第二个值不会是ffffffff，因为unsigned char是单字节的

因此C选项"ffffffff, ff"是正确答案。
知识点：C语言
题友讨论(45)
单选题
C语言
29.
以下代码的执行结果是().
1
2
3
4
5
#include<stdio.h>
int main(){
   int i = -2147483648;
   return printf("%d,%d,%d,%d", ~i, -i, 1 - i, -1 - i);
}
A
0,2147483648,2147483649,2147483647
B
0,-2147483648,-2147483647,2147483647
C
2147483647,2147483648,2147483649,2147483647
D
2147483647,-2147483648,-2147483647,2147483647
正确答案：D
官方解析：
这道题目考察了C语言中整数运算和位运算的基本知识。让我们逐个分析代码中的运算：

1. i = -2147483648 是int类型的最小值(即-2^31)

2. ~i（按位取反）
当对-2147483648取反时，所有位都会翻转。结果为2147483647(即2^31-1)

3. -i（取负）
对最小值取负会因为溢出仍然得到-2147483648

4. 1-i
1-(-2147483648) = -2147483647

5. -1-i
-1-(-2147483648) = 2147483647

因此printf打印的四个值依次为:
2147483647, -2147483648, -2147483647, 2147483647

分析其他选项：
A错误：第一个值0是错的，应该是2147483647
B错误：第一个值0是错的，应该是2147483647
C错误：第二个值显示为正数2147483648是错的，应该是负数-2147483648

这里要特别注意的是，当对最小的负数(-2147483648)取负值时，由于补码表示的限制，结果仍然是-2147483648，这是因为32位int类型无法表示2147483648这个正数。这就是为什么-i仍然等于-2147483648的原因。
知识点：Java工程师、C++工程师、2016、C语言
题友讨论(81)
单选题
C语言
30.
假设在一个 32 位 little endian 的机器上运行下面的程序，结果是多少？
1
2
3
4
5
6
#include <stdio.h>
int main(){
  long long a = 1, b = 2, c = 3;
  printf("%d %d %d\n", a, b, c);
return 0;
}
A
1,2,3
B
1,0,2
C
1,3,2
D
3,2,1
正确答案：B
官方解析：
这道题目考察了在32位little endian机器上的数据存储和printf格式化输出的特点。

在32位机器上:
1. long long是64位(8字节)整型
2. printf中使用%d格式符只能打印32位整数
3. 参数从右向左压入栈中

当执行printf("%d %d %d ", a, b, c)时:
- c的值3被分成高32位(0)和低32位(3)压栈
- b的值2被分成高32位(0)和低32位(2)压栈
- a的值1被分成高32位(0)和低32位(1)压栈

由于是little endian,所以:
- 第一个%d读取到的是a的低32位:1
- 第二个%d读取到的是a的高32位:0
- 第三个%d读取到的是b的低32位:2

因此输出为"1 0 2"

分析其他选项:
A选项"1,2,3"错误:忽略了64位数据在32位机器上的存储特点
C选项"1,3,2"错误:参数压栈顺序和读取方式理解有误
D选项"3,2,1"错误:完全相反的参数顺序

所以B选项"1,0,2"是正确答案。
知识点：C语言

试卷02_题目