笔试强训48天——day16

一. 单选

1.下列一段 C++ 代码的输出结果是（）

#include 
class Base{
public:
//重载
int Bar(char x){
return (int)(x);
} 
v
irtual int Bar(int x){
return (2 * x);
}
};
class Derived : public Base{
public:
int Bar(char x){
return (int)(-x);
} 
i
nt Bar(int x){
return (x / 2);
}
};
int main(void){
//多态
Derived Obj;
Base *pObj = &Obj;

printf("%d,", pObj->Bar((char)(100)));
printf("%d,", pObj->Bar(100));
} 
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

A 100，-100
B 100，50
C 200，-100
D 200，50
正确答案：B

第一个没有构成虚函数重写，所以是去调父类的实现
第二个子类构成虚函数重写，并且构成多态，所以会去调子类的实现

 

2. 关于函数的描述正确的是（）

A 虚函数是一个static型的函数
B 派生类的虚函数与基类的虚函数具有不同的参数个数和类型
C 虚函数是一个非成员函数
D 基类中说明了虚函数后，派生类中起对应的函数可以不必说明为虚函数

正确答案：D

 

3. 代码执行后，a和b的值分别为?

class Test{
public:
int a;
int b;
virtual void fun() {}
Test(int temp1 = 0, int temp2 = 0)
{
a=temp1 ;
b=temp2 ;
}
  i
nt getA()
{
return a;
} 
i
nt getB()
{
return b;
}
};
int main()
{
Test obj(5, 10);
// Changing a and b
int* pInt = (int*)&obj;

*(pInt+0) = 100;
*(pInt+1) = 200;
cout << "a = " << obj.getA() << endl;
cout << "b = " << obj.getB() << 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

A 200 10
B 5 10
C 100 200
D 100 10
正确答案：A

如果没有虚函数，修改的成员就是a和b
但是有了虚函数就多了一个虚表指针__vfptr
所以一开始修改的是a虚表指针，+1修改的才是a成员
所以b就不变，想要修改b需要+2

 

4. 当一个类的某个函数被说明为virtual，则在该类的所有派生类中的同原型函数_____?

A 只有 被重新说明时才识虚函数
B 只有被重新说明为virtual时才是虚函数
C 都不是虚函数
D 都是虚函数

正确答案：D

 

5. 下面有关虚函数和非虚函数的区别说法错误的是？

A 子类的指针访问虚函数访问的是子类的方法
B 子类的指针访问非虚函数访问的是子类的方法
C 父类的指针访问虚函数访问的是父类的方法
D 父类的指针访问非虚函数访问的是父类的方法
正确答案：C

子类访问都是访问的子类，与虚不虚没有关系
如果父类的虚函数被重写了，访问的会是子类的方法——多态
非虚——父类永远访问的是父类的

 

6.下列程序的输出结果：

#include 
using namespace std;
class A
{
 p
ublic:
void print()
{
cout << "A:print()";
}
};

 //私有继承
class B: private A
{ 
p
ublic:
void print()
{
cout << "B:print()";
}
};
class C: public B
{ 
p
ublic:
void print()
{
A:: print();
}
};
int main()
{C b;
b.print();
} 
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

A A:print()
B B:print()
C 编译出错
正确答案：C

B是私有继承，编译不通过，根本调不动

 

7. 以下关于C++的描述中哪一个是正确的（）

A 任何指针都必须指向一个实例
B 子类指针不可以指向父类实例
C 任何引用都必须指向一个实例
D 引用所指向的实例不可能无效

正确答案：C

指针可以定义成空指针
父子兼容——向上转换

A *pa = new B;
1

编译会出错，可以动态强转——向下转换

B *pb = dynamic_cast<B*>(new A);
1

引用必须初始化，不能空引用

释放ptr，引用也就无效了

int *ptr = new int(10);
int * &q = ptr;
delete ptr;
1
2
3

 

8. 下面关于多态性的描述，错误的是（）

A C++语言的多态性分为编译时的多态性和运行时的多态性
B 编译时的多态性可通过函数重载实现
C 运行时的多态性可通过模板和虚函数实现
D 实现运行时多态性的机制称为动态绑定
正确答案：C

模板与多态没有关系

 

9. 写出下面程序的输出结果

class A
{ public:
void FuncA()
{
printf( "FuncA called\n" );
} 
v
irtual void FuncB()
{
printf( "FuncB called\n" );
}
};
class B : public A
{public:
void FuncA()
{
A::FuncA();
printf( "FuncAB called\n" );
} 
v
irtual void FuncB()
{
printf( "FuncBB called\n" );
}
};
void main( void )
{
//多态
B b;
A *pa;
pa = &b;

A *pa2 = new A;

pa->FuncA();// 非虚——父
pa->FuncB(); //虚——子

 //只跟父类有关系
pa2->FuncA(); 
pa2->FuncB();
delete pa2;
} 
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

A FuncA called FuncB called FuncA called FuncB called
B FuncA called FuncBB called FuncA called FuncB called
C FuncA called FuncBB called FuncAB called FuncBB called
D FuncAB called FuncBB called FuncA called FuncB called

正确答案：B
 

10.在32位环境下，以上程序的输出结果是？

#include
using namespace std;
class Base
{ public:
virtual int foo(int x)
{
return x * 10;
} 
i
nt foo(char x[14])
{
//char *x 是指针，所以x是4字节大小
return sizeof(x) + 10;
}
};
class Derived: public Base
{
int foo(int x)
{
return x * 20;//100*20 = 2000
}
 v
irtual int foo(char x[10])
{

return sizeof(x) + 20;
}
} ;
int main()
{
Derived stDerived;
Base *pstBase = &stDerived;
char x[10];
printf("%d\n", pstBase->foo(100) + pstBase->foo(x));
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

A 2000
B 2004
C 2014
D 2024
正确答案：C
 

 

二. 编程

1. 完全数计算

链接

完全数（Perfect number），又称完美数或完备数，是一些特殊的自然数。
它所有的真因子（即除了自身以外的约数）的和（即因子函数），恰好等于它本身。

例如：28，它有约数1、2、4、7、14、28，除去它本身28外，其余5个数相加，1+2+4+7+14=28。
输入n，请输出n以内(含n)完全数的个数。

输入描述：
输入一个数字n
输出描述：
输出不超过n的完全数的个数

示例1:
输入
1000
输出
3

正确答案：

#include 
using namespace std;



int fun(int n)
{
    int count = 0,sum = 0;
    for(int i = 2;i<n ;i++)
    {
        for(int j = 1;j<i;j++)
        {
            if(i%j == 0)
            sum += j;
        }
        if(sum == i)
        count++;
        sum = 0;
    }
    return count;
}

int main() {
    int n,count;
    while(cin>>n)
    {
        count = fun(n);
        cout<<count<<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

 

2. 扑克牌大小

链接

扑克牌游戏大家应该都比较熟悉了，一副牌由54张组成，含3~A、2各4张，小王1张，大王1张。牌面从小到
大用如下字符和字符串表示（其中，小写joker表示小王，大写JOKER表示大王）：
3 4 5 6 7 8 9 10 J Q K A 2 joker JOKER
输入两手牌，两手牌之间用"-“连接，每手牌的每张牌以空格分隔，”-"两边没有空格，如：4 4 4 4-
joker JOKER。
请比较两手牌大小，输出较大的牌，如果不存在比较关系则输出ERROR。

基本规则：
（1）输入每手牌可能是个子、对子、顺子（连续5张）、三个、炸弹（四个）和对王中的一种，不存在其他
情况，由输入保证两手牌都是合法的，顺子已经从小到大排列；
（2）除了炸弹和对王可以和所有牌比较之外，其他类型的牌只能跟相同类型的存在比较关系（如，对子跟对
子比较，三个跟三个比较），不考虑拆牌情况（如：将对子拆分成个子）；
（3）大小规则跟大家平时了解的常见规则相同，个子、对子、三个比较牌面大小；顺子比较最小牌大小；炸
弹大于前面所有的牌，炸弹之间比较牌面大小；对王是最大的牌；
（4）输入的两手牌不会出现相等的情况。

输入描述：
输入两手牌，两手牌之间用"-“连接，每手牌的每张牌以空格分隔，”-"两边没有空格，如 4 4 4 4-
joker JOKER。
输出描述：
输出两手牌中较大的那手，不含连接符，扑克牌顺序不变，仍以空格隔开；如果不存在比较关系则输出
ERROR。

示例1:
输入
4 4 4 4-joker JOKER
输出
joker JOKER
NOWCODER.COM

正确答案：

#include
#include
#include
using namespace std;
string FindMax(const string &line)
{
if(line.find("joker JOKER") != string::npos)
return "joker JOKER";
int dash = line.find('-');
//分开两手牌
string car1 = line.substr(0, dash);
string car2 = line.substr(dash+1);
//获取两手牌的张数
int car1_cnt = count(car1.begin(), car1.end(), ' ') + 1;
int car2_cnt = count(car2.begin(), car2.end(), ' ') + 1;
//获取两手牌的各自第一张牌
string car1_first = car1.substr(0, car1.find(' '));
string car2_first = car2.substr(0, car2.find(' '));
if(car1_cnt == car2_cnt) //两手牌的类型相同
{
    string str = "345678910JQKA2jokerJOKER";
if(str.find(car1_first) > str.find(car2_first))
return car1;
return car2;
} if(car1_cnt == 4) //说明是炸弹
return car1;
else if(car2_cnt == 4)
return car2;
return "ERROR";
} int main()
{
string line, res;
while(getline(cin, line))
{
res = FindMax(line);
cout<<res<<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