有没有很自然的方法向下转换的方法?

[XueBoy163]

class A
{
}
class B : public A
{
}

main()
{
A* a = new A()
B* b = a;
}

有没什么办法使B* b = a编译通过?
我的想法是用operator实现,可是我写不出,请教高手

[iu_81]

B* b = (B*)a;

[北极猩猩]

class A
{
}
class B : public A
{
}

main()
{
A* a = new B()
B* b = dynamic_cast<B*>(a);
}

[北极猩猩]

向下转型，最好还是不要那么自然。因为本来就是一个有风险的动作，做起来太自然了，反倒会有害。

[Baku]

这样转换不行的吧，除非
A* a = new B();

operator ＝ 也是B ＝， 不是B*

[Shadow_Mor]

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<派生类指针>（基类指针）

[merlinfang]

dynamic_cast就可以了，如果编译器旧的话也可以强制转换

[houdy]

我觉得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

[guanwl]

向下转, 还要自然. 为什么呀.

人是动物的一个子类. 如果向下转很自然,
岂不是任何动物都可以安全的当成人处理了.
写童话呢, 还是写程序呢.

[dyf198215]

main()
{
A* a = new A()
B* b = (B*)a;
}

强转，但运行肯定是错的，a的空间只有a的所有数据那么大。

把它强转成B类型的，会已a的起始地址处开始，找出B类型这么大的空间 附给b，出错了。

除非是
main()
{
A* a = new B()
B* b = (B*)a;
}

这样没问题，但 还是不提倡。

[longshanks]

没有，是有意不让它有很自然的方法向下转换。因为“丑陋的代码，应当以丑陋的形式表现”。向下转换本身就是不合理的和危险的。所以，得用dynamic_cast<>这种麻烦的方法操作。目的是为了让你尽量少写这种代码。另外，不要用(B*)这种c风格的转换，因为这种代码是难以查找到的。而xxxx_cast<>操作符很容易通过文本查找找到。
最后，用了dynamic_cast<>之后，请检查结果，因为如果转换不成功，返回0。如果不想出现非法访问，这种检查是必须的：
B* b=dynamic_cast<B*>(a);
if(b==0)
... // 错误处理
总之，如果你在编程时发现必须使用向下转换，那么请检查你的设计，那里肯定有些不合理地方。如果实在无法避免，就使用dynamic_cast<>，并检查结果。这样做，才是严谨的和可靠的。

[longshanks]

至于operator=，因为它的参数不能是指针，所以这样的操作符重载是无法实现的。

[meiZiNick]

lz要干嘛？