你还可以从模式的角度理解所有权和可变性。Rust 的模式出现在以下地方：

• let declarations
• Function and closure parameters
• match expressions
• if let expressions
• while let expressions
• for expressions

什么是模式？

Patterns are used to match values against structures and to, optionally, bind variables to values inside these structures. They are also used in variable declarations and parameters for functions and closures.

比如以下代码：

fn main() {
    {
        let s = "string".into();
        f(s);
    }
    // 以上代码等价于以下代码
    {
        let s: String = "string".into();
        {
            let mut a = s; // let 声明中的模式
            a += "s";
            assert_eq!(a, "strings");
        }
    }
}

fn f(mut a: String) { // 函数参数中的模式
    a += "s";
    assert_eq!(a, "strings");
}

作为参数传给函数和使用 let 从形式上看如出一辙，功能上毫无差别：你把数据的所有权转交出去，和 数据以新的、可变（独占）或者不可变（共享）方式使用，并不冲突。

一开始想的是如果一个变量一开始设置为不可变, 那么所有权转移后, 应该也是不可变的.

但是其实是否可变是一个概念, 所有权是一个概念.

所有权是 是否拥有这个变量.

是否可变 是在一个作用域内和相关上下文里表示我这段代码里的这个变量是否可变.

拥有所有权的代码可以重新设置是否可变.

嗯嗯, 理解了. 我把所有权和是否可变混为一谈了. 谢谢大佬.

--
👇
c5soft: 所有权移交后，可变不可变就由接收方自行处理了。

嗯嗯, 明白了. 所有权转移下, 是否可变就可以重新设置了. 谢谢大佬

--
👇
viruscamp: v1_iter 是不可变的，但是调用 sum 的时候 move 进 sum 变成 sum 里的一个 mut 变量了啊。 就像

struct A(i32);

fn move_mut(mut b: A) {
  // b 是可变的
}

fn main() {
  let a = A(8);// a 是不可变的
  move_mut(a); // 作为参数 move 给函数调用
}

v1_iter 是不可变的，但是调用 sum 的时候 move 进 sum 变成 sum 里的一个 mut 变量了啊。 就像

struct A(i32);

fn move_mut(mut b: A) {
  // b 是可变的
}

fn main() {
  let a = A(8);// a 是不可变的
  move_mut(a); // 作为参数 move 给函数调用
}

所有权移交后，可变不可变就由接收方自行处理了。

调用迭代器的next()才需要对变量做mut声明，为什么？去看看next调用的声明的说明或者源代码就清楚了。sum调用后果相当于std::mem::drop。

有点纠结, 内部是通过unsafe再去转换的吗, 一开始迭代器就声明成了不可变的.

--
👇
c5soft: sum函数的签名是：fn sum(self) -> S,不是 fn sum(&mut self) -> S，调用sum的时候v1_iter的所有权完全转移到sum内部，调用sum后v1_iter不能再用,所以不需要申明为 let mut v1_iter = v1.iter()。 换一种理解思路：sum拿到v1_iter后，内部会将v1_iter变成mut变量。可以理解为下面这样一段虚拟的代码：

fn sum(self:impl Iterator<Item=i32>) -> i32 {
  let mut sum=0;
  let mut self=self;
  while Some(v)=self.next() {
    sum+=v;
  }
  sum
}

sum函数的签名是：fn sum(self) -> S,不是 fn sum(&mut self) -> S，调用sum的时候v1_iter的所有权完全转移到sum内部，调用sum后v1_iter不能再用,所以不需要申明为 let mut v1_iter = v1.iter()。 换一种理解思路：sum拿到v1_iter后，内部会将v1_iter变成mut变量。可以理解为下面这样一段虚拟的代码：

fn sum(self:impl Iterator<Item=i32>) -> i32 {
  let mut sum=0;
  let mut self=self;
  while Some(v)=self.next() {
    sum+=v;
  }
  sum
}