basic/compound-type/array

[giscus[bot]]

basic/compound-type/array

https://course.rs/basic/compound-type/array.html

[TDMaker]

one 数组和 blank1 数组的元素类型是从 arrays 数组的绑定语句中推导的吗？不然，只看他们自身的绑定的话，元素应该默认为 i32 的吧？

[zhangdekui]

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

[9a-aaaaaaaa]

i am a looser!

[gongxufan]

固定数组实现了Copy吧

[HalfAkilo]

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

[Endermanbugzjfc]

编译器成精

[MoNaEcho]

  //声明数组类型后初始化值
    let array:[u8;3] = [0;3];
    //声明数组类型时同时初始化
    let array = [0u8; 3];

[ZLD1819858]

get

[Garker]

在实际开发中，使用最多的是数组切片[T]，我们往往通过引用的方式去使用&[T]，因为后者有固定的类型大小
？ 使用最多的不应该是引用切片类型吗 因为引用切片类型长度是固定的

[MagicPrince666]

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

[small-white0-0]

@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禁止所有权从数组转移出去，就会报错。
个人理解，不一定对。

[kimchi-shi]

“- 数组类型容易跟数组切片混淆，[T;n]描述了一个数组的类型，而[T]描述了切片的类型， 因为切片是运行期的数据结构，它的长度无法在编译期得知，因此不能用[T;n]的形式去描述

• [u8; 3]和[u8; 4]是不同的类型，数组的长度也是类型的一部分
• 在实际开发中，使用最多的是数组切片[T]，我们往往通过引用的方式去使用&[T]，因为后者有固定的类型大小”
  上面这段总结里，”而[T]描述了切片的类型“，”使用最多的是数组切片[T]“，这两句话是不是有问题？对应的[T]如果没有”&“符号，怎么能形成切片呢？

[wolfboyyang]

固定长度数组[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]`

[underwoodnoble]

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

[Desiki-high]

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

[preoge]

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

[minminm]

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

[acejs]

我们这里说的数组是 Rust 的基本类型，是固定长度的，这点与其他编程语言不同，其它编程语言的数组往往是可变长度的，与 Rust 中的动态数组 Vector 类似

数组是 复合类型 吧

[panxy2013]

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

[lesonky]

哎呀，越学越迷糊，可能是我TS用多了，总觉得这也不能动，那也不能动，动不动所有权就丢了，就很迷茫。就像是开拖拉机的进了飞机驾驶舱，手都不知道该放哪里

[LXGMAX]

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

[whyoyyx]

如果是结构体数组也是存储在栈上吗？

[ZLD1819858]

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

[ZLD1819858]

我是这样理解。

[Jly13]

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

[YuhangGe]

fn main() {
    let a = [1, 2, 3];
    
    let b = &(a[0..1]);
    println!("{:?}", b);

    let tmp = a[0..1];
    let b = &(tmp);
}

第 4 行的 &() 的写法也是合法的，但这里的括号怎么理解呢？理解成括号里是表达式似乎不对。如果是表达式的话就能用一个 tmp 变量来间接表达了，但第 7 行显然不对。

[wolfboyyang]

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

[Tangjj1996]

// 借用arrays的元素用作循环中
  for a in &arrays {
    print!("{:?}: ", a);
    // 将a变成一个迭代器，用于循环
    // 你也可以直接用for n in a {}来进行循环
    for n in a.iter() {
      print!("\t{} + 10 = {}", n, n+10);
    }
    let mut sum = 0;
    // 0..a.len,是一个 Rust 的语法糖，其实就等于一个数组，元素是从0,1,2一直增加到到a.len-1
    for i in 0..a.len() {
      sum += a[i];
    }
    println!("\t({:?} = {})", a, sum);
  }

为什么第一个for循环用到了引用&array，而第二个for循环只需要用a的iter()或者不用也行呢？造成这种差异最大原因是什么？

[panxy2013]

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

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

[raotaohub]

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

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

[WankkoRee]

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

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

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

fn main() {
    let one = [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

[sxfreesky123]

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

[sxfreesky123]

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

[gccdChen]

有个疑问,为什么 &[T] 是 [T;n] 类型?

[gccdChen]

let a: [i32; 5] = [1, 2, 3, 4, 5];

let slice: &[i32] = &a[1..3];

assert_eq!(slice, [2, 3]);

[gccdChen]

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

[gccdChen]

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

[Wan-Yifei]

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

[zhouyu00]

切片引用的&[T]既然是固定长度，为啥不体现在类型中呢

[ZLD1819858]

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

[panxy2013]

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

[Wan-Yifei]

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

[Capri0110]

Update: rust-lang/rust#89379
目前调用 array::from_fn 函数已经无法通过编译，会报 use of unstable library feature
请问还有什么优雅的方法初始化 array 的 heap 对象

[panxy2013]

尝试用这个 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 的表达式>). 两个竖线的语法标识有哪里介绍么. 还是多看几遍就见怪不怪了

[Wan-Yifei]

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

[st-open]

最后的总结的最后两个循环直接用 for i in a就可以了吧？

[Wan-Yifei]

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

[wangyaoyao233]

切片类型[T]拥有不固定的大小，而切片引用类型&[T]则具有固定的大小，因为 Rust 很多时候都需要固定大小数据类型，因此&[T]更有用,&str字符串切片也同理

1.切片类型为什么是[T], 切片不都是引用吗？
2.切片类型[T]拥有不固定的大小，是说切片类型的内存大小不固定吗。切片类型底层是什么样的？

[Wan-Yifei]

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

[Wan-Yifei]

查了下英文原书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: 我是小白，不知道理解对不对，希望有大神指点。

[stevenkitter]

vector没有讲么

[madjxatw]

在实际开发中，使用最多的是数组切片[T]，我们往往通过引用的方式去使用&[T]，因为后者有固定的类型大小

为什么 &[T] 是固定长度？长度是多少？如果按照C的语法来理解，难道 &[T] 相当于指针的数据长度？感觉很多地方都讲一半。

[minminm]

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

[Wan-Yifei]

切片类型[T]拥有不固定的大小，而切片引用类型&[T]则具有固定的大小

这句话我想了好半天才反应过来，切片[T]是你想切多大就有多大，而&[T]实际上就是指针。但是Rust中切片使用的具体应该是fat pointer,同时包含ptr和len两个值，ptr当然是固定大小，但是len是怎么存储的我不太清楚。不知道我理解对不对，还请高人指教。

[Endermanbugzjfc]

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

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

https://stackoverflow.com/a/29592369

[TDAkory]

std::array::from_fn(|_i| your_item_cstor)

[J1nH4ng]

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

这个例子也没看的太懂

[small-white0-0]

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的值（因为这个上下文无法推导出这个参数。）

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

[small-white0-0]

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

[J1nH4ng]

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

[small-white0-0]

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

<>中的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这个函数声明的。学完，再看就很简单了。