#1652. GESP-C++六级(2026-06)

GESP-C++六级(2026-06)

CCF GESP C++ 六级 (2026 年 06 月)

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

1. 下列关于 C++ 中继承和多态的描述中，错误的是（ ）

{{ select(1) }}

  • 通过基类指针调⽤虚函数时，会根据对象实际类型决定调⽤版本。
  • 基类析构函数常声明为虚函数，以便通过基类指针正确释放派⽣类对象。
  • 派⽣类可以重写基类中的虚函数。
  • 构造函数可以声明为 virtual ，以便在构造对象时实现动态绑定。

2. 下列代码中， d1->work(); 和 d2->work(); 输出不同结果的主要原因是（ ）

class Device {
public:
    virtual void work() {
        cout << "Device is working" << endl;
    }
    virtual ~Device() {}
};
class Printer : public Device {
public:
    void work() override {
        cout << "Printer is printing" << endl;
    }
};
class Scanner : public Device {
public:
    void work() override {
        cout << "Scanner is scanning" << endl;
    }
};
int main() {
    Device* d1 = new Printer();
    Device* d2 = new Scanner();
    d1->work();
    d2->work();
    delete d1;
    delete d2;
    return 0;
}

{{ select(2) }}

  • Printer 和 Scanner 使⽤了相同的构造函数。
  • work() 是虚函数，且 d1 和 d2 实际指向不同派⽣类对象，发⽣动态绑定。
  • d1 和 d2 是不同的指针变量。
  • 程序中使⽤了 delete 释放对象。

3. 下⾯代码在 main() 中有⼀⾏会导致编译错误，请找出来 4 8 12 17

class Student {
public:
  Student(string n, int s) : name(n), score(s) {}
  string getName() {
    return name;
  }
  void setScore(int s) {
    score = s;
  }
private:
  string name;
  int score;
};
int main() {
  Student stu("Tom", 85);
  cout << stu.getName();   // ①
  stu.setScore(90);        // ②
  stu.score = 100;        // ③ 
  cout << stu.getName();   // ④
  return 0;
}

{{ select(3) }}

  • 第 ① ⾏
  • 第 ② ⾏
  • 第 ③ ⾏
  • 第 ④ ⾏

4. 某⽂本编辑器把⽤户输⼊的字符依次压⼊栈 S 。⽤户依次输⼊ X, Y, Z, W 后，连续执⾏两次撤销操作 每次撤销都会弹出栈顶⼀个字符。此时栈从栈底到栈顶的内容是（ ）。

{{ select(4) }}

  • X Y
  • X Y Z
  • Y Z
  • X Z

5. 假设循环队列数组长度为 N = 7 ，队空判断条件为 front == rear 。⼊队和出队操作如下：

const int N = 7;
int q[N];
int front = 3, rear = 3;
void enqueue(int x) {
  q[rear] = x;
  rear = (rear + 1) % N;
}
void dequeue() {
  front = (front + 1) % N;
}

依次执⾏：

enqueue(10);
enqueue(20);
enqueue(30);
dequeue();
enqueue(40);
dequeue();
enqueue(50);

最终 (front, rear) 的值是（ ）。 {{ select(5) }}

  • (5, 1)
  • (4, 0)
  • (5, 0)
  • (3, 1)

6. 以下函数 check() ⽤于判断⼀棵⼆叉树是否为（ ）

bool check(TreeNode* root) {
  if (!root) return true;
  queue<TreeNode*> q;
  q.push(root);
  bool hasNull = false;
  while (!q.empty()) {
    TreeNode* cur = q.front();
    q.pop();
    if (cur == nullptr) {
      hasNull = true;
    } else {
      if (hasNull) return false;
      q.push(cur->left);
      q.push(cur->right);
    }
  }
  return true;
}

}

{{ select(6) }}

  • 满⼆叉树
  • 完全⼆叉树
  • ⼆叉搜索树
  • 平衡⼆叉树

7. 以下代码实现了⼆叉树的哪种遍历⽅式？

void traverse(TreeNode* root) {
  if (root == nullptr) return;
  cout << root->val << " ";
  traverse(root->left);
  traverse(root->right);
}

{{ select(7) }}

  • 前序遍历
  • 中序遍历
  • 后序遍历
  • 层序遍历

8. 已知⼀棵⼆叉树的先序遍历序列为： A B D E H C F G ，中序遍历序列为： D B H E A F C G ， 则该⼆叉树的后序遍历序列是（ ）。

{{ select(8) }}

  • D H E B F G C A
  • D E H B F G C A
  • H D E B F C G A
  • D H E B G F C A

9. 有 6 个字符，它们出现的次数分别为：{3,4,7,8,12,15} ，现在⽤哈夫曼编码为这些字符编码，最⼩加权路 径长度 WPL 的值为（ ）。

{{ select(9) }}

  • 113
  • 119
  • 126
  • 31

10. 对 n 个不同符号进⾏哈夫曼编码。若⽣成的哈夫曼树共有 63个结点，则 n 的值是（ ）

{{ select(10) }}

  • 31
  • 32
  • 63
  • 64

11. 在格雷码中，相邻两个编码只能有⼀位不同。若当前编码为 110 ，则它的下⼀个编码不可能是（ ）

{{ select(11) }}

  • 010
  • 111
  • 100
  • 001

12. 给定⼀棵⼆叉树，采⽤⼴度优先搜索 BFS 返回其右视图，其中右视图中的每个节点都是该层最右侧的节 点。横线处应填写（ ）。

vector<int> rightSideView(TreeNode* root) {
    vector<int> result;
    if (!root) return result;
    queue<TreeNode*> q;
    q.push(root);
    while (!q.empty()) {
        int sz = q.size();
        for (int i = 0; i < sz; ++i) {
            TreeNode* node = q.front();
            q.pop();
            __________________________
            if (node->left) q.push(node->left);
            if (node->right) q.push(node->right);
        }
    }
    return result;
}
}

{{ select(12) }}

  • if (i == 0) result.push_back(node->val);
  • if (i == sz - 1) result.push_back(node->val);
  • result.push_back(q.front()->val);
  • if (node->right) result.push_back(node->right->val);

13. 下⾯代码实现⼆叉搜索树的插⼊操作。假设树中不存在重复值，横线处应填写（ ）

TreeNode* insertNode(TreeNode* root, int x) {
    if (root == nullptr) {
        return new TreeNode(x);
    }
    if (x < root->val) {
        __________________________
    } else {
        root->right = insertNode(root->right, x);
    }
    return root;
}
}

{{ select(13) }}

  • root->left = insertNode(root->left, x);
  • root = insertNode(root->left, x);
  • root->right = insertNode(root->left, x);
  • insertNode(root->left, x);

14. 给定⼀个整数数组 a ，每个元素表⽰⼀个位置上的数值。要求从数组中选择若⼲个元素，使得任意两个被 选择的元素在原数组中都不相邻，并且所选元素的总和最⼤。函数 choose(vector& a) 返回能够得到的最 ⼤总和，则横线处应填写（ ）。

int choose(vector<int>& a) {
  if (a.empty()) return 0;
  int n = a.size();
  if (n == 1) return a[0];
  vector<int> dp(n, 0);
  dp[0] = a[0];
  dp[1] = max(a[0], a[1]);
  for (int i = 2; i < n; ++i) {
    dp[i] = __________________________;
  }
  return dp[n - 1];
}

{{ select(14) }}

  • dp[i - 1] + a[i]
  • max(dp[i - 1], dp[i - 2] + a[i])
  • max(dp[i - 2], a[i])
  • dp[i - 1] + dp[i - 2]

15. 下⾯代码实现 0/1 背包的⼀维动态规划。第 i 个物品重量为 wt[i] ，价值为 val[i] ，背包容量为 W 横线处应填写（ ）。 4 10

int knapsack(int W, vector<int>& wt, vector<int>& val) {
  int n = wt.size();
  vector<int> dp(W + 1, 0);
  for (int i = 0; i < n; ++i) {
    for (int w = W; w >= wt[i]; --w) {
      __________________________
    }
  }
  return dp[W];
}

{{ select(15) }}

  • dp[w] = max(dp[w], dp[w - wt[i]] + val[i]);
  • dp[w] = max(dp[w - 1], dp[w - wt[i]] + val[i]);
  • dp[w] = dp[w] + val[i];
  • dp[w - wt[i]] = max(dp[w], val[i]);

二、判断题（每题 2 分，共 20 分）

1. C++ 中构造函数可以声明为虚函数，从⽽实现运⾏时多态

{{ select(16) }}

  • 对
  • 错

2. 通过指向 Base 的指针删除 Derived 对象时，⼀定会先调⽤ Derived 的析构函数，再调⽤ Base 的析 构函数。

#include <iostream>
using namespace std;
class Base {
public:
    ~Base() {
        cout << "Base destructor" << endl;
    }
};
class Derived : public Base {
public:
    ~Derived() {
        cout << "Derived destructor" << endl;
    }
};
int main() {
    Base* p = new Derived();
    delete p;
    return 0;
}

{{ select(17) }}

  • 对
  • 错

3. 在 C++ STL 中， stack 的 pop() 函数会返回栈顶元素并将其删除

{{ select(18) }}

  • 对
  • 错

4. 程序运⾏后会输出 2

int main() {
    queue<int> q;
    q.push(1);
    q.push(2);
    q.push(3);
    q.pop();
    cout << q.front() << endl;
    return 0;
}

{{ select(19) }}

  • 对
  • 错

5. 下列函数试图将整数 x 插⼊到⼀棵⼆叉搜索树中。假设⼆叉搜索树满⾜如下性质：对于任意结点，左⼦树 中所有结点的值均⼩于该结点的值，右⼦树中所有结点的值均⼤于或等于该结点的值。判断该函数是否能够在插⼊ 后保持⼆叉搜索树性质。

struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};
TreeNode* insertNode(TreeNode* root, int x) {
    if (root == nullptr) {
        return new TreeNode(x);
    }
    if (x < root->val) {
        root->right = insertNode(root->right, x);
    } else {
        root->left = insertNode(root->left, x);
    }
    return root;
}

{{ select(20) }}

  • 对
  • 错

6. 哈夫曼编码⼀定唯⼀，只要字符频率相同，得到的编码也⼀定完全相同

{{ select(21) }}

  • 对
  • 错

7. 若⽤数组按层序存储完全⼆叉树，且根节点下标为 0 ，则下标为 i 的节点左孩⼦下标为 2 * i + 1 ，右 孩⼦下标为 2 * i + 2 。

{{ select(22) }}

  • 对
  • 错

8. 以下代码可以正确地按层换⾏输出⼆叉树的节点值

void printByLevel(TreeNode* root) {
  if (!root) return;
  queue<TreeNode*> q;
  q.push(root);
  while (!q.empty()) {
    for (int i = 0; i < q.size(); ++i) {
      TreeNode* cur = q.front();
      q.pop();
      cout << cur->val << " ";
      if (cur->left) q.push(cur->left);
      if (cur->right) q.push(cur->right);
    }
    cout << endl;
  }
}

{{ select(23) }}

  • 对
  • 错

9. 使⽤栈⾮递归实现⼆叉树前序遍历时，若希望先访问左⼦树，通常应先将右孩⼦⼊栈，再将左孩⼦⼊栈

{{ select(24) }}

  • 对
  • 错

10. 动态规划问题通常要求具有最优⼦结构，并且常常存在重叠⼦问题

{{ select(25) }}

  • 对
  • 错
  1. 关于
  2. 联系我们
  3. 隐私
  4. 服务条款
  5. 版权申诉
  6. Language
  7. 兼容模式
  8. 主题
  3. Worker 0, 13ms
  4. Powered by Hydro v4.13.3 Community