首页 › 题库 › GESP编程能力等级认证 › GESP-C++六级

GESP-C++六级 题库

共 270 道题 ,第 4 / 14 页 · 按题型筛选,点「查看答案」核对解析
61 单选题 适中 GESP编程能力等级认证 ·GESP-C++六级 · 5.1 面向对象思想

面向对象编程(OOP)是一种特殊的程序设计方法。下面( )不是重要的OOP特性。

A
抽象
B
封装
C
继承
D
模块化
答案与解析
正确答案:D
这道题暂未补解析。
题目详情
62 单选题 适中 GESP编程能力等级认证 ·GESP-C++六级 · 5.1 面向对象思想

以下关于C++中类的说法,哪一项是正确的?

A
类中定义的所有成员变量和成员函数默认是 public 访问权限。
B
类的构造函数必须显式声明返回类型为 void 。
C
在C++中,类的数据一般设置为私有,其公有成员函数提供访问私有数据的唯一途径。
D
同一个类的实例有各自的成员数据和成员函数。
答案与解析
正确答案:C
这道题暂未补解析。
题目详情
63 单选题 适中 GESP编程能力等级认证 ·GESP-C++六级 · 5.1 面向对象思想

以下C++代码段中存在语法错误或逻辑错误,( )是正确的。

#include <iostream>
using namespace std;
class MyClass {
public:
	MyClass() {
		cout << "Constructor called!" << endl;
	}
	void display() {
		cout << "Display function called!" << endl;
	}
};
int main() {
	MyClass* obj = NULL;
	obj->display();
	return 0;
}
A
NULL 在C++中无法用于指针初始化,应使用 nullptr 。
B
obj 的定义应该是 MyClass obj; 而不是指针类型。
C
obj->display() 语句存在空指针访问错误, obj 应该初始化为一个有效的对象。
D
obj->display() 语句会调用 display() 函数,但它没有输出任何内容。
答案与解析
正确答案:C
这道题暂未补解析。
题目详情
64 单选题 适中 GESP编程能力等级认证 ·GESP-C++六级 · 6.1 栈

阅读以下代码,下面哪一项是正确的?

void processData() {
	stack<int> s;
	queue<int> q;
	for (int i = 1; i <= 5; ++i) {
		s.push(i);
		q.push(i);
	}
	while (!s.empty()) {
		cout << "Stack pop: " << s.top() << endl;
		s.pop();
	}
	while (!q.empty()) {
		cout << "Queue pop: " << q.front() << endl;
		q.pop();
	}
}
A
栈 s 的输出顺序是 1 2 3 4 5 ,队列 q 的输出顺序是 5 4 3 2 1 。
B
栈 s 的输出顺序是 5 4 3 2 1 ,队列 q 的输出顺序是 1 2 3 4 5 。
C
栈 s 的输出顺序是 1 2 3 4 5 ,队列 q 的输出顺序是 1 2 3 4 5 。
D
栈 s 的输出顺序是 1 2 3 4 5 ,队列 q 的输出顺序是 1 2 3 4 5 ,程序不会正常执行。
答案与解析
正确答案:B
这道题暂未补解析。
题目详情
65 单选题 适中 GESP编程能力等级认证 ·GESP-C++六级 · 1.1 树的基本概念

N 个节点的双向循环链,在其中查找某个节点的平均时间复杂度是( )。

A
O(1)
B
O(N)
C
O(logN)
D
O(N3)
答案与解析
正确答案:B
这道题暂未补解析。
题目详情
66 单选题 适中 GESP编程能力等级认证 ·GESP-C++六级 · 1.1 树的基本概念

以下关于树的说法,( )是正确的。

A
在一棵二叉树中,叶子结点的度一定是2。
B
满二叉树中每一层的结点数等于 O(2 (层数−1))。
C
在一棵树中,所有结点的度之和等于所有叶子结点的度之和。
D
一棵二叉树的先序遍历结果和中序遍历结果一定相同。
答案与解析
正确答案:B
这道题暂未补解析。
题目详情
67 单选题 适中 GESP编程能力等级认证 ·GESP-C++六级 · 1.1 树的基本概念

已知字符集 {A, B, C, D} 的出现频率如下表所示:

根据哈夫曼编码法,下面( )是正确的哈夫曼树。

A
 ABCD
 / \
A   BCD
    / \
   D   BC
      / \
     B   C
B
 ABCD
 / \
A   BCD
    / \
   B   CD
      / \
     C   D
C
 ABCD
 / \
D   ABC
    / \
   A   BC
      / \
     B   C
D
 ABCD
 / \
C   ABC
    / \
   B   AD
      / \
     A   D
答案与解析
正确答案:A
这道题暂未补解析。
题目详情
68 单选题 适中 GESP编程能力等级认证 ·GESP-C++六级 · 1.2 哈夫曼树

上一题中各字符的哈夫曼编码是( )。

A
A: 0, B: 10, C: 110, D: 111
B
A: 0, B: 10, C: 11, D: 10
C
A: 0, B: 101, C: 100, D: 11
D
A: 11, B: 10, C: 01, D: 00
答案与解析
正确答案:C
这道题暂未补解析。
题目详情
69 单选题 适中 GESP编程能力等级认证 ·GESP-C++六级 · 2.1 格雷编码

( )是 3 位格雷编码。

A
000 001 011 010 110 111 101 100
B
000 001 010 011 100 101 110 111
C
000 001 100 101 011 010 111 110
D
000 010 001 011 100 110 101 111
答案与解析
正确答案:A
这道题暂未补解析。
题目详情
70 单选题 适中 GESP编程能力等级认证 ·GESP-C++六级 · 1.1 树的基本概念

根据下面二叉树和给定的代码,

#include <iostream>
using namespace std;

struct TreeNode {
	int val;
	TreeNode* left;
	TreeNode* right;
	TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

TreeNode* search(TreeNode* root, int val) {
	cout << root->val << " ";
	if (root == NULL || root->val == val) return root;
	
	if (val < root->val)
		return search(root->left, val);
	else
		return search(root->right, val);
}

给定以下二叉搜索树,调用函数 search(root,7) 时,输出的结果是( )。

    5
   / \
  3   7
 / \ / \
2  4 6  8
A
5 3 7
B
5 7
C
2 3 4 5 6 7
D
8 7
答案与解析
正确答案:B
这道题暂未补解析。
题目详情
71 单选题 适中 GESP编程能力等级认证 ·GESP-C++六级 · 1.1 树的基本概念

阅读以下二叉树的深度优先搜索算法,横线上应填写( )。

void dfs(TreeNode* root) {
	if (root == nullptr)
		return;
		
	stack<TreeNode*> s;
	s.push(root);
	while (!s.empty()) {
		———————————————————————— // 在此处填入代码
		cout << node->value << " ";
		
		if (node->right) s.push(node->right);
		if (node->left) s.push(node->left);
	}
}
A
TreeNode* node = s.top();
B
TreeNode* node = s.top(); s.pop();
C
TreeNode* node = s.front();
D
TreeNode* node = s.front(); s.pop();
答案与解析
正确答案:B
这道题暂未补解析。
题目详情
72 单选题 适中 GESP编程能力等级认证 ·GESP-C++六级 · 1.1 树的基本概念

阅读以下二叉树的广度优先搜索的代码,横线上应填写( )。

#include <queue>
void bfs(TreeNode* root) {
	if (root == NULL) return;
	
	queue<TreeNode*> q;
	q.push(root);
	while (!q.empty()) {
		———————————————————————— // 在此处填入代码
		cout << node->val << " ";
		if (node->left) {
			q.push(node->left);
		}
		if (node->right) {
			q.push(node->right);
		}
	}
}
A
TreeNode* node = q.top();
B
TreeNode* node = q.top(); q.pop();
C
TreeNode* node = q.front();
D
TreeNode* node = q.front(); q.pop();
答案与解析
正确答案:D
这道题暂未补解析。
题目详情
73 单选题 适中 GESP编程能力等级认证 ·GESP-C++六级 · 1.1 树的基本概念

使用上题中的宽度优先搜索算法遍历以下这棵树,可能的输出是( )。

  1
   / \
  2   3
 / \   \
8   9   6
   / \   \
  4   5   7
A
1 2 8 9 4 5 3 6 7
B
1 2 3 4 5 6 6 8 9
C
1 2 3 8 9 6 4 5 7
D
8 4 5 9 2 1 3 6 7
答案与解析
正确答案:C
这道题暂未补解析。
题目详情
74 单选题 适中 GESP编程能力等级认证 ·GESP-C++六级 · 4.1 一维动态规划

以下关于动态规划的描述,( )是正确的。

A
动态规划适用于没有重叠子问题的优化问题。
B

动态规划要求问题具有最优子结构和无后效性。

C

动态规划通常通过递归来实现。

D

动态规划与贪心算法不同,贪心算法不适用于有重叠子问题的问题。

答案与解析
正确答案:B
这道题暂未补解析。
题目详情
75 单选题 适中 GESP编程能力等级认证 ·GESP-C++六级 · 4.2 简单背包问题

假设背包的最大容量 W=8kg,共有有 4 个物品可供选择,4个物品的重量分别为weights=[2,3,5,7],对应的价值分别为 values=[30,40,60,80],则该0/1背包问题中,背包的最大价值为( )。

A
70
B
90
C
100
D
120
答案与解析
正确答案:C
这道题暂未补解析。
题目详情
76 单选题 适中 GESP编程能力等级认证 ·GESP-C++六级 · 5.1 面向对象思想

以下( )没有涉及 C++ 语言的面向对象特性支持。

A
C++ 中构造一个 class 或 struct
B
C++ 中调用 printf 函数
C
C++ 中调用用户定义的类成员函数
D
C++ 中构造来源于同一基类的多个派生类
答案与解析
正确答案:B

C++的面向对象特性主要包括类(class)与结构体(struct)的定义、继承(inheritance)、封装(encapsulation)以及多态(polymorphism)等。

A.构造一个class或struct,这是面向对象编程的基本组成部分之一,它允许开发者定义自己的数据类型,这些类型可以包含数据成员和成员函数。因此,这显然涉及到C++的面向对象特性。

B.调用printf函数,并不是面向对象特性的体现。printf是一个标准库函数,用于格式化输出到标准输出设备(如屏幕)。它并不属于任何类的一部分,也不涉及到类、继承或多态的概念。

C.调用用户定义的类成员函数,这与面向对象编程密切相关,因为成员函数是类的一部分,用于操作类的数据成员或者实现类的行为。

D.构造来源于同一基类的多个派生类,这是继承的一个典型例子,是面向对象编程中的一个重要特性,允许创建新的类来重用现有类的代码。

因此,选项C++ 中调用printf函数 没有涉及C++语言的面向对象特性支持。

题目详情
77 单选题 适中 GESP编程能力等级认证 ·GESP-C++六级 · 5.1 面向对象思想

关于以下C++代码,( )行代码会引起编译错误。

#include <iostream>
using namespace std;

class Base {
private:
	int a;
protected:
	int b;
public:
	int c;
	Base() : a(1), b(2), c(3) {}
};

class Derived : public Base {
public:
	void show() {
		cout << a << endl; // Line 1
		cout << b << endl; // Line 2
		cout << c << endl; // Line 3
	}
};


A
Line 1
B
Line 2
C
Line 3
D
没有编译错误
答案与解析
正确答案:A

这段代码中定义了两个类,Base和从Base继承的Derived。在Derived类中有一个show()成员函数,试图输出基类中定义的a, b, 和c的值。

根据C++的访问规则:

私有(private)成员只能由声明它的类的成员函数访问。

保护(protected)成员可以被该类及其派生类的成员函数访问。

公有(public)成员可以被任何地方访问。

具体来看:

a是Base类中的私有成员,所以不能在派生类Derived中直接访问。

b是Base类中的保护成员,所以在派生类Derived中是可以访问的。

c是Base类中的公有成员,自然也是可以被派生类Derived访问的。

根据上述分析,Line 1 会尝试访问Base类中的私有成员a,这会导致编译错误。因此,正确答案是Line 1。

题目详情
78 单选题 适中 GESP编程能力等级认证 ·GESP-C++六级 · 6.1 栈

有6个元素,按照 6,5,4,3,2,1 的顺序进入栈S,下列( )的出栈序列是不能出现的( )。(2024.9-6)

A
5,4,3,6,1,2
B
4,5,3,1,2,6
C
3,4,6,5,2,1
D
2,3,4,1,5,6
答案与解析
正确答案:C

模拟C:6,5,4,3进,3出,4出,5没出6是不能出的。选C

题目详情
79 单选题 适中 GESP编程能力等级认证 ·GESP-C++六级 · 6.1 栈

采用如下代码实现检查输入的字符串括号是否匹配,横线上应填入的代码为( )。

#include <iostream>
#include <stack>
#include <string>

using namespace std;

bool is_valid(string s) {
	stack<char> st;
	char top;
	
	for (char& ch : s) {
		if (ch == '(' || ch == '{' || ch == '[') {
			st.push(ch); // 左括号入栈
		}
		else
		{
			if (st.empty())
				return false;
			———————————————————————— // 在此处填入代码
			if ((ch == ')' && top != '(') ||
				(ch == '}' && top != '{') ||
				(ch == ']' && top != '[')) {
				return false;
			}
		}
	}
	
	return st.empty(); // 栈为空则说明所有括号匹配成功
}
A
top = st.top(); st.pop();
B
st.pop(); top = st.top();
C
st.pop(); top = st.front();
D
top = st.front(); st.pop();
答案与解析
正确答案:A

括号匹配问题,若是碰到左括号则入栈,碰到右括号要拿出左括号与之对比,若栈中没有左括号则配对失败,若左括号与之不匹配则配对失败,否则 继续配对,最终返回栈是否为空,为空则匹配成功,否则匹配失败,这里询问的是拿出栈中首元素后删除的操作,选A是top = st.top; st.pop; front 一般是队列中取出队头的操作。

题目详情
80 单选题 适中 GESP编程能力等级认证 ·GESP-C++六级 · 6.2 队列

下面代码判断队列的第一个元素是否等于a,并删除该元素,横向上应填写( )。

A
is_equal = (q.front() == a);
B
is_equal = (q.front() == a); q.pop();
C
q.pop(); is_equal = (q.front() == a);
D
q.pop(); is_equal = (q.top() == a);
答案与解析
正确答案:B

完美衔接上一题,取出队头是q.front(),去掉队头上q.pop(),所以选B

题目详情