笔试强训48天——day8

一. 单选

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

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

正确答案：A

函数重载：在相同作用域中，函数名字相同，参数列表不用的一系列函数
参数列表不同的具体体现：参数个数不同 参数类型不同 类型的次序不同
注意：与函数返回值类型是否相同没有关系。

 

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

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

正确答案：E

B

 int main()
  {
      int a = 10;
      int& ra = b;
      
      //引用初始化以后不能被改变
      int b = 20;
      ra = b;
      &a = b;//err
      
      //指针可以改变所指的对象,只要不是const类型的指针
      int* p = &a;
      p = &b;
      
      return 0;                            
  }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

E
引用的底层是使用指针来实现的，引用的本质就是一个指针

void swap(int& left,int& right)
{
    int temp = left;
    left = rught;
    right = temp;
}

int main()
{
    int a = 10;
    int b = 20;
    swap(a,b);
    
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

 

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

A 所有类成员
B private或protected的类成员
C public的类成员
D public或private的类成员
正确答案：C

 

4.请将下列构造函数补充完整，使得程序的运行结果是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
22

A *p=x;
B p=new int(x);
C *p=new int(x);
D p=&x;
正确答案：B

AC：p都没有指向怎么解引用
D: x是构造函数的参数，p会指向非法空间，delete时会出现问题

 

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

A 用一个对象去初始化同一个类的另一个新对象时 1
B 将类的一个对象赋值给该类的另一个对象时 a1 = a2;此处调用的是赋值运算符重载，a1是已经存在的对象
C 函数的形参对象，调用函数进行形参和实参结合时 2
D 函数的返回值是类的对象，函数执行返回调用时 3

正确答案：B

概念：是一个特殊的构造函数，是单参，参数的类型必须是类类型& 一般情况下会用const进行修饰
A(const A& a)
调用时机：当用已经存在的对象构造新对象时，编译器会自动调用拷贝构造函数
场景：

//1
A a1;
A a2(a1);//拷贝构造函数

//2
void Fun(A a)//传参时也会调用拷贝构造函数
{}

//3
A fun()
{
    A a;
    return a;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

 

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

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

正确答案：D

y对象的构造将来也需要调用构造函数
内部的f(x)的结果需要当做外部f(x)的参数
注意：当函数返回值是类类型对象时，编译器可能会对返回值类型进行优化

 

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

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

正确答案：D

当用户定义了一个类之后，想要通过该类的对象直接使用某种运算符——编译器不支持
原因：类对象中可能有多个成员，在用该类的对应进行相应的运算符操作时，该如何处理，编译器无法判断。
这种时候需要进行运算符重载：
重载成类的成员函数——形参数目看起来要比运算符需要的参数个数少1——因为成员函数有隐藏的this指针
重载成类的友元函数——必须有一个参数也是类类型的对象

 

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

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

A b构造 - a构造 - a析构 - b析构
B a构造 - a析构 - b构造 - b析构
C b构造 - a构造 - b析构 - a析构
D a构造 - b构造 - b析构 - a析构
正确答案：D

先构造的后析构
构造顺序按定义顺序

 

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

#include 
using namespace std;
class cla {
static int n;//共享,n = 0
public:
cla() { n++; }
~cla() { n--; }
static int get_n() { return n; }
};
int cla::n = 0;

 
  
int main() {
cla* p = new cla;//new了一个对象，调用构造函数 n++ 1
delete p;//销毁空间 n-- 0
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
19

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

正确答案：D

 

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

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

 

二. 编程

1. 两种排序方法

链接

考拉有n个字符串字符串，任意两个字符串长度都是不同的。考拉最近学习到有两种字符串的排序方法：
1.根据字符串的字典序排序。例如：
“car” < “carriage” < “cats” <
"doggies < “koala”
2.根据字符串的长度排序。例如：
“car” < “cats” < “koala” <
“doggies” < “carriage”
考拉想知道自己的这些字符串排列顺序是否满足这两种排序方法，考拉要忙着吃树叶，所以需要你来帮忙验证。

输入描述：
输入第一行为字符串个数n(n ≤ 100)
接下来的n行,每行一个字符串,字符串长度均小于100，均由小写字母组成
输出描述：
如果这些字符串是根据字典序排列而不是根据长度排列输出"lexicographically",
如果根据长度排列而不是字典序排列输出"lengths",
如果两种方式都符合输出"both"，否则输出"none"

示例1:
输入
3
a
aa
aaa
bbb
输出
both

正确答案：

#include 
#include 
#include 
using namespace std;

int main()
{
    int n;
    cin>>n;

    vector<string> v;
    v.resize(n);
    for(auto& str : v)
    {
       cin>>str;
    }

    bool lsort = true,csort = true;
    for(int i = 1;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

 

2. 求最小公倍数

链接

正整数A和正整数B 的最小公倍数是指 能被A和B整除的最小的正整数值，设计一个算法，求输入A和B的最小公倍数。
数据范围：

输入描述：
输入两个正整数A和B。
输出描述：
输出A和B的最小公倍数。

示例1:
输入
5 7
输出
35
示例2:
输入
2 4
输出
4

思路一：暴力枚举法
从两个数中较大的数开始，逐个进行判断，能够被两个数都整除，则第一个就是最小公倍数

正确答案：

#include 
using namespace std;

int main()
{
    int a,b,m;
    while(cin>>a>>b){
          m = max(a,b);

    while(1)
    {
        if(m%a == 0 && m%b == 0)
        {
            cout<<m<<endl;
            break;
        }
        m++;
    }
            
    }

  

    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

思路二：更优解
两个数的最小公倍数，就是两个数的乘积，除以最小公约数
最小公约数：辗转相除法

正确答案：

#include 
using namespace std;

int gcd(int a, int b)
{ int r;
while(r = a%b){
a = b;
b = r;
} 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