#G4107. [GESP202412 四级] 客观题

    ID: 181 Type: Objective Tried: 0 Accepted: 0 Difficulty: (None) Uploaded By: Tags>GESP C++编程能力等级认证

[GESP202412 四级] 客观题

单选题

  1. 下面的语句中，（ ）正确定义了一个计算浮点数 ( x ) 的平方 (( x^2 = x \times x )) 的函数，并成功调用该函数。

    {{ select(1) }}

  • float square(float x) {
    return x * x;
}
float area = square(2);

  • square(float x) {
    return x * x;
}
float area = square(2);

  • void square(float x) {
    return x * x;
}
area = square(2.0);

  • void square(float x) {
    x * x;
    return;
}
area = square(2);

  1. 下面代码的描述中，正确的是（ ）。

    void n_chars(char c, int n) {
    while (n-- > 0)
        cout << c;
}

char my_char = 'w';
int times = 5;
n_chars(my_char, times);

    {{ select(2) }}

  • 代码执行结束后，times 的值为0
  • n 是形参，times 是实参
  • n 是实参，times 是形参
  • 代码最后一行换成 n_chars(times, my_char); 也可以

  1. 给定以下代码，

    void func(int& x) {
    x = x * 2;
}

int a = 5;
func(a);

    执行上述代码后，变量 a 的值为（ ）。

    {{ select(3) }}

  • 5
  • 10
  • 15
  • 20

  1. 运行下面代码，屏幕上输出是（ ）。

    double* p_arr = new double [3];
p_arr[0] = 0.2;
p_arr[1] = 0.5;
p_arr[2] = 0.8;
p_arr += 1;
cout << p_arr[0] << endl;
p_arr -= 1;
delete p_arr;

    {{ select(4) }}

  • 0.2
  • 0.5
  • 1.2
  • 1.5

  1. 运行下面代码片段后，x 和 *p 的结果分别是（ ）。

    int x = 20;
int* p = &x;
*p = *p + 2;

    {{ select(5) }}

  • 20 20
  • 20 22
  • 22 20
  • 22 22

  1. 下面的描述中，（）不能正确定义一个名为Student的结构体以及一个包含20个元素的结构数组。

    {{ select(6) }}

  • struct Student {
    string name;
    int age;
    float score;
};
struct Student students[20];

  • struct Student {
    string name;
    int age;
    float score;
};
Student students[20];

  • struct Student {
    string name;
    int age;
    float score;
};
Student* students = new Student[20];

  • struct Student {
    string name;
    int age;
    float score;
};
Student students = new Student[20];

  1. 假定整型是32位，对一个2行3列的二维整数数组array，假设数组第一个元素在内存中的地址为0x7ffee4065820，则第2行第2个元素的地址&array[1][1]为（ ）。

    int array[2][3] = {
    {0, 1, 2},
    {3, 4, 5}
};

    {{ select(7) }}

  • 0x7ffee4065824
  • 0x7ffee4065828
  • 0x7ffee406582c
  • 0x7ffee4065830

  1. 下面（ ）正确定义二维数组。

    {{ select(8) }}

  • int a[3][1];
  • int a[][];
  • inta[][]4];
  • int a[][]2] = {{1,2},{1,2},{3,4}};

  1. 下面代码采用递推算法来计算斐波那契数列 ( f(n) = f(n-1) + f(n-2) )，则横线上应填写（ ）。

    int fib(int n) {
    if (n == 0 || n == 1)
        return n;
    int f1 = 0;
    int f2 = 1;
    int result = 0;
    for (int i = 2; i <= n; i++) {
        // 在此处填入代码
    }
    return result;
}

    {{ select(9) }}

  • result = f1 + f2;
f1 = f2;
f2 = result;

  • result += f1 + f2;
f1 = f2;
f2 = result;

  • result += f1 + f2;
f2 = result;
f1 = f2;

  • result = f1 + f2;
f2 = result;
f1 = f2;

  1. 下面关于排序算法（冒泡排序、插入排序和选择排序）的描述中，不正确的是（ ）。

    {{ select(10) }}

  • 冒泡排序基于元素交换实现，需借助临时变量、共涉及3个单元操作；而插入排序基于元素赋值实现，仅需1个单元操作。因此冒泡排序的计算开销通常比插入排序更高。
  • 选择排序在任何情况下的时间复杂度都为 (O(n^2))。
  • 冒泡排序在任何情况下的时间复杂度都为 (O(n^2))。
  • 如果给定数据部分有序，插入排序通常比选择排序效率更高。

  1. 冒泡排序的第一轮操作是从左到右遍历数组，通过两两比较相邻元素，将当前最大的元素移动到末尾。给定数组 arr[]={4, 1, 3, 1, 5, 2}，执行第一轮冒泡排序后数组 arr 中的内容为（ ）。

    {{ select(11) }}

  • 1, 4, 3, 1, 5, 2
  • 1, 3, 1, 4, 2, 5
  • 1, 4, 3, 1, 2, 5
  • 4, 1, 3, 1, 5, 2

  1. 给定如下代码，其时间复杂度为（ ）。

    int cellRecur(int n) {
    if (n == 1)
        return 1;
    return cellRecur(n - 1) + cellRecur(n - 1) + 1;
}

    {{ select(12) }}

  • (O(n^2))
  • (O(2^n))
  • (O(1))
  • (O(n))

  1. 下面代码实现了插入排序函数，则横线上应填写（ ）。

    void insertion_sort(vector<int> &nums) {
    for (int i = 1; i < nums.size(); i++) {
        while (j >= 0 && nums[j] > base)
            nums[j + 1] = nums[j];
            j--;
        }
        nums[j + 1] = base;
    }
}

    {{ select(13) }}

  • int base = nums[i], j = i - 1;
  • int base = nums[i], j = i;
  • int base = nums[0], j = i - 1;
  • int base = nums[0], j = i;

  1. 下面哪种方式不能实现将字符串"Welcome to GESP!"输出重定向到文件log.txt（ ）。

    {{ select(14) }}

  • freopen("log.txt", "w", stdout);
cout << "Welcome to GESP!" << endl;
fclose(stdout);

  • std::ofstream outFile("log.txt");
outFile << "Welcome to GESP!" << endl;
outFile.close();

  • std::ofstream outFile("log.txt");
cout << "Welcome to GESP!" << endl;
outFile.close();

  • ofstream log_file("log.txt");
streambuf* org_cout = cout.rdbuf();
cout.rdbuf(log_file.rdbuf());
cout << "This output will go to the log file." << endl;
cout.rdbuf(org_cout);

  1. 运行下面的代码，将出现什么情况？（ ）

    double hmean(double a, double b) {
    if (a == -b )
        throw runtime_error("Runtime error occurred");
    return 2.0*a*b/(a + b);
}

int main() {
    double x = 10;
    double y = -10;

    try {
        int result = hmean(x, y);
        cout << "hmean: " << result << endl;
    }
    catch (const runtime_error& e) {
        cout << "Caught: " << e.what() << endl;
    } catch (...) {
        cout << "Caught an unknown exception." << endl;
    }
    return 0;
}

    {{ select(15) }}

  • 屏幕上输出 Caught: Runtime error occurred
  • 屏幕上输出 Caught an unknown exception
  • 程序调用 std::terminate()
  • 编译错误

判断题

  1. 在 C++ 中，下面代码可以正确定义指针和初始化指针。

    int* ptr;
*ptr = 10;

    {{ select(16) }}

  • 对
  • 错

  1. 一个函数必须在调用之前既声明又定义。

    {{ select(17) }}

  • 对
  • 错

  1. 函数参数可以通过值传递、引用传递和指针传递，这样函数内对参数的修改可以直接修改传入变量的值。

    {{ select(18) }}

  • 对
  • 错

  1. int arr[3][1] 是一个正确的二维数组的声明。

    {{ select(19) }}

  • 对
  • 错

  1. 递推是一种通过已知的初始值和递推公式，逐步求解目标值的算法。

    {{ select(20) }}

  • 对
  • 错

  1. 某算法的递推关系式为 ( T(n) = T(n-1) + n )（n 为正整数）及 ( T(0) = 1 )，则该算法的时间复杂度为 ( O(n^2) )。

    {{ select(21) }}

  • 对
  • 错

  1. 自排序的平均时间复杂度为 ( O(n^2) )，但最优情况下为 ( O(n) )。

    {{ select(22) }}

  • 对
  • 错

  1. 自排序和插入排序都是稳定的排序算法。

    {{ select(23) }}

  • 对
  • 错

  1. 选择排序是稳定的排序算法。

    {{ select(24) }}

  • 对
  • 错

  1. 在 C++ 语言中，如果一个函数可能抛出异常，那么一定要在 try 子句里调用这个函数。

    {{ select(25) }}

  • 对
  • 错
  1. Language
  2. Legacy mode
  3. Theme
  3. Worker 0, 15ms
  4. Powered by Hydro v5.0.0-beta.5 Community