【C++笔试强训】第十七天

🎇C++笔试强训

---

• 博客主页：一起去看日落吗
• 分享博主的C++刷题日常，大家一起学习
• 博主的能力有限，出现错误希望大家不吝赐教
• 分享给大家一句我很喜欢的话：夜色难免微凉，前方必有曙光 🌞。

---

💦🔥

---

选择题

💦第一题

假设A为抽象类，下列声明（）是正确的

A int fun(A);
B A Obj;
C A fun(int);
D A *p;

抽象类不可以实例化对象，所以和对象有关的都是错误的

D 建立相对应类型的指针，所以只有D是正确的，可以用于实现多态

这道题的答案是D

---

💦第二题

虚函数可不可以重载为内联？

A 可以
B 不可以
C 语法错误

内联函数不可以当作虚函数，在前几天的题目中我们都有相应的讲解，因为内联函数最后需要展开

这道题的答案是B

---

💦第三题

下面有关虚函数的描述，说法错误的是？

A 虚函数的作用是实现了继承性
B 虚函数的作用就是实现“动态联编”，也就是在程序的运行阶段动态地选择合适的成员函数
C 和类的静态成员函数与非类的成员函数相比，虚函数的效率较低
D 要正确的实现虚函数，只能用一个基类的指针或者引用来指向派生类对象

A 继承的目的是为了实现多态，关键要靠的是虚函数，反过来是不对的

B 虚函数的作用就是实现“动态联编”，也就是在程序的运行阶段动态地选择合适的成员函数，这就是多态

C 和类的静态成员函数与非类的成员函数相比，虚函数的效率较低，一个类如果有虚函数会产生虚表，我们要先找到虚表才能调动虚函数，所以效率低

D 实现多态需要子类继承父类，父类需要有虚函数，子类需要重写虚函数，如果要调动多态需要父类的指针和引用，用父类的对象不可以

这道题的答案是A

---

💦第四题

#include 
#include 
using namespace std;

int main(void)
{
	vector<int>array;
	array.push_back(100);
	array.push_back(300);
	array.push_back(300);
	array.push_back(300);
	array.push_back(300);
	array.push_back(500);
	vector<int>::iterator itor;
	for(itor=array.begin();itor!=array.end();itor++)
	{
		if(*itor==300)
		{
			itor=array.erase(itor);
		}
	}
	for(itor=array.begin();itor!=array.end();itor++)
	{
		cout<<*itor<<"";
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

下面这个代码输出的是（）

A 100 300 300 300 300 500
B 100 300 300 300 500
C 100 300 300 500
D 100 300

数据在尾插之后是 100 300 300 300 300 500

通过循环如果迭代器的值等于300就删除，最后把返回值给回，迭代器并不会失效

迭代器删除数据会把后面的值往前移动，然后返回当前位置的迭代器，然后循环会++，指向下一位，所以并不会删除所有的300

最后打印的是 100 300 300 500

这道题的答案是C

---

💦第五题

在 C++ 中，用于实现动态多态性的是（ ）。

A 内联函数
B 重载函数
C 模板函数
D 虚函数

这是送分题，内联是提升程序效率，重载和模版都不是实现多态的技术，多态是靠虚函数实现的

这道题的答案是D

---

💦第六题

调用一成员函数时, 使用动态联编的情况是（）

A 通过对象调用一虚函数
B 通过指针或引用调用一虚函数
C 通过对象调用静态函数
D 通过指针或应用调用一静态函数

使用动态联编的情况是多态，实现多态的条件是调用虚函数

这道题的答案是B

---

💦第七题

下面有关继承、多态、组合的描述，说法错误的是?

A 封装，把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏

B 继承可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展

C 隐藏是指派生类中的函数把基类中相同名字的函数屏蔽掉了

D 覆盖是指不同的函数使用相同的函数名，但是函数的参数个数或类型不同

---

A 封装是面向对象的特性之一，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏

B 继承可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展，这是继承的一大特点，子类可以继承父类从而把父类的所有信息继承下来

C 隐藏我们是指同名隐藏，是指派生类中的函数把基类中相同名字的函数屏蔽掉了

D 覆盖需要相同的虚函数名，函数参数个数和类型也必须相同

这道题的答案是D

---

💦第八题

“引用”与多态的关系？

A 两者没有关系
B 引用可以作为产生多态效果的手段
C 一个基类的引用不可以指向它的派生类实例
D 以上都不正确

多态必须通过父类的引用获得指针

这道题的答案是B

---

💦第九题

下面这段程序的输出是什么?

class A{
public:
	A(){p();}
	virtual void p(){print("A")}
	virtual ~A(){p();}
};
class B:public A{
public:
	B(){p();}
	void p(){print("B")}
	~B(){p();}
};
int main(int, char**){
	A* a=new B();
	delete a;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

A AABB
B BBAA
C ABAB
D ABBA

先构造父类，再构造子类，子类构造完成前virtual无效，析构则会反过来

所以会先打印AB 再打印BA

这道题的答案是D

---

💦第十题

以下代码的运行结果为（）

class Base {
public:
	Base() {
		echo();
	}
	virtual void echo() {
		printf("Base");
	}
};
class Derived:public Base {
public:
	Derived() {
		echo();
	}
	virtual void echo() {
		printf("Derived");
}
};
int main() {
	Base* base = new Derived();
	base->echo();
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

A DerivedDerivedDerived
B DerivedBaseDerived
C BaseDerivedBase
D BaseDerivedDerived

首先声明Base类型的指针指向实际类型为Derived的对象，先调用基类构造函数，再调用派生类构造函数。输出Base, Derived.

base->echo(); 指针是base类型，但是因为有关键词 virtual，所以不是隐藏而是重写.调用的是Derived的方法，输出Derived。

这道题的答案是D

---

编程题

🔥 第一题

链接：杨辉三角的变形

• 解题思路

按照题目意思，可以发现第n行有2n - 1个元素，第i,j元素等于上一行第j - 2,j - 1,j三列元素之和，每一行的第一列和最后一列都为1，如果是第二列，则只是两个元素之和。

• 代码演示：

#include 
using namespace std;

int main() {
    // int n;
    // while(cin >> n)
    // {
    //     代码有点捞，写的高级点
    //     if(n <= 2)
    //         cout << -1 << endl;
    //     else if(n % 4 == 1 || n % 4 == 3)
    //         cout << 2 << endl;
    //     else if (n % 4 == 2)
    //         cout << 4 << endl;
    //     else
    //         cout << 3 << endl;


    // }
    //     高级点
    int n;

    int Index[] = {4, 2, 3, 2};
    while (cin >> n) {
        int res = -1;
        if (n > 2)
            res = Index[(n - 2) % 4];
        cout << res << endl;
    }

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

---

🔥 第二题

链接：计算某字符出现次数

• 题目描述

写出一个程序，接受一个由字母、数字和空格组成的字符串，和一个字符，然后输出输入字符串中该字符的出现次数。（不区分大小写字母）

• 解题思路

首先，字符串中包含有空格，因此我们使用gets 函数获取一行数据，而不用scanf ，因为scanf 函数会默认以空格截断输入作为输入的结束.

其次，因为在计算字符出现次数中，要求是不区分大小写的，因此在处理过程中，如果输入的是小写字母，

则计数不但要加上小写字母的计数，还要加上大写字母的计数，反之大写字母也是同样如此，而在ascii 表中，大写字母和小写字母的差值是32 （ 'a’的ascii值是97 ; 'A’的ascii值是65 ）

最后，实现思路，因为ascii字符只有128 个，他们的实际存储是0~127 ，那么我们只需要定义一个具有128 个整形元素的数组，第0 号下标位置存放0 对应的ascii字符出现次数， 1 号下标位置存放1 对应的ascii字符的次数…以此类推，数组每个位置存放的就是对应ascii字符出现的次数。最终以指定字符为下标获取它出现的次数进行打印。

• 代码演示

#include
using namespace std;
int main(){
    char ch;
    string s;
    getline(cin,s);
    cin>>ch;
    int count = 0;
    for(int i = 0;i<s.length();i++){
        if(s[i]>='A'&&s[i]<='Z'){
            if(s[i]==ch||s[i]+32==ch)
                count++;
        }
        else if(s[i]>='a'&&s[i]<='z'){
            if(s[i]==ch||s[i]-32==ch)
                count++;
        }
        else if(s[i]==ch)
            count++;
    }
    cout<<count;
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

---