有没有很自然的方法向下转换的方法?
class A
{
}
class B : public A
{
}
main()
{
A* a = new A()
B* b = a;
}
有没什么办法使B* b = a编译通过?
我的想法是用operator实现,可是我写不出,请教高手
[解决办法]
这样转换不行的吧，除非
A* a = new B();
operator ＝ 也是B ＝， 不是B*
[解决办法]
B* b = (B*)a;
[解决办法]
class A
{
}
class B : public A
{
}
main()
{
A* a = new B()
B* b = dynamic_cast <B*> (a);
}
[解决办法]
向下转型，最好还是不要那么自然。因为本来就是一个有风险的动作，做起来太自然了，反倒会有害。
[解决办法]
class A{};
class B{};
class C : public A, public B{};
void main()
{
A* pA = new A;
C* pC = pA; // C包含AB，若A想向C转换，必须告诉C其B部分是什么样的，光有A不行
}
所以如楼上所说，很危险
class A{};
class B: public A{};
void main()
{
A* pA = new B;
B* pB = dynamic_cast <B*> (pA);
}
需要转换的话用dynamic_cast <派生类指针> （基类指针）
[解决办法]
dynamic_cast就可以了，如果编译器旧的话也可以强制转换
[解决办法]
我觉得Polarislee(北极星)(无房无车，飘在北京)说的有道理,无论你使用任何方法 "骗 "过了编译器,就你现在的代码而言,本身是否设计缺陷的,或者说你这样的转化是没有实际意义的.
我这里简单设想一个downcasting发生合理的情况:
1.加入你设计了一个比较深的类的继承结构,例如:
class Base;
class Derived1: public Base;
class Derived2: public Base:
class MyDerived1: Derived1;
class MyDerived2: Derived2;
2.创建多个派生类对象,但是都是通过基类指针保存他们的地址,例如:
Base* pBase1 = new Derived1;
Base* pBase2 = new MyDerived2;
3.这时候你需要将这些基类指针转化它他们正确的派生类对象指针,这时候你就需要 "安全 "的downcasting,你可以通过dynamic_cast <> 来完成:
Derived1* pD = dynamic_cast <Derived1*> (pBase1); //ok
Derived1* pD2 = dynamic_cast <MyDerived2*> (pBase1); //error
[解决办法]
向下转, 还要自然. 为什么呀.
人是动物的一个子类. 如果向下转很自然,
岂不是任何动物都可以安全的当成人处理了.
写童话呢, 还是写程序呢.
[解决办法]
main()
{
A* a = new A()
B* b = (B*)a;
}
强转，但运行肯定是错的，a的空间只有a的所有数据那么大。
把它强转成B类型的，会已a的起始地址处开始，找出B类型这么大的空间 附给b，出错了。
除非是
main()
{
A* a = new B()
B* b = (B*)a;
}
这样没问题，但 还是不提倡。
[解决办法]
没有，是有意不让它有很自然的方法向下转换。因为“丑陋的代码，应当以丑陋的形式表现”。向下转换本身就是不合理的和危险的。所以，得用dynamic_cast <> 这种麻烦的方法操作。目的是为了让你尽量少写这种代码。另外，不要用(B*)这种c风格的转换，因为这种代码是难以查找到的。而xxxx_cast <> 操作符很容易通过文本查找找到。
最后，用了dynamic_cast <> 之后，请检查结果，因为如果转换不成功，返回0。如果不想出现非法访问，这种检查是必须的：
B* b=dynamic_cast <B*> (a);
if(b==0)
... // 错误处理
总之，如果你在编程时发现必须使用向下转换，那么请检查你的设计，那里肯定有些不合理地方。如果实在无法避免，就使用dynamic_cast <> ，并检查结果。这样做，才是严谨的和可靠的。
[解决办法]
至于operator=，因为它的参数不能是指针，所以这样的操作符重载是无法实现的。
