C++多态基类和派生类之间转换

#include <iostream>
#include<iostream>
using namespace std;

class A
{
public:
    void foo()
    {
        printf("1\n");
    }
    virtual void fun()
    {
        printf("2\n");
    }
};
class B : public A
{
public:
    void foo()
    {
        printf("3\n");
    }
    void fun()
    {
        printf("4\n");
    }
    void testB()
    {
        printf("testB\n");
    }
};

int main(int argc, const char * argv[]) {
    A a;
    B *ptr = (B *)&a;
    ptr->foo();
    ptr->fun();
    ptr->testB();

    B bb;
    A *aa = &bb;
    aa->foo();
    aa->fun();

    return 0;
}

A a;
B *ptr = (B *)&a;
ptr->foo();
ptr->fun();
ptr->testB();

派生类的对象B并没有创建？？
为什么能够使用，
多态是怎么调用的

不能这样用，只是这样写编译器让你编译通过。
强制类型转换为派生类型，调用虚函数，这个是编译期间绑定的，所以可以调用。
但是这么写其实很危险，不知道会有什么后果，当试图读写派生类的变量的时候。

C++是一种充满坑的语言，编译器检查很弱，你不能指望它。
好比数组，你明明越界了，也能通过编译，你觉得编译器会自动给你加大内存么？当然不会。

A a;
B *ptr = (B *)&a;
ptr->foo();
ptr->fun();
ptr->testB();
派生类的对象B并没有创建？？这里已创建 了，你强制把父类转成子类了，这样有可能会出错
为什么能够使用，
多态是怎么调用的。。。多态分为两种，动态多态的机制其实是虚函数表

父类直接转成子类，当访问子类特有的成员，会找不到，访问会出错，这是很容易出错的行为。
而函数是存放在其它地方，不是对象中，所有访问纯函数是可以，但是函数中访问类成员就会有问题了。

http://blog.csdn.net/meetings/article/details/47418441 具体原理就是虚函数的运行原理，你可以看看前边的那个链接，应该有帮助~

如果你认为
int x[1];
int y = 2;
x[3]=y;
y = 0;
y = x[3];
这样y还能恢复出3来说明你的程序是对的

就当我白说了。

如果你认为
int x[1];
int y = 2;
x[3]=y;
y = 0;
y = x[3];
这样y还能恢复出3来说明你的程序是对的

就当我白说了。

class B : public A
{
public:
    void foo()
    {
        printf("3\n");
    }
    void fun()
    {
        printf("4\n");
    }
    void testB()
    {
        bb = 11;
        printf("testB  %d\n", bb);
    }
public:
    int bb;
};

int main(int argc, const char * argv[]) {
    A a;
    B *ptr = (B *)&a;
    ptr->foo();
    ptr->fun();
    ptr->testB();
    ptr->testA();

//    int aa[3];
        printf("%d \n", aa[4]);//结果确实不确定
    printf("%d \n", ptr->bb);//结果确定的一定是 11

    return 0;
}

printf("%d \n", aa[4]);//结果确实不确定
printf("%d \n", ptr->bb);//结果确定的一定是 11

@caozhy 你说的我没有太理解，能否详细点谢谢。

继续看书，把书中关于多态看完就知道了。
基类和派生类，之间的相互转化最好通过dynamic_cast运算符。转化后还需要检查结果是否为空