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

ゝ一世哀愁。 2024-04-20 06:11 92阅读 0赞

> **?C++笔试强训**
> 
> --------------------
> 
>  *  **博客主页：**[一起去看日落吗][Link 1]
>  *  **分享博主的C++刷题日常，大家一起学习**
>  *  **`博主的能力有限，出现错误希望大家不吝赐教`**
>  *  **分享给大家一句我很喜欢的话：夜色难免微凉，前方必有曙光** ?。
> 
> --------------------
> 
> ![在这里插入图片描述][047d8ad26e314dc7bc7aa19a6ce9ccb0.jpeg_pic_center]

? ?

--------------------

## 选择题 ##

### ?第一题 ###

内联函数在以下场景中最有用的（）

A 当函数代码较长且多层嵌套循环的时候  
B 当函数中有较多的静态变量的时候  
C 当函数代码较小并且被频繁调用的时候  
D 以上都不对

在C++中被inline修饰的函数是内联函数

A 函数代码较长不建议内联  
B 函数有较多静态变量不建议内联  
C 当函数代码较小并且被频繁调用的时候适合内联

> **`这道题的答案是C`**

--------------------

### ?第二题 ###

下列运算符中，在C++语言中不能重载的是：

A \*  
B >=  
C ::  
D delete

这道题注意是不能被重载，C++并不是所有运算符都可以被重载

. .\* :: ?: sizeof 需要记一下，这五个不可以被重载

> **`这道题的正确答案是C`**

--------------------

### ?第三题 ###

拷贝构造函数的特点是（）

A 该函数名同类名，也是一种构造函数，该函数返回自身引用  
B 该函数只有一个参数，是对某个对象的引用  
C 每个类都必须有一个拷贝初始化构造函数，如果类中没有说明拷贝构造函数，则编译器系统会自动生成一个缺省拷贝构造函数，作为该类的保护成员  
D 拷贝初始化构造函数的作用是将一个已知对象的数据成员值拷贝给正在创建的另一个同类的对象

拷贝构造是一个特殊的构造函数

![请添加图片描述][8e4e1320dabe47a0b5d41023efc5216b.png]

A 构造函数无返回值  
B 一定是对本类类型对象的引用，不是某个  
C 是作为该类public成员，不是保护成员  
D 这种说法是拷贝构造的调用场景

> **`这道题的答案是D`**

--------------------

### ?第四题 ###

print()函数是一个类的常成员函数，它无返回值，下列表示中正确的是()

A const void print();  
B void const print();  
C void print() const;  
D void print(const);

常成员函数 即 const成员函数 const应该在参数列表之后，如果是返回值前代表返回值不能修改

![请添加图片描述][6cf54b99703349a9a01d49f4e44adfa5.png]

> **`这道题的答案是C`**

--------------------

### ?第五题 ###

不能作为重载函数的调用的依据是：

A 参数个数  
B 参数类型  
C 函数类型  
D 函数名称

重载函数和函数类型没有关系，作用域，函数名都必须相同

> **`这道题的答案是C`**

--------------------

### ?第六题 ###

如果MyClass为一个类，执行”MyClass a\[5\], \*b\[6\]”语言会自动调用该类构造函数的次数是()

A 2  
B 5  
C 4  
D 9

![请添加图片描述][0daa82836fc1442daba79d5852c608c6.png]  
指针在调用期间并不会调用构造函数

> **`这道题的答案是B`**

--------------------

### ?第七题 ###

下面的程序输出可能是什么?

class Printer{
        
    public:
    	Printer(std::string name) {
        std::cout << name;}
    };
    class Container{
        
    public:
    	Container() : b("b"), a("a") {
        }
    	Printer a;
    	Printer b;
    };
    int main(){
        
    	Container c;
    	return 0;
    }

A 可能是 “ab” 或 “ba”。 依赖于具体的实现  
B 一直都是 “ba”  
C 一直都是 “ab”

这道题就是将形参打印一下

![请添加图片描述][ac20e80bd86b4a60be54650ff196c861.png]

注意是和生成的先后次序一致

> **`这道题的答案是C`**

--------------------

### ?第八题 ###

在Windows 32位操作系统中，假设字节对齐为4，对于一个空的类A，sizeof(A)的值为（）？

A 0  
B 1  
C 2  
D 4

![请添加图片描述][ad6de9e144d441858b87062338221e7e.png]

![请添加图片描述][ac7c0b14f1e24262809325e5ba93995f.png]

> **`这道题的答案是B`**

--------------------

### ?第九题 ###

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

#include<iostream>
    #include<string>
    using namespace std;
    
    class A {
        
    friend long fun(A s) {
        
    if (s.x < 3) {
        
    	return 1;
    }
    	return s.x + fun(A(s.x - 1));
    }
    public:
    	A(long a) {
        
    		x = a--;
    	}
    private:
    	long x;
    };
    int main() {
        
    	int sum = 0;
    	for (int i = 0; i < 5; i++) {
        
    		sum += fun(A(i));
    	}
    	cout << sum;
    	return 0;
    	}
    }

A 21  
B 15  
C 9  
D 36

注意A（long a）是后置–：先使用a的值再-1

看主函数的话，会循环5次

fun里面是一个递归函数，需要列举出来依次解题

![请添加图片描述][c69293340df34e0cab8fdd297da7a596.png]

> **`这道题的答案是B`**

--------------------

### ?第十题 ###

以下程序输出是\_\_\_\_。

#include <iostream>
    using namespace std;
    int main(void)
    {
        
    	const int a = 10;
    	int * p = (int *)(&a);
    	*p = 20;
    	cout<<"a = "<<a<<", *p = "<<*p<<endl;
    	return 0;
    }

A 编译阶段报错运行阶段报错  
B a = 10, \*p = 10  
C a = 20, \*p = 20  
D a = 10, \*p = 20  
E a = 20, \*p = 10

![请添加图片描述][b4a8b69be8414cf8bcecacb1fd5ffaba.png]

这道题&a的类型是const int\* ，理论上const指向的内容是可以改变的，但是c++中的编译器具有替换作用，在读取的时候会使用常量的内容替换，这里需要注意一下

> **`这道题的答案是D`**

--------------------

## 编程题 ##

### ?第一题 ###

链接：[井字棋][Link 2]

![请添加图片描述][f1f3acf043d74720af79a709cb4a4e72.png]

*  题目解析：

井字棋，是一种在3\*3格子上进行的连珠游戏，三个相同就代表获胜。

*  解题思路：

井字棋有四种情况表示当前玩家获胜，1代表当前玩家棋子 1. 行全为1， 即行的和为3 2. 列全为1， 列的和为3 3. 主对角全为1， 对角和为3 4. 副对角全为1， 对角和为3 5. 如果扩展为N\*N的话，判断和是否等于N，下面代码适用任何情况

*  解题思路：

class Board {
        
    public:
        bool checkWon(vector<vector<int> > board) {
        
            // write code here
            int row = board.size();
            int col = board[0].size();
            //每一行是否连续
            for(int i = 0; i < row ;i++)
            {
        
                int sum = 0;
                for(int j = 0;j < col ;j++)
                {
        
                    sum += board[i][j] ;
                }
                if(sum == col)
                    return true;
            }
            //每一列是否连续
            for(int i = 0; i < col ;i++)
            {
        
                int sum = 0;
                for(int j = 0;j < row ;j++)
                {
        
                    sum += board[j][i] ;
                }
                if(sum == row)
                    return true;
            }
            //对角线是否连续
            int sum = 0;
            for(int i = 0;i < row ;i++)
            {
        
                sum += board[i][i];
            }
            if(sum == row)
                return true;
            //副对角线是否连续
            sum = 0;
            for(int i = 0;i < row;i++)
            {
        
                sum += board[i][col - i - 1];
            }
            if(sum == row)
                return true;
    
            return false;
        }
    };

--------------------

### ?第二题 ###

链接：[密码强度等级][Link 3]

**描述**  
密码按如下规则进行计分，并根据不同的得分为密码进行安全等级划分。

一、密码长度:  
5 分: 小于等于4 个字符  
10 分: 5 到7 字符  
25 分: 大于等于8 个字符

二、字母:  
0 分: 没有字母  
10 分: 密码里的字母全都是小（大）写字母  
20 分: 密码里的字母符合”大小写混合“

三、数字:  
0 分: 没有数字  
10 分: 1 个数字  
20 分: 大于1 个数字

四、符号:  
0 分: 没有符号  
10 分: 1 个符号  
25 分: 大于1 个符号

五、奖励（只能选符合最多的那一种奖励）:  
2 分: 字母和数字  
3 分: 字母、数字和符号  
5 分: 大小写字母、数字和符号

最后的评分标准:

> = 90: 非常安全  
> = 80: 安全（Secure）  
> = 70: 非常强  
> = 60: 强（Strong）  
> = 50: 一般（Average）  
> = 25: 弱（Weak）  
> = 0: 非常弱（Very\_Weak）

对应输出为：

VERY\_SECURE  
SECURE  
VERY\_STRONG  
STRONG  
AVERAGE  
WEAK  
VERY\_WEAK

请根据输入的密码字符串，进行安全评定。

注：  
字母：a-z, A-Z  
数字：0-9  
符号包含如下： (ASCII码表可以在UltraEdit的菜单view->ASCII Table查看)  
!"\#$%&'()\*+,-./ (ASCII码：0x21~0x2F)  
:;<=>?@ (ASCII码：0x3A~0x40)  
\[\]^\_\` (ASCII码：0x5B~0x60)  
\{|\}~ (ASCII码：0x7B~0x7E)

提示:  
1 <= 字符串的长度<= 300  
输入描述：

输入一个string的密码  
输出描述：

输出密码等级

![请添加图片描述][016d67bb975d4ef398945b5abeff5700.png]

*  解题思路：  
    这里对于不同种类的字符得分不同，同学们可以现对每一个维度进行单独判断，即对于长度，字母，数字，符号单独判断，最后把所有的单项值根据题目要求相加，输出对应的安全级别。
 *  代码演示：

#include <iostream>
    #include <string>
    using namespace std;
    
    int score_count(string& str) {
        
        int digit = 0, symbol = 0;
        int lower = 0, upper = 0, charc = 0;
        int size = 0, sum = 0;
        for (auto ch : str) {
        
            if (ch >= 'a' && ch <= 'z') {
        
                lower++;
                charc++;
            } else if (ch >= 'A' && ch <= 'Z') {
        
                upper++;
                charc++;
            } else if (ch  >= '0' && ch  <= '9') {
        
                digit++;
            } else if ((ch >= 0x21 && ch <= 0x2F) ||
                       (ch >= 0x3A && ch <= 0x40) ||
                       (ch >= 0x5B && ch <= 0x60) ||
                       (ch >= 0x7B && ch <= 0x7E)) {
        
                symbol++;
            }
        }
    
        size = str.size();
        if (size <= 4)
            sum += 5;
        else if (size <= 7)
            sum += 10;
        else
            sum += 25;
        if (lower > 0 && upper > 0)
            sum += 20;
        else if (lower == charc || upper == charc)
            sum += 10;
        if (digit == 1)
            sum += 10;
        else if (digit > 1)
            sum += 20;
        if (symbol == 1)
            sum += 10;
        else if (symbol > 1)
            sum += 25;
        if (lower > 0 && upper > 0 && digit > 0 && symbol > 0)
            sum += 5;
        else if ((lower > 0 || upper > 0) && digit > 0 && symbol > 0)
            sum += 3;
        else if ((lower > 0 || upper > 0) && digit > 0 && symbol == 0)
            sum += 2;
        return sum;
    }
    
    int main() {
        
        string str;
        while (cin >> str) {
        
            int score = score_count(str);
            if (score >= 90) {
        
                cout << "VERY_SECURE" << endl;
            } else if (score >= 80) {
        
                cout << "SECURE" << endl;
            } else if (score >= 70) {
        
                cout << "VERY_STRONG" << endl;
            } else if (score >= 60) {
        
                cout << "STRONG" << endl;
            } else if (score >= 50) {
        
                cout << "AVERAGE" << endl;
            } else if (score >= 25) {
        
                cout << "WEAK" << endl;
            } else {
        
                cout << "VERY_WEAK" << endl;
            }
        }
        return 0;
    
    }

--------------------

[Link 1]: https://blog.csdn.net/m0_60338933?type=blog
[047d8ad26e314dc7bc7aa19a6ce9ccb0.jpeg_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/80b9122a7078426095bd4c3436016484.jpeg
[8e4e1320dabe47a0b5d41023efc5216b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/1d3837ab555e42fabd1619933af47e4d.png
[6cf54b99703349a9a01d49f4e44adfa5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/c48f764eb642446b89c2596e25ede6c7.png
[0daa82836fc1442daba79d5852c608c6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/ae9f0425e54d4a54a908a2377f8db07f.png
[ac20e80bd86b4a60be54650ff196c861.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/5097221cc5234917bba47bb715ddbefc.png
[ad6de9e144d441858b87062338221e7e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/7ad2eb07dc1e4236bbf54941b10f3586.png
[ac7c0b14f1e24262809325e5ba93995f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/bcd4aa9101f549f0983a333db6b0c189.png
[c69293340df34e0cab8fdd297da7a596.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/309edea6ef4845288d4c92f124687470.png
[b4a8b69be8414cf8bcecacb1fd5ffaba.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/bd8547780eb44f69b3ebe718fb93bd95.png
[Link 2]: https://www.nowcoder.com/practice/e1bb714eb9924188a0d5a6df2216a3d1?tpId=8&&tqId=11055&rp=1&ru=/activity/oj&qru=/ta/cracking-the-coding-interview/question-ranking
[f1f3acf043d74720af79a709cb4a4e72.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/cca0ea8017c4476ba839673f1a132604.png
[Link 3]: https://www.nowcoder.com/practice/52d382c2a7164767bca2064c1c9d5361?tpId=37&&tqId=21310&rp=1&ru=/activity/oj&qru=/ta/huawei/question-ranking
[016d67bb975d4ef398945b5abeff5700.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/4442ba78cd92470b981324e9f43f57a2.png