c++ type conversion

c Type conversion

In C language, to perform type conversion, you only need to add the variable type in front of the variable , and the conversion can be bidirectional. For example, the int type can be converted to the double type, and the double type can also be converted to the int type. (Recommended tutorial: c manual tutorial)

But this simple and crude method is inappropriate in C. First, the custom data type class in C cannot be completed; second, the C language can convert between any types. For example, a pointer to a const object can be converted to a pointer to a non-const object. This is very useful for For C, which has very strict type checking, it is obviously unreasonable, so C provides 4 unique type conversion operators.

1. static_cast

is similar to type conversion in C language and can perform unconditional type conversion. Application scenarios:

Basic type conversion.

int i = 1;
double j = static_cast <double> (i);

Conversion between parent class and subclass pointers. If the parent class pointer points to an object, it is unsafe to convert the parent class pointer to a subclass pointer, but it is safe to convert the subclass pointer to a parent class pointer.

class Base( ) { };
class Derived : public Base { };
Base * p1 = new Base;
Derived * p2 = new Derived;
Derived * p3 = static_cast <Derived *> (p1);      // 不安全
Base * p4 = static_cast <Base *> (p2);  // 安全

Convert any type of expression to void type.

Note: static_cast cannot remove the const or volatile attributes of a type; it cannot perform unrelated type conversions (such as non-base classes and subclasses).

2. dynamic_cast

dynamic_cast can only be used to convert between object pointers, and the conversion result can also be applied. When performing upward conversion between class levels, the effect of dynamic_cast and static_cast is the same; when performing downward conversion, dynamic_cast has a type checking function and is safer than static_cast.

class Base { virtual void dummy ( ) { } };
class Derived : public Base { };
Base *  b1 = new Base;
Base * b2 = new Derived;
Derived * b3 = dynamic_cast <Derived * > (b1);  //  转换失败，返回 NULL
Derived * b4 = dynamic_cast <Derived * > (b2);  // 转换成功
Derived & b5 = dynamic_cast <Derived & > (b1);   // 转换失败（抛出异常）
Derived & b6 = dynamic_cast <Derived & > (b2);  // 转换成功

Note: When converting pointers between parent and child classes, the parent class must contain a virtual function.

3. const_cast

is used to take out the const attribute, remove the const or volatile attribute of the type, and change the const type pointer into a non-const type pointer.

const int * fun(int x, int y) { };　
int * ptr = const_cast < int * > (fun(2, 3));

4. reinterpret_cast

reinterpret_cast only reinterprets the type, without binary conversion. Application:

The converted type must be a pointer, reference, arithmetic type, function pointer or member pointer. Conversion is performed at the bit level. It can convert a pointer into an integer, or an integer into a pointer (first convert a pointer into an integer, and then convert the integer into a pointer of the original type, and you can also get the original pointer value). However, non-32bit instances cannot be converted into pointers.

Generally used to convert between function pointer types.

Portability is not guaranteed.

Note: This type conversion is unsafe and should be used with caution.

The above is the detailed content of c++ type conversion. For more information, please follow other related articles on the PHP Chinese website!