Const_cast dynamic_cast reinterpret_cast static_cast usage.

Const_cast

　　Usage: Const_cast <type_id> (expression)
This operator is used to modify the const or volatile attributes of the type. In addition to const or volatile modification, type_id and expression are of the same type.
Constant pointers are converted to non-constant pointers and still point to the original object;
Constant reference is converted to a non-constant reference and still points to the original object. Constant object is converted to a non-constant object.
Voiatile and const classes. Take the following example:
Class B {
Public:
Int m_inum;
}
Void Foo (){
Const B B1;
B1.m _ inum = 100; // comile Error
B b2 = const_cast <B> (B1 );
B2. m_inum = 200; // fine
}
The above code will report an error during compilation, because B1 is a constant object and cannot be changed;
Using const_cast to convert it into a constant object, you can change its data members at will. Note: B1 and B2 are two different objects.

Dynamic_cast

　　Usage: Dynamic_cast <type-ID> (expression)
This operator converts expression to type-ID objects. Type-ID must be a class pointer, class reference, or void *;
If type-ID is a class pointer type, expression must also be a pointer. If type-ID is a reference, expression must also be a reference.
Dynamic_cast is mainly used for upstream and downstream conversions between classes, and can also be used for cross conversions between classes.
When performing upstream conversion between classes, dynamic_cast and static_cast have the same effect;
Dynamic_cast provides the type check function for downstream conversions, which is safer than static_cast.
Class B {
Public:
Int m_inum;
Virtual void Foo ();
};
Class D: Public B {
Public:
Char * m_szname [100];
};
Void func (B * pb ){
D * pd1 = static_cast <D *> (PB );
D * Pd2 = dynamic_cast <D *> (PB );
}
In the above Code segment, if PB points to a D-type object, pd1 and Pd2 are the same, and it is safe to execute D-type operations on these two pointers;
However, if PB points to a B-type object, pd1 will be a pointer to this object, it is not safe to perform operations of the D type (for example, to access m_szname ),
Pd2 is a null pointer.
Note: B must have virtual functions; otherwise, compilation errors may occur. static_cast does not have this restriction.
This is because the runtime type check requires runtime type information, which is stored in the virtual function table of the class (
For more information about the concept of virtual function tables, see <inside C ++ object model>). Only classes that define virtual functions have virtual function tables,
Classes that do not define virtual functions do not have virtual function tables.
In addition, dynamic_cast also supports cross cast ). The following code is used.
Class {
Public:
Int m_inum;
Virtual void F (){}
};
Class B: Public {
};
Class D: Public {
};
Void Foo (){
B * pb = new B;
Pb-> m_inum = 100;
D * pd1 = static_cast <D *> (PB); // compile Error
D * Pd2 = dynamic_cast <D *> (PB); // Pd2 is null
Delete Pb;
}
In function Foo, using static_cast for conversion is not allowed, and errors will occur during compilation. Using dynamic_cast for conversion is allowed, and the result is a null pointer.

Reinterpret_cast

　　Reinterpret_castIs the forced type conversion character in C ++.
The operator modifies the operand type, but only re-explains the BIT model of the given object without binary conversion.
For example, int * n = new int;
Double * D =Reinterpret_cast<Double *> (N );
After calculation, D contains useless values. This is becauseReinterpret_castOnly copying the bits of N to D is not necessary for analysis.
Therefore, exercise caution when usingReinterpret_cast.
And:Reinterpret_castIt can only be converted between pointers.

========================================================== =====
= Static_cast..Reinterpret_cast

========================================================== ============
　　Reinterpret_castTo map to a completely different type, this keyword is used when we need to map the type back to the original type. The type we map to is only for xuanjicang and other purposes, which is the most dangerous of all mappings. (This sentence is the original statement in C ++ programming ideas)

Static_cast andReinterpret_castThe operator modifies the operand type. They are not reciprocal. static_cast performs conversions using type information during compilation, and performs necessary checks during conversions (such as cross-border pointer calculation and type check). Its operations are relatively safe. On the other hand;Reinterpret_cast
Only the BIT model of the given object is re-interpreted without binary conversion. The example is as follows:
Int n = 9; double D = static_cast <double> (N );
In the above example, we convert a variable from int to double. These types of binary expressions are different. To convert an integer 9 to a double-precision integer 9, static_cast needs to complement the bit with a double-precision integer d correctly. The result is 9.0. WhileReinterpret_castBut the behavior is different:

Int n = 9;
Double D =Reinterpret_cast<Double &> (N );
This time, the results are different. After calculation, D contains useless values. This is because
Reinterpret_castOnly copying the bits of N to D is not necessary for analysis.
Therefore, you need to use it with caution.Reinterpret_cast.

Static_cast

　　Usage: Static_cast <type-ID> (expression)

This operator converts expression to the Type-ID type, but does not check the runtime type to ensure the conversion security. It mainly has the following typesUsage:
① It is used to convert pointers or references between classes and subclasses in the class hierarchy.
It is safe to perform upstream conversion (converting the pointer or reference of a subclass to a base class;
When performing a downstream conversion (converting a base class pointer or reference to a subclass), it is not safe because there is no dynamic type check.
② It is used for conversion between basic data types. For example, convert int to Char and convert int to enum. The security of such conversions must also be ensured by developers.
③ Convert a null pointer to a null pointer of the target type.
④ Convert any type of expression to void type.
Note: static_cast cannot convert the const, volitale, or _ unaligned attribute of expression.
Static_cast andReinterpret_castDifference
In chapter 5 of C ++ primer, the compiler implicitly executes any type conversion, which can be displayed by static_cast;Reinterpret_castIt usually provides a lower-layer re-interpretation for the bit mode of the operand.

1. static_cast in C ++ performs non-polymorphism conversion instead of the normal conversion operation in C. Therefore, it is used as an implicit type conversion. For example:
Int I;
Float F = 166.7f;
I = static_cast <int> (f );
In this case, the result is that the I value is 166.
2. In C ++Reinterpret_castData is converted from one type to another. The so-called "usually provides lower-level re-interpretation for the bit mode of the operand" means re-interpretation of the data in the form of binary existence. For example:

Int I;
Char * P = "this is a example .";
I =Reinterpret_cast<Int> (P );

In this case, the values of I and P are exactly the same.Reinterpret_castThe function is to interpret the value of P as an integer in binary (bit mode) and assign it to I. An obvious phenomenon is that there is no digital loss before and after conversion.

 

Reference: http://blog.csdn.net/public/article/details/4944505