一、单选题（每题 2 分，共 30 分）

高级语言编写的程序需要经过以下（）操作，可以生成在计算机上运行的可执行代码。

A.编辑
B.保存
C.调试
D.编译
【答案】D
【考纲知识点】编程环境(一级)
【解析】本题属于考察计算机基础知识中的编辑、编译、解释、调试的概念；其中编辑是编写修改代码，保存是将代码保存下来，调试是测试运行代码，而编译是将源程序翻译成可执行代码，所以本题正确答案为 D。
排序算法是稳定的（Stable Sorting），就是指排序算法可以保证，在待排序数据中有两个相等记录的关键字 R 和 S（R 出现在 S 之前），在排序后的列表中 R 也一定在 S 前。下面关于排序稳定性的描述，正确的是（）。

A.冒泡排序是不稳定的。
B.插入排序是不稳定的。
C.选择排序是不稳定的。
D.以上都不正确。
【答案】C
【考纲知识点】排序算法 (四级)
【解析】本题属于考察排序的基本概念；冒泡排序、插入排序一般是稳定的，而选择排序一般是不稳定的，所以本题正确答案为 C。
下列关于 C++语言中指针的叙述，不正确的是（）。

A.指针变量中存储的是内存地址。
B.定义指针变量时必须指定其指向的类型。
C.指针变量只能指向基本类型变量，不能指向指针变量。
D.指针变量指向的内存地址不一定能够合法访问。
【答案】C
【考纲知识点】指针(四级)
【解析】本题属于考察指针的基本概念；指针变量不仅可以指向基本类型的变量也可以指向其它的指针变量，所以本题正确答案为 C。
下列关于 C++语言中数组的叙述，不正确的是（）。

A.一维数组在内存中一定是连续存放的。
B.二维数组是一维数组的一维数组。
C.二维数组中的每个一维数组在内存中都是连续存放的。
D.二维数组在内存中可以不是连续存放的。
【答案】D
【考纲知识点】二维及多维数组(四级)
【解析】本题属于考察二维数组的基本概念；数组（包括多维数组）在内存中必须要连续存放，所以本题正确答案为 D。
下列关于 C++语言中函数的叙述，正确的是（）。

A.函数必须有名字。
B.函数必须有参数。
C.函数必须有返回值。
D.函数定义必须写在函数调用前。
【答案】A
【考纲知识点】函数(四级)
【解析】本题属于考察函数的基本概念；函数可以没有参数和返回值，同时函数定义可以在调用之后，只需要在调用前要加函数声明，但是函数必须要有名字，所以本题正确答案为 A。
注：如果了解“匿名函数”概念（该概念超出考纲范围），应注意区分：匿名函数，正式名称为“表达式”，是一种可捕捉参数变量的无命名函数对象，属于 “函数对象”的一种，并不属于“函数”范畴。函数对象与函数在使用时经常可以自动相互转换，但二者在实现机制上完全不同。
下列关于 C++ 语言中变量的叙述，正确的是（）。

A.变量定义后可以一直使用。
B.两个变量的变量名不能是相同的。
C.两个变量的变量名可以相同，但它们的类型必须是不同的。
D.两个变量的变量名可以相同，但它们的作用域必须是不同的。
【答案】D
【考纲知识点】全局/局部作用域(四级)
【解析】本题属于考察变量定义域的基本概念；在 C++中两个变量可以取相同的变量名，只要它们在不同的作用域下即可，所以本题正确答案为 D。
一个二维数组定义为 double array[3][10];，则这个二维数组占用内存的大小为（）

A.30
B.60
C.120
D.240
【答案】D
【考纲知识点】二维及多维数组(四级)
【解析】本题属于考察内存的基本概念； double 类型的数据占用内存是 8 字节， array 数组共使用了 30 个 double 类型的数据，占用内存为 30*8=240 字节。所以本题正确答案为 D。
一个变量定义为 int *p = nullptr;，则下列说法正确的是（）。

A.该指针变量的类型为 int。
B.该指针变量指向的类型为 int。
C.该指针变量指向的内存地址是随机的。
D.访问该指针变量指向的内存会出现编译错误。
【答案】B
【考纲知识点】指针(四级)
【解析】本题属于考察指针的基本概念。指针变量的类型为 int *，A 选项错误； nullptr 指向的是固定的内存地址 0，C 选项错误；nullptr 指向的内存位置通常不存放有效数据，因此常用来表示未指向有效数据，访问它可能出现运行时错误，但不会出现编译错误，D 选项错误。本题正确答案为 B。
一个二维数组定义为 int array[5][3];，则 array[1][2]和 array[2][1]在内存中的位置相差多少字节？（）

A.2 字节。
B.4 字节。
C.8 字节。
D.无法确定。
【答案】C
【考纲知识点】二维及多维数组(四级)
【解析】本题属于考察内存地址的基本概念；array[1][2]和 array[2][1]中间差了 array[2][0]，相当于差了 2 个 int，也就是 8 字节，所以本题正确答案为 C。
如果 a 为 int 类型的变量，且 a 的值为 6，则执行 a &= 3;之后，a 的值会是（）。

A.3
B.9
C.2
D.7
【答案】C
【考纲知识点】位运算(三级)
【解析】本题属于考察位运算的基本概念；a &= 3;等价于 a = a & 3;。&为按位与运算，a 的原值为 6，6 & 3 的结果为 2。所以本题正确答案为 C。
一个数组定义为 int a[5] = {1, 2, 3, 4, 5};，一个指针定义为 int * p = &a[2];，则
执行 a[1] = *p;后，数组 a 中的值会变为（）。

A.{1, 3, 3, 4, 5}
B.{2, 2, 3, 4, 5}
C.{1, 2, 2, 4, 5}
D.{1, 2, 3, 4, 5}
【答案】A
【考纲知识点】指针(四级)
【解析】本题属于考察指针的基本概念；首先让指针 p 指向变量 a[2]的内存地址，然后让 a[1]=*p，也就是让 a[1]=a[2]，所以 a 数组变为 {1, 3, 3, 4, 5}。所以本题正确答案为 A。
如果 a 为 char 类型的变量，下列哪个表达式可以正确判断“a 是数字”？（）

A. void BubbleSort(int a[][4]);

B. void BubbleSort(int a[3][]);

C. void BubbleSort(int a[][]);

D. void BubbleSort(int ** a);
【答案】A
【考纲知识点】函数、指针、二维及多维数组(四级)
【解析】本题属于考察函数参数的基本概念。当把数组作为函数的一个参数时，实际上只传递了数组的首指针。于是，传递多维数组时，只有形式参数的第一维的长度可以省略，形式参数的其他维的长度都不能省略。所以本题正确答案为 A。
在下列代码的横线处填写（），使得输出是20 10。

#include <iostream>
using namespace std;

void xchg(______________) { // 在此处填入代码
    int t = *x;
    *x = *y;
    *y = t;
}

int main() {
    int a = 10, b = 20;
    xchg(&a, &b);
    cout << a << " " << b << endl;
    return 0;
}

A.int x, int y
B.int * x, int * y
C.int a, int b
D.int & a, int & b

【答案】B
【考纲知识点】函数、指针（四级）
【解析】本题属于考察指针的基本概念；题目要求输出 20 10，也就是把 a 和 b 进行交换，参数中传递了 a 和 b 的内存地址，需要使用相应类型的指针来存放，所以本题正确答案为 B。
执行以下 C++语言程序后，输出结果是（）。

#include <iostream>
using namespace std;
int main() {
    int array[3][3];
    for (int i = 0; i < 3; i++)
        for (int j = 0; j < 3; j++)
            array[i][j] = i * 10 + j;
    int sum;
    for (int i = 0; i < 3; i++)
        sum += array[i][i];
    cout << sum << endl;
    return 0;
}

A.3
B.30
C.33
D.无法确定。

【答案】D
【考纲知识点】全局/局部作用域（四级）
【解析】本题属于考察变量初始化相关概念；因为 sum 是在函数内部定义的，所以 sum 的初始值并不一定是 0，也就无法确定最终的输出了，所以本题正确答案为 D。
在下列代码的横线处填写（），完成对有 n 个 int 类型元素的数组 array 由小到大排序。

void SelectionSort(int array[], int n) {
    int i, j, min, temp;
    for (i = 0; i < n - 1; i++) {
        min = i;
        for (j = i + 1; j < n; j++) {
            if (_____________) // 在此处填入代码
                min = j;
        }
        temp = array[min];
        array[min] = array[i];
        array[i] = temp;
    }
}

A.array[min] > array[j]
B.array[min] > array[i]
C.min > array[j]
D.min > array[i]