basic/collections/vector

[giscus[bot]]

basic/collections/vector

https://course.rs/basic/collections/vector.html

[Jesse-666]

感觉这里的内容不够全

[sunface]

是的，后面会完善下，同时也会在后面的标准库解读里增加一个 Vector 常用方法的章节

[ZLD1819858]

emmm。Vector常用方法章节还是todo状态，有人接这个事情吗？没有的话我可以试试接下吗，想学习的同时献一份自己的力

[arielherself]

可以参考这个文档，我感觉还是挺全的，包括有序的集合和映射都有

[zhucan]

有个问题：动态数组，默认会分多大内存，为了避免频繁的申请内存，应该有个默认值吧，还有请问，每次push的时候都会重新分配内存吗，golang的内存分配不是这样的，如果不是重新分配内存，push时，原来的地址还是有效的，麻烦仔细讲一下这个地方。

[sunface]

其实不用想这么复杂，如果你知道你需要性能，就提前分配好相应的 capacity 即可，这个在书中和练习题中都有覆盖。

总之，感谢建议，后续会完善下。

[sunface]

对了好奇问一下。。你怎么会觉得每次 push 都重新分配内存🤣。

按理来说，熟悉 go 的切片后，看到 rust 的 len、capacity 应该很熟悉才对。

[zhucan]

就是你给的example会让人误解为，push后，内存重新分配，导致编译不过。。。。

[csx12588]

例子讲的是重新分配啊，难道默认不是重新分配？

[ghost]

这个例子其实和go是差不多的啊？go也是有个容量，当长度大于容量的时候会根据一定规则创建新切片，这个切片的地址和旧的切片地址是不一样的。这个例子不是和go的一样的吗？当容量不足时会创建新的vec，那你原来的&v[0]引用的地址肯定就不对了，rust在编译期就会拒绝编译。这也是可变借用和不可变借用为什么不能同时存在的原因

[zhucan]

我的意思是，你可以把这个地方讲细一点，我知道push不会每次都分配内存，当len=cap的时候才会，而且内存分配分两种情况，一种是grow，一种重新分配。而且你说的原因在于，内存重新分配导致那个问题，不是很正确，就算不重新分配，也会编译不过，与所有权有关系。

[Disc4will]

超长以后才重分配，重分配又要求每一个元素所有权，谁知道你什么时候重分配呢？直接在编译时写死准入就好了

[791045873]

let mut v = vec![1, 2, 3]; // 这里已经声明为mut了
for i in &mut v { // 为什么这里还要对v再次声明为mut
    *i += 10
}

要修改得是i，就算要声明，不应该是&mut i吗

[rustbomber]

这里可以好几种写法：

    for mut item in v {
        item = 234;
        println!("{}", item);
    }

或者

    for  item in &mut v {
        *item = 234;
        println!("{}", item);
    }

或者

    for  item in  v.iter_mut() {
        *item = 234;
        println!("{}", item);
    }

[jinliming2]

for 循环需要可变借用吧？取决于你离开循环后还用不用这个 vec 了。不过既然修改了，肯定是要用的，所以得是可变借用

[tianshimoyi]

为什么不直接使用 let third: i32 = v[2]; 而使用 let third: &i32 = &v[2]; 呢？这个 vector 里面的 值友 clone 属性，不会发生权的转移吧

[Endermanbugzjfc]

@rustbomber 代码一会使 v 转移
https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=74d9ab8b6c11b610d3ec20f31551abb1

[Disc4will]

确实，可能是思维惯势

…

------------------ 原始邮件 ------------------ 发件人: ***@***.***>; 发送时间: 2022年6月22日(星期三) 晚上9:39 收件人: ***@***.***>; 抄送: ***@***.***>; ***@***.***>; 主题: Re: [sunface/rust-course] basic/collections/vector (Discussion #727) 为什么不直接使用 let third: i32 = v[2]; 而使用 let third: &i32 = &v[2]; 呢？这个 vector 里面的 值友 clone 属性，不会发生权的转移吧 — Reply to this email directly, view it on GitHub, or unsubscribe. You are receiving this because you commented.Message ID: ***@***.***>

[ANIDENTIFIER]

在实际使用场景中，特征对象数组要比枚举数组常见很多，主要原因在于特征对象非常灵活，而编译器对枚举的限制较多，且无法动态增加类型。
请问什么叫动态增加类型？

[Caozhiii]

使用枚举的话，编写代码就要将可能使用到的类型写到枚举的成员当中；
使用特征对象，可以在运行中将某个实现了该特征的类型添加到数组中吧？

[sinopec]

枚举的话，增加类型得改枚举代码，特征对象的话，你改自己的代码就行。

[FlorentinoJink]

特征对象的实现也可以使用&dyn

    let v1 = V6(String::from("::1"));
    let v2 = V4(String::from("127.0.0.1"));

    let v: Vec<&dyn IpAddr> = vec![&v1, &v2];
    for ip in v {
        ip.display();
    }

[csx12588]

我觉得本页的内容我都学会了，挺舒服的，看了评论区这种感觉就又没了，哎

[Swenlon]

同感，评论区大佬多。

[DjPeng-tab]

我也是这感觉，感觉后面开始综合应用再补吧

[ghost]

”数组的大小是可变的，当旧数组的大小不够用时，Rust 会重新分配一块更大的内存空间，然后把旧数组拷贝过来。这种情况下，之前的引用显然会指向一块无效的内存“
这里有个疑问，我创建了一个容量为1的vec，分别在添加第一个元素时以及第二个元素打印内存地址，根据我对上面这句话的理解：在添加第二个元素时，容量不足应该会重新创建一个新的数组才对，可是我打印了一下地址，发现是一样的。可以解惑一下吗？

let mut v1 = Vec::with_capacity(1);
    v1.push(0);
    println!("addr: {:p}", &v1);

    v1.push(1);
    println!("addr: {:p}", &v1);

输出：

addr: 0x600003c78040
addr: 0x600003c78040

[tickscn]

1. 你打印的是 v1 的地址。v1 是一个栈上的变量，地址是不会变的。
2. 试试打印 &v1[0]，不过这样结果也不一定会变，如果这个地址后面有空闲地址，很有可能直接申请过来用，这样首地址就没有发生变化。

[Jly13]

取buffer地址的话可以用v1.as_ptr()，方法说明中说：

Returns a raw pointer to the vector's buffer, or a dangling raw pointer valid for zero sized reads if the vector didn't allocate.

[liaosunny123]

"先不运行，来推断下结果，首先 first = &v[0] 进行了不可变借用，v.push 进行了可变借用，如果 first 在 v.push 之后不再使用，那么该段代码可以成功编译"
为什么v.push是可变借用？而不是因为绑定的时候声明了mut的缘故？

[Unik-lif]

应该是因为做了mut的缘故，push的操作才合法，并且push默认是可变借用。
这是下面一小段代码的运行情况

fn main() {
    let v = vec![1, 2, 3, 4, 5];

    // let first = &v[0];

    v.push(6);
    // println!("The first element is: {}", first);
}

运行结果

   Compiling playground v0.0.1 (/playground)
error[E0596]: cannot borrow `v` as mutable, as it is not declared as mutable
 --> src/main.rs:6:5
  |
2 |     let v = vec![1, 2, 3, 4, 5];
  |         - help: consider changing this to be mutable: `mut v`
...
6 |     v.push(6);
  |     ^^^^^^^^^ cannot borrow as mutable

从报错信息来看，似乎push这种操作方法默认对应的v实例是一个可变的，因此v.push是可变借用。

[Flatigers]

看 push 的方法签名，参数接收的是 &mut self。

[Kev1n3zz]

直观的理解是使用v.push(6)改变了数组的长度，这样可能会使得存储的堆的地址发生改变，即可能重新申请了存储空间，相应数组在堆的地址可能发生改变。
因此这里使用一个可变的借用是合适的，可变借用更加灵活，可以用于这种地址可能出现变化的情况。
也就是说：不可变借用和可变借用使用的出发点是 地址是否改变。

[xuyongfine]

“答案很简单，当你确保索引不会越界的时候，就用索引访问，否则用 .get。”
如何确保索引不会越界？this is a question.

[Endermanbugzjfc]

例如，访问第几个数组元素并不取决于我们，而是取决于用户的输入时，用 .get 会非常适合

[jgsun]

貌似链接失效了，Document not found (404)
请参见本书的标准库解析章节：Vector常用方法

[DearYangs]

有几个问题：
代码片段1无法通过编译（上面的“同事借用多个数组元素”）：

let mut v = vec![1, 2, 3, 4, 5];
let f: &i32 = &v[0];
v.push(6);
println!("The first element is: {f}");

代码片段2可以通过编译通过：

let mut v = vec![1, 2, 3, 4, 5];
let v1 = &v;
let f: i32 = v1[0];
v.push(6);
println!("The first element is: {f}");

这里我有几个问题：
问题1.片段2之所以能编译通过是因为它返回的是对象类型是i32，感觉就是 v1[0] ->v[0]。为什么会有这种情况问题2：这种情况在结构体的实例方法也存在，假设我要返回Person的name字段的借用对象

pub fn get_name(&self) -> &str {
     // 为什么不能是self.name，明明self都是表示的借用对象
    &self.name
}

问题3.Rust的下标索引是一个语法糖，底层是调用的Index::index方法

fn index(&self, index: I) -> &Self::Output {
    Index::index(&**self, index)
}

根据方法定义和生命周期消除规则的第3条，方法返回值和&self的生命周期是一致的，为什么片段2的f不受此影响。理论上说，片段1就是因为方法返回值和&self的生命周期是一致导致的

[DearYangs]

片段2感觉就像等价于如下的代码：

let mut v = vec![1, 2, 3, 4, 5];
let v1 = &v;
let f: i32 = v[0];
v.push(6);
println!("The first element is: {f}");

[yyleng]

片段1： f 是对v不可变借用, v.push(6) 是对 v 的可变借用。在可变借用之后使用不可变借用不合理，所以编译不过。
片段2： v1 是不可变借用, v.push(6) 是对v 的可变借用。在可变借用之后没有再使用不可变借用 v1, 所以编译通过。如果将输出的 f 修改成 v1[0], 编译依旧会错误，同理片段1。

[yyleng]

针对问题3：

// 自动解引用
let f: i32 = v1[0];

[fanchenio]

总体而言，非稳定 排序的算法的速度会“由于” 稳定 排序算法，同时，稳定 排序还会额外分配原数组一半的空间。

优于？

[miaooo0000OOOO]

希望给Person排序的那一段可以用"{:#?}"输出，否则我还要拉横向的滚动条

[hansenz42]

一开始看的时候还有点疑惑，其实这里的 “特性” 指的就是之前的 “特征” Trait 对吧？

[jinmingzhuo]

rust没有函数重载吗，为什么不用new(10)来创建一个容量为10的数组，而用with_capacity呢？

[lfod1997]

Rust 没有也不会有函数重载，但不同特征可以有重名方法，见特征章节。

话说很多新语言都丢弃了重载特性，Dart 也是。

[Endermanbugzjfc]

这样容易产生疑惑
有人可能不知道 10 代表什么，是预设数值吗？很难第一眼就想到容量的

[lbczblll]

浮点数数组的排序， 不包含 NAN 值，那么我们可以使用 partial_cmp 来作为大小判断的依据。 这里是不是要把不去掉，前面都说了存在一个 NAN 的值，还是我理解错了

[Endermanbugzjfc]

如果我们确定... 不包含 NAN 值

[dcwon]

想请教一下各位大神下面这个问题，按报错的说法，只打印v的时候也是有mutable借用和immutable借用吧？为什么把a也打印出来就会报错，不打印a就不报错？

fn main() {
  let mut v = vec![1, 2, 3];
  let a = &mut v[0];
  *a =  10;
  // 添加下面这行可以正常正常打印
  println!("{:?}", v);
  // 添加下面这行则编译报错，cannot borrow `v` as immutable because it is also borrowed as mutable
  // println!("{:?}, {a}", v);
}

[dcwon]

明白了，我的编译器版本是1.76的。

• 不打印a时，v的mutable借用的作用域是Line 1到Line4，v的immutable借用的作用域是Line 5，这样两个作用域无重叠，所以不会报错。
• 打印a时，v的mutable借用的作用域是Line 1到Line6，v的immutable借用的作用域是Line 6，两个作用域有重叠部分Line 6，导致编译报错。

fn main() {                              // Line 1
  let mut v = vec![1, 2, 3];       // Line 2
  let a = &mut v[0];                // Line 3
  *a =  10;                               // Line 4
  println!("{:?}", v);                   // Line 5
  // println!("{:?}, {a}", v);         // Line 6
}

[Wan-Yifei]

感觉还是得介绍下|a, b|是个啥。

[DylanJinx]

在 Rust 中，Vec::with_capacity(3) 创建一个具有足够空间存放 3 个元素的 Vec，但这并不意味着你不能添加更多的元素。这里的容量只是初始时预分配的内存大小，当超过这个容量时，Vec 会自动增加其容量来容纳更多元素。

[ppinkpant]

不理解EQ和Ord的可以看看这篇博客
https://rustcc.cn/article?id=6b1d9149-b557-45ea-81f2-8bd4fd9c8e6f

[cctga]

感觉这里报错和 Vec 扩容不扩容没什么关系， 即使 Vec 没有扩容操作也会报错，这里我感觉就是纯纯的 push 方法使用了 &mut self，导致和 v[0] 的 immutable borrow 冲突，虽然我们知道 push 不会改变 v[0] 的值，但是我感觉编译器不会知道 push 到底做了什么操作

let mut v = vec![1, 2, 3, 4, 5];

let first = &v[0];

v.push(6);

println!("{:?}", first);