🎇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<iostream>
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;
}
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));
}
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;
}
在 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 <iostream>
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;
}
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 <iostream>
#include <vector>
#include <string>
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;
}
🔥第二题
链接：求最小公倍数
- 解题思路
最小公倍数 = 两数之积除以最大公约数，这里使用碾转相除法进行最大公约数的求解：即a与b的最大公约数可以转化为a、b之间的余数为两者之间最小的数之间的公约数。所以对于输入的两个数进行连续求余，直到余数为0，求余的分母即为结果。
- 代码演示
#include <iostream>
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;
}