【C++笔试强训】第十五天

创始人

2024-01-17 20:25:15

0次

💦🔥

选择题

💦第一题

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

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

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

💦第二题

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

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

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

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

D 纯虚函数可以有函数体

💦第四题

以下程序输出结果是（）

class A
{
public:
virtual void func(int val = 1){ std::cout<<"A->"< func();}
};
class B : public A
{
public:void func(int val=0) {std::cout<<"B->"<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”。所以大家还是记住上述结论：绝不重新定义继承而来的缺省参数值！

💦第五题

下面程序的输出是（）

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继承类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()

我觉得大家把重载，重写，重定义根本没有理解清楚。

重载是作用域相同，函数名相同，参数列表不同的两个函数构成重载。

重写是子类继承父类，并重写父类的虚函数，这要求函数名，返回值，参数列表必须和父类相同（协变例外）

重定义：两个父类和子类的同名函数不构成重写就是重定义。

这个题目说法就有问题。他说重载？没有重写父类的虚函数，就没办法重载，那样就成重定义了……

多态只发生在指针和引用，如果对于对象调用虚函数，在编译期间已经确定该函数了

💦第七题

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

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

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

💦第八题

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

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

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

C 是定义

💦第九题

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

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的默认析构函数，导致內存溢出错误。

💦第十题

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

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的析构函数

编程题

🔥 第一题

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

请添加图片描述

解题思路

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

代码演示

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

🔥 第二题

链接：手套