编译器会根据上下文自动推断变量类型

i am a looser!

固定数组实现了Copy吧

怎么还能从下往上推断啊我去

编译器成精

get

多维数组该怎么表示呢，矩阵运算会经常用到多维数组，有小伙伴能解答一下吗

@MagicPrince666
和c/c++好像差不多。

c里面数组名有两个意思——代表数组本身，仅限于使用sizeof的时候；代表数组的头指针。
rust里面就把这意思分开了，[i32;5]代表数组本身；&[i32]就是数组的指针，不过不是头指针，而是切片的第一个元素的指针。（[i32]没有找到可以类比的东西，不太明白。）

let a: [[i32;5];3] = [[1;5];3];
// 访问第一行
let a1: &[i32;5] = &a[0];
// 访问第一行，第一个
let a11: &i32 = &a[0][0];

// 利用切片
// 在一维度上获取除了第一行的整个数组的切片引用
let b: &[[i32;5]] = &a[1..];
// 利用整个数组的切片，获取获取第二行，除了第一个的切片
let b1: &[i32] = &b[0][1..];
// 获取第二行第二个的引用
let b11: &i32 = &b1[0];

等号左边的类型声明不是必须的，这里写出来方便理解。
如果不是用&，例如a1 = a[0],如果不是基础类型的数组，就会导致所有权转移，而rust禁止所有权从数组转移出去，就会报错。
个人理解，不一定对。

固定长度数组[T; length]，切片&[T]，rust不接受不定长度的数组[T]

use std::mem::size_of;

fn main() {
    dbg!(size_of::<&[i32]>());
    dbg!(size_of::<&[i32; 3]>());
}

输出：

[src/main.rs:4] size_of::<&[i32]>() = 16
[src/main.rs:5] size_of::<&[i32; 3]>() = 8

如果你尝试size_of::<[i32]>() 会提示

the size for values of type `[i32]` cannot be known at compilation time
the trait `Sized` is not implemented for `[i32]`

[src/main.rs:4] size_of::<&[i32]>() = 16
[src/main.rs:5] size_of::<&[i32; 3]>() = 8
为什么两次的输出会不同啊，是因为&[i32]需要首尾指针，而&[i32;3]不需要吗

&[i32] 是切片 应该是一个指针加上长度(我猜测长度应该取的是isize)，&[i32; 3]应该是数组的引用为一个指针大小，64位机器寻址是八个字节，所以前者为8+8(i64)后者为8, 如果是32位机器的话，前者大小为 4 + 4(i32) 后者是 4.

拿c来说，c的数组名字代表数组本身及头指针，但是rust有分开了他们。数组名字既代表数组，但是一般用引用来使用它。

&[T]因为不知道长度，不仅需要一个usize储存地址，还要多花一个usize储存数据长度，是个胖指针，16字节。
&[T; N]因为在编译期知道数据长度固定为N所以仅储存地址，一个usize就可以了，是个瘦指针，8字节。
见知乎这个回答
Rust 的 &[T] 用了什么黑魔法，大小有时是8字节，有时是16字节？ - FancyFlame的回答 - 知乎
https://www.zhihu.com/question/613011034/answer/3127368455

对呀, 在2.4 复合类型下面. 组合基本类型都是复合类型.

我觉得需要摒弃其他语言的特性来全新学习rust，不然会很难接受它的设计；我是从c过来学的，认为rust比c更方便以及安全，比python更具体，更确定（python使用变量并不需要提前定义）

数组还是在栈上，但是数组里存的是堆上的指针（引用）

我是这样理解。

我觉得结构体数组（Array）应该也是在栈上的。结构体的长度是固定的，不必放在堆上。所以结构体数组的长度也是固定的，不必放在堆上。

我同意Jly13的观点，我认为结构体数组也是分配到栈上的，因为结构体中的元素大小是确定的

你可以把&当作获取引用的操作符，括号()这里只相当于确定表达式运算优先级

看了下一章的流程控制, 提到
对于实现了 copy 特征的数组(例如 [i32; 10] )而言， for item in arr 并不会把 arr 的所有权转移，而是直接对其进行了拷贝，因此循环之后仍然可以使用 arr 。

所以,对于我举的例子, (1) 是引用借用 =>代价低； （2）是数组Copy, 深度拷贝 => 无所有权转移, 代价高
(3) 迭代器 => 和(1) 等价（因为发现 for a in &array.iter() 会编译错误.... ）

   for t in arrays {
        println!("{:?}", t);
        for k in t {
            println!("{:?}", k);
        }
    }

我这边外层和内层不加 & 借用引用，根据楼上的说法，应该是自动对arrays和t调用的.iter()

@raotaohub 的说法并不对， @panxy2013 的说法是对的。

实际上在for里面&arrays和arrays.iter()在底层是等价的，而arrays并不是直觉中的隐式调用了.iter()，而是使用Copy特性新建了一个数组。

具体可以看三个写法获取到的数据的指针，&arrays和arrays.iter()拿到的是同一个指针，而且直接就是原数组的指针，说明其底层实现确实等价，而arrays拿到的则是完全指向了另一个地址的数据集。

fn main() {
    let  class="pl-kos">[1, 2, 3];

    // 为了化简，只保留一个数组值
    let arrays: [[u8; 3]; 1]  = [one];

    println!("{:p} {:?}", &arrays, arrays);

    for t in &arrays {
        println!("{:p} {:?}", t, t);
        for k in t {
            println!("{:p} {:?}", k, k);
        }
    }
    for t in arrays {
        println!("{:p} {:?}", &t, t);
        for k in t {
            println!("{:p} {:?}", &k, k);
        }
    }
    for t in arrays.iter() {
        println!("{:p} {:?}", t, t);
        for k in t {
            println!("{:p} {:?}", k, k);
        }
    }
}

输出：

0x48297ff224 [[1, 2, 3]]
0x48297ff224 [1, 2, 3]
0x48297ff224 1
0x48297ff225 2
0x48297ff226 3
0x48297ff39c [1, 2, 3]
0x48297ff437 1
0x48297ff437 2
0x48297ff437 3
0x48297ff224 [1, 2, 3]
0x48297ff224 1
0x48297ff225 2
0x48297ff226 3

有个问题,arrays是one的copy,那么&arrays应该是array的引用,指向的是arrays的地址.arrays本身是one的copy,是已经copy后的数组了,那么arrays所在的地址应该就是&arrays指向的地址吧?为什么两个会不同?

哦,这里说的copy是for t in arrays, t是对arrays中元素的copy...这样也解释了为啥这里没有发生move

&[T] 不是 [T;n] 的话,为什么&[T] 是有长度?

&[T] 应该是 [T] 的引用?

&[T]是引用也就是个胖指针吧，包含ptr和len。ptr指向切片的开头，同时提供切片的大小len。

引用可以理解为指针，长度看硬件平台的位数决定的。

我理解 &[T] 是切片, 长度是根据当前切片 [start,end] 来决定. 算是动态长度. 所以不能明确体现在类型中.
而数组定义是需要定义长度的, 所以是 [T;n], 这样理解对么

我查了下文档，我认为指针的理解应当是正确的，Rust的引用其实是胖指针fat pointer。

尝试用这个 array:from_fn 做了几个用数组索引,作为 array value 的初始化
let array: [i32;5] = core::array::from_fn(|i| i as i32);

数组需要明确定义长度, 数组索引是 usize 类型, 定义是 i32 需要做强制转换, 查到可以用 i as i32 来表达.
from_fn 参数有点小奇怪, (|<变量>| <可以使用包含 i 的表达式>). 两个竖线的语法标识有哪里介绍么. 还是多看几遍就见怪不怪了

|_i|似乎是创建闭包的标识符，但是我还没仔细看文档。

结果一样，但是效率不同。直接for in a， 是使用了array的deep copy，在复制的array上遍历，不存在所有权转移，但是开销变大。而使用&a,就会直接在原始array上遍历，开销小。a.iter()在for in中和&a等价，因为for in有语法糖会隐式调用into_iter由&a生成和a.iter()一样的iterator。

我怀疑是不是写作发生了术语混淆，[T]其实是代表在Heap上的字面量，而[T]是Stack中对应的指针？本章节中所用的切片与之前字符串章节中的切片不是一个意思?

查了下英文原书The Rust Programming Language,高度怀疑中文版这里是术语用混淆了。

let a = [1, 2, 3, 4, 5];
let slice = &a[1..3];

英文版在这只点明了slice的type是&[i32]，所以slice应该是个指针。
而中文版的[T]应该是指解析变量slice之后得到的具体字面值[2, 3]， 显而易见[T]的大小取决于数组a里面具体是什么和切片包含的元素数量，但是编译器并不会执行切片操作然后检查a的切片大小，这要到程序运行时才会计算，所以字面值[T]大小未知。举例来说如果[T]是[i32]，但是切片大小未必是i32，还需要知道切片包含n个这样的元素，那么必须进行切片操作来计算n，最终得到[i32;n]确定[T]大小，但是编译器不负责这个。
应该说是切片取出的字面值大小不固定而不是切片的大小不固定，切片这一术语指的就是（胖）指针，大小是固定的。
这些内容在原书Dynamically Sized Types and the Sized Trait进行了专门讨论。
PS: 我是小白，不知道理解对不对，希望有大神指点。

我就更懵了, 这个 "切片类型[T]" 是什么我直接不知道, 我从前面一直看过来, 没有哪里有 "切片类型[T]" 这个术语啊

&[T]和&str一样，都是切片引用，是一个胖指针，由指向数据的指针+数据的长度组成。

可以根据编译器推导得知：
len 是 usize （基于核心架构正正数）

usize 保证始终足够大以容纳任何指针或数据结构的下标

https://stackoverflow.com/a/29592369

pub fn from_fn<T, const N: usize, F>(cb: F) -> [T; N]
where
    F: FnMut(usize) -> T,

Creates an array of type [T; N], where each element T is the returned value from cb using that element’s index.

可以帮忙解释一下这个函数构成吗，有点不太理解。这个尖括号里面的 F 的作用是什么

let bool_arr = core::array::from_fn::<_, 5, _>(|i| i % 2 == 0);
// indexes are:       0     1      2     3      4
assert_eq!(bool_arr, [true, false, true, false, true]);

这个例子也没看的太懂

pub fn from_fn<T, const N: usize, F>(cb: F) -> [T; N]
where
    F: FnMut(usize) -> T,

上面就是等价于下面这个

pub fn from_fn<T, const N: usize, F: FnMut(usize) -> T>(cb: F) -> [T; N]

泛型参数F的约束是要实现trait FnMut。
FnMut(usize) -> T 是闭包（函数）相关的三个trait的特殊语法，表示参数是usize返回类型T的并允许捕获了可变引用的闭包。
所以F是一个闭包类型的泛型参数，表示可以接受满足“参数是usize返回类型是T的并允许捕获了可变引用的闭包”要求的闭包类型。

let bool_arr = core::array::from_fn::<_, 5, _>(|i| i % 2 == 0);
// indexes are:       0     1      2     3      4
assert_eq!(bool_arr, [true, false, true, false, true]);

这个例子也没看的太懂

这个从类型来看就是返回一个长度为5的bool类型的数组。

尖括号里面的_表示泛型参数让编译器自动推导，5表示泛型参数N的值（因为这个上下文无法推导出这个参数。）

虽然实现代码没看，但是根据函数声明和你的那个例子。这个函数的作用就是利用闭包生成数组，传入的闭包是接受数组下标，然后根据下标生成数组对应下标的元素。

关于闭包相关的Fn，FnMut，FnOnce。你可以去看看。看完，你就能轻松看懂这个函数声明了。

已经看了这一点，个人观点是，感觉< >内的F类似于返回一个函数的执行结果，然后 ( )内是空值 | i | func()，|是一个分隔符，不知道这样理解是不是错误的。

对于你的内容，我不太能准确理解你的意思，所以无法判断你的回复。可能是你还没有看完教程，理解但是表述不准确，也可能就是错的。我尽量简单说一下我的理解内容，你可以自己判断一下。

<>中的F是一个泛型。泛型是表示某种类型，不是具体的值。这里F表示任意一个可变闭包类型。

函数调用的时候，| i | { i % 2 == 0 } 是闭包声明语法，是一个整体，是一个值。它作为函数调用的参数。如果无法理解闭包，可以先不太准确地理解为匿名函数的函数指针，例如下面这个函数f。

fn f(i:usize)-> bool {
  i % 2 == 0
}

简而言之，F是泛型，代表类型，|i| i%2 == 0 是闭包，一个值（不理解闭包，可以不完全正确地理解为函数指针也行）。

如果依旧不解，可以看看下面两章。我简短的回复肯定是不如文章的详细解说介绍。

https://course.rs/basic/trait/intro.html

https://course.rs/advance/functional-programing/intro.html

但是，如果是初学者建议先跳过这个问题。没学泛型，trait，闭包这些内容，肯定是无法理解的from_fn这个函数声明的。学完，再看就很简单了。