【C++】笔试训练（九）_6.某函数声明如下: void func(int & nval1);

一、选择题

1、某函数申明如下

void Func(int& nVal1);
1

有int a,下面使用正确的为（）
A Func(a)
B Func(&a)
C Func(*a)
D Func(&(*a))

答案：A

2、C++语言中，类ClassA的构造函数和析构函数的执行次数分别为（）

ClassA* pclassa = new ClassA[5];
delete pclassa;
1
2

A 5,1
B 1,1
C 5,5
D 1,5

答案：A
解析：
1.malloc/calloc/realloc---->free
2.new ----> detele
3.new[] ----> detele
这三种申请空间的方式一定要匹配使用，否则程序可能会产生内存泄露，或者程序可能会崩溃
new T
1.调用operator new(size) 申请空间 ----> 内部是调用malloc循环申请
2.调用T的构造函数对申请的空间进行初始化
delete P
1.调用析构函数释放p指向对象中的资源
2.调用operator delete释放p所指向的空间 ----> 内部真正释放空间的是调用free
注意：new只能申请单个元素的空间，delete只能释放单个元素的空间
new T[N]
1.调用operator new申请空间 ----> 也是调用operator new(size) 申请空间
2.调用N次T的构造函数
delete[] P
1.调用N次析构函数释放p指向的N个对象
2.调用operator delete释放空间 ----> 也是调用operator delete§
题目中使用delete pclassa;释放空间，只释放了p指向的空间中的一个对象，是不严谨的，运行中可能会产生程序崩溃

3、 动态内存分配（C语言中malloc，C++中的new）得到的存储区属于内存中的：
A 静态区
B 堆（heap）
C 栈（stack）
D 堆栈
E 内核内存
F 不确定

答案：B

4、下列静态数据成员的特性中，错误的是（）
A 引用静态数据成员时，要在静态数据成员名前加<类名>和作用域符号
B 说明静态数据成员时前边要加关键字static来修饰
C 静态数据成员在类体外进行初始化
D 静态数据成员不是所有对象所共有的

答案：D
解析：
静态数据成员(静态成员变量)：所有对象共享的，并不属于具体的某个对象----在类中声明，然后需要在类外单独进行定义，一定不能在构造函数的初始化列表的位置初始化----在类外访问静态成员变量时：对象.静态成员变量 或者 类名::静态成员变量

5、用class关键字定义的类，其成员默认的访问属性为（）
A private
B protected
C public
D 无定义

答案：A

6、在重载一个运算符为成员函数时，其参数表中没有任何参数，这说明该运算符是 （ ）
A 无操作数的运算符
B 二元运算符
C 前缀一元运算符
D 后缀一元运算符

答案：C
解析：
一元运算符：指的是该元素只需要一个参数，比如：++、- -
成员函数：每个非静态的成员函数都有一个隐藏的this指针
比如：Dete& operator++() 前置++
           Date operator++(int) 后置++

7、有如下程序：

#include<iostream>
using namespace std;
class MyClass {
public:
    MyClass(int i = 0) { cout << 1; }
    MyClass(const MyClass& x) { cout << 2; }
    MyClass& operator=(const MyClass& x) { cout << 3; return*this; }
    ~MyClass() { cout << 4; }
};
int main() {
    MyClass obj1(1), obj2(2), obj3(obj1);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

运行时的输出结果是
A 121,444
B 112,444
C 11,114,444
D 11,314,445
E 11,314,444

答案：B

8、下面有关c++静态数据成员，说法正确的是（）
A 不能在类内初始化
B 不能被类的对象调用
C 不能受private修饰符的作用
D 可以直接用类名调用

答案：D
解析：
静态数据成员(静态成员变量)：所有对象共享的，并不属于具体的某个对象----在类中声明，然后需要在类外单独进行定义，一定不能在构造函数的初始化列表的位置初始化----在类外访问静态成员变量时：对象.静态成员变量 或者 类名::静态成员变量
有个特殊：const修饰的，可以在类内初始化
class A
{
private:
      const static int a = 10;
      static int b;
};
int A::b = 20;

9、在C++中，为了让某个类只能通过new来创建（即如果直接创建对象，编译器将报错），应该（）
A 将构造函数设为私有
B 将析构函数设为私有
C 将构造函数和析构函数均设为私有
D 没有办法能做到

答案：B
解析：
A类：假设A类的构造函数是私有的
在类外：A* pa = new A[];这是错误的
new原理：1.申请空间
                  2.调用构造函数对申请的空间进行初始化
假设A类的构造函数是私有的，就不能在构造函数对申请的空间进行初始化，第二步就不能完成了
创建对象期间，只需要申请空间，operator new这个函数就已经处理了。
delete pa;
delete原理：1.调用A类的析构函数
                     2.释放空间
把析构函数设成私有的，第一步就不能完成了，但是，我们可以给A类增加一个公有的方法：void Release(A*& p) { delete p; }

10、下列的模板声明中，其中几个是正确的（）
1)template
2)template<T1,T2>
3)template<class T1,T2>
4)template<class T1,class T2>
5)template<typename T1,T2>
6)template<typename T1,typename T2>
7)template<class T1,typename T2>
8)<typename T1,class T2>
A 2
B 3
C 4
D 5

答案：B
解析：template< class T >、template< typename T >、template< class T1, class T2 >这三种是正确的
其中4、6、7是正确的

二、编程题

1、另类加法

入口：题目链接

题目描述：

题目解析：
本题的意思是自己实现加法，不用现成的运算符

解题思路：
本题可以通过位运算实现，具体实现：两个数求和，其实就是求和后当前位的数据+两个数求和的进位
例如：
1 + 2： 00000001 + 00000010
求和后当前位的数据： 00000011 ； 求和后的进位数据： 没有进位，则 00000000
两者相加，则得到： 00000011 就是3
2 + 2： 00000010 + 00000010
求和后当前位的数据： 00000000， 1和1进位后当前为变成0了
求和后进位的数据： 00000100， 两个1求和后进位了
相加后得到： 00000100 就是4
求和后当前位的数据：简便的计算方法就是两个数进行异或 00000001 ^ 00000010 -> 00000011
求和后进位的数据：简便的计算方法就是两个数相与后左移一位 (00000010 & 00000010) << 1
所以这道题使用递归更加容易理解

代码展示：

class UnusualAdd {
public:
    int addAB(int A, int B) {
        if (B == 0)return A;
        if (A == 0)return B;
        int a = A ^ B;//求和后当前位的数据
        int b = (A & B) << 1;//求和后进位的数据
        return addAB(a, b);//递归两个数进行相加，任意为0时截止
    }
};
1
2
3
4
5
6
7
8
9
10

2、走方格的方案数

入口：题目链接

题目描述：

题目解析：
本题为求取路径总数的题目，一般可以通过递归求解，对于复杂的问题，可以通过动态规划求解。

解题思路：
| 1 | 2 | 3 |
| 4 | 5 | 6 |
| 7 | 8 | 9 |
对于上面的n * m(3 * 3)的格子，有两种情况
a. 如果n或者m为1，则只有一行或者一列，从左上角走到右下角的路径数为n + m
比如： 1 * 1格子，可以先向下走，再向右走，到达右下角；或者先向右走，再向下走，到达右下角，共两条，即 1 + 1 = 2，对于1 * m和 n * m的情况同学们自己画一下
b. 如果n,m都大于1，那么走到[n][m]格子的右下角只有两条路径，
<1>: 从[n - 1][m]格子的右下角向下走，到达
<2>: 从[n][m - 1]格子的右下角向右走，到达
所以走到[n][m]格子的右下角的数量为[n-1][m] + [n][m - 1],可以通过递归实现，情况a为递归的终止条件

递归代码展示：

#include <iostream>
using namespace std;
int pathnum(int n, int m)
{
    if (n == 0 || m == 0)
    {
        return 1;
    }
    return pathnum(n - 1, m) + pathnum(n, m - 1);
}

int main() 
{
    int n, m;
    while (cin >> n >> m)
    {
        cout << pathnum(n, m) << endl;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

动态规划代码展示：

#include <iostream>
#include <vector>
using namespace std;
int pathnum(int n, int m)
{
    vector<vector<int>> dp(n + 1, vector<int>(m + 1, 1));
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= m; j++)
        {
            dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
        }
    }
    return dp[n][m];
}

int main() {
    int n, m;
    while (cin >> n >> m)
    {
        cout << pathnum(n, m) << endl;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23