C++——继承和多态常见的面试问题

对于继承和多态有不清楚的老铁可以看下面两篇文章
继承博客
多态博客

1. 继承和多态常见的面试问题

1.1 概念查考

1. 下面哪种面向对象的方法可以让你变得富有( A )
   A: 继承
   B: 封装
   C: 多态
   D: 抽象

2. ( D )是面向对象程序设计语言中的一种机制。这种机制实现了方法的定义与具体的对象无关，而对方法的调用则可以关联于具体的对象。
   A: 继承
   B: 模板
   C: 对象的自身引用
   D: 动态绑定
   分析：动态绑定也叫多态

3. 面向对象设计中的继承和组合，下面说法错误的是？（C）
   A：继承允许我们覆盖重写父类的实现细节，父类的实现对于子类是可见的，是一种静态复用，也称为白盒复用
   B：组合的对象不需要关心各自的实现细节，之间的关系是在运行时候才确定的，是一种动态复用，也称为黑盒复用
   C：优先使用继承，而不是组合，是面向对象设计的第二原则
   D：继承可以使子类能自动继承父类的接口，但在设计模式中认为这是一种破坏了父类的封装性的表现
   分析：优先使用组合，详情参考继承博客中对于继承的总结与反思

4. 以下关于纯虚函数的说法,正确的是( A )
   A：声明纯虚函数的类不能实例化对象
   B：声明纯虚函数的类是虚基类
   C：子类必须实现基类的纯虚函数
   D：纯虚函数必须是空函数
   分析：
   A.正确
   B.有纯虚函数的类叫抽象类，它不能用来定义对象，一般用于接口的定义
   C.子类不必实现父类所有的纯虚函数
   D.纯虚函数可以有函数体，只是意义不大

5. 关于虚函数的描述正确的是( B )
   A：派生类的虚函数与基类的虚函数具有不同的参数个数和类型
   B：内联函数不能是虚函数
   C：派生类必须重新定义基类的虚函数
   D：虚函数可以是一个static型的函数
   分析：
   A.既然是继承下来的那么参数个数和类型以及返回值都是一样的。
   B.正确
   C.可以不重新定义
   D.静态成员函数没有隐藏的this指针，可以通过类名::成员函数名 直接调用，此时没有this无法拿到虚表，就无法实现多态，因此不能设置为虚函数

6. 关于虚表说法正确的是（ D ）
   A：一个类只能有一张虚表
   B：基类中有虚函数，如果子类中没有重写基类的虚函数，此时子类与基类共用同一张虚表
   C：虚表是在运行期间动态生成的
   D：一个类的不同对象共享该类的虚表
   分析：
   A.一个类如果是多继承会有多张虚表，
   B.子类是子类的虚表、基类是基类的虚表、即使虚表内虚函数相同，都是基类的虚函数，但是是两份虚表
   C.虚函数表是在编译阶段就生成的，在构造函数初始化列表中进行初始化(虚表指针)。
   D.正确

7. 假设A类中有虚函数，B继承自A，B重写A中的虚函数，也没有定义任何虚函数，则（ D ）
   A：A类对象的前4个字节存储虚表地址，B类对象前4个字节不是虚表地址
   B：A类对象和B类对象前4个字节存储的都是虚基表的地址
   C：A类对象和B类对象前4个字节存储的虚表地址相同
   D：A类和B类虚表中虚函数个数相同，但A类和B类使用的不是同一张虚表
   分析：
   对于A、B、C选项：A类和B类前四个字节都是虚表地址，但地址不同。

8. 下面程序输出结果是什么? （A）

#include
using namespace std;
class A {
public:
	A(const char* s) { cout << s << endl; }
	~A() {}
};

class C :virtual public A
{
public:
	C(const char* s1, const char* s2) :A(s1) { cout << s2 << endl; }
};


class B :virtual public A
{
public:
	B(const char* s1, const char* s2) :A(s1) { cout << s2 << endl; }
};


class D :public B, public C
{
public:
	D(const char* s1, const char* s2,const char* s3, const char* s4) :  B(s1, s2), C(s1, s3), A(s1)
	{
		cout << s4 << endl;
	}
};

int main() {
	D* p = new D("class A", "class B", "class C", "class D");
	delete p;
	return 0;
}

A：class A class B class C class D
B：class D class B class C class A
C：class D class C class B class A
D：class A class C class B class D
分析：
B和C都是虚继承，D继承B和C那么D也是虚继承，整个继承体系就一份A
针对D对象，对于A的初始化不在B也不在C中，所以初始化列表的B、C、A中，首先应该初始化的就是A。
然后由于class D :public B, public C那么D继承的顺序就是初始化列表的初始化顺序，
所以接下来是B，然后是C，最后打印D类中的cout << s4 << endl;初始化就结束了。

9. 多继承中指针偏移问题？下面说法正确的是( C )

class Base1 { public: int _b1; };
class Base2 { public: int _b2; };
class Derive : public Base1, public Base2 { public: int _d; };
int main() {
	Derive d;
	Base1* p1 = &d;
	Base2* p2 = &d;
	Derive* p3 = &d;
	return 0;
}

A：p1 == p2 == p3
B：p1 < p2 < p3
C：p1 == p3 != p2
D：p1 != p2 != p3

分析:p1和p2虽然都是其父类，但在子类内存模型中，其位置不同，所以p1和p2所指子类的位置也不相同，因此p1!=p2,
由于p1对象是第一个被继承的父类类型，所以其地址与子类对象的地址p3所指位置都为子类对象的起始位置，因此p1==p3,所以C正确

10. 以下程序输出结果是什么（B）

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
E: 编译出错
F: 以上都不正确

分析：首先父子类中的func符合重写(返回值、函数名、参数列表(只看类型，不用管缺省值)相同），又都是虚函数，
然后子类B继承了父类A的test()函数，当p->test()时，通过test()调用func函数，但是这个test()是从父类继承过来的，里面的this指针是A*，此时this->func()，正好就是父类的指针或者引用去调用，所以构成多态调用。多态调用就跟指针/引用指向的对象有关了，整个过程在B类中，所以此时指向的对象是B，调用B的func函数。
然后接口继承（参数、缺省值、函数名…有关接口的都一样）完全继承于A，多态调用只改变的是实现，所以打印出来的结果是B->1

1.2 问答题

1.什么是多态？

• 静态绑定又称为前期绑定(早绑定)，在程序编译期间确定了程序的行为，也称为静态多态，比如：函数重载
• 动态绑定又称后期绑定(晚绑定)，在程序运行期间，根据具体拿到的类型确定程序的具体行为，调用具体的函数，也称为动态多态。

2.什么是重载、重写(覆盖)、重定义(隐藏)？

答：

3.多态的实现原理？

答：要达到多态，有两个条件，一个是虚函数覆盖，一个是对象的指针或引用调用虚函数。满足多态以后的函数调用，不是在编译时确定的，是运行起来以后到对象中的虚表指针，通过虚表找到要调用虚函数的实现，从而完成多态的正确调用。
具体可以参考该博客多态博客链接

4.inline函数可以是虚函数吗？

答：可以，不过编译器就忽略inline属性，这个函数就不再是inline，因为虚函数要放到虚表中去。inline是建议性关键字，多态调用就没有inline属性了。普通调用继续可以保持inline属性。

5.静态成员可以是虚函数吗？

答：不能，因为静态成员函数没有this指针，使用类型::成员函数的调用方式无法访问虚函数表，所以静态成员函数无法放进虚函数表。

6.构造函数可以是虚函数吗？

答：不能，因为对象中的虚函数表指针是在构造函数初始化列表阶段才初始化的。
把构造函数都变为虚函数了，谁来初始化虚表指针呢？而且这样做也没有意义。

7.析构函数可以是虚函数吗？什么场景下析构函数是虚函数？

答：可以，并且最好把基类的析构函数定义成虚函数。

• 如果基类没有把析构函数变为虚函数，子类也没有设置，它俩只是继承关系，那么下面的例子中delete p1;和delete p2;只是普通调用。
  普通调用的话delete对于自定义类型：
  第一步：在空间上执行析构函数，完成对象中资源的清理工作
  第二步：调用operator delete函数释放对象的空间
  那么就会看到下面错误析构的场景
  
  delete看到谁的指针就只析构谁，那么这样的话p2所维护的Student那一部分没有被析构，就造成了内存泄漏。
• 当基类加上virtual的时候此时Person和Student就具有了多态的特性，这时使用delete的时候就是多态调用，那么多态调用的话，调用析构函数就跟指向的对象有关了，此时Person指针p2指向的对象是student，析构的时候会先析构派生类再析构基类。如下图所示：

class Person {
public:
	virtual ~Person() { cout << "~Person()" << endl; }
};
class Student : public Person {
public:
	virtual ~Student() { cout << "~Student()" << endl; }
};

int main()
{
	Person* p1 = new Person;
	Person* p2 = new Student;
	delete p1;
	delete p2;
	return 0;
}

所以实现父类的时候，可以无脑给析构函数加virtaul。

8.对象访问普通函数快还是虚函数更快？

答：
如果都是普通调用，是一样快的。
如果是指针对象或者是引用对象，则调用的普通函数快，因为调用虚函数构成多态，运行时需要到虚函数表中去查找。

9.虚函数表是在什么阶段生成的，存在哪的？

答：虚函数表是在编译阶段就生成的，一般情况下存在代码段(常量区)的。
在构造函数初始化列表中进行初始化(虚表指针)。

10.C++菱形继承的问题？虚继承的原理？

答：继承博客中有详细介绍哦。注意这里不要把虚函数表和虚基表搞混了。

11.什么是抽象类？抽象类的作用？

答：抽象类强制重写了虚函数，抽象类体现出了接口继承关系。

附加题：如何实现一个不能被继承的类？

1、把基类的构造函数设置为 私有（C++98）
有人会问，把析构设置为私有也行吗？在vs2019下，B* ptr = new B;其实析构设置为私有也是会报错的，但是在vs2013下B* ptr = new B;只是警告，而把构造设置为私有是都会报错的，所以想实现一个不能被继承的类，最好把基类的构造函数设置为私有。
2、类定义时 加final （C++11）

//class A final
class A final
{
//private:
	A()
	{}
};

class B : public A
{};

int main()
{
	B bb;
	//B* ptr = new B;

	return 0;
}