有没有办法以数组的形式访问结构体字段？

我是 Rust 新手，正在尝试弄清楚这是否可行。

因此，有时函数/方法以数组形式访问数据会更干净，有时按名称访问数据会更干净

在 Rust 中我可以定义这样的东西：

struct Vector3D{
    x : f64,
    y : f64,
    z : f64,
    coordinates : [f64;3]
}

但每个值只需要一个存储位置。

在Java中，我所要求的（我相信）是不可能的，我使用的解决方案是这样的：

public class Vector3D {
    public static class Vec3D {
        public static final int ARRAY_SIZE = 3;
        public static final int X = 0;
        public static final int Y = 1;
        public static final int Z = 2;
    }
    private double[] coords;

    public double x(){
        return coords[Vec3D.X];
    }
}

这有点混乱，但允许我按名称访问固定大小数组的值。

在 Rust 中是否有更好的方法来做这样的事情？

你可以保留coordinates作为主存储并提供通过名称访问每个存储的方法。 此外，实施Index/IndexMut特质给人一些安慰。

#[derive(Debug)]
struct Vector3D {
    coordinates: [f64; 3],
}

impl Vector3D {
    fn x(&self) -> f64 {
        self.coordinates[0]
    }
    fn y(&self) -> f64 {
        self.coordinates[1]
    }
    fn z(&self) -> f64 {
        self.coordinates[2]
    }
    fn x_mut(&mut self) -> &mut f64 {
        &mut self.coordinates[0]
    }
    fn y_mut(&mut self) -> &mut f64 {
        &mut self.coordinates[1]
    }
    fn z_mut(&mut self) -> &mut f64 {
        &mut self.coordinates[2]
    }
}

impl std::ops::Index<usize> for Vector3D {
    type Output = f64;
    fn index(
        &self,
        idx: usize,
    ) -> &Self::Output {
        &self.coordinates[idx]
    }
}

impl std::ops::IndexMut<usize> for Vector3D {
    fn index_mut(
        &mut self,
        idx: usize,
    ) -> &mut Self::Output {
        &mut self.coordinates[idx]
    }
}

fn main() {
    let mut v = Vector3D {
        coordinates: [1.1, 2.2, 3.3],
    };
    println!("x={}, y={}, z={}", v.x(), v.y(), v.z());
    *v.x_mut() += 10.01;
    *v.y_mut() += 20.02;
    *v.z_mut() += 30.03;
    for idx in 0..3 {
        println!("v[{}]={}", idx, v[idx]);
        v[idx] *= -1.0;
    }
    println!("v={:?}", v);
}
/*
x=1.1, y=2.2, z=3.3
v[0]=11.11
v[1]=22.22
v[2]=33.33
v=Vector3D { coordinates: [-11.11, -22.22, -33.33] }
*/