Type casting is an operation that we should avoid, but most of the time we have to perform it. The most common way we use is to enclose the desired type in parentheses, but this is not recommended.

The “(type)” casting intention is unclear, whether it is casting between two unrelated objects, removing const, or performing upcasting or downcasting, it is all the same.

At the same time, the “(type)” casting is also not conspicuous, both for programmers and other tools.

To address the above issues, C++ has specifically prepared four type casting operators for us:

1. static_cast

“static_cast” is the type casting operator that is most similar to “(type)”.The other three are suitable for more explicit type casting operations; all other type casts should be handled by “static_cast”.：

2. const_cast

As the name suggests, “const_cast” is definitely related to “const”. In fact, it controls the modification of “const” and “volatile”.“const_cast” allows changing “const” and “volatile”.。

If “const_cast” is used for other types of casting, the compiler will explicitly reject it:

3. dynamic_cast

This is used specifically for performing casts within an inheritance hierarchy,converting a base class pointer or reference to a derived class (or sibling base class) pointer or reference.。

When the cast is not within the inheritance hierarchy, if the cast is a pointer, it will return a null pointer; if it is a reference, it will throw an exception:

4. reinterpret_cast

This is commonly used to perform casts of function pointers, converting to a function pointer that differs from the parameter type.

However, if it is not absolutely necessary, the program should avoid using it,please do not use “reinterpret_cast”.。

Because “reinterpret_cast” lacks portability and may lead to undefined behavior in certain situations.

5. Conclusion

Good programs should minimize the use of type casting; if it is necessary, please use the four type casting operators.