How C++ uses naming transformations
This article introduces the knowledge of "how C++ uses naming conversion". In the operation of actual cases, many people will encounter such a dilemma. Then let the editor lead you to learn how to deal with these situations. I hope you can read it carefully and be able to achieve something!
ES.49: if type conversion is necessary, use naming conversion
Reason (reason)
Readability. Avoid mistakes. Naming conversions are more explicit than C-style conversions or functional transformations, allowing the compiler to catch more errors.
The named casts are:
Naming transformations include:
Static_cast
Static conversion
Const_cast
Constant conversion
Reinterpret_cast
Reinterpret the transformation
Dynamic_cast
Dynamic conversion
Std::move / / move (x) is an rvalue reference to x
Mobile / / move (x) is the right reference of x
Std::forward / / forward (x) is an rvalue or an lvalue reference to x depending on T
Value transfer / / depending on the type of T, forward (x) is a left or right value reference
Gsl::narrow_cast / / narrow_cast (x) is static_cast (x)
Narrowing conversion / / narrow_cast (x) is static_cast (x)
Gsl::narrow / / narrow (x) is static_cast (x) if static_cast (x) = = x or it throws narrowing_error
Narrow conversion (throw an exception) / / if static_cast (x) = = x recording (x) is static_cast (x), otherwise an exception is thrown
Example (sample)
Class B {/ *... * /}
Class D {/ *... * /}
Template D* upcast (B* pb)
{
D* pd0 = pb; / / error: no implicit conversion from B* to D*
D* pd1 = (D*) pb; / / legal, but what is done?
D* pd2 = static_cast (pb); / / error: D is not derived from B
D* pd3 = reinterpret_cast (pb); / / OK: on your head be it!
D* pd4 = dynamic_cast (pb); / / OK: return nullptr
/ /...
}
The example is a collection of errors collected from the actual code on the premise that D used to inherit from B, but someone refactored the inheritance relationship. The danger of C style conversion comes from the fact that it can be any type of conversion, which obliterates any possibility of error protection (now or in the future).
Note (Note)
If you want lossless conversions between types (for example, from float to double, or from int32 to int64), consider using curly braces initialization instead.
Double d {some_float}
Int64_t i {some_int32}
On the one hand, this method defines the intention of type conversion, on the other hand, it can prevent the loss of precision during conversion. (for example, in the case shown in the code, a compilation error occurs if the float variable is initialized with the declare value)
Note (Note)
Reinterpret_cast can be essential, but the essential uses (e.g.turning a machine address into pointer) are not type safe:
Reinterpret_cast is essential, but this necessary use (for example, converting machine addresses to pointers) is not type-safe.
Auto p = reinterpret_cast (0x800); / / inherently dangerousEnforcement (implementation recommendation)
Flag C-style and functional casts.
Remind of the conversion of C style and function form
The type profile bans reinterpret_cast.
Type rule group forbids reinterpret_cast.
The type profile warns when using static_cast between arithmetic types.
The type rules group warns against the use of static_cast when converting between arithmetic types.
Translator's note:
C style conversion: B = int (a)
Function form conversion: b=int (a)
That's all for the content of "how C++ uses naming conversion". Thank you for reading. If you want to know more about the industry, you can follow the website, the editor will output more high-quality practical articles for you!
