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

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

概念查考

1. 下面哪种面向对象的方法可以让你变得富有( )
   A: 继承  B: 封装  C: 多态  D: 抽象
2. ( )是面向对象程序设计语言中的一种机制。这种机制实现了方法的定义与具体的对象无关，
   而对方法的调用则可以关联于具体的对象。
   A: 继承  B: 模板  C: 对象的自身引用  D: 动态绑定
3. 面向对象设计中的继承和组合，下面说法错误的是？（）
   A：继承允许我们覆盖重写父类的实现细节，父类的实现对于子类是可见的，是一种静态复
   用，也称为白盒复用
   B：组合的对象不需要关心各自的实现细节，之间的关系是在运行时候才确定的，是一种动
   态复用，也称为黑盒复用
   C：优先使用继承，而不是组合，是面向对象设计的第二原则
   D：继承可以使子类能自动继承父类的接口，但在设计模式中认为这是一种破坏了父类的封
   装性的表现
4. 以下关于纯虚函数的说法,正确的是( )
   A：声明纯虚函数的类不能实例化对象  B：声明纯虚函数的类是虚基类
   C：子类必须实现基类的纯虚函数  D：纯虚函数必须是空函数
5. 关于虚函数的描述正确的是( )
   A：派生类的虚函数与基类的虚函数具有不同的参数个数和类型  B：内联函数不能是虚函数
   C：派生类必须重新定义基类的虚函数  D：虚函数可以是一个static型的函数
6. 关于虚表说法正确的是（ ）
   A：一个类只能有一张虚表
   B：基类中有虚函数，如果子类中没有重写基类的虚函数，此时子类与基类共用同一张虚表
   C：虚表是在运行期间动态生成的
   D：一个类的不同对象共享该类的虚表
7. 假设A类中有虚函数，B继承自A，B重写A中的虚函数，也没有定义任何虚函数，则（ ）
   A：A类对象的前4个字节存储虚表地址，B类对象前4个字节不是虚表地址
   B：A类对象和B类对象前4个字节存储的都是虚基表的地址
   C：A类对象和B类对象前4个字节存储的虚表地址相同
   D：A类和B类虚表中虚函数个数相同，但A类和B类使用的不是同一张虚表
8. 下面程序输出结果是什么? （）

class A {
public:
	A(const char* s) { cout << s << endl; }
	~A() {}
};

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

class C :virtual public A
{
public:
	C(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

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

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

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

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: 以上都不正确

解析

1. A。继承是复用父类的成员和接口；封装是对外只提供接口隐藏内部的细节；多态是因继承而产生的相关不同类；抽象是提取出对象的共同特性。从父亲的手中继承财富，是让我变富有的方法，故选A。
2. D。理解题意，方法的定义与具体的对象无关，类和抽象类都可以办到；重点是方法的调用则可以关联于具体的对象，这明显是多态性；而多态分静态多态和动态多态，静态多态是由重载实现的，它要依靠对象的类型；而动态多态是程序运行时确定调用哪个函数，故选D。
3. C。软件设计中，优先使用组合而不是继承。因为继承破坏了父类的封装，耦合度较高；而组合仅提供接口，不展现细节，耦合度较低，故选C。
4. A。含有纯虚函数的类被称为抽象类，抽象类不能实例化对象，但可以由指针，故选A。
5. B。一个类在编译时就生成了一张虚函数表，而内联函数在编译时展开在原来位置，不生成对应地址，所以内联函数不能作为虚函数；静态成员函数是属于某个类而不是具体的对象，而虚函数会在程序运行时被特定的对象执行，故选B。
6. D。单继承情况下，一个类只会有一个虚表，而多继承下，子类会分别继承父类的虚表，可能有多个，A排除；子类如果没有重写虚函数，那它虚函数会和父类一致，但是它们两个的虚函数表是不同的，虚函数表中存的才是虚函数地址，B排除；虚表是编译期间就形成的，C排除；故选D。
7. 多态体系中，对象的内存模型前4字节（32位）存储的都是虚表地址，而非虚基表，虚基表是菱形虚拟继承中的概念，A、B排除；基类和子类的虚表地址不同，C排除；故选D。
8. 基类被继承时如果使用virtual关键字则基类为虚基类，若不使用virtual关键字，则基类为非虚基类；在一个成员初始化列表中同时出现对虚基类和非虚基类构造函数的调用时，虚基类的构造函数先于非虚基类的构造函数执行;且虚基类只能被实例化一次，故选A。
9. 多继承对象模型中，为了保证切片赋值（派生类对象可以赋值给基类的对象/基类的指针/基类的引用），派生类的指针和一个个继承的指针地址是一样的，但是解引用的结构是不一样的；而创建变量优先使用低地址，后使用高地址，所以p1=p3<p2，故选C。
10. p是B*的指针，去调用test函数，由于B类没有重写test函数，只有继承自A类的test函数，所以调用的是A类的test函数；在A类的test函数中，调用了func()，由于func是虚函数，实际调用的是B类的func函数；关键点在这里：当B类的func函数被调用时，默认参数值并不是B类中的0，而是A类中定义的默认参数值1，因为默认参数是在编译时解析的，解析默认参数时使用的是基类A的默认参数值，可以理解为虚函数重写的是实现而不是函数头。

问答题

1. 什么是多态？
2. 什么是重载、重写(覆盖)、重定义(隐藏)？
3. 多态的实现原理？
4. inline函数可以是虚函数吗？
5. 静态成员可以是虚函数吗？
6. 构造函数可以是虚函数吗？
7. 析构函数可以是虚函数吗？什么场景下析构函数是虚函数？
8. 对象访问普通函数快还是虚函数更快？
9. 虚函数表是在什么阶段生成的，存在哪的？
10. C++菱形继承的问题？虚继承的原理？
11. 什么是抽象类？抽象类的作用？

答案

1. 多态允许不同类型的对象执行相同的操作而表现出不同的行为，提高了代码的可复用性、灵活性和可维护性，是面向对象编程的重要特性之一。
2. 重载是位于同一作用域，函数名和参数相同的两个函数构成的；重写是分别位于基类和派生类作用域的两个函数，函数名、参数、返回值都相同构成重写；重定义是分别位于基类和派生类作用域的两个函数，函数名相同且不构成重写，它们就构成重定义。
3. 静态多态通过重载实现，在程序编译期间确定好调用哪个函数，进而实现多态；而动态多态由继承和虚函数实现，在程序编译期间，生成虚函数表，其中包含了虚函数的地址，到运行时，再根据对象的实际类型去确定调用哪个函数，进而实现多态。
4. 内联函数不能是虚函数，内联函数要求编译器在编译时确定函数调用的具体实现并进行展开；虚函数要求在运行时通过vtable进行函数调用，编译时无法确定具体的函数实现。
5. 不能，因为静态成员函数没有this指针，使用类型::成员函数
   的调用方式无法访问虚函数表，所以静态成员函数无法放进虚函数表。
6. 在调用构造函数时，对象的虚函数表（vtable）还没有完全建立，因为虚函数表是类对象的一部分，而对象还没有完全构造完成；虚函数依赖于虚函数表（vtable），它在对象构造之后才存在，如果构造函数是虚函数，那么在调用构造函数时还没有虚函数表，这会导致无法调用虚函数。
7. 析构函数可以是虚函数，并且最好把基类的析构函数定义成虚函数，编译器会自动把析构函数的函数名转换成统一的destructor，这时把析构函数定义成虚函数，就构成了重写，保证我们通过基类指针或引用删除派生类对象时，能完成对派生类部分的析构。
8. 访问普通成员函数更快，因为普通成员函数的地址在编译阶段就已确定，因此在访问时直接调用对应地址的函数，而虚函数在调用时，需要首先在虚函数表中寻找虚函数所在地址，因此相比普通成员函数速度要慢一些。
9. 虚函数表是在编译阶段就生成的，一般情况下存在代码段(常量区)的。
10. 菱形继承会产生二义性和数据冗余的问题。虚继承只建议存在于菱形虚拟继承中，最终的派生类对象中只有一份虚基类的部分，而非虚基类的部分中各有一份虚基表，虚基表中存的是与虚基类部分的指针偏移量；虚继承使得在整个派生类对象中虚基类的内容只有一份，很好地解决了二义性和数据冗余的问题。
11. 含有纯虚函数的类被称为抽象类。抽象类作为基类，要求它的派生类强制重写虚函数，否则无法实例化出对象；抽象类还体现出了接口继承关系。