笔试强训48天——day15

一. 单选

1. 在公有派生的情况下，派生类中定义的成员函数只能访问原基类的()

A 公有成员和私有成员
B 私有成员和保护成员
C 公有成员和保护成员
D 私有成员,保护成员和公有成员

正确答案：C

私有：类里类外都不能访问

 

2.有如下C++代码：

struct A{
void foo(){printf("foo");}
virtual void bar(){printf("bar");}
A(){bar();}
};
struct B:A{
void foo(){printf("b_foo");}
void bar(){printf("b_bar");}
};
1
2
3
4
5
6
7
8
9

那么

A *p = new B;
p->foo();
p->bar();
1
2
3

输出为（）
A barfoob_bar
B foobarb_bar
C barfoob_foo
D foobarb_fpp
正确答案：A

先构造A类：A(){bar();}
没有虚函数父类调用父类：void foo(){printf(“foo”);}
有虚函数调用父类用子类方法实现：void bar(){printf(“b_bar”);}

 

3. 关于抽象类和纯虚函数的描述中，错误的是

A 纯虚函数的声明以“=0;”结束
B 有纯虚函数的类叫抽象类，它不能用来定义对象
C 抽象类的派生类如果不实现纯虚函数，它也是抽象类
D 纯虚函数不能有函数体

正确答案：D

 

4.以下程序输出结果是（）

class A
{ public:
virtual void func(int val = 1)
{ std::cout<<"A->"<<val <<std::endl;}
virtual void test()
{ func();}
};
class B : public A
{ public:
void func(int val=0) {std::cout<<"B->"<<val <<std::endl;}
};
int main(int argc ,char* argv[])
{
B*p = new B;
p->test();
return 0;
} 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

A A->0
B B->1
C A->1
D B->0
正确答案：B

考察多态

 

5. 下面程序的输出是（）

class A
{ p
ublic:
void foo()
{
printf("1");
}
 v
irtual void fun()
{
printf("2");
}
};
class B: public A
{ 
p
ublic:
void foo()
{
printf("3");
} 
v
oid fun()
{
printf("4");
}
};
int main(void)
{
A a;
B b;
A *p = &a;
p->foo();
p->fun();
p = &b;
p->foo();
p->fun();
A *ptr = (A *)&b;
ptr->foo();
ptr->fun();
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

A 121434
B 121414
C 121232
D 123434
正确答案：B

 

6.如果类B继承类A，A::x()被声明为虚函数，B::x()重载了A::x()方法，在下述语句中哪个x()方法会被调用（）

B b;
b.x();
A A::x()
B B::x()
C A::x() B::x()
D B::x() A::x()

正确答案：B

b里的x就用B调

 

7. 下面关于虚函数的描述，错误的是

A 在成员函数声明的前面加上virtual修饰，就可把该函数声明为虚函数
B 基类中说明了虚函数后，派生类中对应的函数也必须说明为虚函数
C 虚函数可以是另一个类的友元函数，但不能是静态成员函数
D 基类中说明的纯虚函数在其任何需要实例化的派生类中都必须实现

正确答案：B

基类必须写virtual，子类可写可不写，但规范还是得写

 

8. 下列为纯虚函数的正确声明的是（）

A void virtual print()=0;
B virtual void print()=0;
C virtual void print(){};
D virtual void print();
正确答案：B

 

9.下面这段代码运行时会出现什么问题？

class A
{
 p
ublic:
void f()
{
printf("A\n");
}
};
class B: public A
{ p
ublic:
virtual void f()
{
printf("B\n");
}
};
int main()
{
A *a = new B;
a->f();
delete a;
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

A 没有问题，输出B
B 不符合预期的输出A
C 程序不正确
D 以上答案都不正确
正确答案：B

 

10.下面这段代码会打印出什么？

class A
{ 
p
ublic:
A()
{
printf("A ");
} 
~
A()
{
printf("deA ");
}
};
class B
{ 
p
ublic:
B()
{
printf("B ");
} 
~
B()
{
printf("deB ");
}
};
class C: public A, public B
{ p
ublic:
C()
{
printf("C ");
} ~
C()
{
printf("deC ");
}
};
int main()
{
A *a = new C();
delete a;
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

A A B C deA
B C A B deA
C A B C deC
D C A B deC
正确答案：A

 

二. 编程

1. 查找输入整数二进制中1的个数

链接

输入一个正整数，计算它在二进制下的1的个数。
注意多组输入输出！！！！！！

示例1:
输入
5
输出
2
说明
5的二进制表示是101，有2个1

示例2:
输入
0
输出
0

正确答案：

#include
using namespace std;
int Count(size_t value)
{
int count = 0;
while(value)
{
value &= (value-1); //表达式只跟1的个数有关系，跟1所在的位置无关
count++;
} return count;
} int main()
{
size_t value; //unsigned int
int one_count = 0;
while(cin >> value)
{
one_count = Count(value);
cout<<one_count<<endl;
} return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

 

2. 手套

链接

在地下室里放着n种颜色的手套，手套分左右手，但是每种颜色的左右手手套个数不一定相同。A先生现在要出门，所以他要去地下室选手套。但是昏暗的灯光让他无法分辨手套的颜色，只能分辨出左右手。所以他会
多拿一些手套，然后选出一双颜色相同的左右手手套。现在的问题是，他至少要拿多少只手套(左手加右手)，
才能保证一定能选出一双颜色相同的手套。
给定颜色种数n(1≤n≤13),同时给定两个长度为n的数组left,right,分别代表每种颜色左右手手套的数量。数据
保证左右的手套总数均不超过26，且一定存在至少一种合法方案。

测试样例：
4,[0,7,1,6],[1,5,0,6]
返回：10(解释：可以左手手套取2只，右手手套取8只)

正确答案：

class Gloves {
public:
int findMinimum(int n, vector<int> left, vector<int> right) {
int left_sum = 0, left_min = INT_MAX;
int right_sum = 0, right_min = INT_MAX;
int sum = 0;
//遍历每一种颜色的左右手套序列
for(int i=0;i<n;i++){
//对于有0存在的颜色手套，累加
if(left[i]*right[i]==0)
sum += left[i] + right[i];
//对于左右手都有的颜色手套，执行累加-最小值+1
//找到最小值和总数
else{
left_sum += left[i];
right_sum += right[i];
left_min = min(left_min, left[i]);
right_min = min(right_min, right[i]);
}
} 
//结果为有左右都有数量的手套序列的结果+有0存在的手套数+最后再加一肯定就能保证了
return sum + min(left_sum-left_min+1, right_sum-right_min+1) + 1;
}
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24