我想将i128转换为f64 。
我知道我可以默默地施展as。
let nb: i128 = 1337;
let converted = nb as f64;
但它没有给我处理任何错误的机会。
有没有办法做类似的事情
let nb: i128 = 1337;
let converted: f64 = nb.try_into()?;
如果转换后的值不适合 f64 ，我可以在哪里处理错误？
我有一个变量，我对它进行了很多算术运算。
我的代码是这样的：
let a: u32 = 3;
let res = (a*2) - 42
a当太低时就会溢出，所以我必须使用它saturating_sub()来解决问题：
let a: u32 = 3;
let res = (a * 2).saturating_sub(42);
这确实很有效，但saturating_sub可读性不如-。
由于我有很多这样的操作，而且在每种情况下，我都希望a饱和。我想知道是否可以定义应该a始终饱和。而不是用替换-每个saturate_sub。
如果我尝试构建以下代码：
fn main () {
let my_val: u32 = 42;
match my_val % 2 {
0 => println!("We're even now"),
1 => println!("Well, that's odd"),
}
}
我会收到以下错误信息：
error[E0004]: non-exhaustive patterns: `2_u32..=u32::MAX` not covered
--> src/main.rs:4:11
|
4 | match my_val % 2 {
| ^^^^^^^^^^ pattern `2_u32..=u32::MAX` not covered
|
= note: the matched value is of type `u32`
help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
|
6 ~ 1 => println!("Well, that's odd"),
7 ~ 2_u32..=u32::MAX => todo!(),
|
我不太明白。 代表什么情况2_u32..=u32::MAX？
我想编写一个add函数，可以将这两个参数作为i64输入。f64
我得出了以下结论：
use std::ops::Add;
fn add<T: Add<Output = T>>(a: T, b: T) -> T{
a + b
}
fn main() {
let a: i64 = 10;
let b: i64 = 20;
let c: f64 = 10.5;
let d: f64 = 20.5;
println!("{:?}", add(a, b)); // Outputs: 30
println!("{:?}", add(c, d)); // Outputs: 31.0
}
是否可以修改此功能以便可以实现：
- 一个参数是
i64 - 另一个参数是
f64
如果任一参数是，f64我们进行强制转换并返回f64。
类型a |
类型b |
返回type |
|---|---|---|
i64 |
i64 |
i64 |
i64 |
f64 |
f64 |
f64 |
i64 |
f64 |
f64 |
f64 |
f64 |
主要函数将有以下输出：
fn main() {
let a: i64 = 10;
let b: i64 = 20;
let c: f64 = 10.5;
let d: f64 = 20.5;
println!("{:?}", add(a, b)); // Outputs: 30 | i64 + i64 -> i64
println!("{:?}", add(a, c)); // Outputs: 20.5 | i64 + f64 -> f64
println!("{:?}", add(c, a)); // Outputs: 20.5 | f64 + i64 -> f64
println!("{:?}", add(c, d)); // Outputs: 30.0 | f64 + f64 -> f64
}
在下面的代码中，我不明白为什么 Span需要 life。由于所有参数都实现了复制特征，我的理解是 Span 拥有所有必需的变量。
use ratatui::{
style::{Color, Style},
text::Span,
};
/// Take a u8, and render a colorized ascii, or placeholdler
fn render_ascii_char(val: u8) -> Span {
match val {
val if val > 0x20 && val < 0x7f => {
Span::styled(
val.to_string(),
Style::default().fg(Color::LightCyan)
)
},
_ => {
Span::styled(
"•",
Style::default().fg(Color::Yellow)
)
}
}
}
fn test_function() -> Span {
let val = 0x42;
render_ascii_char(val)
}
fn main() {
let _my_span = test_function();
}
这段代码使用ratatui.波纹管Cargo.toml：
[package]
name = "span_lifetime"
version = "0.1.0"
edition = "2024"
[dependencies]
crossterm = "0.27.0"
ratatui = "0.26.2"
编译时出现以下错误消息cargo build：
$ cargo build
Compiling span_lifetime v0.1.0 (/tmp/playground/span_lifetime)
error[E0106]: missing lifetime specifier
--> src/main.rs:7:34
|
7 | fn render_ascii_char(val: u8) -> Span {
| ^^^^ expected named lifetime parameter
|
= help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from
help: consider using the `'static` lifetime, but this is uncommon unless you're returning a borrowed value from a `const` or a `static`, or if you will only have owned values
|
7 | fn render_ascii_char(val: u8) -> Span<'static> {
| +++++++++
error[E0106]: missing lifetime specifier
--> src/main.rs:26:23
|
26 | fn test_function() -> Span {
| ^^^^ expected named lifetime parameter
|
= help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from
help: consider using the `'static` lifetime, but this is uncommon unless you're returning a borrowed value from a `const` or a `static`, or if you will only have owned values
|
26 | fn test_function() -> Span<'static> {
| +++++++++
For more information about this error, try `rustc --explain E0106`.
error: could not compile `span_lifetime` (bin "span_lifetime") due to 2 previous errors
使用<'static>生命周期似乎不是一个好主意，因为我不只将此函数与常量一起使用。
使用引用val: &u8作为参数，而不是val: u8确实有效。但当传递的值超出范围时，就会产生问题。
到目前为止我的解决方案是指定生命周期：
fn render_ascii_char<'a>(val: u8) -> Span<'a> {
match val {
[...]
但我真的不明白为什么需要这样做，也不明白这一生的含义。