标签：des style io ar os 使用 sp for on
1、static_cast Operator
The
expression static_cast < type-id > ( expression ) converts
expression to the type of type-id based solely on the types present in
the expression. No run-time type check is made to ensure the safety of
the conversion.
Syntax
static_cast < type-id > ( expression )
The
static_cast operator can be used for operations such as converting a
pointer to a base class to a pointer to a derived class. Such
conversions are not always safe. For example:
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
...
}
In
contrast to dynamic_cast, no run-time check is made on the static_cast
conversion of pb. The object pointed to by pb may not be an object of
type D, in which case the use of *pd2 could be disastrous. For instance,
calling a function that is a member of the D class, but not the B
class, could result in an access violation.
The dynamic_cast and
static_cast operators move a pointer throughout a class hierarchy.
However, static_cast relies exclusively on the information provided in
the cast statement and can therefore be unsafe. For example:
class B { ... };
class D : public B { ... };
void f(B* pb)
{
D* pd1 = dynamic_cast<D*>(pb);
D* pd2 = static_cast<D*>(pb);
}
If
pb really points to an object of type D, then pd1 and pd2 will get the
same value. They will also get the same value if pb == 0.
If pb
points to an object of type B and not to the complete D class, then
dynamic_cast will know enough to return zero. However, static_cast
relies on the programmer’s assertion that pb points to an object of type
D and simply returns a pointer to that supposed D object.
Consequently,
static_cast can do the inverse of implicit conversions, in which case
the results are undefined. It is left to the programmer to ensure that
the results of a static_cast conversion are safe.
This behavior
also applies to types other than class types. For instance, static_cast
can be used to convert from an int to a char. However, the resulting
char may not have enough bits to hold the entire int value. Again, it is
left to the programmer to ensure that the results of a static_cast
conversion are safe.
The static_cast operator can also be used
to perform any implicit conversion, including standard conversions and
user-defined conversions. For example:
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);
...
}
The
static_cast operator can explicitly convert an integral value to an
enumeration type. If the value of the integral type does not fall within
the range of enumeration values, the resulting enumeration value is
undefined.
The static_cast operator converts a null pointer value to the null pointer value of the destination type.
Any
expression can be explicitly converted to type void by the static_cast
operator. The destination void type can optionally include the const,
volatile, or __unaligned attribute.
The static_cast operator cannot cast away the const, volatile, or __unaligned attributes.
static_cast
在功能上基本上与C风格的类型转换一样强大，含义也一样。它也有功能上限制。例如，你不能用static_cast象用C风格的类型转换一样把
struct转换成int类型或者把double类型转换成指针类型，另外，static_cast不能从表达式中去除const属性，因为另一个新的类
型转换操作符const_cast有这样的功能。
2、const_cast Operator
MSDN:
The const_cast operator can be used to remove the const, volatile, and __unaligned attribute(s) from a class.
Syntax
const_cast < type-id > ( expression )
A
pointer to any object type or a pointer to a data member can be
explicitly converted to a type that is identical except for the const,
volatile, and __unaligned qualifiers. For pointers and references, the
result will refer to the original object. For pointers to data members,
the result will refer to the same member as the original (uncast)
pointer to data member. Depending on the type of the referenced object, a
write operation through the resulting pointer, reference, or pointer to
data member might produce undefined behavior.
The const_cast operator converts a null pointer value to the null pointer value of the destination type.
const_cast
用于类型转换掉表达式的const或volatileness属性。通过使用const_cast，你向人们和编译器强调你通过类型转换想做的只是改变一
些东西的constness或者
volatileness属性。这个含义被编译器所约束。如果你试图使用const_cast来完成修改constness
或者volatileness属性之外的事情，你的类型转换将被拒绝。
3、dynamic_cast Operator
MSDN:
The
expression dynamic_cast<type-id>( expression ) converts the
operand expression to an object of type type-id. The type-id must be a
pointer or a reference to a previously defined class type or a “pointer
to void”. The type of expression must be a pointer if type-id is a
pointer, or an l-value if type-id is a reference.
Syntax
dynamic_cast < type-id > ( expression )
If
type-id is a pointer to an unambiguous accessible direct or indirect
base class of expression, a pointer to the unique subobject of type
type-id is the result. For example:
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
...
}
This
type of conversion is called an “upcast” because it moves a pointer up a
class hierarchy, from a derived class to a class it is derived from. An
upcast is an implicit conversion.
If type-id is void*, a
run-time check is made to determine the actual type of expression. The
result is a pointer to the complete object pointed to by expression. For
example:
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
}
If
type-id is not void*, a run-time check is made to see if the object
pointed to by expression can be converted to the type pointed to by
type-id.
If the type of expression is a base class of the type
of type-id, a run-time check is made to see if expression actually
points to a complete object of the type of type-id. If this is true, the
result is a pointer to a complete object of the type of type-id. For
example:
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
...
}
This
type of conversion is called a “downcast” because it moves a pointer
down a class hierarchy, from a given class to a class derived from it.
dynamic_cast，
它被用于安全地沿着类的继承关系向下进行类型转换。这就是说，你能用dynamic_cast把指向基类的指针或引用转换成指向其派生类或其兄弟类的指针
或引用，而且你能知道转换是否成功。失败的转换将返回空指针（当对指针进行类型转换时）或者抛出异常（当对引用进行类型转换时）。
dynamic_casts在帮助你浏览继承层次上是有限制的。它不能被用于缺乏虚函数的类型上，也不能用它来转换掉constness。
4、reinterpret_cast Operator
MSDN:
The
reinterpret_cast operator allows any pointer to be converted into any
other pointer type. It also allows any integral type to be converted
into any pointer type and vice versa. Misuse of the reinterpret_cast
operator can easily be unsafe. Unless the desired conversion is
inherently low-level, you should use one of the other cast operators.
Syntax
reinterpret_cast < type-id > ( expression )
The
reinterpret_cast operator can be used for conversions such as char* to
int*, or One_class* to Unrelated_class*, which are inherently unsafe.
The
result of a reinterpret_cast cannot safely be used for anything other
than being cast back to its original type. Other uses are, at best,
nonportable.
The reinterpret_cast operator cannot cast away the const, volatile, or __unaligned attributes.
使用这个操作符的类型转换，其的转换结果几乎都是执行期定义（implementation-defined）。因此，使用reinterpret_casts的代码很难移植。 reinterpret_casts的最普通的用途就是在函数指针类型之间进行转换。
比如转换函数指针的代码是不可移植的（C++不保证所有的函数指针都被用一样的方法表示），在一些情况下这样的转换会产生不正确的结果（参见条款M31），所以你应该避免转换函数指针类型。
5、如果你使用的编译器缺乏对新的类型转换方式的支持，你可以用传统的类型转换方法代替static_cast, const_cast, 以及reinterpret_cast。也可以用下面的宏替换来模拟新的类型转换语法：
#define static_cast(TYPE,EXPR) ((TYPE)(EXPR))
#define const_cast(TYPE,EXPR) ((TYPE)(EXPR))
#define reinterpret_cast(TYPE,EXPR) ((TYPE)(EXPR))
这些模拟不会象真实的操作符一样安全，但是当你的编译器可以支持新的的类型转换时，它们可以简化你把代码升级的过程。
没
有一个容易的方法来模拟dynamic_cast的操作，但是很多函数库提供了函数，安全地在派生类与基类之间进行类型转换。如果你没有这些函数而你有必
须进行这样的类型转换，你也可以回到C风格的类型转换方法上，但是这样的话你将不能获知类型转换是否失败。当然，你也可以定义一个宏来模拟
dynamic_cast的功能，就象模拟其它的类型转换一样：
#define dynamic_cast(TYPE,EXPR) (TYPE)(EXPR)
请记住，这个模拟并不能完全实现dynamic_cast的功能，它没有办法知道转换是否失败。
C++ static_cast const_cast dynamic_cast 和reinterpret_cast的区别
标签：des style io ar os 使用 sp for on
原文地址：http://www.cnblogs.com/zhouminliang/p/4109172.html
