#G099. GESP level4 真题模拟2

GESP level4 真题模拟2

GESP level4 - 真题模拟2

  1. 运行下面代码片段后,x和p的结果分别是( )。
    int x = 20;
    int</em> p = &x;
    *p = *p + 2;
    {{ select(1) }}
  • 20 20
  • 20 22
  • 22 20
  • 22 22
  1. 下面的描述中,( )正确定义一个名为Person的结构体并正确初始化了一个Person结构体的变量p。 {{ select(2) }}
  • struct Person {
      string name;
      int age;
    </li>
    </ul>
    

    }; Person p("Yang", 10);

    </p>
    • struct Person {
        string name,
        int age;
      </li>
      </ul>
      

      }; Person p; p.age = 10; p.name = "Yang";

      </p>
      • struct Person {
          string name;
          int age;
        </li>
        </ul>
        

        }; Person p = { "Yang", 10 };

        </p>
        • struct Person {
            string name;
            int age;
          </li>
          </ul>
          

          }; Person p = new Person("Yang", 10);

          </p>
          1. 冒泡排序的平均时间复杂度为O(n²),但最优情况下为O(n)。 {{ select(3) }}
          • 正确
          • 错误
          1. 选择排序是稳定的排序算法。 {{ select(4) }}
          • 正确
          • 错误
          1. 在C++语言中,如果一个函数可能抛出异常,那么一定要在try子句里调用这个函数。 {{ select(5) }}
          • 正确
          • 错误
          1. 运行下面代码片段的结果是( )。
            int y = 24;
            int x = 20;
            int* p = &x;
            int* q = &y;
            p = q;
            {{ select(6) }}
          • x将赋值为24
          • y将赋值为20
          • p将指向y的地址
          • q将指向x的地址
          1. 在C++中,( )正确定义一个名为student的结构体,其中包含一个name字符数组和一个age整数? {{ select(7) }}
          • struct student { char name[20]; int age; };
          • student struct { char name[20]; int age; };
          • student struct { string name; int age; };
          • struct student { char[20] name; int age; };
          1. 在C++中,( )正确声明了一个3行4列的二维数组。 {{ select(8) }}
          • int arr[3, 4];
          • int arr[3][4];
          • int arr[4][3];
          • int arr(3, 4);
          1. 给定如下算法,其时间复杂度为( )。
            bool f(int arr[], int n, int target) {
            for (int i = 0; i < (1 << n); i++) {
            int sum = 0;
            for (int j = 0; j < n; j++) {
            if (i & (1 << j)) {
            sum += arr[j];
            }
            }
            if (sum == target)
            return true;
            }
            return false;
            }
            {{ select(9) }}
          • O(n²)
          • O(n×2ⁿ)
          • O(2ⁿ)
          • O(n×log n)
          1. 下面关于排序稳定性的描述,正确的是( )。 {{ select(10) }}
          • 稳定性指算法的时间复杂度恒定
          • 稳定排序保证相同元素的相对顺序不变
          • 选择排序是稳定排序
          • 插入排序不是稳定排序
          1. 给定如下代码,下面描述错误的是( )。
            struct Person {
            std::string name;
            int age;
            struct Address {
            std::string street;
            std::string city;
            };
            Address address;
            };
            {{ select(11) }}
          • 结构Person内嵌套结构Address
          • Person有一个Address类型的address成员
          • 一个Person类型的变量p的address的初始化可以写成:p.address.street = "123 Main St"; p.address.city = "Anytown";
          • 结构的嵌套可以减少命名冲突,因此可以不必控制嵌套层次
          1. 假设int arr[2][3] = {{1,2,3},{4,5,6}};,则arr[1][2]的值是( )。 {{ select(12) }}
          • 2
          • 3
          • 5
          • 6
          1. 下面( )正确定义了二维数组。 {{ select(13) }}
          • int arr[3,4];
          • int arr[3][4];
          • int arr(3,4);
          • int a[3-4];
          1. 递推算法通常有初始值。 {{ select(14) }}
          • 正确
          • 错误
          1. 冒泡排序是一种稳定的排序算法。 {{ select(15) }}
          • 正确
          • 错误
          1. C++语言中,如果异常发生,但没有处理异常的代码,则程序会由于一直等待处理而死机。 {{ select(16) }}
          • 正确
          • 错误
          1. C++语言中的局部变量在函数调用结束后会被销毁。 {{ select(17) }}
          • 正确
          • 错误
          1. 在C++中,引用传递允许函数修改传递给它的参数的值。 {{ select(18) }}
          • 正确
          • 错误
          1. 指针的大小与其所指向的变量的数据类型的大小相同。 {{ select(19) }}
          • 正确
          • 错误
          1. 二维数组的行的大小必须在定义时确定,列的大小可以动态变化。 {{ select(20) }}
          • 正确
          • 错误
          1. 递推算法通过逐步求解当前状态和前一个或几个状态之间的关系来解决问题。 {{ select(21) }}
          • 正确
          • 错误
          1. 插入排序的时间复杂度总是比冒泡排序低。 {{ select(22) }}
          • 正确
          • 错误
          1. 在C++中,如果没有捕获到异常(没有匹配的catch块),程序会继续执行而不会终止。 {{ select(23) }}
          • 正确
          • 错误
          1. 函数不可以调用自己。 {{ select(24) }}
          • 正确
          • 错误
          1. 函数参数传递过程中,如果传常量值、常量引用和常量指针都是不能被修改的,它们可以防止函数对实参的值或地址进行修改。 {{ select(25) }}
          • 正确
          • 错误