Rust中自定义一个迭代器来迭代集合的可变引用（mut reference）的时候，经常会碰到报错：
text
error[E0495]: cannot infer an appropriate lifetime for lifetime parameter in function call due to conflicting requirements今天我们就来剖析一下到底为什么会报错。
假设我们自定义一个可变迭代器来迭代&mut Vec<T>:
rust
// 自定义的一个迭代器
// 因为迭代器struct中保存了Vec的引用，且Vec是支持范型的，所以我们的struct的签名中
// 必须得包含T，'a。'a表示Vec的引用的生命周期，T表示Vec中元素的类型
pub struct IterMut<'a, T> {
// 保存迭代进度的index
index: usize,
// 被迭代的集合的可变引用，因为我们是可变迭代，后续会修改Vec中的元素，所以需要mut引用
referred_vec: &'a mut Vec<T>,
}
// 为可变迭代器定义方法，主要是new方法，用于创建可变迭代器
impl<'a, T> IterMut<'a, T> {
pub fn new(vec: &'a mut Vec<T>) -> Self {
IterMut {
index: 0,
referred_vec: vec,
}
}
}
// 为我们自定义的IterMut实现标准库中的Iterator trait
impl<'a, T> Iterator for IterMut<'a, T> {
type Item = &'a mut T;
fn next(&mut self) -> Option<Self::Item> {
if self.index < self.referred_vec.len() {
let result:Option<&mut T> = self.referred_vec.get_mut(self.index);
self.index+=1;
result
} else {
None
}
}
}
fn main() {
// 创建一个mut的vec，绑定到Vec实例上。因为我们后续要对vec元素进行可变迭代，所以vec必须是mut的
let mut vec = vec![1, 2, 3, 4, 5];
println!("[before]vec is:{:?}", vec);
// 创建一个可变迭代器
let iterator = IterMut::new(&mut vec);
// item是&mut i32类型的，所以要改变它的值，必须得通过*解引用
for item in iterator {
if *item % 2 == 0 {
// 将偶数都乘以2
*item *= 2;
}
}
println!("[after]vec is:{:?}", vec);
}很朴实无华的程序对不对？
运行cargo run，编译器输出以下内容：
text
Compiling rust-learining v0.1.0 (/Users/dufeng/CLionProjects/rust-learining)
error[E0495]: cannot infer an appropriate lifetime for lifetime parameter in function call due to conflicting requirements
--> src/main.rs:26:41
|
26 | let result:Option<&mut T> = self.referred_vec.get_mut(self.index);
| ^^^^^^^^^^^^^^^^^
|
note: first, the lifetime cannot outlive the anonymous lifetime defined here...
--> src/main.rs:24:13
|
24 | fn next(&mut self) -> Option<Self::Item> {
| ^^^^^^^^^
note: ...so that reference does not outlive borrowed content
--> src/main.rs:26:41
|
26 | let result:Option<&mut T> = self.referred_vec.get_mut(self.index);
| ^^^^^^^^^^^^^^^^^
note: but, the lifetime must be valid for the lifetime `'a` as defined here...
--> src/main.rs:22:6
|
22 | impl<'a, T> Iterator for IterMut<'a, T> {
| ^^
note: ...so that the types are compatible
--> src/main.rs:24:46
|
24 | fn next(&mut self) -> Option<Self::Item> {
| ______________________________________________^
25 | | if self.index < self.referred_vec.len() {
26 | | let result:Option<&mut T> = self.referred_vec.get_mut(self.index);
27 | | self.index+=1;
... |
31 | | }
32 | | }
| |_____^
= note: expected `<IterMut<'a, T> as Iterator>`
found `<IterMut<'_, T> as Iterator>`
For more information about this error, try `rustc --explain E0495`.
error: could not compile `rust-learining` due to previous error真叫人头大，不是吗？
都说Rust新手可以在编译器的帮忙下写出正确的程序，但是编译器给了我提示，我还是看不懂，无从下手，抓狂，好在在网上找到了原因，一个stackoverflow上的回答，链接在参考资料中。
让我们先按照网上的解决方法解决一下，将迭代器的next方法修改一下：
再运行一下，控制台输出漂亮的正确信息：
text
Compiling rust-learining v0.1.0 (/Users/dufeng/CLionProjects/rust-learining)
Finished dev [unoptimized + debuginfo] target(s) in 0.79s
Running `target/debug/rust-learining`
[before]vec is:[1, 2, 3, 4, 5]
[after]vec is:[1, 4, 3, 8, 5]也就是说我们将next方法中的这段代码：
rust
let result:Option<&mut T> = self.referred_vec.get_mut(self.index);
self.index+=1;
result改成了：
rust
let index = self.index;
self.index += 1;
let ptr = self.referred_vec.as_mut_ptr();
Some(unsafe { &mut *(ptr.add(index)) })Why?
因为我们的迭代器其实就是个中转站，它将&mut Vec<T>中的元素的可变引用&mut T给我们一一找出来，然后我们就可以直接对&mut T进行操作了，只要一开始定义的Vec还没被回收，我们就可以操作它的元素的可变引用，不再需要迭代器了，迭代器只不过是给我们提供了方便的next方法，用于从&mut Vec<T>中拿出一系列的&mut T。
让我们再审视一下迭代器：
rust
impl<'a, T> Iterator for IterMut<'a, T> {
type Item = &'a mut T;
fn next(&mut self) -> Option<Self::Item> {
if self.index < self.referred_vec.len() {
let result:Option<&mut T> = self.referred_vec.get_mut(self.index);
self.index+=1;
result
} else {
None
}
}
}从编译器角度，next方法其实是这样的（将生命周期标出来）：
rust
fn next<'a,'b>(&'b mut self) -> Option<&'a mut T> 因为next方法入参的self是迭代器，迭代器引用有自己的生命周期'b，和&mut Vec<T>的生命周期'a没关系。
Rust编译器在方法入参只有一个引用的时候，会将入参的生命周期应用到输出上（方法中返回的result也和self有关不是吗，也就是说编译器会认为方法返回的result不应该超过迭代器&mut self的生命周期），所以，它希望next方法是这样的：
rust
fn next<'b>(&'b mut self) -> Option<&'b mut T> 那么就和我们定义的type Item = &'a mut T中的生命周期'a冲突了。
所以报错信息：
text
cannot infer an appropriate lifetime for lifetime parameter in function call due to conflicting requirements的意思就是：编译器推断的生命周期和你给的冲突了。也就是说你定义的迭代器期望是<IterMut<'a, T>,而编译器给你推断出来的是<IterMut<'_, T>,其中'_应该就是迭代器&mut self中没标记的生命周期。
解决方法就是像上面的那样，利用Unsafe跳过编译器检查：
rust
let index = self.index;
self.index += 1;
let ptr = self.referred_vec.as_mut_ptr();
Some(unsafe { &mut *(ptr.add(index)) })
这儿将vec引用转成指针，其实就是将vec第0个元素的地址作为指针返回，而且指针是有类型的，对指针加上index个步长（偏移量），会被编译器乘以T类型所占字节数的。就像在C语言中的指针操作的感觉，最后我们再将其转换成可变引用返回。
参考资料：