C++面试笔记--继承和接口

在面试过程中，各大企业会考量你对虚函数、纯虚函数、私有继承、多重继承等知识点的掌握程度，因此就有了我们这一节的内容，开始吧。

1、以下代码的输出结果是什么？

#include<iostream>
using namespace std;

class A
{
protected:
	int m_data;
public:
	A(int data = 0)
	{
		m_data = data;
	}
	int GetData()
	{
		return doGetData();
	}
	virtual int doGetData()
	{
		return m_data;
	}
};

class B : public A
{
protected:
	int m_data;
public:
	B(int data = 1)
	{
		m_data = data;
	}
	int doGetData()
	{
		return m_data;
	}

};

class C : public B
{
protected:
	int m_data;
public:
	C(int data = 2)
	{
		m_data = data;
	}
};

int main ()
{
	C c(10);

	cout << c.GetData() <<endl;
	cout << c.A::GetData() <<endl;
	cout << c.B::GetData() <<endl;
	cout << c.C::GetData() <<endl;

	cout << c.doGetData() <<endl;
	cout << c.A::doGetData() <<endl;
	cout << c.B::doGetData() <<endl;
	cout << c.C::doGetData() <<endl;
	return 0;
}

解析:构造函数从最初始的基类开始构造的,各个类的同名变量没有形成覆盖,都是单独的变量.理解这两个重要的C++特性后解决这个问题就比较轻松了,下面我们看看:

cout << c.GetData() <<endl;

本来是要调用C类的GetData()，C中未定义，故调用B中的，但是B中也未定义，故调用A中的GetData()，因为A中的doGetData()是虚函数，所以调用B类中的doGetData()，而B类的doGetData()返回B::m_data，故输出 1。

cout << c.A::GetData() <<endl;

因为A中的doGetData()是虚函数，所以调用B类中的doGetData()，而B类的doGetData()返回B::m_data，故输出 1。

cout << c.B::GetData() <<endl;

肯定是B类的返回值 1 了。

cout << c.C::GetData() <<endl;

跟cout << c.GetData() <<endl;语句是一样的。

cout << c.doGetData() <<endl;

B类的返回值 1 了。

cout << c.A::doGetData() <<endl;

因为直接调用了A的doGetData() ，所以输出0。

cout << c.B::doGetData() <<endl;
     cout << c.C::doGetData() <<endl;

这两个都是调用了B的doGetData()，所以输出 1。

这里要注意存在一个就近调用，如果父类存在相关接口则优先调用父类接口，如果父类也不存在相关接口则调用祖父辈接口。

答案：

1 1 1 1 1 0 1 1

2、以下代码输出结果是什么？

#include<iostream>
using namespace std;

class A
{
public:
	void virtual f()
	{
		cout<<"A"<<endl;
	}
};

class B : public A
{
public:
	void virtual f()
	{
		cout<<"B"<<endl;
	}
};

int main ()
{
	A* pa=new A();
	pa->f();
	B* pb=(B*)pa;
	pb->f();

	delete pa,pb;
	pa=new B();
	pa->f();
	pb=(B*)pa;
	pb->f();

	return 0;
}

        解析：这是一个虚函数覆盖虚函数的问题。A类里的f()函数是一个虚函数，虚函数是被子类同名函数所覆盖的。而B类里的f()函数也是一个虚函数，它覆盖A类f()函数的同时，也会被它的子类覆盖。但是在 B* pb=(B*)pa;里面，该语句的意思是转化pa为B类型并新建一个指针pb，将pa复制到pb。但是这里有一点请注意，就是pa的指针始终没有发生变化，所以pb也指向pa的f()函数。这里并不存在覆盖的问题。

delete pa，pb;删除了pa和pb所指向的地址，但是pa、pb指针并没有删除，也就是我们通常说的悬浮指针，现在重新给pa指向新地址，所指向的位置是B类的，而之前pa指针类型是A类的，所以就产生了一个覆盖。pa->f();的值是B。

pb=(B*)pa;转化pa为B类指针给pb赋值，但pa所指向的f()函数是B类的f() 函数，所以pb所指向的f()函数是B类的f()函数。pb->f();的值是B。

       答案：

A A B B

3、派生类的3种继承方式？

       答案：

（1）公有继承方式：

基类成员对其对象的可见性与一般类及其对象的可见性相同，公有成员可见，其他成员不可见。这里保护成员与私有成员相同。

基类成员对派生类的可见性对派生类来说，基类的公有成员和保护成员可见，基类的公有成员和保护成员作为派生类的成员时，它们都保持原有的状态；基类的私有成员不可见，基类的私有成员仍然是私有的，派生类不可访问基类中的私有成员。

基类成员对派生类对象的可见性对派生类对象来说，基类的公有成员是可见的，其他成员是不可见的。

（2）私有继承方式：

基类成员对其对象的可见性与一般类及其对象的可见性相同，公有成员可见，其他成员不可见。

基类成员对派生类的可见性对派生类来说，基类的公有成员和保护成员可见，基类的公有成员和保护成员都作为派生类的私有成员，并且不能被这个派生类的子类所访问；基类的私有成员不可见，派生类不可访问基类中的私有成员。

基类成员对派生类对象的可见性对派生类对象来说，基类的所以成员都是不可见的。

所以说，在私有继承时，基类的成员只能由直接派生类访问，而无法再往下继承。

（3）保护继承方式：

这种继承方式与私有继承方式的情况相同，两者的区别仅在于对派生类的成员而言，基类成员对其对象的可见性与一般类及其对象的可见性相同，公有成员可见，其他成员不可见。

基类成员对派生类的可见性对派生类来说，基类的公有成员和保护成员可见，基类的公有成员和保护成员都作为派生类的保护成员，并且不能被这个派生类的子类所访问；基类的私有成员不可见，派生类不可访问基类中的私有成员。

基类成员对派生类对象的可见性对派生类对象来说，基类的所以成员都是不可见的。

所以说，在私有继承时，基类的成员只能由直接派生类访问，而无法再往下继承。

4、下面程序运行结果是什么？

#include<iostream>
using namespace std;

class A
{
	char k[3];
public:
	virtual void aa(){};
};

class B : public virtual A
{
	char j[3];
public:
	virtual void bb(){};
};

class C : public virtual B
{
	char i[3];
public:
	virtual void cc(){};
};

int main ()
{
	cout << "sizeof(A):" << sizeof(A) << endl;
	cout << "sizeof(B):" << sizeof(B) << endl;
	cout << "sizeof(C):" << sizeof(C) << endl;
	return 0;
}

      解析：（1）对于A类，由于有一个虚函数，那么必须有一个对应的虚函数表来记录对应的函数入口地址。每个地址需标有一个虚指针，指针的大小为4。类中还有一个char k[3]，每一个char值所占空间是1，所以char k[3]所占大小是3。做一个数据对齐后变为4。所以，sizeof(A)的结果就是char k[3]所占大小4和虚指针所占大小4之和等于8。

（2）对于B类，由于B继承了A，同时还拥有自己的虚函数，那么B中首先拥有一个vfptr_B，指向自己的虚函数表。还有char j[3]，大小为4，可虚继承该如何实现呢？首先要通过加入一个虚类指针（记vbptr_B_A）来指向其父类，然后还要包含父类的所有内容，所以sizeof(B)的大小是：A类所占大小8，char j[3]所占大小4，vfptr_B所占大小4，vbptr_B_A所占大小4，它们之和等于20。

（3）对于C类和B类差不多，结果是32。

答案：

sizeof(A):8

sizeof(B):20

sizeof(C):32

知识扩展：编译器对每个包含虚函数的类创建一个表（Vtable：V表）。在V表中，表放置特定类的虚函数地址。在每个带着虚函数的类中，编译器秘密的设置一指针，称为V-ptr，指向这个对象的V表，通过基类指针做函数调用时（也就是多态调用时），编译器静态地插入取得这个V-ptr，并在V表中哈找函数地址的代码，这样就能调用正确的函数使晚绑定发生。

为每个类设置V-ptr，初始化vptr，为虚函数调用插入代码，所有这些都是自动发生的，所以我们不必担心这些。利用虚函数这个对象的合适的函数就能被调用了，哪编译器还不知道这个对象的特定类型。

5、什么是虚继承？它与一般的继承有什么不同？它有什么用？写出一段虚继承的C++代码。

答案：

虚拟继承是多重继承中特有的概念。虚拟基类是为了解决多重继承而出现的，请看下图：

在图 1中，类D接触自类B和类C，而类B和类C都继承自类A，因此出现了图 2所示的情况。

在图 2中，类D中会出现两次A。为了节省内存空间，可以将B、C对A的继承定义为虚拟继承，而A成了虚拟基类。最后形成了图 3。

代码如下：

?

1 2 3 4

class A; class B : public virtual A; class C : public virtual A; class D : public B,public C;