向下转型为何不被允许且需显式操作？其不安全原因与设计问题问询

先贴出示例代码方便对照：

#include <iostream>

class A{
  public:
      virtual void display(){
        std::cout<<"A Class"<<std::endl;
      }
};

class B: public A{
  public:
        void show(){
          std::cout<<"B Class"<<std::endl;
        }
};

int main() 
{
    A *ob = new B();
    ob->display();//输出A Class（B未重写display）
    B *ob1 = (B*)(ob);
    ob1->show();//输出B Class

    A *obj = new A();
    B *obj1 = (B*)obj;
    obj1->display();//输出A Class
    obj1->show();//输出B Class，但属于未定义行为
    
    return 0;
}

1. 为什么向下转型不被默认允许，必须显式进行？ #

先搞清楚两种转型的本质：

• 向上转型（子类转父类）：比如A *ob = new B();，这就像把"猫"当成"动物"看待——子类对象必然包含父类的所有成员，这种转换100%安全，编译器可以自动完成，不需要你额外声明。
• 向下转型（父类转子类）：比如B *obj1 = (B*)obj;，这是把"动物"强行当成"猫"，但父类对象（比如示例里的obj指向的A实例）根本没有子类独有的成员（比如B的show()逻辑、可能存在的子类成员变量）。

编译器默认无法判断你要转换的父类指针背后，到底是不是真正的子类对象。所以它不会自动帮你做这个操作，必须让你显式写转型代码——相当于你在告诉编译器："我清楚这里可能有风险，后果我自己承担"。

2. 为什么向下转型存在安全性问题，且被视为不良设计？ #

安全性问题：用示例说话 #

示例里的第二个场景就是典型的危险情况：
A *obj = new A(); 是一个纯父类对象，转成B*后调用show()，虽然看起来输出了"B Class"，但这属于未定义行为——因为obj指向的内存里只有A对象的内容，根本没有B类的相关数据。

如果给B加个成员变量试试：

class B: public A{
  public:
        int num = 100;
        void show(){
          std::cout<<"B Class, num: "<<num<<std::endl;
        }
};

这时再调用obj1->show()，你会看到num输出的是随机垃圾值，甚至可能直接导致程序崩溃——因为你在访问不属于当前对象的内存区域。

而第一个场景里ob实际是B对象，转成B*是安全的，但编译器没办法区分这两种情况，只要你写了强制转型，它就会执行，不管背后的对象实际类型是什么，这就是风险的根源。

为什么是不良设计？ #

良好的面向对象设计，应该依赖多态来处理不同子类的行为，而不是强行向下转型。比如如果所有子类都需要show()这个行为，应该把它定义成父类的虚函数，让子类去重写：

class A{
  public:
      virtual void display(){
        std::cout<<"A Class"<<std::endl;
      }
      virtual void show() = 0; // 纯虚函数，强制子类实现
};

class B: public A{
  public:
      void show() override {
          std::cout<<"B Class"<<std::endl;
      }
};

这样直接用父类指针调用show()，就会自动执行子类的实现，根本不需要向下转型。如果你的代码必须靠向下转型才能完成功能，说明你的父类接口设计得不够完善，没有覆盖所有需要的行为，是设计上的缺陷。

内容的提问来源于stack exchange，提问作者Fedrick