【C++】笔试训练（十）

一、选择题

1、内联函数在以下场景中最有用的（）
A 当函数代码较长且多层嵌套循环的时候
B 当函数中有较多的静态变量的时候
C 当函数代码较小并且被频繁调用的时候
D 以上都不对

答案：C

2、下列运算符中，在C++语言中不能重载的是：
A *
B >=
C ::
D delete

答案：C
解析： .  .*  ::  ?:  sizeof 这些都是不能被重载的运算符

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

答案：D
解析：
拷贝构造概念：是一个特殊的构造函数，是单参的，参数的类型必须是类类型&，一般情况下，会使用const来进行修饰 A(const A& a)。
调用时机：当用已经存在的对象构造新对象时，编译器会自动调用拷贝构造函数
构造函数是没有返回值的，是对本对象的引用，所以A、B是错误的
编译器系统会自动生成一个缺省拷贝构造函数，作为该类的公有成员，所以C是错误的
A(A&) 或者 A(const A& a)
A a1;
A a2(a1); // 调用拷贝构造

4、print()函数是一个类的常成员函数，它无返回值，下列表示中正确的是()
A const void print();
B void const print();
C void print() const;
D void print(const);

答案：C
解析：print()函数是一个类的const成员函数，const应该在函数后
注意：C选项中的const实际修饰的是this指针，表明在该成员函数中，不能被修改非静态的成员变量

5、不能作为重载函数的调用的依据是：
A 参数个数
B 参数类型
C 函数类型
D 函数名称

答案：C
解析：函数重载：在相同作用中，函数名字相同，参数列表不同的一系列函数称为函数重载。
参数列表不同具体的体现：参数个数不同，参数类型不同，类型的次序不同。

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

答案：B
解析：
MyClass a[5]：表示5个MyClass对象的一个数组----调用5次MyClass类的构造函数
*b[6]：b实际为一个指针数组----该数组中的每个元素都是一个MyClass *

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

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”

答案：C
解析：在初始化列表中初始化成员的次序：与该成员在初始化列表中出现的先后次序没有关系，真正的初始化次序与成员变量在类中生成的先后次序保持一致

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

答案：B
解析：class A{};//这是一个空类
类大小的计算方式：将类中非静态成员大小相加，注意内存对齐----和成员函数没有关系，与结构体大小的计算方式类似
注意：空类大小并不是0，在主流编译器中，将空类的大小设置为1

9、下面 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

答案：B
解析：后置- -：先使用a的值，然后给a减去1
fun(A(0)) + fun(A(1)) + fun(A(2)) + fun(A(3)) + fun(A(4))
fun(A(0)) == fun(A(1)) == fun(A(2)) == 1
fun(A(3)) ----> 3 + fun(A(2)) ----> fun(A(3)) == 4
fun(A(4)) ----> 4 + fun(A(3)) ----> 3 + fun(A(2)) ----> fun(A(4)) == 8

10、以下程序输出是____。

#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

答案：D
解析：&a 的类型：const int *
C++中被const修饰的变量：该变量已经是一个常量了，还具有替换的作用
编译器在编译代码，在程序中看到对常量中内容读取时，会直接使用常量中的内容替换该常量

二、编程题

1、井字棋

入口：题目链接

题目描述：

题目解析：
井字棋，是一种在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) {
        int row = board.size();
        int col = board[0].size();
        int sum = 0;
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                sum += board[i][j];
            }
            if (sum == col) {
                return true;
            }
        }
        for (int i = 0; i < col; i++) {
            sum = 0;
            for (int j = 0; j < row; j++) {
                sum += board[j][i];
            }
            if (sum == row) {
                return true;
            }
        }
        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;
    }
};

2、密码强度等级

入口：题目链接

题目描述：

题目解析：
本题考查的是对于字符的使用

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

代码展示：

#include <iostream>
#include <string>
using namespace std;

int 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;
    int sum = 0;
    while (cin >> str) {
        sum = count(str);
        if (sum >= 90) {
            cout << "VERY_SECURE" << endl;
        }
        else if (sum >= 80) {
            cout << "SECURE" << endl;
        }
        else if (sum >= 70) {
            cout << "VERY_STRONG" << endl;
        }
        else if (sum >= 60) {
            cout << "STRONG" << endl;
        }
        else if (sum >= 50) {
            cout << "AVERAGE" << endl;
        }
        else if (sum >= 25) {
            cout << "WEAK" << endl;
        }
        else {
            cout << "VERY_WEAK" << endl;
        }
    }
}