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

标签：

• 整个C++程序设计全面围绕面向对象的方式进行。类的继承特性是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）保护继承方式：

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

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

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

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

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

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

标签：

原文地址：http://www.cnblogs.com/Kobe10/p/5563181.html