C++进阶--继承和多态常见题目

概念考查

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

这道题说哪种面向对象的方法可以让我们更富有，也就是东西更多，那么一定是继承无疑了，因为继承可以让我们获得所有父类的东西。

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

这道题的关键在于“方法的定义与具体的对象无关”这句话，选项里只有多态才满足这样的要求，当我们是父类指针的时候调用一个函数有可能调用的是父类的实现，有可能调用的是子类的实现，这要看指针里面存放的是什么类型的对象，如果不是多态那么父类指针只能调用父类的方法。

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

C选项错误的原因是优先使用对象组合，而不是类继承，通常可以看他们的关系是is a（每个派生类对象都是一个基类对象）还是has a（组合是has a的关系，假设B组合了A，那么每个B对象中都有一个A对象）

4. 以下关于纯虚函数的说法,正确的是(A )
   A：声明纯虚函数的类不能实例化对象?? B：声明纯虚函数的类是虚基类
   C：子类必须实现基类的纯虚函数 ??D：纯虚函数必须是空函数

纯虚函数不可以实例化出对象，声明纯虚函数的类是抽象类，如果不用子类可以不重写基类的纯虚函数，纯虚函数的函数体内可以实现，不一定必须是空函数。

5. 关于虚函数的描述正确的是(B )
   A：派生类的虚函数与基类的虚函数具有不同的参数个数和类型
   B：内联函数不能是虚函数
   C：派生类必须重新定义基类的虚函数
   D：虚函数可以是一个static型的函数

A：虚函数有三同，函数名相同，返回值相同，参数相同（协变和析构函数除外），协变就是返回值可以是具有父子关系的指针或引用，而析构函数由于编译器统一识别为destruct，所以即使每个类看着析构函数的函数名不同，但是却可以实现虚函数。B：内联函数不能成为虚函数，因为内联函数会被展开没有地址，而虚函数需要地址。C：派生类可以不重新定义基类的虚函数。D：虚函数不可以是static类型，因为虚函数需要this指针调用，而static类型的函数无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<iostream>
using namespace std;
class A{
public:
	A(char *s) { cout<<s<<endl; }
	~A(){}
};

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

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

class D:public B,public C
{
public:
	D(char *s1,char *s2,char *s3,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::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. 什么是重载、重写(覆盖)、重定义(隐藏)？

重载：两个函数在同一作用域内，函数名相同，参数不同
重写（覆盖）：两个函数分别在基类和派生类的作用域，函数名/参数/返回值都必须相同（协变例外），两个函数必须是虚函数。
重定义（隐藏）：两个函数分别在基类和派生类的作用域，函数名相同，两个基类和派生类的同名函数不构成重写就是重定义

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

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

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

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

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

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

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

菱形虚拟继承因为子类对象当中会有两份父类的成员，因此会导致数据冗余和二义性的问题。
虚继承对于相同的虚基类在对象当中只会存储一份，若要访问虚基类的成员需要通过获取到偏移量，进而找到对应的虚基类成员，从而解决了数据冗余和二义性的问题。

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

在虚函数的后面写上=0，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。抽象类强制重写了虚函数，另外抽象类体现出了接口继承关系。