static_cast转换类似于C/C++里面的强制类型转换。
dynamic_cast转换是根据基类派生类的原则进行转换，把一个派生类转换为基类使用这个转换。
const_cast转换是去掉const变量的const
--------------------------------------------------------------------------------------------------
dynamic_cast: 通常在基类和派生类之间转换时使用,run-time cast
const_cast: 主要针对const和volatile的转换.
static_cast: 一般的转换，no run-time check.通常，如果你不知道该用哪个，就用这个。
reinterpret_cast: 用于进行没有任何关联之间的转换，比如一个字符指针转换为一个整形数。
这些偏重于口语化解释，最好还是看看书，讲述标准c＋＋的教材上都会有的。
--------------------------------------------------------------------------------------------------
我基本上明白了，谢谢楼上的几位．
问下：goodluckyxl(被人遗忘的狗)
你是zju的那个wishingbone么？
我看msdn做了下笔记．
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
这个例子说明,子类向基类转换.
class B { ... };
class C : public B { ... };
class D : public C { ... };
void f(D* pd)
{
C* pc = dynamic_cast <C*> (pd); // ok: C is a direct base class
// pc points to C subobject of pd
B* pb = dynamic_cast <B*> (pd); // ok: B is an indirect base class
// pb points to B subobject of pd
...
}
这个例子说明的是void*类型的向某一种类型的转换
其实这里不用dynamic_cast <type_id> 也可以,他会隐士转换
class A { ... };
class B { ... };
void f()
{
A* pa = new A;
B* pb = new B;
void* pv = dynamic_cast <void*> (pa);
// pv now points to an object of type A
...
pv = dynamic_cast <void*> (pb);
// pv now points to an object of type B
}
这个例子说明自身类型转换主要是看它当前所直的对象和它将要转换的类型是否一致.而且这个一直是在程序运行中检测的.
class B { ... };
class D : public B { ... };
void f()
{
B* pb = new D; // unclear but ok
B* pb2 = new B;
D* pd = dynamic_cast <D*> (pb); // ok: pb actually points to a D
...
D* pd2 = dynamic_cast <D*> (pb2); //error: pb2 points to a B, not a D
// pd2 == NULL
...
}
下面是多重继承的,
这里我觉得有点奇怪,因为msdn上说从type D to type A,存在二义性.
但我觉得类型A就是一种啊,怎么会有二义性呢?
Class A
Class B : public A{….}
Class C: public A{….}
Class D: B,C;
void f()
{
D* pd = new D;
A* pa = dynamic_cast <A*> (pd); // error: ambiguous
B* pb = dynamic_cast <B*> (pd); // first cast to B
A* pa2 = dynamic_cast <A*> (pb); // ok: unambiguous
}
下面这个我就更有问题了.
Class A{….}
Class B: public A{……}
Class C:public A{……..}
Class D{……………}
Class E:public B,C,D{…….}
//这里是从父类到基类
void f(D* pd)
{
E* pe = dynamic_cast <E*> (pd);
B* pb = pe; // upcast, implicit conversion
A* pa = pb; // upcast, implicit conversion
}//这里从子类到父类,没用到dynamic_cast,也就是说,从子类到父类是可以不用这个的,我以前学C++的时候,觉得是可以不用dynamic_cast的,但必须要隐士转换.
下面这样转换都可以啊—cross cast!第一次看到.
void f(D* pd)
{
B* pb = dynamic_cast <B*> (pd); // cross cast
A* pa = pb; // upcast, implicit conversion
}
Static_cast
1.当类型从父类到子类转换时,不安全!
class B { ... };
class D : public B { ... };
void f(B* pb, D* pd)
{
D* pd2 = static_cast <D*> (pb); // not safe, pb may
// point to
just B
B* pb2 = static_cast <B*> (pd); // safe conversion
...
}
2.用static_cast感觉好象是程序员要强制类型转换,是否安全就由程序员自己决定了.
typedef unsigned char BYTE
void f()
{
char ch;
int i = 65;
float f = 2.5;
double dbl;
ch = static_cast <char> (i); // int to char
dbl = static_cast <double> (f); // float to double
...
i = static_cast <BYTE> (ch);
...
}
现在我的认识就是:static_cast和dynamic_cast的区别主要在与,前者是静态检测类型,而后者是动态的.