Question

总体问题是如何使用类型注释进行嵌套的解构分配。我将两个f32值相乘，但是我不确定如果多个溢出会发生什么。因此，我想将它们分配为f64值，以防止溢出。

的Rust By Example章节中进行了轻微修改。

struct Point {
    x: f32,
    y: f32,
}

struct Rectangle {
    p1: Point,
    p2: Point,
}

fn area(rect: Rectangle) -> f64 {
    // Here's where I'd like have type annotations
    // while doing destructuring assignment:
    let Rectangle {
        p1: Point { x: x1, y: y1 },
        p2: Point { x: x2, y: y2 },
    } = rect;

    ((x2 - x1) * (y2 - y1)).abs() as f64
}

Answer 1

在类型结构分解期间无法执行广播。这是因为您无法注释将要包含在您要销毁的类型中的类型，因此它不依赖于您，而是依赖于要销毁的类型。例如：

struct Point {
    x: f32,
    y: f32,
}
let myOtherPoint = Point { x: 0, y: 0 };
let Point {x, y} = myOtherPoint;

x和y的类型由类型Point定义。另一方面，在元组和数组的情况下可以更改：

fn main() {
    let [x, y, z]: [f32; 3] = [1.2, 2.3, 3.4];
    let (x, y, z): (usize, f32, String) = (1, 2.3, "3.4".into());
}

这主要是由于编写函数签名时元组需要类型注释：

fn foo((a, b, c): (usize, f32, String)) {}

但这只是因为元组本身不是命名类型，所以需要通过注释类型来命名元组。另一方面，struct和enum被命名并且因此是可破坏的。

正文中描述的针对您特定问题的解决方案，而不是标题：
使用带有阴影的单独变量以保留可用性。还要注意，浮点类型（f32和f64）不能溢出（They have an infinity），只能是整数（[u, i][size, 8, 16, 32, 64, 128]）。

fn area(x: Rectangle) -> f64 {
    // Here's where I'd like have type annotations
    // while doing destructuring assignment:
    let Rectangle {
        p1: Point { x: x1, y: y1 },
        p2: Point { x: x2, y: y2 },
    } = rect;

    let (x1, x2, y1, y2) = (x1 as f64, x2 as f64,
                            y1 as f64, y2 as f64);

    ((x2 - x1) * (y2 - y1)).abs()
}

可以使用类型注释来破坏分配吗？

1 个答案: