renzhe20092584
renzhe20092584
采纳率100%
2015-08-19 14:15 阅读 2.4k

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并没有创建??
为什么能够使用,
多态是怎么调用的

  • 点赞
  • 写回答
  • 关注问题
  • 收藏
  • 复制链接分享

8条回答 默认 最新

  • 已采纳
    caozhy 从今以后生命中的每一秒都属于我爱的人 2015-08-19 14:36

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

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

    点赞 评论 复制链接分享
  • Evankaka Evankaka 2015-08-19 14:38

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

    点赞 评论 复制链接分享
  • oyljerry oyljerry 2015-08-19 14:51

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

    点赞 评论 复制链接分享
  • meetings meetings 2015-08-19 15:12

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

    点赞 评论 复制链接分享
  • caozhy 从今以后生命中的每一秒都属于我爱的人 2015-08-19 15:18

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

    就当我白说了。

    点赞 评论 复制链接分享
  • caozhy 从今以后生命中的每一秒都属于我爱的人 2015-08-19 15:19

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

    就当我白说了。

    点赞 评论 复制链接分享
  • renzhe20092584 renzhe20092584 2015-08-19 16:02
    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 你说的我没有太理解,能否详细点谢谢。

    点赞 评论 复制链接分享
  • woaixunlei 大松哥 2015-08-20 03:35

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

    点赞 评论 复制链接分享

相关推荐