1 不使用生命周期注解```rust

//=========== 3.5 Iter version 1: 不使用生命周期 // cargo test —features ver1

[cfg(feature = “ver1”)]

mod version1 { use super::*;

  1. pub struct Iter<T> {
  2.     next: Option<&Node<T>>, //ver1: 结构体中涉及引用时，没有生命周期注解，定然出错
  3. }
  5. impl<T> List<T> {
  6.     pub fn iter(&self) -> Iter<T> {
  7.         // ver1: 定然出错: map()方法要求所有权,不能通过&self获取self.head的所有权:
  8.         Iter {
  9.             next: self.head.map(|node| &node),
  10.         }
  11.     }
  12. }
  14. impl<T> Iterator for Iter<T> {
  15.     type Item = &T;
  16.     // ver1: 定然出错: 关联类型涉及引用时没有生命周期注解
  17.     fn next(&mut self) -> Option<Self::Item> {
  18.         self.next.map(|node| {
  19.             // ver1: 不能通过&mut self取得map()所要求的self.next的所有权
  20.             self.next = node.next.map(|node| &node);
  21.             &node.elem // ver1: 涉及引用时没有生命周期注解
  22.         })
  23.     }
  24. }

}

  2. - 结构体字段涉及引用时，一定需要生命周期注解
  3. - 函数签名涉及引用时，除self之外，通常需要生命周期注解，除非是后面论述的省略生命周期注解的情形
  4. <a name="7wGXT"></a>
  5. # 2 涉及引用的地方都使用生命周期```rust
  6. //=========== 3.5 Iter Version 2: 所有引用都使用生命周期注解
  7. // cargo test --features ver2
  8. #[cfg(feature = "ver2")]
  9. mod version2 {
  10.     use super::*;
  12.     pub struct Iter<'a, T> {
  13.         next: Option<&'a Node<T>>,
  14.     }
  16.     impl<'a, T> List<T> {
  17.         pub fn iter(&'a self) -> Iter<'a, T> {
  18.             Iter {
  19.                                 // 这里有词法错误: 即使不使用特征 ver2,这里也编译出错：生命周期注解只能用于类型声明、函数签名中。
  20.                 next: self.head.map(|node| &'a node),
  21.             }
  22.         }
  23.     }
  25.     impl<'a, T> Iterator for Iter<'a, T> {
  26.         type Item = &'a T;
  27.         fn next(&'a mut self) -> Option<Self::Item> {
  28.             self.next.map(|node| {
  29.                 // 这里有词法错误: 即使不使用特征 ver2,这里也编译出错：生命周期注解只能用于类型声明、函数签名中。
  30.                 self.next = node.next.map(|node| &'a node);
  31.                 &node.elem
  32.             })
  33.         }
  34.     }
  35. }
  • 生命周期注解仅用于类型声明、函数签名等处，用于修饰引用类型；而不能用于取引用的场合。

  • 如果在取引用的地方使用生命周期注解，则词法检查都通不过，根本不会进行到语法检查步骤。

    3 生命周期详解

    3.1 生命周期是什么

  • 生命周期是程序中一个代码区域(region/block/scope)的名字。

    • 对引用标记生命周期就表示，引用必须在生命周期代表的整个代码区域内有效。
    • 很多东西会影响引用必须存活多长，以及可以存活多长。
    • 生命周期系统就是一个尝试计算出每个引用的最小存活区域的协调系统。
      • 能够为引用找到一个满足所有约束条件的区域，则程序编译通过
      • 不能找到这样的区域，则编译出错。常见的错误是，引用的生命周期不够长。

        3.2 何时使用生命周期注解

  • 通常不用关注函数体中的生命周期：编译器有完全的信息，可以推导出所有约束关系，为引用找到最小存活区域。

  • 在类型声明和API级别，编译器没有完全的信息：程序员需要告知不同生命周期之间的关系，让编译器知道你要做什么。也就是说，仅仅需要在类型声明和函数签名中使用生命周期注解。
    • 理论上说，类型声明和API级别的生命周期约束也可以推导出来，但这要求对整个程序进行分析，开销巨大，实际上难以实现。而且，即使实现了，一旦编译出错，错误可能不是局部于一个函数的，难以理解。
    • 所以编译器分别对每个函数体进行借用检查，检查出的错误仅仅是局部于单个函数的，容易理解。

  • 前面的代码，在函数签名中使用了引用，但没有提供生命周期注解。这是因为某些情况非常普遍，编译器可以自动处理这些情况下的生命周期。这就是

    3.3 生命周期省略

  • 仅有一个输入参数涉及引用，则输出参数的生命周期等于这个输入参数的生命周期。

    1. fn foo(&A) -> &B; // sugar for:
    2. fn foo<'a>(&'a A) -> &'a B;

  • 每个引用类型的参数有自己的生命周期。

    1. fn foo(&A, &B, &C); // sugar for:
    2. fn foo<'a, 'b, 'c>(&'a A, &'b B, &'c C);

  • 如果有一个输入参数为&self或者&mut self，则输出生命周期等于self的生命周期。这一条仅适用于方法。

    1. fn foo(&self, &B, &C) -> &D; // sugar for:
    2. fn foo<'a, 'b, 'c>(&'a self, &'b B, &'c C) -> &'a D;

    4 正确使用生命周期注解

    4.1 仅在类型声明和函数签名中使用生命周期注解

    ```rust

    //=========== Iter Version 3: 仅在类型声明和函数签名中使用生命周期注解 // cargo test —features ver3

    [cfg(feature = “ver3”)]

    mod version3 { use super::*;

    pub struct Iter<’a, T> {

    1.   next: Option<&'a Node<T>>,

    }

    impl List {

    1.   // 这里应该可以省略生命周期注解
    2.   pub fn iter<'a>(&'a self) -> Iter<'a, T> {
    3.       // 1 List<T>的 head 字段的类型是 Option<Box<Node<T>>>
    4.       // 则 self.head 的类型是 &Option<Box<Node<T>>>(因为self的类型是&List<T>)
    5.       // 2 Option::map()方法的签名为: pub fn map<U, F>(self, f: F) -> Option<U> where F: FnOnce(T) -> U,
    6.       // 则可知node的类型是Box<Node<T>>,&node的类型是&Box<Node<T>>,map()方法的返回类型是Option<&Box<Node<T>>>
    7.       // 3 而 Iter::next的类型是 Option<&'a Node<T>>,与map()方法返回类型不匹配
    8.       // 4 此外,map()要求所有权,但不能通过引用&'a self获取self.head的所有权,必须使用 self.head.as_ref()转化成 Option<&T>
    9.       Iter {
    10.           next: self.head.map(|node| &node),
    11.       }
    12.   }

    }

    impl<’a, T> Iterator for Iter<’a, T> {

    1.   type Item = &'a T;
    2.   fn next(&mut self) -> Option<Self::Item> {
    3.       self.next.map(|node1| {
    4.           // 类似上面: self.next的类型是Option<&'a Node<T>>
    5.           // node1的类型是&'a Node<T>
    6.           // node1.next的类型是 Option<Box<&'a Node<T>>>
    7.           // node2 的类型是Box<&'a Node<T>>,其引用为&Box<&'a Node<T>>
    8.           // 这与self.next的Option类型要求的&'a Node<T>类型不匹配
    9.           self.next = node1.next.map(|node2| &node2);
    10.           &node1.elem
    11.       })
    12.   }

    } } ```

4.2 增加解引用运算符```rust

//=========== Iter Version 4: 仅在类型声明和函数签名中使用生命周期注解,并且添加解引用 // cargo test —features ver4

[cfg(feature = “ver4”)]

mod version4 { use super::*;

  1. pub struct Iter<'a, T> {
  2.     next: Option<&'a Node<T>>,
  3. }
  5. impl<T> List<T> {
  6.     pub fn iter<'a>(&'a self) -> Iter<'a, T> {
  7.         // 这里与 version3 的差别是: 增加了解引用运算符 *
  8.         // 注意: &*node 似乎是没有意义的: 解引用 与 引用 运算符的效果抵消了?
  9.         // 1 node  的类型是 Box<Node<T>>
  10.         // 2 *node 的类型是 Node<T>
  11.         // 3 &*node的类型是 &Node<T>,这与Box<Node<T>>是不同的,虽然都是引用类型
  12.         // 现在问题是: map() 要求所有权类型,而 self.head 是引用类型,不能移动所有权
  13.         Iter {
  14.             next: self.head.map(|node| &*node),
  15.         }
  16.     }
  17. }
  19. impl<'a, T> Iterator for Iter<'a, T> {
  20.     type Item = &'a T;
  21.     fn next(&mut self) -> Option<Self::Item> {
  22.         self.next.map(|node1| {
  23.             // 这里与 version4 的差别是: 增加了解引用运算符 *
  24.             // 注意: &*node2 似乎是没有意义的: 解引用 与 引用 运算符的效果抵消了?
  25.             // 1 node2  的类型是 Box<Node<T>>
  26.             // 2 *node2 的类型是 Node<T>
  27.             // 3 &*node2的类型是 &Node<T>,这与Box<Node<T>>是不同的,虽然都是引用类型
  28.             // 现在问题是: node1 类型是 &Node<T>,进而 node1.next 是引用类型,而 map() 要求所有权类型
  29.             self.next = node1.next.map(|node2| &*node2);
  30.             &node1.elem
  31.         })
  32.     }
  33. }

}

  2. <a name="H1okJ"></a>
  3. ## 4.3 使用两级解引用运算符和as_ref()```rust
  4. //=========== Iter Version 5: 仅在类型声明和函数签名中使用生命周期注解,并且添加两级解引用,使用as_ref()
  5. // cargo test --features ver5
  6. #[cfg(feature = "ver5")]
  7. mod version5 {
  8.     use super::*;
  10.     pub struct Iter<'a, T> {
  11.         next: Option<&'a Node<T>>,
  12.     }
  14.     impl<T> List<T> {
  15.         pub fn iter<'a>(&'a self) -> Iter<'a, T> {
  16.             // 这里与 version4 的差别是: (1) 增加了 as_ref() (2) 增加了一级解引用
  17.             // type Link<T> = Option<Box<Node<T>>>;
  18.             // 1 self.head 类型是 Link<T>,即 Option<Box<Node<T>>>,被包装的是所有权类型
  19.             // 2 self.head.as_ref() 类型是 Option<&Box<Node<T>>>,被包装的是引用类型
  20.             // 3 node 的类型是 &Box<Node<T>>
  21.             // 4 *node 的类型是 Box<Node<T>>
  22.             // 5 **node 的类型是 Node<T>
  23.             // 6 &**node 的类型是 &Node<T>
  24.             Iter {
  25.                 next: self.head.as_ref().map(|node| &**node),
  26.             }
  27.         }
  28.     }
  30.     impl<'a, T> Iterator for Iter<'a, T> {
  31.         type Item = &'a T;
  32.         fn next(&mut self) -> Option<Self::Item> {
  33.             self.next.map(|node1| {
  34.                 // 这里与 version4 的差别是: 增加了 as_ref()
  35.                 // type Link<T> = Option<Box<Node<T>>>;
  36.                 // 1 node1.next 类型是 Link<T>,即 Option<Box<Node<T>>>,被包装的是所有权类型
  37.                 // 2 node1.next.as_ref() 类型是 Option<&Box<Node<T>>>,被包装的是引用类型
  38.                 // 3 node2 的类型是 &Box<Node<T>>
  39.                 // 4 *node2 的类型是 Box<Node<T>>
  40.                 // 5 **node2 的类型是 Node<T>
  41.                 // 6 &**node2 的类型是 &Node<T>
  42.                 self.next = node1.next.as_ref().map(|node2| &**node2);
  43.                 &node1.elem
  44.             })
  45.         }
  46.     }
  47. }

4.4 强制解引用和泛型类型提示符

  • 编译器在必要的时候可以自动在引用类型前增加一个或者多个解引用运算符（星号），使得类型匹配，这就是强制解引用(deref coercion)
  • 但在4.3节中强制解引用没法完成工作：self.next = node1.next.as_ref().map(|node2| &**node2);
    • 右侧的node2类型为&Box<Node<T>>，加两级解引用运算符之后，类型为Node<T>，经过map()方法得到 Option<Node<T>>
    • 与左侧要求的类型是Option<&Node<T>> 相差一个引用

  • 这时候可以使用turbofish运算符::<>:rust self.next = node.next.as_ref().map::<&Node<T>, _>(|node| &node);

  • 因为map是一个带有泛型的方法rust pub fn map<U, F>(self, f: F) -> Option<U>

  • turbofish运算符的作用，就是告诉编译器，泛型参数对应的具体类型应该是什么。这也让编译器知道，应该对&node中的node应用强制解引用，程序员就不用手动加两级解引用运算符了。

    5 最终代码```rust

    //=========== Iter Version 6: 在 version5 的基础上,增加 turbofish 运算符,并且应用生命周期省略 // cargo test —features ver6

    [cfg(feature = “ver6”)]

    mod version6 { use super::*;

    pub struct Iter<’a, T> {

    1.   next: Option<&'a Node<T>>,

    }

    impl List {

    1.   pub fn iter(&self) -> Iter<T> {
    2.       Iter {
    3.           next: self.head.as_ref().map::<&Node<T>,_>(|node| &node),
    4.       }
    5.   }

    }

    impl<’a, T> Iterator for Iter<’a, T> {

    1.   type Item = &'a T;
    2.   fn next(&mut self) -> Option<Self::Item> {
    3.       self.next.map(|node1| {
    4.           self.next = node1.next.as_ref().map::<&Node<T>,_>(|node2| &node2);
    5.           &node1.elem
    6.       })
    7.   }

    } } ```

6 测试代码```rust

//========== 3.5 Iter ==========

[test]

fn iter() { let mut list = List::new(); list.push(1); list.push(2); list.push(3);

  1. let mut iter = list.iter();
  2. assert_eq!(iter.next(), Some(&3));
  3. assert_eq!(iter.next(), Some(&2));
  4. assert_eq!(iter.next(), Some(&1));
  5. assert_eq!(iter.next(), None);

} ```