相关疑难解决方法(0)

将值传递给函数并通过"Box"传递给函数有什么区别:

fn main() {
    let mut stack_a = 3;
    let mut heap_a = Box::new(3);

    foo(&mut stack_a);
    println!("{}", stack_a);

    let r = foo2(&mut stack_a);
    // compile error if the next line is uncommented
    // println!("{}", stack_a);

    bar(heap_a);
    // compile error if the next line is uncommented
    // println!("{}", heap_a);
}

fn foo(x: &mut i32) {
    *x = 5;
}

fn foo2(x: &mut i32) -> &mut i32 {
    *x = 5;
    x
}

fn bar(mut x: Box<i32>) {
    *x = 5;
} …

如何轻松地将矢量矢量作为一片切片借用？

fn use_slice_of_slices<T>(slice_of_slices: &[&[T]]) {
    // Do something...
}

fn main() {
    let vec_of_vec = vec![vec![0]; 10];
    use_slice_of_slices(&vec_of_vec);
}

我会收到以下错误:

error[E0308]: mismatched types
 --> src/main.rs:7:25
  |
7 |     use_slice_of_slices(&vec_of_vec);
  |                         ^^^^^^^^^^^ expected slice, found struct `std::vec::Vec`
  |
  = note: expected type `&[&[_]]`
             found type `&std::vec::Vec<std::vec::Vec<{integer}>>`

我可以很容易地定义use_slice_of_slices为

fn use_slice_of_slices<T>(slice_of_slices: &[Vec<T>]) {
    // Do something
}

并且外部向量将作为切片借用,并且所有都可以工作.但是,如果仅仅为了争论,我想把它作为一片切片借用呢？

从假设自动胁迫&Vec<Vec<T>>至&[&[T]]是不可能的,那么我怎样才能定义一个函数borrow_vec_of_vec,如下？

fn borrow_vec_of_vec<'a, T: 'a>(vec_of_vec: Vec<Vec<T>>) -> &'a [&'a [T]] {
    // Borrow vec_of_vec...
}

把它用另一种方式,我怎么可能实现Borrow<[&[T]]> …

什么是错的类型a吗？

fn foo(a: &[&[f64]], x: &[f64]) {
    for i in 0..3 {
        for j in 0..4 {
            println!("{}", a[i][j]);
        }
    }
}

fn main() {
    let A: [[f64; 4]; 3] = [
        [1.1, -0.2, 0.1, 1.6],
        [0.1, -1.2, -0.2, 2.3],
        [0.2, -0.1, 1.1, 1.5],
    ];
    let mut X: [f64; 3] = [0.0; 3];

    foo(&A, &X);
}

我得到编译失败:

error[E0308]: mismatched types
  --> src/main.rs:17:9
   |
17 |     foo(&A, &X);
   |         ^^ expected slice, found array of 3 elements
   |
   = …

编者注:这个问题早于Rust 0.1(标记为2013-07-03),并且在语法上不是有效的Rust 1.0代码.答案可能仍包含有价值的信息.

有谁知道如何在Rust中创建可变的二维向量并将它们传递给要操作的函数？

这是我到目前为止所尝试的:

extern crate std;

fn promeni(rec: &[u8]) {
    rec[0][1] = 0x01u8;
}

fn main() {
    let mut rec = ~[[0x00u8,0x00u8],
        [0x00u8,0x00u8]
    ];
    io::println(u8::str(rec[0][1]));
    promeni(rec);
    io::println(u8::str(rec[0][1]));
}

这段代码不会编译：

fn main() {
    let m1 = vec![1, 2, 3];
    let m2 = vec![&m1, &m1, &m1];
    let m3 = vec![vec![1, 2, 3], vec![4, 5, 6], vec![7, 8, 9]];

    for i in &m2 {
        for j in i {
            println!("{}", j);
        }
    }

    for i in &m3 {
        for j in i {
            println!("{}", j);
        }
    }
}

fn main() {
    let m1 = vec![1, 2, 3];
    let m2 = vec![&m1, &m1, &m1];
    let m3 = vec![vec![1, 2, 3], vec![4, 5, …