湘西网站建设吧互联网广告

一、迭代与循环

1.循环

定义：循环是一种控制流结构，它会反复执行一组语句，直到满足某个条件。
控制条件：循环通常包含一个条件表达式，只有在条件为真时，循环体中的语句才会执行。
退出条件：循环执行直到条件不再满足，或者通过break、语句显式中断循环。
使用场景：适用于需要反复执行某个操作直到满足某个条件的情况。

2.迭代iteration

·定义：选代是对序列中的元素进行逐个访问的过程。
·控制条件：迭代通常使用迭代器（lterator）来实现，迭代器提供了对序列元素的访问和操作。
·退出条件：通常不需要显式的退出条件，迭代器会在处理完所有元素后自动停止。
·使用场景：适用于需要遍历数据结构中的元素的情况，例如数组、切片、集合等。

3.区别

·1.循环是一种控制流结构，它反复执行一组语句。
·2.送代是对序列中的元素进行逐个访问的过程，通常使用迭代器实现。
·3.循环可以是有限的（通过设置退出条件）或无限的（使用loop）关键字）。
·4.迭代器提供了一种更抽象的方式来处理序列，使得代码更具可读性和灵活性。
在Rust中，循环和迭代性能的差距可能会取决于具体的使用情况和编译器的优化。绝大多数情况下，Rust的迭代器是经过优化的，可以达到或接近手动编写循环的性能水平。

// &[i32] &Vec
// loop
fn sum_with_loop(arr: &[i32]) -> i32 {let mut sum = 0;for &item in arr {sum += item;}sum
}// iter
fn sum_with_iter(arr: &[i32]) -> i32 {arr.iter().sum()
}fn main() {const ARRAY_SIZE: usize = 10000;let array: Vec<i32> = (1..=ARRAY_SIZE as i32).collect();let sum1 = sum_with_loop(&array);println!("sum loop {}", sum1);let sum2 = sum_with_iter(&array);println!("sum loop {}", sum2);
}

编译及运行：

▶ cargo runCompiling ch5_iter_loop v0.1.0 (/home/wangji/code/rust/2024_rust/rust_project/ch4_iter_loop)Finished `dev` profile [unoptimized + debuginfo] target(s) in 19.20sRunning `target/debug/ch5_iter_loop`
sum loop 50005000
sum loop 50005000

二、Intoiterator、Iterator和Iter之间的关系

1.Intolterator

Intolterator是一个RustTrait，它定义了一种将类型转换为迭代器的能力。
该Trait包含一个方法into_iter，该方法返回一个实现了IteratorTrait的迭代器。

通常，当你有一个类型，希望能够对其进行迭代时，你会实现IntolteratorTrait来提供将该类型转换为迭代器的方法。

2.Iterator Trait

Iterator是Rust标准库中的Trait，定义了一种访问序列元素的方式。
·它包含了一系列方法，如next、map、filter、sum、等，用于对序列进行不同类型的操作。

·通过实现Iterator丶Trait，你可以创建自定义的迭代器，以定义如何迭代你的类型中的元素。

pub trait Iterator{
type Item;
fn next(&mut self) -> Option<Self::Item>;
}

3. 源码中经常出现的iter

·Iter是IteratorTrait的一个具体实现，通常用于对集合中的元素进行迭代。
·在Rust中，你会经常看到Iter，特别是在对数组、切片等集合类型进行迭代时。
·通过lntolteratorTrait，你可以获取到一个特定类型的迭代器，比如Iter，然后可以使用IteratorTrait的方法进行操作。

fn main() {// veclet v = vec![1, 2, 3, 4, 5]; // intoIterator 特质 into_iter// 转换为迭代器let iter = v.into_iter(); // move 所有权转移 类似ppt中的Iter Iterator的特质对象let sum: i32 = iter.sum();println!("sum: {}", sum);// println!("{:?}", v)// arraylet array = [1, 2, 3, 4, 5];let iter: std::slice::Iter<'_, i32> = array.iter();//所有权没有转移let sum: i32 = iter.sum();println!("sum: {}", sum);println!("{:?}", array);// charslet text = "hello, world!";let iter = text.chars();//所有权没有转移// 等价于let uppercase：String = iter.map(|c| c.to_ascii_uppercase()).collect();// collect表示迭代器的下一个， <String>表示返回的类型是Stringlet uppercase = iter.map(|c| c.to_ascii_uppercase()).collect::<String>();println!("uppercase: {}", uppercase);println!("{:?}", text);
}

编译及运行

▶ cargo runCompiling ch2_intoiterator_iterator_iter v0.1.0 (/home/wangji/code/rust/2024_rust/rust_project/ch5_intoiterator_iterator_iter)Finished `dev` profile [unoptimized + debuginfo] target(s) in 11.04sRunning `target/debug/ch2_intoiterator_iterator_iter`
sum: 15
sum: 15
[1, 2, 3, 4, 5]
uppercase: HELLO, WORLD!
"hello, world!"

三、获取迭代器的三种方法iter(),iter_mut()和into_iter()

1.iter()方法

iter（）方法返回一个不可变引用的迭代器，用于只读访问集合的元素。
该方法适用于你希望在不修改集合的情况下迭代元素的场景。

2.iter_mut()方法

iter_mut（）方法返回一个可变引用的迭代器，用于允许修改集合中的元素。
该方法适用于你希望在迭代过程中修改集合元素的场景。

3.into_iter()方法—尽量写

into_iter（）方法返回一个拥有所有权的迭代器，该迭代器会消耗集合本身，将所有权转移到迭代器。

该方法适用于你希望在迭代过程中拥有集合的所有权，以便进行消耗性的操作，如移除元素。

fn main() {let vec = vec![1, 2, 3, 4, 5];// iter（）for &item in vec.iter() {println!("{}", item);}println!("{:?}", vec);// 可变引用let mut vec = vec![1, 2, 3, 4, 5];for item in vec.iter_mut() {*item *= 2;}// 所有权转移println!("{:?}", vec);let vec = vec![1, 2, 3, 4, 5];for item in vec.into_iter() {println!("{}", item);}// println!("{:?}", vec);
}

编译加运行

▶ cargo runCompiling ch3_iter v0.1.0 (/home/wangji/code/rust/2024_rust/rust_project/ch6_iter)Finished `dev` profile [unoptimized + debuginfo] target(s) in 10.14sRunning `target/debug/ch3_iter`
1
2
3
4
5
[1, 2, 3, 4, 5]
[2, 4, 6, 8, 10]
1
2
3
4
5

四、自定义类型实现iter(),iter_mut()和into_iter()

#[derive(Debug)]
struct Stack<T> {items: Vec<T>,
}impl<T> Stack<T> {fn new() -> Self {Stack { items: Vec::new() }}// 入栈fn push(&mut self, item: T) {self.items.push(item);}// 出栈fn pop(&mut self) -> Option<T> {self.items.pop()}// 不可变引用fn iter(&self) -> std::slice::Iter<T> {self.items.iter()}// 返回可变引用fn iter_mut(&mut self) -> std::slice::IterMut<T> {self.items.iter_mut()}// 所有权转移！！fn into_iter(self) -> std::vec::IntoIter<T> {self.items.into_iter()}
}fn main() {let mut my_stack = Stack::new();my_stack.push(1);my_stack.push(2);my_stack.push(3);for item in my_stack.iter() {println!("Item {}", item);}println!("{:?}", my_stack);for item in my_stack.iter_mut() {*item *= 2;}println!("{:?}", my_stack);for item in my_stack.into_iter() {println!("{}", item);}// println!("{:?}", my_stack);
}

编译及运行

 cargo runCompiling ch28_custom_iter v0.1.0 (/home/wangji/installer/rust/project/ch28_custom_iter)
warning: method `pop` is never used--> src/main.rs:15:8|
6  | impl<T> Stack<T> {| ---------------- method in this implementation
...
15 |     fn pop(&mut self) -> Option<T> {|        ^^^|= note: `#[warn(dead_code)]` on by defaultwarning: `ch28_custom_iter` (bin "ch28_custom_iter") generated 1 warningFinished `dev` profile [unoptimized + debuginfo] target(s) in 12.50sRunning `target/debug/ch28_custom_iter`
Item 1
Item 2
Item 3
Stack { items: [1, 2, 3] }
Stack { items: [2, 4, 6] }
2
4
6

参考

• 2024 Rust现代实用教程