【C++笔试强训】第八天

🎇C++笔试强训

---

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

---

💦 🔥

---

选择题

💦第一题

关于重载函数，哪个说明是正确的（）

A 函数名相同，参数类型或个数不同
B 函数名相同，返回值类型不同
C 函数名相同，函数内部实现不同
D 函数名称不同

这道题主要是考验函数重载，需要知道什么是函数重载

这道题的答案是A

---

💦第二题

关于引用以下说法错误的是（）。

A 引用必须初始化，指针不必
B 引用初始化以后不能被改变，指针可以改变所指的对象
C 不存在指向空值的引用，但是存在指向空值的指针
D 一个引用可以看作是某个变量的一个“别名”
E 引用传值，指针传地址
F 函数参数可以声明为引用或指针类型

这道题注意是选择错误的，需要注意一下

A 引用是给变量取的别名，所以需要知道是给谁，所以需要初始化，指针不强制要求

B 引用初始化之后就不能被二次引用，但指针的指向的对象可以改变

C 引用不存在空，指针可以指向空

D 引用就是变量别名

E 引用底层使用是使用指针来实现的，引用的本质就是一个指针，所以在传参的时候也是传实参的地址

F 函数参数可以声明为引用或指针类型

这道题的答案是E

---

💦第三题

类定义的外部，一定可以被访问的成员有（ ）

A 所有类成员
B private或protected的类成员
C public的类成员
D public或private的类成员

这道题一眼看到答案，public修饰的成员是公有的，被private或protected不可以在类外访问

这道题的答案是C

---

💦第四题

请将下列构造函数补充完整，使得程序的运行结果是5

#include
using namespace std;
class Sample{
public:
	Sample(int x){
		________
	}
	~Sample(){
		if(p) delete p;
	}
	int show(){
		return *p;
	}
private:
	int*p;
};
int main(){
	Sample S(5);
	cout<<S.show()<<endl;
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

A *p=x;
B p=new int(x);
C *p=new int(x);
D p=&x;

这道题在main创建了一个Sample，需要调用构造函数

这道题打印5，调用了show，show里面是对指针解引用，所以初始化的时候应该是开辟了新空间，用p来存放

A C p都没有指向，不可以解引用

D 构造函数之后x会被笑话，导致野指针问题

这道题的答案是B

---

💦第五题

下列情况中，不会调用拷贝构造函数的是（）

A 用一个对象去初始化同一个类的另一个新对象时
B 将类的一个对象赋值给该类的另一个对象时
C 函数的形参对象，调用函数进行形参和实参结合时
D 函数的返回值是类的对象，函数执行返回调用时

这道题需要对拷贝构造了解才可以解题，理解其概念

A 就是场景1
B 赋值调用的不是拷贝构造，调用的是赋值运算符重载
C 这种情况会讲实参拷贝构造一份给给形参
D 就是场景3

这道题的答案是B

---

💦第六题

以下代码共调用多少次拷贝构造函数：

Widget f(Widget u)
{
	Widget v(u);
	Widget w=v;
	return w;
}
main(){
	Widget x;
	Widget y=f(f(x));
}
1
2
3
4
5
6
7
8
9
10

A 1
B 3
C 5
D 7

这道题有一定的难度，我们上一道题已经了解了构造场景，我们这道题来验证一下

y对象的构造将来也需要调用构造函数

f（x）在传参数会调用一次，用v（u）拷贝一次，用v构造w又一次，返回需要借助w调用临时对象，所以又有一次，结束之后需要利用临时对象再次进入f（x）中进行调用，这里也有4次，最后用返回值构造y，一共有9次

注意：按照我们刚刚的算法没有任何问题，但是当函数返回值是类类型对象时，编译器可能会对返回值的类型进行优化

在返回值的时候我们需要创建临时对象，编译器可能会直接拿着临时对象使用，这样子可以少调用一次

这道题的答案是D

---

💦第七题

如果友元函数重载一个运算符时，其参数表中没有任何参数则说明该运算符是（）

A 一元运算符
B 二元运算符
C 选项A）和选项B）都可能
D 重载错误

这道题需要知道什么时候需要运算符重载

如果重载成友元函数，但没有任何参数，所以错误，必须要有一个参数是类类型的对象

这道题的答案是D

---

💦第八题

class A;
class B;
int main() {
	A a;
	B b;
	return 0;
}
1
2
3
4
5
6
7

在 main 函数中，变量 a 和 b 的构造函数和析构函数的调用顺序是（）

A b构造 - a构造 - a析构 - b析构
B a构造 - a析构 - b构造 - b析构
C b构造 - a构造 - b析构 - a析构
D a构造 - b构造 - b析构 - a析构

F 函数先构造a 再构造b，析构是在栈上的，所以后构造的先析构

这道题的答案是D

---

💦第九题

下面 C++ 程序的运行结果为（）

#include 
using namespace std;
class cla {
	static int n;
public:
	cla() { n++; }
	~cla() { n--; }
	static int get_n() { return n; }
};

int cla::n = 0;

int main() {
	cla* p = new cla;
	delete p;
	cout << "n=" << cla::get_n() << endl;
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

A n=3
B n=4
C n=1
D n=0

在cla中定了类静态类型的对象，所以是所有类共享的，将n初始为0，然后构造n++，之后析构n–

在main函数中，先构造，然后n = 1，然后析构，n = 0，然后打印，所以n的值并不会变

这道题的答案是D

---

💦第十题

运行的程序总要与内存进行交互。内存作为操作系统中的重要资源，对内存的分配和释放进行管理是一项非常重要的工作，以下说法中错误的是 ______。

A 内存泄露是内存管理中的常见问题
B 悬挂引用指的是对某个对象的应用实际上指向一个错误的内存地址
C 在C、C++等系统语言中，有自动的内存管理机制，不需要考虑内存管理的问题
D 程序的动态性越强，内存管理就越重要，内存分配程序的选择也就更重要

C/C++没有内存回收机制，所有在堆上申请的内存都需要用户手动释放

A 因为没有内存回收机制，所以内存泄漏这个问题需要用户处理

B 我们用个Swap来进行举例，看起来是用整型变量，实际上是使用地址

C 没有内存回收机制，需要考虑内存管理问题

D 程序的动态性越强，内存管理就越重要，内存分配程序的选择也就更重要

这道题的答案是C

---

编程题

🔥第一题

链接：两种排序方法

• 解题思路

思路很简单，将接受的字符串都放到vector容器中，利用string的operator>=运算符重载来按ascii比较字符串，利用string的size来比较字符串的长度

• 代码演示

#include 
#include 
#include 
using namespace std;

int main() 
{
    vector<string> v;
    int n;
    cin >> n;
    v.resize(n);
    for(auto &str : v)
    {
        cin >> str;
    }
    bool lsort = true, csort = true;
    
    for(int i = 0;i < n;i++)
    {
        if(v[i - 1].size() > v[i].size())
        {
            lsort = false;//并非按长度排序
            break;
        }
    }

    for(int i = 1 ; i< n;i++)
    {
        if(v[i - 1] > v[i])
        {
            csort = false;//并非按字典排序
            break;
        }
    }
	
	//判断是哪种情况
    if(lsort && csort)
        cout << "both" << endl;
    else if(lsort)
        cout << "lengths" << endl;
    else if(csort)
        cout << "lexicographically" << endl;
    else
        cout << "none" << 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
33
34
35
36
37
38
39
40
41
42
43
44
45
46

---

🔥第二题

链接：求最小公倍数

• 解题思路

最小公倍数 = 两数之积除以最大公约数，这里使用碾转相除法进行最大公约数的求解：即a与b的最大公约数可以转化为a、b之间的余数为两者之间最小的数之间的公约数。所以对于输入的两个数进行连续求余，直到余数为0，求余的分母即为结果。

• 代码演示

#include 
using namespace std;

// 方法一：暴力破解，用最大的数枚举得到最小公倍数

// int main() {
//     int A, B;
//     while (cin >> A >> B) {
//         int m = max(A, B);
//         while (1) {
//             if (m % A == 0 && m % B == 0) {
//                 cout << m << endl;
//                 break;
//             }
//             m++;
//         }
//     }

//     return 0;
// }

// 方法二： 更优解法，数学公式：两个数的最小公倍数就是两个数的乘积 / 最小公约数
// 最小公约数：辗转相除法：9%6 == 3，6 % 3 == 0 ，3 就是最小公约数

int gcd(int a, int b) {
    int c;
    while ((c = a % b)) {
        a = b;
        b = c;
    }
    return b;
}

int main() {
    int A, B;
    while (cin >> A >> B) {
        cout << A* B / gcd(A, B) << 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
33
34
35
36
37
38
39
40

---