Rust中的Iterator和IntoIterator介紹及應用小結

更新時間：2023年07月25日 11:13:42 作者：pilaf1990

Iterator即迭代器，它可以用于對數(shù)據(jù)結構進行迭代，被迭代的數(shù)據(jù)結構是可迭代的(iterable)，所謂的可迭代就是這個數(shù)據(jù)結構有返回迭代器的方法，這篇文章主要介紹了Rust中的Iterator和IntoIterator介紹及應用,需要的朋友可以參考下

Iterator即迭代器，它可以用于對數(shù)據(jù)結構進行迭代。被迭代的數(shù)據(jù)結構是可迭代的(iterable)，所謂的可迭代就是這個數(shù)據(jù)結構有返回迭代器的方法，由于Rust的所有權機制，對一個數(shù)據(jù)結構的迭代器，有三種：

拿走數(shù)據(jù)結構的所有權的迭代器，在數(shù)據(jù)結構的方法上體現(xiàn)為into_iter(self)。在Rust中，into方法通常都是拿走所有權的，而且方法的入?yún)elf也表明了會拿走所有權，不會拿走所有權的是&self、&mut self這種入?yún)ⅰ?/li>
不拿走數(shù)據(jù)結構的所有權，只讀取數(shù)據(jù)結構內(nèi)容的迭代器，在數(shù)據(jù)結構的方法上體現(xiàn)為iter(&self)。&self表明了只是只讀借用。
不拿走數(shù)據(jù)結構的所有權，但是可以讀寫數(shù)據(jù)結構內(nèi)容的迭代器，在數(shù)據(jù)結構的方法上體現(xiàn)為iter_mut(&mut self)。

每調(diào)用一次數(shù)據(jù)結構的迭代器方法就會返回一個迭代器（拿走數(shù)據(jù)結構所有權的迭代器方法只能調(diào)用一次），迭代器迭代完了就不能繼續(xù)使用了。

迭代器在Rust中是一個trait:

pub trait Iterator {
    /// The type of the elements being iterated over.
    /// 迭代器迭代的元素類型
    #[stable(feature = "rust1", since = "1.0.0")]
    type Item;
    /// Advances(向前移動) the iterator and returns the next value.
    ///
    /// Returns [`None`] when iteration is finished. Individual iterator
    /// implementations may choose to resume iteration, and so calling `next()`
    /// again may or may not eventually start returning [`Some(Item)`] again at some
    /// point.
    /// 迭代器取下一個元素的方法，如果沒有下一個元素，會返回None
    /// 請注意next方法的入?yún)⑹?amp;mut self，也就是入?yún)⑹强勺兊牡?，為什么可變？因為迭代器?nèi)部通常都有
    /// 記錄迭代進度的變量，比如數(shù)組下標這種，隨著迭代的進行，變量會自增，所以需要改變迭代器的狀態(tài)，用可變借用
    fn next(&mut self) -> Option<Self::Item>;
    /// 省略其它內(nèi)容
}

你可以為你的數(shù)據(jù)結構實現(xiàn)Iterator trait，使得它可迭代。我們通常在for循環(huán)中使用迭代器。Rust標準庫中的集合基本上都提供了返回迭代器的方法。比如我們最常用的Vec：

fn main() {
    // 下面是只讀迭代器的使用
    let students = vec!["張三".to_string(),"李四".to_string(),"韓老二".to_string()];
    for student in &students{
        println!("&students寫法:{}",student);
    }
    // Vec的iter()方法返回的是只讀迭代器
    for student in students.iter(){
        println!("iter()方法調(diào)用寫法:{}",student);
    }
    let mut ugly_girls = vec!["韓老二".to_string(),"葉慧三".to_string()];
    // for循環(huán)中的&mut ugly_girls寫法等同于ugly_girls.iter_mut()
    for girl in &mut ugly_girls{
        girl.push_str("--really ");
    }
    // iter_mut()方法返回的是讀寫迭代器，可以對被迭代的元素進行修改
    for girl in ugly_girls.iter_mut(){
        girl.push_str("ugly");
    }
    println!("{:?}",ugly_girls);
    let ugly_boys = vec!["吳亦".to_string(),"肖障".to_string()];
    // for ugly_boy in ugly_boys等同于for ugly_boy in ugly_boys.into_iter
    for ugly_boy in ugly_boys {
        println!("{}",ugly_boy);
    }
    // 這兒不能再訪問ugly_boys了，因為它的所有權在for循環(huán)的時候就被轉(zhuǎn)移到迭代器中了
}

執(zhí)行上述的代碼后輸出:

&students寫法:張三
&students寫法:李四
&students寫法:韓老二
iter()方法調(diào)用寫法:張三
iter()方法調(diào)用寫法:李四
iter()方法調(diào)用寫法:韓老二
["韓老二--really ugly", "葉慧三--really ugly"]
吳亦
肖障

好了，讓我們來自己搞一個數(shù)據(jù)結構，然后為它實現(xiàn)三個迭代器方法加深理解。

假設我們有一個struct:

#[derive(Debug)]
pub struct SongList {
    // 歌單中歌曲列表
    pub songs: Vec<String>,
    // 歌單創(chuàng)建時間
    pub create_time: SystemTime,
}

表示歌單的數(shù)據(jù)結構，如果我們想要在for循環(huán)中去迭代歌單內(nèi)容，我們當然可以直接通過SongList的songs字段進行迭代，但是這個是利用了Vec為我們實現(xiàn)好的迭代器，如果我們不暴露SongList內(nèi)部的結構，把SongList當成一個黑盒去遍歷，我們需要為它實現(xiàn)幾個迭代器方法，每個方法返回一個迭代器，從而可以在for循環(huán)中通過迭代器來迭代SongList。

我們需要三個自定義的struct：Iter、IterMut、IntoIter分別表示SongList的三種迭代器，然后需要SongList提供三個方法分別返回三種迭代器：

impl SongList {
    fn iter(&self) -> Iter {
        Iter::new(self)
    }
    fn iter_mut(&mut self) -> IterMut {
        IterMut::new(self)
    }
    fn into_iter(self)->IntoIter{
        IntoIter::new(self)
    }
}

實現(xiàn)只讀迭代器

// 只讀迭代器，會用到引用，所以struct要帶生命周期范型，這兒遵循Rust習慣，用'a表示生命周期參數(shù)
pub struct Iter<'a> {
    // 迭代器本身不擁有被迭代的數(shù)據(jù)，而是引用被迭代的數(shù)據(jù)，所以需要定義引用，有人的地方就有江湖，同樣有引用的地方就有生命周期'a
    pub song_list: &'a SongList,
    // 記錄迭代進度的變量
    pub index: usize,
}
impl<'a> Iter<'a> {
    // 傳入&SongList引用，就可以創(chuàng)建迭代器Iter
    fn new(song_list: &'a SongList) -> Iter {
        Iter {
            song_list,
            index: 0,
        }
    }
}
// 為Iter實現(xiàn)Iterator trait，從而讓它變成真正的迭代器
impl<'a> Iterator for Iter<'a> {
    type Item = &'a String;
    fn next(&mut self) -> Option<Self::Item> {
        if self.index < self.song_list.songs.len() {
            let result = Some(&self.song_list.songs[self.index]);
            self.index += 1;
            result
        } else {
            None
        }
    }
}
// 為了讓我們可以在for循環(huán)中通過&song_list來替代song_list.iter()，需要為&SongList實現(xiàn)IntoIterator
// 參考https://doc.rust-lang.org/std/iter/index.html中提到的內(nèi)容
// If a collection type C provides iter(), it usually also implements IntoIterator for &C, 
// with an implementation that just calls iter(). Likewise, a collection C that provides iter_mut() 
// generally implements IntoIterator for &mut C by delegating to iter_mut(). This enables a convenient shorthand:
// 
// let mut values = vec![41];
// for x in &mut values { // same as `values.iter_mut()`
//     *x += 1;
// }
// for x in &values { // same as `values.iter()`
//     assert_eq!(*x, 42);
// }
// assert_eq!(values.len(), 1);
impl<'a> IntoIterator for &'a SongList {
    // 我們的SongList中被迭代的songs是Vec<String>，所以這兒迭代的Item就是&String
    type Item = &'a String;
    type IntoIter = Iter<'a>;
    fn into_iter(self) -> Self::IntoIter {
        self.iter()
    }
}
impl SongList {
    fn iter(&self) -> Iter {
        Iter::new(self)
    }
}
fn main() {
    let song_list = SongList {
        songs: vec![
            "做個真的我".to_string(),
            "刀劍如夢".to_string(),
            "難念的經(jīng)".to_string(),
            "任逍遙".to_string(),
        ],
        create_time: SystemTime::now(),
    };
    for song in song_list.iter() {
        println!("{}", song);
    }
    for song in &song_list {
        println!("{}", song);
    }
    println!("song_list:{:#?}", song_list);
}

實現(xiàn)可修改迭代器

// 讀寫迭代器
pub struct IterMut<'a> {
    // 要持有被迭代數(shù)據(jù)結構的可變應用
    song_list: &'a mut SongList,
    index: usize,
}
impl<'a> IterMut<'a> {
    // 將&mut SongList變成IterMut的方法
    fn new(song_list: &'a mut SongList) -> IterMut {
        IterMut {
            song_list,
            index: 0,
        }
    }
}
// 為IterMut實現(xiàn)Iterator trait，讓它成為一個真正的迭代器
impl<'a> Iterator for IterMut<'a> {
    type Item = &'a mut String;
    fn next(& mut self) -> Option<Self::Item> {
        if self.index < self.song_list.songs.len() {
            let ptr = self.song_list.songs.as_mut_ptr();
            let result = Some(unsafe{&mut *ptr.add(self.index)});
            // 上面兩行不能用下面這一行實現(xiàn)，
            // 否則會報錯：error[E0495]: cannot infer an appropriate lifetime for lifetime parameter in function call due to conflicting requirements
            // 參考：https://stackoverflow.com/questions/62361624/lifetime-parameter-problem-in-custom-iterator-over-mutable-references
            // let result = Some(&mut self.song_list.songs[self.index]);
            self.index += 1;
            result
        } else {
            None
        }
    }
}
// 為了讓我們可以在for循環(huán)中通過&mut song_list來替代song_list.iter_mut()，需要為&mut SongList實現(xiàn)IntoIterator
impl<'a> IntoIterator for &'a mut SongList {
    type Item = &'a mut String;
    type IntoIter = IterMut<'a>;
    fn into_iter(self) -> Self::IntoIter {
        self.iter_mut()
    }
}
impl SongList {
    fn iter_mut(&mut self) -> IterMut {
        IterMut::new(self)
    }
}
fn main() {
    let mut zhangsan_song_list = SongList {
        songs: vec!["笑臉盈盈".to_string(), "我是一只魚".to_string()],
        create_time: SystemTime::now(),
    };
    for song in &mut zhangsan_song_list{
        song.push_str("-真的");
    }
    for song in zhangsan_song_list.iter_mut() {
        song.push_str("-好好聽啊");
    }
    println!("zhagnsan_song_list:{:#?}", zhangsan_song_list);
}

實現(xiàn)可以會拿走所有權的迭代器

// 定義一個會拿走所有權的迭代器struct
pub struct IntoIter{
    song_list:SongList
    // 不用index了，因為拿走所有權的話，從songs中拿走一個就少一個，不用再記錄迭代進度了，迭代過的都被從Vec中移除了
}
impl IntoIter {
    // 將SongList直接消耗掉，變成IntoIter，傳入的song_list變量的所有權就這樣被轉(zhuǎn)移到了迭代器中
    fn new(song_list:SongList)->Self{
       IntoIter{
           song_list
       }
    }
}
// 為IntoIter實現(xiàn)Iterator trait，讓它成為一個真正的迭代器
impl Iterator for IntoIter {
    type Item = String;
    fn next(&mut self) -> Option<Self::Item> {
        // 從Vec中pop出的元素就沒了，所以不需要我們額外定義index來記錄迭代進度了
        self.song_list.songs.pop()
    }
}
// 為了讓我們可以在for循環(huán)中通過for item in song_list來替代for item in song_list.into_iter()，需要為SongList實現(xiàn)IntoIterator
impl IntoIterator for SongList {
    type Item = String;
    type IntoIter = IntoIter;
    // 直接消耗掉SongList類型變量，將其所有權轉(zhuǎn)移到迭代器中
    fn into_iter(self) -> Self::IntoIter {
        IntoIter::new(self)
    }
}
impl SongList {
    fn into_iter(self)->IntoIter{
        IntoIter::new(self)
    }
}
fn main() {
    let lisi_song_list = SongList{
        songs:vec!["天涯".to_string(),"死不了".to_string()],
        create_time:SystemTime::now()
    };
    //或者直接寫成 for song in lisi_song_list{
    for song in lisi_song_list.into_iter(){
        println!("{}",song);
    }
}

完整代碼：

use std::iter::Iterator;
use std::time::SystemTime;
#[derive(Debug)]
pub struct SongList {
    // 歌單中歌曲列表
    pub songs: Vec<String>,
    // 歌單創(chuàng)建時間
    pub create_time: SystemTime,
}
// 只讀迭代器，會用到引用，所以struct要帶生命周期范型，這兒遵循Rust習慣，用'a表示生命周期參數(shù)
pub struct Iter<'a> {
    // 迭代器本身不擁有被迭代的數(shù)據(jù)，而是引用被迭代的數(shù)據(jù)，所以需要定義引用，有人的地方就有江湖，同樣有引用的地方就有生命周期'a
    pub song_list: &'a SongList,
    // 記錄迭代進度的變量
    pub index: usize,
}
impl<'a> Iter<'a> {
    // 傳入&SongList引用，就可以創(chuàng)建迭代器Iter
    fn new(song_list: &'a SongList) -> Iter {
        Iter {
            song_list,
            index: 0,
        }
    }
}
// 為Iter實現(xiàn)Iterator trait，從而讓它變成真正的迭代器
impl<'a> Iterator for Iter<'a> {
    type Item = &'a String;
    fn next(&mut self) -> Option<Self::Item> {
        if self.index < self.song_list.songs.len() {
            let result = Some(&self.song_list.songs[self.index]);
            self.index += 1;
            result
        } else {
            None
        }
    }
}
// 為了讓我們可以在for循環(huán)中通過&song_list來替代song_list.iter()，需要為&SongList實現(xiàn)IntoIterator
// 參考https://doc.rust-lang.org/std/iter/index.html中提到的內(nèi)容
// If a collection type C provides iter(), it usually also implements IntoIterator for &C,
// with an implementation that just calls iter(). Likewise, a collection C that provides iter_mut()
// generally implements IntoIterator for &mut C by delegating to iter_mut(). This enables a convenient shorthand:
//
// let mut values = vec![41];
// for x in &mut values { // same as `values.iter_mut()`
//     *x += 1;
// }
// for x in &values { // same as `values.iter()`
//     assert_eq!(*x, 42);
// }
// assert_eq!(values.len(), 1);
impl<'a> IntoIterator for &'a SongList {
    // 我們的SongList中被迭代的songs是Vec<String>，所以這兒迭代的Item就是&String
    type Item = &'a String;
    type IntoIter = Iter<'a>;
    fn into_iter(self) -> Self::IntoIter {
        self.iter()
    }
}
// 讀寫迭代器
pub struct IterMut<'a> {
    // 要持有被迭代數(shù)據(jù)結構的可變應用
    song_list: &'a mut SongList,
    index: usize,
}
impl<'a> IterMut<'a> {
    // 將&mut SongList變成IterMut的方法
    fn new(song_list: &'a mut SongList) -> IterMut {
        IterMut {
            song_list,
            index: 0,
        }
    }
}
// 為IterMut實現(xiàn)Iterator trait，讓它成為一個真正的迭代器
impl<'a> Iterator for IterMut<'a> {
    type Item = &'a mut String;
    fn next(& mut self) -> Option<Self::Item> {
        if self.index < self.song_list.songs.len() {
            let ptr = self.song_list.songs.as_mut_ptr();
            let result = Some(unsafe{&mut *ptr.add(self.index)});
            // 上面兩行不能用下面這一行實現(xiàn)，
            // 否則會報錯：error[E0495]: cannot infer an appropriate lifetime for lifetime parameter in function call due to conflicting requirements
            // 參考：https://stackoverflow.com/questions/62361624/lifetime-parameter-problem-in-custom-iterator-over-mutable-references
            // let result = Some(&mut self.song_list.songs[self.index]);
            self.index += 1;
            result
        } else {
            None
        }
    }
}
// 為了讓我們可以在for循環(huán)中通過&mut song_list來替代song_list.iter_mut()，需要為&mut SongList實現(xiàn)IntoIterator
impl<'a> IntoIterator for &'a mut SongList {
    type Item = &'a mut String;
    type IntoIter = IterMut<'a>;
    fn into_iter(self) -> Self::IntoIter {
        self.iter_mut()
    }
}
// 定義一個會拿走所有權的迭代器struct
pub struct IntoIter{
    song_list:SongList
    // 不用index了，因為拿走所有權的話，從songs中拿走一個就少一個，不用再記錄迭代進度了，迭代過的都被從Vec中移除了
}
impl IntoIter {
    // 將SongList直接消耗掉，變成IntoIter，傳入的song_list變量的所有權就這樣被轉(zhuǎn)移到了迭代器中
    fn new(song_list:SongList)->Self{
       IntoIter{
           song_list
       }
    }
}
// 為IntoIter實現(xiàn)Iterator trait，讓它成為一個真正的迭代器
impl Iterator for IntoIter {
    type Item = String;
    fn next(&mut self) -> Option<Self::Item> {
        // 從Vec中pop出的元素就沒了，所以不需要我們額外定義index來記錄迭代進度了
        self.song_list.songs.pop()
    }
}
// 為了讓我們可以在for循環(huán)中通過for item in song_list來替代for item in song_list.into_iter()，需要為SongList實現(xiàn)IntoIterator
impl IntoIterator for SongList {
    type Item = String;
    type IntoIter = IntoIter;
    // 直接消耗掉SongList類型變量，將其所有權轉(zhuǎn)移到迭代器中
    fn into_iter(self) -> Self::IntoIter {
        IntoIter::new(self)
    }
}
impl SongList {
    fn iter(&self) -> Iter {
        Iter::new(self)
    }
    fn iter_mut(&mut self) -> IterMut {
        IterMut::new(self)
    }
    fn into_iter(self)->IntoIter{
        IntoIter::new(self)
    }
}
fn main() {
    let song_list = SongList {
        songs: vec![
            "做個真的我".to_string(),
            "刀劍如夢".to_string(),
            "難念的經(jīng)".to_string(),
            "任逍遙".to_string(),
        ],
        create_time: SystemTime::now(),
    };
    for song in song_list.iter() {
        println!("{}", song);
    }
    for song in &song_list {
        println!("{}", song);
    }
    println!("song_list:{:#?}", song_list);
    let mut zhangsan_song_list = SongList {
        songs: vec!["笑臉盈盈".to_string(), "我是一只魚".to_string()],
        create_time: SystemTime::now(),
    };
    for song in &mut zhangsan_song_list{
        song.push_str("-真的");
    }
    for song in zhangsan_song_list.iter_mut() {
        song.push_str("-好好聽啊");
    }
    println!("zhagnsan_song_list:{:#?}", zhangsan_song_list);
    let lisi_song_list = SongList{
        songs:vec!["天涯".to_string(),"死不了".to_string()],
        create_time:SystemTime::now()
    };
    //或者直接寫成 for song in lisi_song_list{
    for song in lisi_song_list.into_iter(){
        println!("{}",song);
    }
}

運行的控制臺輸出：

做個真的我
刀劍如夢
難念的經(jīng)
任逍遙
做個真的我
刀劍如夢
難念的經(jīng)
任逍遙
song_list:SongList {
songs: [
"做個真的我",
"刀劍如夢",
"難念的經(jīng)",
"任逍遙",
],
create_time: SystemTime {
tv_sec: 1690101338,
tv_nsec: 120053000,
},
}
zhagnsan_song_list:SongList {
songs: [
"笑臉盈盈-真的-好好聽啊",
"我是一只魚-真的-好好聽啊",
],
create_time: SystemTime {
tv_sec: 1690101338,
tv_nsec: 120146000,
},
}
死不了
天涯

到此這篇關于Rust中的Iterator和IntoIterator介紹及應用的文章就介紹到這了,更多相關Rust中的Iterator和IntoIterator內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

您可能感興趣的文章:

深入理解 Rust 中的模式匹配語法(最新推薦)
Rust中的模式匹配提供了多種方式來處理不同的數(shù)據(jù)類型和場景,本文給大家介紹Rust 中的模式匹配語法,感興趣的朋友一起看看吧
2025-03-03
Rust 中單線程 Web 服務器的實現(xiàn)
本文用Rust構建單線程Web服務器,通過HTTP/TCP處理請求,返回hello.html或404.html,文中通過示例代碼介紹的非常詳細,對大家的學習或者工作具有一定的參考學習價值,需要的朋友們下面隨著小編來一起學習學習吧
2025-06-06
探索?Rust?中實用的錯誤處理技巧
探索Rust中實用的錯誤處理技巧！Rust是一門靜態(tài)類型系統(tǒng)安全且高效的編程語言,但使用過程中難免會遇到各種錯誤,學會如何正確處理這些錯誤至關重要,本指南將為您提供一些實用的錯誤處理技巧,幫助您更好地編寫健壯的代碼,需要的朋友可以參考下
2024-01-01
Rust語言之Prometheus系統(tǒng)監(jiān)控工具包的使用詳解
Prometheus?是一個開源的系統(tǒng)監(jiān)控和警報工具包,最初是由SoundCloud構建的,隨著時間的發(fā)展,Prometheus已經(jīng)具有適用于各種使用場景的版本,為了開發(fā)者方便開發(fā),更是有各種語言版本的Prometheus的開發(fā)工具包,本文主要介紹Rust版本的Prometheus開發(fā)工具包
2023-10-10
rust?中生成與使用protobuf的方法
這篇文章主要介紹了rust中protobuf生成與使用,本文給大家介紹的非常詳細，對大家的學習或工作具有一定的參考借鑒價值，需要的朋友可以參考下
2023-05-05
R語言ggplot2繪圖安裝與調(diào)試
ggplot2是R語言中最常用的繪圖包之一，它提供了一種基于圖層的繪圖語法，使得用戶可以輕松地創(chuàng)建高質(zhì)量的數(shù)據(jù)可視化圖表。在使用ggplot2之前，需要先安裝該包并進行調(diào)試。安裝ggplot2可以通過CRAN或GitHub進行，調(diào)試則需要注意數(shù)據(jù)格式、語法錯誤等問題。
2023-06-06
Rust CLI 項目構建的實現(xiàn)步驟
本文提供了一個完整的Rust CLI項目構建流程,以 anthropic-config 配置管理工具為例,文中通過示例代碼介紹的非常詳細,對大家的學習或者工作具有一定的參考學習價值,需要的朋友們下面隨著小編來一起學習學習吧
2025-12-12
Rust中的panic定義及觸發(fā)條件詳解
這篇文章主要為大家介紹了Rust中的panic定義及觸發(fā)條件詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪
2023-04-04
一文學會Rust語言如何操作JSON
JSON在Web開發(fā)中被廣泛應用于數(shù)據(jù)交換,本文主要介紹了Rust語言操作JSON,包括序列化、反序列化、JSON創(chuàng)建等多個方面,具有一定的參考價值,感興趣的可以了解一下
2024-03-03
libbpf和Rust開發(fā)ebpf程序?qū)崙?zhàn)示例
這篇文章主要為大家介紹了libbpf和Rust開發(fā)ebpf程序?qū)崙?zhàn)示例,有需要的朋友可以借鑒參考下,希望能夠有所幫助,祝大家多多進步,早日升職加薪
2023-12-12