data-structures - 创建命名结构的静态可迭代集合的惯用方式？

创建命名结构的静态可迭代集合的惯用方式是什么？我有一个结构的n实例，其中n在编译时是已知的，并且小于20。我希望能够遍历所有条目，还能够通过名称而不是索引来引用每个条目。所有数据在编译时都是已知的。
我可以使用数组或枚举，以及将标签映射到索引的手写常量。但这似乎很挑剔。

fn common_behaviour(x: f64) {
   print!("{}", x);
}

const ADD: usize = 0;
const SUBTRACT: usize = 1;

fn main () {
    let mut foos: [f64; 2] = [0.0; 2];
    foos[ADD] = 4.0;
    foos[SUBTRACT] = 2.0;

    for foo in &foos {
       common_behaviour(*foo);
    }
    foos[ADD] += 1.0;
    foos[SUBTRACT] -= 1.0;
}

另外，我可以只支付性能成本并使用HashMap，因为散列开销实际上可能无关紧要，但这似乎也不是很理想。
也许，我可以重构代码以使用函数指针代替特殊情况下的特殊大小写。

fn common_behaviour(x: f64) {
   print!("{}", x);
}

fn add(x: f64) -> f64 {
    x + 1.0
}

fn subtract(x: f64) -> f64 {
    x - 1.0
}

struct Foo {
   data: f64,
   special: fn(f64) -> f64
}

impl Foo {
    fn new(data: f64, special: fn(f64) -> f64) -> Foo {
        Foo { data, special }
    }
}

fn main() {
    let mut foos = [Foo::new(4.0, add), Foo::new(2.0, subtract)];

    for foo in &mut foos {
       common_behaviour(foo.data);
       foo.data = (foo.special)(foo.data);
    }
}

处理这种情况的最惯用的方法是什么？

最佳答案

看着:

fn main() {
    let mut foos = [Foo::new(4.0, add), Foo::new(2.0, subtract)];

    for foo in &mut foos {
       common_behaviour(foo.data);
       foo.data = (foo.special)(foo.data);
    }
}

我看到Command Pattern努力出现了，并且由于enum，Rust非常擅长表达这种模式:

enum Foo {
    Add(f64),
    Sub(f64),
}

impl Foo {
    fn apply(&mut self) {
        match self {
            Foo::Add(x) => {
                Self::common(*x);
                *x += 1.0;
            },
            Foo::Sub(x) => {
                Self::common(*x);
                *x -= 1.0;
            },
        }
    }

    fn common(x: f64) {
        print!("{}", x);
    }
}

您的示例变为:

fn main() {
    let mut foos = [Foo::Add(4.0), Foo::Sub(2.0)];

    for foo in &mut foos {
       foo.apply();
    }
}

关于data-structures - 创建命名结构的静态可迭代集合的惯用方式？，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/54997231/