基类指针和子类的关系

（from http://blog.csdn.net/FX677588/article/details/77727110）
这块我们需要分为两种情况来考虑，第一种是类继承（静态绑定），第二种是父类中包含虚函数（动态绑定）。
2 具体实现　　
　2.1 没有虚函数的继承
　　如果以一个基础类指针指向一个派生类对象，那么经由该指针只能访问基础类定义的函数（静态绑定）。
　　如果以一个派生类类指针指向一个基础类对象，必须先做强制转型动作（explicit cast），这种做法很危险，也不符合生活习惯，在程序设计上也会给程序员带来困扰。（一般不会这么去使用）
　　如果基础类和派生类类定义了相同名称的成员函数，那么通过对象指针调用成员函数时，到底调用那个函数要根据指针的原型来确定，而不是根据指针实际指向的对象类型确定。（指针类型是谁就调用谁）
　　这块我需要说明一下为何基础类可以指向派生类对象，而派生类不去指向父类对象。
　　通常来说，子类总是含有一些父类没有的成员变量，或者方法函数。而子类肯定含有父类所有的成员变量和方法函数。所以用父类指针指向子类时，没有问题，因为父类有的，子类都有，不会出现非法访问问题。
　　但是如果用子类指针指向父类的话，一旦访问子类特有的方法函数或者成员变量，就会出现非法，因为被子类指针指向的由父类创建的对象，根本没有要访问的那些内容，那些是子类特有的，只有用子类初始化对象时才会有。
　2.2 包含虚函数的继承
　　有虚函数的继承，那么父类指针指向子类对象就是我们常见的多态实现，也就是动态绑定。
　　虚拟函数就是为了对“如果你以一个基础类指针指向一个衍生类对象，那么通过该指针，你只能访问基础类定义的成员函数”这条规则反其道而行之的设计。
　　当然这里还包括纯虚拟函数，只要是拥有纯虚拟函数的类，就是抽象类，它们是不能够被实例化的（只能被继承）。如果一个继承类没有改写父类中的纯虚函数，那么他也是抽象类，也不能被实例化。抽象类不能被实例化，不过我们可以拥有指向抽象类的指针，以便于操纵各个衍生类。
　　总结　
　　当定义一个指向子类实例的父类指针的时候，内存中实例化了子类，由于子类继承了父类,因此内存中的子类里包含父类的所有成员。但由于生命的时父类指针，因此该指针不能够访问子类的成员，而只能访问父类的成员。然而在父类里可以声明纯虚函数和定义虚函数，使用父类指针访问虚函数或纯虚函数的时候，访问到的是子类里重写的函数。当然，对于虚函数，如果子类里没有对其重写的话，仍然访问到父类里定义的虚函数。可见虚函数和纯虚函数的却别仅仅在于：纯虚函数没有定义,只有声明。
实例：
（from http://blog.csdn.net/jingjingtr/article/details/7884017）
一

二

class Base1
{
public:
    virtual void fun1() {cout << "Base1::fun1" << endl;};
};

class Base2
{
public:
    virtual void fun2() {cout << "Base2::fun1" << endl;};
};

class Derive : public Base1, public Base2
{
public:
    virtual void fun1 () {cout << "Derive::fun1" << endl;}
    virtual void fun2 () {cout << "Derive::fun2" << endl;}
};

int main()
{
    Derive oD;
    Base1 *pB1 = (Base1*)(&oD);
    Base2 *pB2 = (Base2*)(&oD);
    cout << "&oD=" << &oD << '\n';
    cout << "pB1=" << pB1 << '\n';
    cout << "pB2=" << pB2 << '\n';
    if (&oD == pB1) cout << "&oD == pB1" << '\n';
    if (&oD == pB2) cout << "&oD == pB2" << '\n';
}

首先，可以看到&oD和pB1指针指向相同的存储地址。为什么？
这是因为当我们new一个Derive类的时候，计算机给Derive类分配的空间可以分为三部分：首先是类Base1的部分，然后是Base2的部分，然后是Derive中除去Base和Base2剩余部分，如下图。

Base1
Base2
Derive
所以&oD肯定保存的是整体的首地址，而pB1指向的是Base1的首地址，恰好也是整体的首地址，所以有&oD和pB1的值刚好相等。pB2则指向的是Base2的首地址。
可是后面为什么会有&oD == pB2呢？这是因为当编译器发现一个指向派生类的指针和指向其某个基类的指针进行==运算时，会自动将指针做隐式类型提升已屏蔽多重继承带来的指针差异。因为两个指针做比较，目的通常是判断两个指针是否指向了同一个内存对象实例，在上面的场景中，&oD和pB2虽然指针值不等，但是他们确确实实都指向了同一个内存对象（即new Derive产生的内存对象）。

指针类型转换问题
还是使用上面的类，看主函数：

int main(){
    Derive oD;
    cout << "&oD=" << &oD << '\n';

    Base1 *pB1 =  &oD;
    cout << "pB1=" << pB1 << '\n';
    pB1->fun1();
    cout << endl;

    Base2 *pB2 = (Base2*)(pB1); // 指针强行转换，没有偏移
    cout << "pB2=" << pB2 << '\n';
    pB2->fun2();
    cout << endl;

    pB2 = dynamic_cast<Base2*>(pB1); // 指针动态转换,dynamic_cast帮你偏移
    cout << "pB2=" << pB2 << '\n';
    pB2->fun2();

    return 0;
}

为什么pB2->fun2()的结果是Derive::fun1。这里我们看到的是使用强制类型转换是不能把Base1类型的指针转成Base2类型的指针的，必须使用dynamic_cast的形式进制转换才奏效。

//dynamic_cast <type-id> (expression)
//该运算符把expression转换成type-id类型的对象。Type-id 必须是类的指针、类的引用或者void*；
//如果 type-id 是类指针类型，那么expression也必须是一个指针，如果 type-id 是一个引用，
//那么 expression 也必须是一个引用。

下面我们探索下为什么输出的是Derive::fun1。
我们修改Base1的定义：

class Base1
{
public:
    virtual void fun3() {cout << "Base1::fun3" << endl;};
    virtual void fun1() {cout << "Base1::fun1" << endl;};
};

给添加一个函数fun3，然后再次执行上面的main函数，结果如下：

我们可以发现强制转换不会成功，也不会报错，你调用Base2的fun2函数，因为强制转换不成功，所以指针仍然指向Base1，而Base1中没有fun2，所以就会自动调用声明的函数中的第一个函数。（不知道为什么会这样设计！）

上面强制将Base1转为Base2不会报错，但是不能运行处正确结果。而我们强制将Base2转为Base1呢？

int main()
{
    Derive *pD = new Derive();
    Base2 *pB2 = pD;
    pB2->fun2();
    Base1 *pB1 = (Base1*)(pB2);
    pB1->fun1();
    return 0;
}

这样程序执行到第6行的时候会直接奔溃。
所以：

1. C++多重继承需要慎用
2. 类型转换尽量采用c++内置的类型转换函数，而不要强行转换。

实例：

#include<iostream>
using namespace std;
class Base
{
public:
virtual void f(){cout<<"Base::f"<<endl;}
void f1(){cout<<"Base::f1"<<endl;}
private:
double x;
double y;
};
class Derived:public Base
{
public:
virtual void f(){cout<<"Derived::f"<<endl;}
virtual void k(){cout<<"Derived::k"<<endl;}
private:
double z;
};
class Base1
{
public:
virtual void g(){cout<<"Base1::g"<<endl;}
void g1(){cout<<"Base1::g1"<<endl;}
};
class Derived1:public Base,public Base1
{
public:
virtual void f(){cout<<"Derived1::f"<<endl;}
virtual void h(){cout<<"Derived1::h"<<endl;}
};
void Test1()
{
//对于单继承，
//如果pD真的指向Derived，用dynamic_cast和static_cast效果相同
Base*pD=new Derived;
Derived*pD1=dynamic_cast<Derived*>(pD);
pD1->f();
pD1->k();
pD1->f1();
Derived*pD2=static_cast<Derived*>(pD);
pD2->f();
pD2->k();
pD2->f1();
//但是如果pB不是真的指向Derived，则用dynamic_cast则返回NULL，能够更早的禁止error的发生，
//如果用static_cast虽然返回的不为NULL，但是运行时可能抛出exception。
/**/Errorcode
//Base*pB=new Base();
//Derived*pD3=static_cast<Derived*>(pB);
//pD3->f();
//pD3->k();
//pD3->f1();
//Derived*pD4=dynamic_cast<Derived*>(pB);
//pD4->f();
//pD4->k();
//pD4->f1();
}
void Test2()
{
//对于多重继承，
//如果pD真的指向的是Derived1，使用dynamic_cast和static_cast都可以转化为Derived1，
//但是如果要转化为Base的兄弟类Base1，必须使用dynamic_cast，使用static_cast不能编译。
Base*pD=new Derived1;
Derived1*pD1=dynamic_cast<Derived1*>(pD);
pD1->f();
pD1->h();
pD1->f1();
Base1*pB1=dynamic_cast<Base1*>(pD);
pB1->g();
Derived1*pD2=static_cast<Derived1*>(pD);
pD2->f();
pD1->h();
pD2->f1();
/**/errorcannotcompiler
//Base1*pB2=static_cast<Base1*>(pD);
//pB2->g();
//当然对于pB不是真的指向Derived1，想要转化为Derived1或Base的兄弟类Base1，情况与Test1中的error情况相同。
}
int main()
{
Test1();
Test2();
return 0 ;
}

输出结果：