继承与接口---覆盖、虚继承

一、关于覆盖：

(1)成员函数的覆盖：子类对父类的成员函数覆盖，必须函数名称一致，参数一
致，返回值一致(当然编译器决定)；！！！！！

(2)成员变量的覆盖：子类覆盖的仅仅是继承来的那个成员变量，而并不改变原
来父类中的变量；！！！！！

(3)构造函数从基类开始构造，各个类的同名变量没有形成覆盖，都是单独的变
量。子类调用就近原则，如果父类存在相关接口则优先调用，如果父类不存在则调用
祖父类接口；当然，如果自己有则首先调用自己的函数；！！！！！

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() <<" ";
    cout << c.A::GetData() <<" ";
    cout << c.B::GetData() <<" ";
    cout << c.C::GetData() <<" ";

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

结果：

1 1 1 1 1 0 1 1

Process returned 0 (0x0)   execution time : 0.152 s
Press any key to continue.

解析:
构造函数从最初始的基类开始构造；各个类的同名变量没有形成覆盖，都是单独的变量。理解这两个重要的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() <

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。

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

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

#include<iostream>
using namespace std;

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

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

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

    delete pa;
    delete pb;
    pa=new B();
    pa->f();
    pb=(B*)pa;
    pb->f();
    cout<<endl;
    return 0;
}

结果：

A A B B

Process returned 0 (0x0)   execution time : 0.043 s
Press any key to continue.

解析：这是一个虚函数覆盖虚函数的问题。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。

二、虚继承

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

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

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

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

代码如下：

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

注：虚继承与虚函数继承是完全不同的两个概念，不能混淆。

http://www.cnblogs.com/iuices/archive/2011/11/06/2237912.html