GESP 客观题评测系统

2024-06-Level-4

试卷解析总览，可直接查看每题答案与解析。

单选题（每题 2 分）

第 1 题（单选题）

下列代码中，输出结果是（）

#include<iostream>
using namespace std;
int func(int x, int y)
{
    int a = x, b = y;
    int t;
    t = a;
    a = b;
    b = t;
    cout << a << " " << b << " "
    ;
}
int main()
{
    int c, d;
    c = 12;
    d = 24;
    func(12, 24);
    cout << c << " " << d << endl;
}

12 24 24 12

24 12 12 24

12 12 24 24

24 24 12 12

正确答案B

解析详情

【答案】B

【考点】函数参数传递与作用域

【解析】 func 函数中通过值传递接收参数，内部交换的是局部变量 a 和 b 的值，并输出“24 12 ”。main 函数中的变量 c 和 d 的值并未受到 func 内部操作的影响，依然是 12 和 24，最后输出“12 24”。拼接结果为 24 12 12 24。

【易错点】误认为值传递会影响实参，或忽略局部变量的作用域。

第 2 题（单选题）

下面函数不能正常执行的是（）

#include<iostream>
using namespace std;
int func()
{
    //...
}
int main()
{
    //...
}

#include<iostream>
using namespace std;
int main()
{
    func();
}
int func()
{
    //...
}

#include<iostream>
using namespace std;
int func()
{
    //...
}
int main()
{
    func();
}

#include<iostream>
using namespace std;
int func();
int main()
{
    func();
}
int func()
{
    //...
}

正确答案B

解析详情

【答案】B

【考点】函数声明与定义顺序

【解析】在 C++ 中，函数必须先声明或定义才能调用。选项 B 中，main 函数调用 func() 时，func 既没有在 main 之前定义，也没有提前声明，因此会导致编译错误。其他选项均符合正确的声明/定义规范。

【易错点】忽略函数调用前需要可见的声明原则。

第 3 题（单选题）

下面程序输出的是（）

#include<iostream>
using namespace std;
int func();
int main()
{
    int i = 2;
    cout << i << endl;
    for (int x = 0; x < 1; x++)
    {
        int i = 10;
        cout << i << endl;
    }
    i = i + 1;
    cout << i << endl;
    i = i * i;
    cout << i << endl;
}

2 2 3 9

2 10 3 9

2 10 11 121

2 10 3 100

正确答案B

解析详情

【答案】B

【考点】局部变量作用域与遮蔽

【解析】 1. main 开始 i=2，输出 2； 2. for 循环内部重新定义局部变量 i=10，输出 10； 3. 循环结束回到外层作用域，外层 i 仍为 2，执行 i=i+1 后输出 3； 4. 执行 i=i*i 后输出 9。输出序列为 2 10 3 9。

【易错点】混淆循环体内定义的变量与循环体外同名变量的作用域关系。

第 4 题（单选题）

假设变量 a 的地址是 0x6ffe14，下面程序的输出是（）。

#include<iostream>
using namespace std;
int main()
{
    int *p;
    int a = 10;
    p = &a;
    p++;
    cout << p << endl;
}

0x6ffe14

0x6ffe15

0x6ffe18

正确答案D

解析详情

【答案】D

【考点】指针运算

【解析】指针 p 指向整型变量 a。执行 p++ 时，指针向后移动一个整型单位的长度。在常见的 64 位环境中，int 占用 4 字节，因此 0x6ffe14 + 4 = 0x6ffe18。输出结果为 0x6ffe18。

【易错点】误认为 p++ 是简单的数值加 1，忽略了指针移动的步长取决于其指向的类型。

第 5 题（单选题）

如果下列程序输出的地址是 0x6ffe00 ，则 cout<<a+1<<endl；输出的是（）

#include<iostream>

using namespace std;

int main()

{

    int a[2][3]={0};

    cout<<a<<endl;

}

0x6ffe04

0x6ffe0C

0x6ffe08

0x6ffe00

正确答案B

解析详情

【答案】B

【考点】二维数组与指针运算

【解析】二维数组名 a 表示指向首行（含有 3 个 int 元素的数组）的指针。a+1 表示指向下一行的指针，跨越的地址长度为 3 * sizeof(int) = 12 字节。0x6ffe00 增加 12（十六进制为 C）后得到 0x6ffe0C。

【易错点】错误理解二维数组名的含义，将其当作简单 int 指针移动一个元素的长度。

第 6 题（单选题）

C++ 中，关于文件路径说法错误的是（）

"GESP.txt": 指定与当前工作目录中的程序文件相同目录中的 GESP.txt 文件

"../data/GESP.txt": 指定与当前工作目录中的程序文件上一级目录下的 data 目录中的 GESP.txt 文件

"./data/GESP.txt": 指定与当前工作目录中的程序文件同级目录下的 data 目录中的 GESP.txt 文件

"GESP.txt" 是绝对路径

正确答案D

解析详情

【答案】D

【考点】文件路径概念

【解析】绝对路径是从根目录开始的完整路径，而 "GESP.txt" 仅包含文件名，属于相对路径（相对于当前工作目录）。因此选项 D 说法错误。A、B、C 均为正确的相对路径表达方式。

【易错点】混淆绝对路径与相对路径的定义。

第 7 题（单选题）

关于直接插入排序，下列说法错误的是（）

插入排序的最好情况是数组已经有序，此时只需要进行n - 1次比较，时间复杂度为

O(n)

最坏情况是数组逆序排序，此时需要进行n(n - 1)/2次比较以及n - 1次赋值操作（插入）

平均来说插入排序算法的复杂度为

O(n^{2})

空间复杂度上，直接插入法是就地排序，空间复杂度为

O(n)

正确答案D

解析详情

【答案】D

【考点】直接插入排序算法复杂度

【解析】直接插入排序是就地排序算法，它在排序过程中只需要常数级的额外空间用于临时变量存取，因此空间复杂度应为 O(1)，而非 O(n)。A、B、C 关于时间复杂度和比较次数的描述均正确。

【易错点】将空间复杂度 O(1) 误记为 O(n)。

第 8 题（单选题）

下列程序横线处，应该输入的是（）。

#include<iostream>
using namespace std;
int n, a[10001];
void swap(int &a, int &b)
{
    int t = a;
    a = b;
    b = t;
}
int main()
{
    cin >> n;
    for (int i = 1; i <= n; i++)
    {
        cin >> a[i];
        for (int i = n; i > 1; i--)
        {
            for (int j = 1; j < i; j++)
            {
                if (a[j] > a[j + 1])
                {
                    ______ // 应在此处填入代码
                    for (int i = 1; i <= n; i++)
                    cout << a[i] << "";
                    cout << endl;
                    return 0;
                }
            }
        }
    }
}

swap(a[j],a[j+1]);

swap(a[j-1],a[j]);

swap(a[j-1],a[j+1]);

swap(&a[j-1],&a[j+1]);

正确答案A

解析详情

【答案】A

【考点】冒泡排序

【解析】代码展示的是一个典型的冒泡排序逻辑。当 a[j] > a[j+1] 时，需要交换相邻的两个元素位置。根据循环变量 j 的定义，此时应填入 swap(a[j], a[j+1]); 以实现升序排列的第一次交换。

【易错点】混淆下标 j 与 j-1 或 j+1 的对应关系。

第 9 题（单选题）

下面关于递推的说法不正确的是（）。

递推表现为自己调用自己

递推是从简单问题出发，一步步的向前发展，最终求得问题。是正向的

递推中，问题的n要求是在计算中确定，不要求计算前就知道n

斐波那契数列可以用递推实现求解

正确答案A

解析详情

【答案】A

【考点】递推与递归的区别

【解析】 “自己调用自己”是递归（Recursion）的典型特征，而非递推（Recurrence）。递推通常是指根据已知的初始项，按照一定的规则逐步推导出后续项的过程。B、C、D 的说法均符合递推的定义。

【易错点】混淆递推与递归的基本概念。

第 10 题（单选题）

关于几种排序算法的说法，下面说法错误的是（）。

选择排序不是一个稳定的排序算法

冒泡排序算法不是一种稳定的排序算法

插入排序是一种稳定的排序算法

如果排序前2个相等的数 in 序列中的前后位置顺序和排序后它们2个的前后位置顺序相同，则称为一种稳定的排序算法

正确答案B

解析详情

【答案】B

【考点】排序算法的稳定性

【解析】冒泡排序在交换时仅处理 a[j] > a[j+1] 的情况，对于相等的元素不进行交换，因此它是稳定的排序算法。选项 B 称其“不是一种稳定的排序算法”是错误的。选择排序不稳定，插入排序稳定，稳定性定义描述正确。

【易错点】错误记忆常见排序算法（如冒泡、插入、选择）的稳定性特征。

第 11 题（单选题）

数组{45,66,23,1,10,97,52,88,5,33}进行从小到大冒泡排序过程中，第一遍冒泡过后的序列是（）。

{45,23,1,10,66,52,88,5,33,97}

{45,66,1,23,10,97,52,88,5,33}

{45,66,23,1,10,52,88,5,33,97}

{45,66,23,1,10,97,52,88,33,5}

正确答案A

解析详情

【答案】A

【考点】冒泡排序过程推演

【解析】第一遍冒泡（从小到大）会将最大值 97 移至末尾： 1. 45,66 不换； 2. 66,23 换 -> 45,23,66...； 3. 66,1 换 -> 45,23,1,66...； 4. 66,10 换 -> 45,23,1,10,66...； 5. 66,97 不换； 6. 97 后续依次与 52,88,5,33 交换，最终 97 位于末尾。结果为 {45,23,1,10,66,52,88,5,33,97}。

【易错点】推演过程不细致，忽略了最大值在移动过程中带动的其他相邻元素交换。

第 12 题（单选题）

下面的排序算法程序中，横线处应该填入的是（）。

int a[8] = { 2, 3, 4, 5, 6, 2, 3, 1 };
for (int i = 1; i < 8; i++)
{
    int key = a[i];
    int j = i - 1;
    while (a[j] > key && j >= 0)
    {
        ______ // 应在此处填入代码
        j -= 1;
    }
    a[j + 1] = key;
}

a[j]=a[j-1];

a[j]=a[j+1];

a[j+1]=a[j-1];

a[j+1]=a[j];

正确答案D

解析详情

【答案】D

【考点】直接插入排序

【解析】这是直接插入排序的代码实现。在 while 循环中，当已排序部分的元素 a[j] 大于待插入元素 key 时，需要将 a[j] 向后移动一位，为 key 腾出位置。因此应填入 a[j+1] = a[j];。

【易错点】混淆赋值方向，或错误使用 a[j-1] 等下标。

第 13 题（单选题）

下面的程序中，如果输入 10 0，会输出（）。

#include<iostream>
using namespace std;

double Division(int a, int b)
{
    if (b == 0)
        throw "Division by zero condition!";
    else
        return ((double)a / (double)b);
}

void func()
{
    int len, time;
    cin >> len >> time;
    cout << Division(len, time) << endl;
}

int main()
{
    try {
        func();
    }
    catch (const char* errmsg)
    {
        cout << errmsg << endl;
    }
    catch (const int errmsg)
    {
        cout << errmsg << endl;
    }
    return 0;
}

Division by zero condition!

100

正确答案A

解析详情

【答案】A

【考点】异常处理机制

【解析】当输入为 10 0 时，Division 函数中 b==0 成立，抛出一个字符串常量（const char* 类型）"Division by zero condition!"。main 函数中的第一个 catch 块捕获到该类型的异常并输出异常内容。

【易错点】不理解 try-catch 的匹配规则，或忽略 throw 抛出的具体数据类型。

第 14 题（单选题）

10 条直线，最多可以把平面分为多少个区域（）。

正确答案B

解析详情

【答案】B

【考点】平面分割规律（递推）

【解析】 n 条直线最多分割平面区域数为 f(n) = n(n+1)/2 + 1。对于 10 条直线：f(10) = 10 * 11 / 2 + 1 = 55 + 1 = 56。规律源自每增加第 n 条直线，若与前 n-1 条均相交且不共点，则新增 n 个区域。

【易错点】记错公式或计算时遗漏了初始的 1 个平面区域。

第 15 题（单选题）

下面程序中，如果语句 `cout<<p<<endl`；输出的是 0x6ffe00，则 `cout<<++p<<endl`；输出的是（）

int x[10][10][10] = {0};
int *p;
p = &x[0][0][0];
cout << p << endl;
cout << ++p << endl;

0x6ffe0c

0x6ffe09

0x6ffe06

0x6ffe04

正确答案D

解析详情

【答案】D

【考点】指针运算与数组寻址

【解析】变量 p 是 int* 类型，指向三维数组的第一个元素 x[0][0][0]。执行 ++p 时，指针向后移动一个 int 单位。由于 int 占用 4 字节，地址从 0x6ffe00 变为 0x6ffe04。

【易错点】被三维数组的维度误导，认为指针移动步长与数组维度有关，实际上 p 仅是普通的 int 指针。

判断题（每题 2 分）

第 1 题（判断题）

int& a 和 &a 是一样的，都是取 a 的地址。

正确答案错误

解析详情

【答案】错误

【考点】引用与取地址符的区别

【解析】 int& a 出现在声明中，表示定义一个整型引用 a；而 &a 作为表达式时，表示取变量 a 的地址。两者的语法意义完全不同方式。

【易错点】混淆符号 & 在不同语境（类型声明 vs 运算表达式）下的含义。

第 2 题（判断题）

以下代码不能够正确执行。

#include<iostream>
using namespace std;
int main()
{
    int a = 20;
    int& ra;
    ra &= &a;
    cout << ra << endl;
}

正确答案正确

解析详情

【答案】正确

【考点】引用的初始化规则

【解析】 C++ 中的引用在定义时必须初始化。代码中 int& ra; 仅声明了引用但未绑定任何对象，这在语法上是不合法的，无法通过编译。

【易错点】忽略引用必须在定义时立即初始化的硬性规定。

第 3 题（判断题）

引用是一个指针常量。

正确答案正确

解析详情

【答案】正确

【考点】引用的底层性质

【解析】引用在底层通常被编译器实现为指针常量（T* const p），即一旦绑定一个对象，其指向的地址就不可更改，且每次使用都会自动解引用。

【易错点】混淆指针常量（地址不可变）与常量指针（内容不可变）的概念。

第 4 题（判断题）

下面程序两个输出结果是一样的。

#include<iostream>
using namespace std;
int main()
{
    int a[2][3] = {0};
    cout << a << endl;
    cout << &a[0][0] << endl;
}

正确答案正确

解析详情

【答案】正确

【考点】数组地址概念

【解析】数组名 a 代表整个数组的首地址，而 &a[0][0] 代表数组第一个元素的起始地址。在数值上，这两个地址是重合的，因此输出一致。

【易错点】不清楚虽然两者的数值相同，但它们的指针类型（类型跨度）是不同的。

第 5 题（判断题）

函数不可以调用自己。

正确答案错误

解析详情

【答案】错误

【考点】递归的概念

【解析】函数调用自身被称为递归。C++ 完全支持递归调用，这是解决分治、树形结构等问题的常用编程技巧。

【易错点】基础概念混淆，不了解递归的基本定义。

第 6 题（判断题）

函数参数传递过程中，如果传常量值、常量引用和常量指针都是不能被修改的，它们可以防止函数对实参的值或地址进行修改。

正确答案正确

解析详情

【答案】正确

【考点】const 修饰符的作用

【解析】 const 修饰符在参数传递中起到了保护作用。常量引用和常量指针限制了函数通过该参数修改外部实参内容或地址的能力，而常量传值则保护了函数内部副本不被修改。

【易错点】对 const 的保护作用范围理解不全。

第 7 题（判断题）

下面代码输出的值等于 0。

#include<iostream>
using namespace std;
int main()
{
    int *p = NULL;
    cout << p << endl;
}

正确答案正确

解析详情

【答案】正确

【考点】空指针的表示

【解析】 NULL 在 C++ 中通常被宏定义为 0。当输出一个指向空地址的指针时，cout 通常会将其地址值以 0 或 0x0 的形式展现。此断言在逻辑上是成立的。

【易错点】认为 NULL 是一种特殊的不可输出对象，忽略了其数值本质为 0。

第 8 题（判断题）

在下面这个程序里，a[i][j] 和一个普通的整型变量一样使用。

#include<iostream>
using namespace std;
int main()
{
    int a[10][10]={0};
    for(int i=0;i<10;i++)
    {
        for(int j=0;j<10;j++)
        {
            if(i==j)
            {
                a[i][j]=1;
            }
        }
    }
}

正确答案正确

解析详情

【答案】正确

【考点】二维数组元素的性质

【解析】二维数组 a[10][10] 的基础元素类型是 int。通过 a[i][j] 访问到的就是一个具体的整型变量，它可以像普通 int 变量一样参与赋值、运算和输出。

【易错点】误认为数组元素具有某种特殊的、不同于其基础类型的属性。

第 9 题（判断题）

一个一维数组，至少含有一个自然数N，是一个合法的数列。可以在一维数组末尾加入一个自然数M，M不能超过一维数组末尾元素的一半，形成一个新的合法的一维数组，如果N=6，那么可以有6个不同的合法数组。

正确答案正确

解析详情

【答案】正确

【考点】递推计数问题

【解析】当 N=6 时，合法数组有：{6}, {6,1}, {6,2}, {6,3}, {6,2,1}, {6,3,1}，共 6 个。推导逻辑：6 的一半是 3，可接 1,2,3；接 1 后不能再接；接 2 后可接 1；接 3 后可接 1。总数为 1+3+2=6。

【易错点】在计数时遗漏了初始只有 N 的那种情况，或者在后续派生中计数不完整。

第 10 题（判断题）

插入排序算法中，平均时间复杂度是 $O(n^{2})$ ，最坏的情况逆序情况下，达到最大时间复杂度。

正确答案正确

解析详情

【答案】正确

【考点】插入排序复杂度分析

【解析】直接插入排序的平均时间复杂度为 O(n²)。在最坏情况（如逆序）下，每个新元素都需要与前面所有元素比较并移动，时间复杂度达到最大值 O(n²)。

【易错点】混淆插入排序与快速排序、归并排序等 O(n\log n) 算法的复杂度特征。