🎇C++笔试强训

---

• 博客主页：一起去看日落吗
• 分享博主的C++刷题日常，大家一起学习
• 博主的能力有限，出现错误希望大家不吝赐教
• 分享给大家一句我很喜欢的话：夜色难免微凉，前方必有曙光 🌞。

---

💦🔥

---

选择题

💦第一题

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

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

在公有派生的情况下，派生类中定义的成员函数只能访问原基类的公有成员和保护成员，不可以访问私有成员

这道题的答案是C

---

💦第二题

有如下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");}
};

那么

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

输出为（）

A barfoob_bar
B foobarb_bar
C barfoob_foo
D foobarb_fpp

• p = new B; // A 的指针指向 B 的对象。
  当执行 new B 时，调用 B 的无参构造函数，由于 B 继承 A，所以先调用 A （父类）的构造函数，
  在 A 的构造函数中调用了虚函数 bar()，这时调用的是 A 的 bar()，输出打印bar
  此时B没有构造函数；
  p->foo(); 因为 foo() 不是虚函数，所以执行的是 A 的 foo()；
  p->bar(); 因为 bar() 是虚函数，所以执行的是 B 的 bar()。

这道题的答案是A

---

💦第三题

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

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

A 纯虚函数的声明以“=0;”结束,首先需要有虚函数，其次是函数，最后需要等于0

B 纯虚函数有了但没有函数体，因为虚表必须有地址，纯虚函数的类叫抽象类，它不能用来定义对象

C 抽象类的派生类如果不实现纯虚函数，它也是抽象类，假设有一个类继承Base，如果父类有纯虚，如果子类没有重写，仍然是一个抽象类

D 纯虚函数可以有函数体

这道题的答案是D

---

💦第四题

以下程序输出结果是（）

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

A A->0
B B->1
C A->1
D B->0

(1) 由于B类中没有覆盖（重写）基类中的虚函数test()，因此会调用基类A中的test()；
(2) A中test()函数中继续调用虚函数 fun()，因为虚函数执行动态绑定，p此时的动态类型（即目前所指对象的类型）为B*，因此此时调用虚函数fun()时，执行的是B类中的fun()；所以先输出“B->”；
(3) 缺省参数值是静态绑定，即此时val的值使用的是基类A中的缺省参数值，其值在编译阶段已经绑定，值为1，所以输出“1”；
最终输出“B->1”。所以大家还是记住上述结论：绝不重新定义继承而来的缺省参数值！

这道题的答案是B

---

💦第五题

下面程序的输出是（）

class A
{
public:
void foo()
{
	printf("1");
}
virtual void fun()
{
	printf("2");
}
};
class B: public A
{
public:
	void foo()
	{
		printf("3");
	}
	void 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;
}

A 121434
B 121414
C 121232
D 123434

把父类给指针，跟子类没有关系，所以会直接调用父类，所以会打印1 2 ，把子类的地址给父类的指针，foo没有虚不会形成多态，所以打印1，fun有虚，子类重写，所以打印4，把b的地址给ptr，和上面没有区别，父子兼容规则也会强转，所以也会打印1 4

这道题的答案是B

---

💦第六题

如果类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

---

💦第七题

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

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

基类中说明的虚函数，在派生类中自然就是虚函数，对于纯虚函数 必须在后面继承的派生类中给出具体的实现；静态成员函数不能进行动态联编，所以虚函数不能是静态的

这道题的答案是B

---

💦第八题

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

A void virtual print()=0;
B virtual void print()=0;
C virtual void print(){};
D virtual void print();

纯虚函数格式 —— 虚 返回值类型 函数 = 0

C 是定义

这道题的答案是B

---

💦第九题

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

class A
{
public:
	void f()
	{
		printf("A\n");
	}
};
class B: public A
{
public:
	virtual void f()
	{
		printf("B\n");
	}
};
int main()
{
	A *a = new B;
	a->f();
	delete a;
	return 0;
}

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

A中的f不是一个虚函数 a->f() 会调用A中的f函数
但是 a实际上是一个*B类型，delete a时 由于析构函数并不没有声明为虚函数，所以 delete a;调用了A的默认析构函数，导致內存溢出错误。

这道题的答案是B

---

💦第十题

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

class A
{
public:
	A()
	{
		printf("A ");
	}
	~A()
	{
		printf("deA ");
	}
};
class B
{
public:
	B()
	{
		printf("B ");
	}
	~B()
	{
		printf("deB ");
	}
};
class C: public A, public B
{
public:
	C()
	{
		printf("C ");
	}
	~C()
	{
		printf("deC ");
	}
};
int main()
{
	A *a = new C();
	delete a;
	return 0;
}

A A B C deA
B C A B deA
C A B C deC
D C A B deC

main函数中
A a创建A类的对象，调用A的构造函数，输出A
B b(a)创建B类的对象
B继承A先调用父类A的构造函数，再次输出A
继续调用B本身的构造函数，这里对象a已经存在，无需再构造无输出，但会调用A的拷贝构造函数，
所以b._a是a的拷贝，B本身的构造函数输出B
main函数调用结束返回时，释放顺序与构造顺序相反。
所以先释放变量b，调用子类析构函数 输出~B
析构上面提到的拷贝，也就是b._a，调用A的析构函数~A
然后父类析构函数
最后对象a调用A的析构函数

这道题的答案是A

---

编程题

🔥 第一题

链接：查找输入整数二进制中1的个数

• 解题思路

本题是计算一个数二进制表示中1的个数，通过（n >> i) & 1可以获取第i位的二进制值，每次n右移一位，可以获取一位的二进制值，右移32次，n变成0，循环终止。

• 代码演示

#include <iostream>
using namespace std;
//方法一，用概念解决
// int Count(size_t value)
// {
//     int count = 0;
//     while(value)
//     {
//         if(value % 2 == 1 )
//         {
//             count++;
//         }
//         value /= 2;
//     }
//     return count;
// }

//方法二，用位运算提高程序效率
// int Count(size_t value)
// {
//     int count = 0;
//     while(value)
//     {
//         if(value & 0x01 == 1 )
//         {
//             count++;
//         }
//         value >>= 1;
//     }
//     return count;
// }

//方法三，value = value & (value - 1)
int Count(size_t value)
{
    int count = 0;
    while(value)
    {
        if(value)
        {
            value &= (value - 1);//只和一的个数有关系，跟1所在的位置无关
            count++;
        }
    }
    return count;
}

int main() {
    size_t value;
    int one_count = 0;
    while(cin >> value)
    {
        one_count = Count(value);
        cout << one_count << endl;
    }
    return 0;
}

---

🔥 第二题

链接：手套

• 题目解析

本题的意思是随意取出的手套至少可以形成一组组合的最少手套数量。题目给的两个数组对应位置表示同一种颜色的左右手套数量。

• 解题思路

对于非0递增序列a1,a2…an，要想最终取值覆盖每一个种类 n = sum(a1…an) - a1 + 1（也就是总数减去最小值之后加一） 所以对于左右手手套颜色都有数量的序列，想要覆盖每一种颜色，则最小数量leftsum = 左边数量和 - 左边最小值 + 1， rightsum = 右边数量和 - 右边的最小值 + 1。而对于有0存在的，则需要做累加，保证覆盖每一种颜色。

• 代码演示

class Gloves {
public:
    int findMinimum(int n, vector<int> left, vector<int> right) {
        // write code here
        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++)
        {
            if(left[i] * right[i] == 0)//有一边手套为0，需要累加求和
            {
                sum += left[i] + right[i];
            }
            else
            {
                left_sum += left[i];
                left_min = left_min < left[i] ? left_min : left[i];
                right_sum += right[i];
                right_min = right_min < right[i] ? right_min : right[i];
            }
        }
        return sum + min(left_sum - left_min +1 , right_sum - right_min + 1) +1;
    }
};

---