【C/C++笔试练习】内联函数、哪些运算符不能重载、拷贝构造函数、const类型、函数重载、构造函数、空类的大小、井字棋、密码强度等级

C/C++笔试练习

选择部分

（1）内联函数

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

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

   答案选：C

  当函数代码较小并且被频繁调用的时候。 内联函数的目的是减少函数调用的开销，因此当函数体较小并且被频繁调用时，使用内联函数可以提高程序的执行效率。

   当函数参数是类对象时。对于类对象，调用成员函数时需要进行一次额外的间接引用，而内联函数可以避免这种开销。

  当函数代码较长或有多层嵌套循环时，内联函数的效率可能会降低，因为内联函数的代码会膨胀，导致编译器无法进行优化。当函数中有较多的静态变量时，内联函数也不会带来明显的性能提升。所以答案选C。

  

（2）哪些运算符不能重载

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

  这些运算符都不能被重载：.  . *  ::  ?: sizeof

   答案选：C

  

（3）拷贝构造函数

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

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

   答案选：D

  拷贝构造函数是一种特殊的构造函数，它用于创建一个新对象，该对象的内容是另一个已存在的对象的复制。 它被用来初始化新对象，以复制现有对象的内容。

  拷贝构造函数的名称与类名相同，但是没有返回值。

  拷贝构造函数通常有两个参数：一个是对现有对象的引用，另一个是分配给新对象的内存空间。

  并非每个类都必须有一个显式的拷贝构造函数。编译器会自动生成一个缺省的拷贝构造函数，如果没有定义拷贝构造函数。所以选择D。

  

（4）const类型

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

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

   答案选：C

  const void print();：这个函数声明表示一个名为print的函数，它返回void类型（即没有返回值），并且是一个常成员函数，这意味着这个函数不会修改类的任何数据成员。

  void const print();：这个函数声明与第一个类似，也是表示一个名为print的函数，它返回void类型，并且是一个常成员函数。这个声明的含义与第一个相同。

  void print() const;：这个函数声明表示一个名为print的函数，它返回void类型，并且是一个常成员函数。这个声明符合常成员函数的语法规则，因此它是正确的。注意：此时的const修饰this指针，表明在该成员函数中不能修饰非静态成员变量。

  void print(const);：这个函数声明表示一个名为print的函数，它接受一个名为const的参数，并且返回void类型。这个声明不符合常成员函数的语法规则，因此它是错误的。常成员函数不应该有参数。所以答案选C。

  

（5）函数重载

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

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

   答案选：C

   函数重载： 是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表(参数个数 或 类型 或 类型顺序)不同 ，常用来处理实现功能类似数据类型不同的问题。

   重载函数是指在同一作用域内，可以有一组具有相同名字但是参数列表不同的函数，这组函数被称为重载函数。 在调用重载函数时，编译器会根据调用时提供的实参的个数、类型和顺序来选择合适的重载函数版本进行调用。因此，参数个数、参数类型和函数名称都可以作为重载函数的调用的依据，而函数类型不是。

  

（6）构造函数

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

   答案选：B

  当你创建一个对象数组时，a[5]中一共有5对象，所以系统会先调用该类的构造函数5次。然后再创建一个指针数组，其中的指针都指向一个类对象，因为类型是指针，所以不会调用该类的构造函数。所以一共调用了5次构造函数。

  

（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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

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

   答案选：C

  这个C++程序创建了一个Container类，这个类初始化了两个Printer对象：a和b。而Printer类的构造函数接受一个字符串参数，并打印这个字符串。

  现在的问题是，当创建Container对象c时，a和b的初始化顺序是怎样的？

  成员初始化的顺序是按照它们在类中的声明顺序。 因此，a会先于b被初始化。因此，打印出的顺序应该是“ab”。

  所以，程序的输出是ab。

  

（8）空类的大小

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

   答案选：B

  在32位系统中，每个对象都会有一个内存地址，即使这个对象是空的。因此，即使是一个空的类A，sizeof(A)的值也会大于0，于是就用1来表示这里有一个空类。

   根据C++的标准，sizeof(A)返回的是类A在内存中的大小，这个大小至少应该包含一个指针，即至少为4字节（32位系统的指针大小）。然而，由于类A是空的，没有任何成员变量，因此sizeof(A)的值实际上为1，即一个指针的大小。所以答案选B。

  

（9）程序分析

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

#include
#include
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;
}

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

  A. 21    B. 15
  C. 9      D. 36

   答案选：B

  递归分析：fun(A(0))+fun(A(1))+fun(A(2))+fun(A(3))+fun(A(4))=15。

  

（10）程序分析

  以下程序输出是____。

#include 
using namespace std;
int main(void)
{
	const int a = 10;
	int * p = (int *)(&a);
	*p = 20;
	cout<<"a = "<<a<<", *p = "<<*p<<endl;
	return 0;
}
1
2
3
4
5
6
7
8
9
10

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

   答案选：D

  C++中const修饰变量，如果该变量已经是一个常量，那么const还具有替换的作用。编译器在编译带没带时候，在程序中看到对常量中内容读取时，会直接使用常量中的内容替换该常量。

            

编程题 day10

井字棋

井字棋

  井字棋有四种情况表示当前玩家获胜，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();
        //检查每一行的和是是否等于row
        int i, j, sum;
        for (i = 0; i < row; i++) {
            sum = 0;
            for (j = 0; j < row; j++) {
                sum += board[i][j];
            }
            if (sum == row)
                return true;
        }
        //检查每一列的和是是否等于row
        for (i = 0; i < row; i++) {
            sum = 0;
            for (j = 0; j < row; j++) {
                sum += board[j][i];
            }
            if (sum == row)
                return true;
        }
        //检查主对角线的和是是否等于row
        sum = 0;
        for (i = 0; i < row; i++) {
            sum += board[i][i];
        }
        if (sum == row)
            return true;
        //检查副对角线的和是是否等于row
        sum = 0;
        for (i = 0; i < row; i++) {
            sum += board[i][row - i - 1];
        }
        if (sum == row)
            return true;
        return false;
    }
};
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

  

密码强度等级

密码强度等级

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

#include 
#include 
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;
}
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
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72