Casting is the act of coercing one type to be another, or dynamically producing the equivalent value in the other type.
C++ has a range of cast operators that turn a pointer or value of one kind into a pointer or value of another kind.
const_cast<T>(value)- removes the const enforcement from a value so it may be modified.
static_cast<T>(value)- attempts to convert between types using implicit and user defined conversions.
reinterpret_cast<T>(value)- a compiler directive to just treat the input as some other kind. It does not involve any form of conversion.
dynamic_cast<T>(value)- attempts to convert a class pointer / reference to/from other classes in its inheritance hierarchy. Involves runtime checks.
- Traditional C-style cast - a C++ compiler will attempt to interpret it as a
reinterpret_castin varying combinations.
That's a very brief summary of casting which probably invokes more questions than it answers. Casting in C++ is very complex and nuanced. Some casts merely instruct the compiler to ignore const or treat one type as another. A static cast might involve code generation to convert a type. A dynamic cast might add runtime checks and throw exceptions.
Rust does not do casting so this complexity is gone. Basically if you wish to "cast" you must do one of the following.
- A numeric type may be coerced to another numeric type using the
- Complex types can implement
From<Foo>traits that allows one structured type to be turned into another.
- Unsafe code can transmutate memory, essentially reinterpretting the contents.
let a = 123i32; let b = a as usize;
Into and From traits
Anything beyond this requires implementing the
From<> traits and making conversion an explicit action.
The compiler also does not allow code to cast away
const-ness or treat one type as another except through
unsafe code blocks.
Rust allows some types to be transmuted to others. Transmute is an
unsafe action but it allows a memory location to be treated as another type, e.g. an array of bytes as an integer.