首页 › 题库 › GESP编程能力等级认证 › 5.1 面向对象思想

GESP-C++六级 题库

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

在面向对象编程中,下列关于 虚函数 的描述中,错误的是( )。

A
虚函数用于支持运行时多态
B
通过基类指针调用虚函数时,会根据对象实际类型决定调用版本
C
构造函数可以声明为虚函数以支持多态
D
基类析构函数常声明为虚函数以避免资源泄漏
答案与解析
正确答案:C
这道题暂未补解析。
题目详情
2 单选题 适中 GESP编程能力等级认证 ·GESP-C++六级 · 5.1 面向对象思想

执行如下代码,会输出 钢琴:叮咚叮咚 和 吉他:咚咚当当 。这体现了面向对象编程的( )特性。

class Instrument {
public:
	virtual void play() {
		cout << "乐器在演奏声音" << endl;
	}
	virtual ~Instrument() {}
};
class Piano : public Instrument {
public:
	void play() override {
		cout << "钢琴:叮咚叮咚" << endl;
	}
};
class Guitar : public Instrument {
public:
	void play() override {
		cout << "吉他:咚咚当当" << endl;
	}
};
int main() {
	Instrument* instruments[2];
	instruments[0] = new Piano();
	instruments[1] = new Guitar();
	for (int i = 0; i < 2; ++i) {
		instruments[i]->play();
	}
	for (int i = 0; i < 2; ++i) {
		delete instruments[i];
	}
	return 0;
}
A
继承
B
封装
C
多态
D
链接
答案与解析
正确答案:C
这道题暂未补解析。
题目详情
3 单选题 适中 GESP编程能力等级认证 ·GESP-C++六级 · 5.1 面向对象思想

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

class Instrument {
public:
	void play() {
		cout << "乐器在演奏声音" << endl;
	}
	virtual ~Instrument() {}
};
class Piano : public Instrument {
public:
	void play() override {
		cout << "钢琴:叮咚叮咚" << endl;
	}
};
class Guitar : public Instrument {
public:
	void play() override {
		cout << "吉他:咚咚当当" << endl;
	}
};
int main() {
	Instrument* instruments[2];
	instruments[0] = new Piano();
	instruments[1] = new Guitar();
	for (int i = 0; i < 2; ++i) {
		instruments[i]->play();
	}
	for (int i = 0; i < 2; ++i) {
		delete instruments[i];
	}
	return 0;
}
A
执行代码会输出两行,内容分别为: 钢琴:叮咚叮咚 和 吉他:咚咚当当
B
执行代码会输出两行,内容分别为: 乐器在演奏声音 和 乐器在演奏声音
C
代码编译出现错误
D
代码运行出现错误
答案与解析
正确答案:C
这道题暂未补解析。
题目详情
4 单选题 适中 GESP编程能力等级认证 ·GESP-C++六级 · 5.1 面向对象思想

下列关于类的说法,错误的是( )。

A

构造函数不能声明为虚函数,但析构函数可以

B

函数参数如声明为类的引用类型,调用时不会调用该类的复制构造函数

C

静态方法属于类而不是某个具体对象,因此推荐用 类名::方法(...) 调用。

D

不管基类的析构函数是否是虚函数,都可以通过基类指针/引用正确删除派生类对象。

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

假设变量 veh 是类 Car 的一个实例,我们可以调用 veh.move() ,是因为面向对象编程有( )性质

A

继承(继承)

B

封装 (Encapsulation)

C

多态 (Polymorphism)

D

链接 (Linking)

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

下面代码中 v1 和 v2 调用了相同接口 move() ,但输出结果不同,这体现了面向对象编程的( )特性

A

继承 (Inheritance)

B

封装 (Encapsulation)

C

多态 (Polymorphism)

D

链接 (Linking)

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

给定 个物品和一个最大承重为 W的背包,每个物品有一个重量 wt[i]和价值 val[i],每个物品只能选择放或不放。目标是选择若干个物品放入背包,使得总价值最大,且总重量不超过W,则横线上应填写( )。

A

dp[w] = max(dp[w], dp[w] + val[i]);

B

dp[w] = dp[w - wt[i]] + val[i];

C

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

D

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

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

下列哪一项不是面向对象编程的基本特征?( )

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

为了让 Dog 类的构造函数能正确地调用其父类 Animal 的构造方法,横线线处应填入?( )

class Animal {
    public:
        std::string name;
        Animal(std::string str) : name(str) {
            std::cout << "Animal created\n";
        }
        virtual void speak() {
            cout << "Animal speaks" << endl;
        }
};
class Dog : public Animal {
        std::string breed;
    public:
        Dog(std::string name, std::string b) : _________________, breed(b) {
            std::cout << "Dog created\n";
        }
        void speak() override {
            cout << "Dog barks" << endl;
        }
};
int main() {
    Animal* p = new Dog("Rex", "Labrador");
    p->speak();
    delete p;
    return 0;
}
A
Animal(name)
B
super(name)
C
Animal::Animal(name)
D
Animal()
答案与解析
正确答案:A
这道题暂未补解析。
题目详情
10 单选题 适中 GESP编程能力等级认证 ·GESP-C++六级 · 5.1 面向对象思想

在面向对象编程中,类是一种重要的概念。下面关于类的描述中,【不正确】的是?( )

A
类是一个抽象的概念,用于描述具有相同属性和行为的对象集合。
B
类可以包含属性和方法,属性用于描述对象的状态,方法用于描述对象的行为。
C
类可以被实例化,生成具体的对象。
D
类一旦定义后,其属性和方法不能被修改或扩展。
答案与解析
正确答案:D

选项D错误,类的属性和方法可以修改或扩展(如通过继承、补丁等)。

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

以下代码中,类的构造函数被调用了( )次?

class MyClass {
    public:
        MyClass() {
            cout << "Constructor called!" << endl;
        }
};
int main() {
    MyClass obj1;
    MyClass obj2 = obj1;
    return 0;
}
A
1
B
2
C
3
D
0
答案与解析
正确答案:A

MyClass obj1:调用 默认构造函数,输出 "Constructor called!"。

MyClass obj2 = obj1,调用的是隐式拷贝构造函数,不会触发默认构造函数。

因此 构造函数仅被调用 1 次。

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

以下代码实现了循环队列的哪种操作?( )

class CircularQueue {
        int* arr;
        int front, rear, size;
    public:
        CircularQueue(int k) {
            size = k;
            arr = new int[k];
            front = rear = -1;
        }
        bool enQueue(int value) {
            if (isFull()) return false;
            if (isEmpty()) front = 0;
            rear = (rear + 1) % size;
            arr[rear] = value;
            return true;
        }
};
A
入队
B
出队
C
查看队首元素
D
判断队列是否为空
答案与解析
正确答案:A

enQueue()函数(入队):

首先检查队列是否已满,如果已满则返回 false,表示入队失败。

如果队列为空(isEmpty()),初始化 front 为 0。

更新 rear 指针:rear = (rear + 1) % size,循环队列利用取模实现环形移动。

将新值 value 存入 arr[rear]。

返回 true 表示入队成功。

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

关于下面代码,说法【错误】的是?( )

class Shape {
    protected:
        string name;
    public:
        Shape(const string& n) : name(n) {}
        virtual double area() const {
            return 0.0;
        }
};
class Circle : public Shape {
    private:
        double radius; // 半径
    public:
        Circle(const string& n, double r) : Shape(n), radius(r) {}
        double area() const override {
            return 3.14159 * radius * radius;
        }
};
class Rectangle : public Shape {
    private:
        double width; // 宽度
        double height; // 高度
    public:
        Rectangle(const string& n, double w, double h) : Shape(n), width(w), height(h) {
        }
        double area() const override {
            return width * height;
        }
};
int main() {
    Circle circle("MyCircle", 5.0);
    Rectangle rectangle("MyRectangle", 4.0, 6.0);
    Shape* shapePtr = &circle;
    cout << "Area: " << shapePtr->area() << endl;
    shapePtr = &rectangle;
    cout << "Area: " << shapePtr->area() << endl;
    return 0;
}
A
语句 Shape* shapePtr = &circle; 和 shapePtr = &rectangle; 出现编译错误
B
Shape 为基类, Circle 和 Rectangle 是派生类
C
通过继承, Circle 和 Rectangle 复用了 Shape 的属性和方法,并扩展了新的功能
D
Circle 和 Rectangle 通过重写(override)基类的虚函数 area 和基类指针,实现了运行时多态
答案与解析
正确答案:A
这道题暂未补解析。
题目详情
14 单选题 适中 GESP编程能力等级认证 ·GESP-C++六级 · 5.1 面向对象思想

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

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

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

A
类中定义的所有成员变量和成员函数默认是 public 访问权限。
B
类的构造函数必须显式声明返回类型为 void 。
C
在C++中,类的数据一般设置为私有,其公有成员函数提供访问私有数据的唯一途径。
D
同一个类的实例有各自的成员数据和成员函数。
答案与解析
正确答案:C
这道题暂未补解析。
题目详情
16 单选题 适中 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
这道题暂未补解析。
题目详情
17 单选题 适中 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++语言的面向对象特性支持。

题目详情
18 单选题 适中 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。

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

面向对象的编程思想主要包括( )原则。

A
贪心、动态规划、回溯
B
并发、并行、异步
C
递归、循环、分治
D
封装、继承、多态
答案与解析
正确答案:D

面向对象的编程思想(OOP)主要包括多态、继承和封装原则。

多态:多态允许程序在运行时根据对象的实际类型来选择执行的方法,增加了代码的灵活性和可扩展性。

继承:通过继承,子类可以扩展父类的功能,而不需要重新编写已有的代码,提高了代码的复用性和维护性。

封装:封装隐藏了对象的内部状态,只提供必要的操作接口,保护对象数据不被外部直接访问,同时确保了数据的安全性和完整性。

这些原则共同构成了面向对象编程的核心,使得代码更加模块化、可重用、可维护和可扩展

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

运行下列代码,屏幕上输出( )。

#include <iostream>
using namespace std;

class my_class {
public:
	static int count;
	my_class() {
		count++;
	}
	~my_class() {
		count--;
	}
	static void print_count() {
		cout << count << " ";
	}
};
int my_class::count = 0;
int main() {
	my_class obj1;
	my_class::print_count();
	my_class obj2;
	obj2.print_count();
	my_class obj3;
	obj3.print_count();
	return 0;
}
A
1 1 1
B
1 2 3
C
1 1 2
D
1 2 2
答案与解析
正确答案:B

构造函数my_class()在对象obj实例化时自动调用,静态局部变量count在程序执行到该对象的声明处时被首次初始化为0,在以后的函数调用不再进行初始化;因此后续调用print_count()方法时,输出count依次自增的结果,程序输出结果为1 2 3,另外析构函数~my_class()会在对象结束调用时做“清理善后” 的工作,即程序结束时,会自动调用三次~my_class()方法,因此最终程序结束时,count的值为0。

题目详情