#G085. GESP level4 2025年9月四级试卷

GESP level4 2025年9月四级试卷

GESP level4 - 2025年9月四级试卷

  1. 运行下面程序后变量a的值是( )。
    int a = 42;
    int* p = &a;
    *p = *p + 1;
    {{ select(1) }}
  • 42
  • 43
  • 编译错误
  • 不确定
  1. 以下关于数组的描述中,( )是错误的。 {{ select(2) }}
  • 数组名是一个指针常量
  • 随机访问数组的元素方便快捷
  • 数组可以像指针一样进行自增操作
  • sizeof(arr) 返回的是整个数组arr占用的字节数
  1. 给定如下定义的数组arr,则*(*(arr + 1) + 2)的值是( )。
    int arr[2][3] = {{1, 2, 3}, {4, 5, 6}};
    {{ select(3) }}
  • 2
  • 5
  • 4
  • 6
  1. 下面这段代码会输出( )。
    int add(int a, int b = 1); // 函数声明</li>
    </ol>
    

    int main() { cout << add(2) << " " << add(2, 3); return 0; }

    int add(int a, int b) { // 函数定义 return a + b; }

    {{ select(4) }}</p>
    • 3 5
    • 编译失败:定义处少了默认参数
    • 运行错误
    • 链接失败:未定义引用
    1. 下面这段代码会输出( )。
      int x = 5;</li>
      </ol>
      

      void foo() { int x = 10; cout << x << " "; }

      void bar() { cout << x << " "; }

      int main() { foo(); bar(); return 0; }

      {{ select(5) }}</p>
      • 5 5
      • 10 10
      • 5 10
      • 10 5
      1. 下面程序运行的结果是( )。
        void increaseA(int x) {
        x++;
        }</li>
        </ol>
        

        void increaseB(int* p) { (*p)++; }

        int main() { int a = 5; increaseA(a); cout << a << " "; increaseB(&a); cout << a; return 0; }

        {{ select(6) }}</p>
        • 6 7
        • 6 6
        • 5 6
        • 5 5
        1. 关于结构体初始化,以下哪个选项中正确的是( )。
          struct Point {int x, y;};
          {{ select(7) }}
        • Point p = (1,2);
        • Point p = {1,2};
        • Point p = new {1,2};
        • Point p = <1,2>;
        1. 运行如下代码会输出( )。
          struct Cat {
          string name;
          int age;
          };</li>
          </ol>
          

          void birthday(Cat& c) { c.age++; }

          int main() { Cat kitty{"Mimi", 2}; birthday(kitty); cout << kitty.name << " " << kitty.age; return 0; }

          {{ select(8) }}</p>
          • Mimi 2
          • Mimi 3
          • kitty 3
          • kitty 2
          1. 关于排序算法的稳定性,以下说法错误的是( )。 {{ select(9) }}
          • 稳定的排序算法不改变相等元素的相对位置
          • 冒泡排序是稳定的排序算法
          • 选择排序是稳定的排序算法
          • 插入排序是稳定的排序算法
          1. 下面代码试图实现选择排序,使其能对数组nums排序为升序,则横线上应分别填写( )。
            void selectionSort(vector& nums) {
            int n = nums.size();
            for (int i = 0; i < n - 1; ++i) {
            int minIndex = i;
            for (int j = i + 1; j < n; ++j) {
            if ( __________ ) { // 在此处填入代码
            minIndex = j;
            }
            }
            ____________________; // 在此处填入代码
            }
            }
            {{ select(10) }}
          • nums[j] < nums[minIndex] swap(nums[i], nums[minIndex])
          • nums[j] > nums[minIndex] swap(nums[i], nums[minIndex])
          • nums[j] <= nums[minIndex] swap(nums[j], nums[minIndex])
          • nums[j] <= nums[minIndex] swap(nums[i], nums[j])
          1. 下面程序实现插入排序(升序排序),则横线上应分别填写( )。
            void insertionSort(int arr[], int n) {
            for (int i = 1; i < n; i++) {
            int key = arr[i];
            int j = i - 1;
            while ( j >= 0 && __________ ) { // 在此处填入代码
            arr[j + 1] = arr[j];
            j--;
            }
            __________; // 在此处填入代码
            }
            }
            {{ select(11) }}
          • arr[j] > key arr[j + 1] = key
          • arr[j] < key arr[j + 1] = key
          • arr[j] > key arr[j] = key
          • arr[j] < key arr[j] = key
          1. 关于插入排序的时间复杂度,下列说法正确的是( )。 {{ select(12) }}
          • 最好情况和最坏情况的时间复杂度都是 (O(n^2))
          • 最好情况是 (O(n)),最坏情况是 (O(n^2))
          • 最好情况是 (O(n)),最坏情况是 (O(2^n))
          • 最好情况是 (O(n^2)),最坏情况是 (O(2^n))
          1. 小杨正在爬楼梯,需要n阶才能到达楼顶,每次可以爬1阶或2阶,求小杨有多少种不同的方法可以爬到楼顶,横线上应填写( )。
            int climbStairs(int n) {
            if (n <= 2) return n;
            int prev2 = 1; // 对应n=1的方法数
            int prev1 = 2; // 对应n=2的方法数
            int current = 0;
            for (int i = 3; i <= n; ++i) {
            ________________ // 在此处填入代码
            }
            return current;
            }
            {{ select(13) }}
          • prev2 = current; prev1 = current; current = prev1 + prev2;
          • current = prev1 + prev2; prev2 = prev1; prev1 = current;
          • current = prev1 + prev2; prev1 = current; prev2 = prev1;
          • prev2 = prev1; prev1 = current; current = prev1 + prev2;
          1. 假设有一个班级的成绩单,存储在一个长度为n的数组scores中,每个元素是一个学生的分数。老师想要找出所有满足scores[i] + scores[j] + scores[k] == 300的三元组,其中i < j < k。下面代码实现该功能,请问其时间复杂度是( )。
            int cnt = 0;
            for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
            for (int k = j + 1; k < n; k++) {
            if (scores[i] + scores[j] + scores[k] == 300) {
            cnt++;
            }
            }
            }
            }
            {{ select(14) }}
          • (O(n))
          • (O(n^2))
          • (O(n^3))
          • (O(2^n))
          1. 关于异常处理,以下说法错误的是( )。 {{ select(15) }}
          • try块中的代码可能会抛出异常
          • catch块可以有多个,处理不同类型的异常
          • throw语句用于抛出异常
          • 所有异常都必须被捕获,否则程序会崩溃
          1. 以下代码能正确初始化指针。
            int a = 5;
            int *p = a;
            {{ select(16) }}
          • 正确
          • 错误
          1. 执行下面C++代码将输出11。
            int x = 10;</li>
            </ol>
            

            void f() { int x = x + 1; cout << x << endl; }

            int main() { f(); return 0; }

            {{ select(17) }}</p>
            • 正确
            • 错误
            1. 以下C++代码合法。
              struct Student {
              string name;
              int age;
              float score;
              };</li>
              </ol>
              

              Student* students = new Student[20];

              {{ select(18) }}</p>
              • 正确
              • 错误
              1. 执行下面C++代码将输出10。
                void func(int* p) {
                *p = 10;
                }</li>
                </ol>
                

                int main() { int a = 5; func(&a); cout << a << endl; return 0; }

                {{ select(19) }}</p>
                • 正确
                • 错误
                1. 下面代码将二维数组arr传递给函数f,函数内部用arr[i][j]访问元素,函数参数声明为int arr[][4]是错误的。
                  void f(int arr[][4], int rows) {
                  // 访问 arr[i][j]
                  }</li>
                  </ol>
                  

                  int main() { int arr[3][4] = { /* 初始化 */ }; f(arr, 3); return 0; }

                  {{ select(20) }}</p>
                  • 正确
                  • 错误
                  1. 递推是在给定初始条件下,已知前一项(或前几项)求后一项的过程。 {{ select(21) }}
                  • 正确
                  • 错误
                  1. 虽然插入排序的时间复杂度为 (O(n^2)\,但由于单元操作相对较少,因此在小数据量的排序任务中非常受欢迎。 {{ select(22) }}
                  • 正确
                  • 错误
                  1. 对整数数组{4, 1, 3, 1, 5, 2}进行冒泡排序(将最大元素放到最后),执行一轮之后是{4, 1, 3, 1, 2, 5}。 {{ select(23) }}
                  • 正确
                  • 错误
                  1. 以下代码只能捕获int类型异常。
                    int main() {
                    try {
                    throw 42;
                    } catch (...) {
                    cout << "Caught" << endl;
                    }
                    return 0;
                    }
                    {{ select(24) }}
                  • 正确
                  • 错误
                  1. 以下代码将Hello写入文件data.txt。
                    ofstream file("data.txt");
                    cout << "Hello" << endl;
                    file.close();
                    {{ select(25) }}
                  • 正确
                  • 错误