Rust is a statically typed language, which means that it emphasizes on knowing the types of all variables at compile time. The concept of type safety is very crucial in Rust, and the language provides several mechanisms for type conversion.
Type conversion in Rust is explicit, meaning that you need to specify the type you want to convert to.
Here are two common forms of type conversion in Rust:
-
Casting: Rust uses the
as
keyword to perform basic casting between primitive types. For instance:let num = 5.6; let integer: i32 = num as i32; // `integer` will be 5
It’s important to note that casting with
as
can be unsafe, especially when casting between types of different sizes. For example, casting from a larger integer type to a smaller one (like from u32 to u8) can lead to data loss. -
From/Into Traits: The
From
andInto
traits are used for more complex conversions. TheFrom
trait allows a type to define how to create itself from another type, while theInto
trait is the reciprocal of theFrom
trait.let my_str = "5"; let num: i32 = my_str.parse().unwrap(); // `num` will be 5
In the above code, we used
parse
function which is based on theFromStr
trait to convert a string slice into an i32.Similarly, we can use
From
/Into
for user-defined conversions:#[derive(Debug)] struct Number { value: i32, } impl From<i32> for Number { fn from(item: i32) -> Self { Number { value: item } } } fn main() { let num = Number::from(30); println!("My number is {:?}", num); }
This example creates a
Number
struct from ani32
using theFrom
trait.文章来源:https://www.toymoban.com/news/detail-619966.html
In all these examples, type conversion is explicit and checked at compile time, adding to the safety and robustness of Rust.文章来源地址https://www.toymoban.com/news/detail-619966.html
fn main() {
let s1 = "Rust";
let s2 = String::from(s1);
let my_number = MyNumber::from(1);
println!("{:?}", my_number); // MyNumber { num: 1 }
let spend = 3;
let my_spend: MyNumber = spend.into();
println!("{:?}", my_spend); // MyNumber { num: 3 }
let cost: i32 = "5".parse().unwrap();
println!("{}", cost); // 5
}
#[derive(Debug)]
struct MyNumber {
num: i32,
}
impl From<i32> for MyNumber {
fn from(value: i32) -> Self {
MyNumber { num: value }
}
}
到了这里,关于Rust- 类型转换的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!