笔试强训48天——day7

一. 单选

1.在（）情况下适宜采用 inline 定义内联函数

A 函数体含有循环语句
B 函数体含有递归语句
C 函数代码少、频繁调用
D 函数代码多，不常调用

正确答案：C

内联函数
概念：inline修饰的函数称为内联函数
特性：在编译阶段，会将内联函数展开——将函数调用直接使用在函数体来进行替换
作用：少了函数调用参数压栈以及创建栈帧等开销——可以提高程序运行的效率
注意：inline是一个建议性的关键字——一般情况 建议：没有循环、没有递归、函数体不是很长

 

2.在 C++ 语言中，对函数参数默认值描述正确的是（）

A 函数带默认值的参数只能有一个
B 一个函数的参数若有多个，则参数默认值的设定可以不连续
C 函数参数必须设定默认值
D 在设定了参数的默认值后，该参数后面定义的所有参数都必须设定默认值
正确答案：D

缺省参数（默认参数）：在声明和定义函数是，可以给函数的参数带上一个默认值；在调用函数时，如果用户没有传递实参，则使用定义时所给的默认值，如果用户传递了实参，就使用用户传递的实参——备胎
全缺省参数：每个参数都有默认值
半缺省参数：部分参数具有默认值，并且默认值必须从右往左依次给出（必须连续）
void f(int a, int b=20, int c=10)编译成功
void f(int a=20, int b, int c=10)编译失败

 

3. 下面关于类定义的说法中，正确的是:

A 类定义中包括数据成员和函数成员的声明
B 类成员的缺省访问权限是保护的
C 数据成员必须被声明为私有的
D 成员函数只能在类体外进行定义
正确答案：A

A
类定义的两种方式：
1.可以将声明和成员函数的定义全部放在类中
2.类中只放成员变量和成员函数的声明，成员函数的定义可以放在.cpp文件中定义。注意：成员函数名前必须添加类名：：
B
class：默认访问权限private
struct：默认访问权限public
C
建议将成员变量设置为private，将成员函数设置为public
D过于绝对

 

4. 假定一个类的构造函数为A(int aa,int bb){a=aa–;b=a*bb;}，则执行A x(4,5);语句后，x.a和x.b的值分别为

（）
A 20和5
B 3和15
C 5和4
D 4和20
正确答案：D

构造函数体重给成员变量进行赋值

 

5. 下列关于构造函数的描述正确的是?

A 构造函数可以声明返回类型 没有返回值
B 构造函数不可以用private修饰
C 构造函数必须与类名相同
D 构造函数不能带参数 根据场景来

正确答案：C

一般情况下，构造函数的权限都是public，因为在类外创建对象是，编译器要调用构造函数
特殊：单例模式——一个类只能创建一个对象——将构造函数设置为private

 

6.有一个类A，其数据成员如下：则构造函数中，成员变量一定要通过初始化列表来初始化的是：______。

class A {
...
private:
int a;
public:
const int b;
float* &c;
static const char* d;
static double* e;
};

A a b c
B b c
C b c d e
D b c d
E b
F c
正确答案：B

初始化列表的位置才是真正的初始化，构造函数体中只是赋值
初始化列表中只能对类中非静态成员变量来进行初始化
必须在初始化列表位置初始化：
1.const修饰的成员变量
2.引用类型的成员变量
3.类类型对象，该类没有默认的构造函数

 

7.C++ 中，有如下类模板定义：已知 b1, b2 是 BigNumber 的两个对象，则下列表达式中错误的是（）

t

emplate<class T> class BigNumber{
long n;
public:
BigNumber(T i) :n(i) {}
BigNumber operator+(BigNumber b) {
return BigNumber(n + b.n);
}
};

A 3+3
B b1+3
C b1+b2
D 3+b1
正确答案：D

如果将运算符重载成类的成员函数，形参的个数要比该运算符需要的参数个数少1
因为成员函数具有隐藏的this指针
对BigNumber 的两个对象进行相加
3+3 本来就是整型的 + 本来就支持两个整型的相加
b1+3 如果类中具有单个参数的构造函数，该构造函数具有类型转换的功能。所以编译器在编译代码节点，会调用单参构造函数将3转换为BigNumber的对象
b1+b2 两个都是BigNumber的对象
3+b1 前面省略了一个this参数，所以第一个参数一定要是BigNumber的对象

 

8. 下面有关友元函数与成员函数的区别，描述错误的是？

A 友元函数可以让本类和友元类对象调用
B 友元函数和类的成员函数都可以访问类的私有成员变量或者是成员函数
C 类的成员函数是属于类的，调用的时候是通过指针this调用的
D 友元函数是有关键字friend修饰，调用的时候也是通过指针this调用的
正确答案：D

友元函数：不是类的成员函数——但是在友元函数中可以访问类中私有的成员
成员函数：具有隐藏的this 受访问限定符的月数，通过对象来调用

 

9.对于以下代码，说法正确的是（）

char * p = new char[100]；

A p 和 new出来的内存都在栈上
B p 和 new出来的内存都在堆上
C p在栈上 new出来的在堆上
D p在堆上 new出来的在栈上
正确答案：C

new：C++中用来从堆上从动态申请空间的，默认情况下，new底层调用的是operator new——>malloc
new默认情况下申请的空间在堆上
全局作用域中：p的空间在数据段
函数体中：p的空间在栈上

 

10. 类模板的使用实际上是类模板实例化成一个具体的__________。

A 类
B 函数
C 模板类
D 对象
正确答案：A

template<class T>
class SeqList
{
    public:
        SeqList()                            
        {}
        void push_back(const T& data)
        {...}
     private:
         T* array;
         int size;
         int capacity;
};

SeqList并不是类型，不能使用SeqList创建对象，因为SeqList只是类模板的名字

SeqList<int> s1;
SeqList<double> s2;

编译器在编译代码是，看到用户对类模板的实例化之后，编译器才会将类模板按照具体的类型生成一个具体的类出来

 

 

二. 编程

1. Fibonacci数列

做题链接

Fibonacci数列是这样定义的：
F[0] = 0
F[1] = 1
for each i ≥ 2: F[i] = F[i-1] + F[i-2]
因此，Fibonacci数列就形如：0, 1, 1, 2, 3, 5, 8, 13, …，在Fibonacci数列中的数我们称为Fibonacci数。给你
一个N，你想让其变为一个Fibonacci数，每一步你可以把当前数字X变为X-1或者X+1，现在给你一个数N求
最少需要多少步可以变为Fibonacci数。

输入描述：
输入为一个正整数N(1 ≤ N ≤ 1,000,000)
输出描述：
输出一个最小的步数变为Fibonacci数"

示例1:
输入
15
输出
2

思路：
找到距离N最近的两个fib数
一个小于N、一个大于N
N-left right-N

正确答案：

#include <iostream>
using namespace std;

int main() {
    int N,f,f1 = 0,f2 = 1;
    int left = 0,right = 0;
    cin>>N;
    while(1)
    {
        //求fib数
        f = f1 + f2;
        f1 = f2;
        f2 = f;

        if(f<N)
        {
            left = f;
        }
        else{
            right = f;
            break;
        }
    }
    cout<<min((N-left),(right-N))<<endl;
    return 0;
    
}
// 64 位输出请用 printf("%lld")
&nbsp;

 

2. 合法括号序列判断

做题链接

给定一个字符串A和其长度n，请返回一个bool值代表它是否为一个合法的括号串（只能由括号组成）。

测试样例：
“(()())”,6
返回：true
测试样例：
“()a()()”,7
返回：false
测试样例：
“()(()()”,7
返回：false
示例1:
输入
输出

思路：
匹配不成功：

1. 当前字符不是括号字符
2. 括号匹配不完整：
   多了左半边
   多出右半边
   遍历字符串，遇到左半边，压栈；遇到右半边则查看栈中是否有对应的左半边
   若没没有，栈为空，则表示匹配不完整，多出了右半边
   若右，则出栈与其匹配成为一个完整的括号，遍历完毕后如果栈不为空，表示多出了一个左半边

正确答案：

class Parenthesis {
public:
    bool chkParenthesis(string A, int n) {
        // write code here
        stack<char> sc;
        for(auto ch:A)
        {
            switch(ch)
            {
                case '(':
                sc.push(ch);
                break;
                case ')':
                if(sc.empty())
                {
                    return false;
                }
                sc.pop();
                break;
                default:
                return false;
            }
        }
        return sc.empty();
    }
};