Передача двумерного массива в функцию (Rust)

#массивы #функции #rust

Кто-нибудь может подсказать, как передать в функцию двумерный массив?

Желательно по ссылке, т.е. без копирования самого массива. К сожалению их "книга"
пока не богата на примеры передачи параметров в функцию. Вот как я себе это пытался
представить:

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);
}


"X" передается без проблем, а вот на "А" ругается при всех комбинациях [ ] и &, которые
я смог придумать:

src/main.rs:16:6: 16:8 error: mismatched types:
 expected `&[&[f64]]`,
    found `&[[f64; 4]; 3]`
(expected slice,
    found array of 3 elements) [E0308]
src/main.rs:16  foo(&A,&X);
                    ^~
error: aborting due to previous error
Could not compile `example`.

    

Ответы

Ответ 1

Дело в том, что, к примеру, выражение [1i32, 2, 3] возвращает тип [i32; 3] — массив
с заданной при компляции длиной. Когда же &[f64] является срезом — ссылочным типом,
состоящим из указателя на массив и длины (известной во время выполнения).

Вот так будет работать:

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];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 x:[f64;3]=[0.0;3];

    foo(&a,&x);
}



  К сожалению их "книга" пока не богата на примеры передачи параметров в функцию.


Кроме собственно официальной документации по Rust существует очень хорошее руководство
с множеством прекрасных примеров Rust by Example.


Ответ 2

Можно делать вот так, получается красивее всего:

fn foo, Row: AsRef<[f64]>>(a:Matrix,x:&[f64])
{
    for i in 0..3 {
        for j in 0..4 {
            println!("{}",a.as_ref()[i].as_ref()[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);
}


Но в этом случае длина массивов не должна превышать 32 (потолок для размерности массивов,
для которых в компиляторе поддерживается реализация типажей, в числе которых AsRef/AsMut).
Ждем реализации параметризации размерностей.