脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → Rust语言 → Rust迭代器

Rust可迭代类型迭代器正确创建自定义可迭代类型的方法

 更新时间：2023年12月08日 09:40:14   作者：SlimeNull  
在 Rust 中, 如果一个类型实现了 Iterator, 那么它会被同时实现 IntoIterator, 具体逻辑是返回自身, 因为自身就是迭代器,这篇文章主要介绍了Rust可迭代类型迭代器正确创建自定义可迭代类型的方法,需要的朋友可以参考下

在 Rust 中, for 语句的执行依赖于类型对于 IntoIterator 的实现, 如果某类型实现了这个 trait, 那么它就可以直接使用 for 进行循环.

直接实现

在 Rust 中, 如果一个类型实现了 Iterator, 那么它会被同时实现 IntoIterator, 具体逻辑是返回自身, 因为自身就是迭代器.

但是如果自身就是迭代器的话, 就意味着自身必须存储迭代状态, 例如当前迭代的位置. 如果是这样的话, 迭代器就只能被使用一次. 况且自身直接被传入 into_iter 方法后, 所有权被转移, 该对象就无法被再次使用了.

定义类型本身:

struct IntRange {
    current: i32,
    step: i32,
    end: i32
}

直接为其实现迭代器:

impl Iterator for IntRange {
    type Item = i32;
    fn next(&mut self) -> Option<Self::Item> {
        if self.current == self.end {
            return None;
        } else {
            let current = self.current;
            self.current += self.step;
            return Some(current);
        }
    }
}

使用该类型:

let range = IntRange { current: 0, step: 1, end: 10 };
for value in range {
    println!("v: {}", value);
}

所以结论是, 如果你的类型是一次性用品, 你可以直接对其实现 Iterator

手动实现迭代器

如果你向手动实现类似于容器的东西, 那么它当然不是一次性的. 我们应该仿照 Rust 中对切片的迭代器实现.

同时实现会转移所有权和不会转移所有权的两个迭代器对 self 和 &self 都实现 IntoIterator, 这样就可以做不转移所有权的迭代了

类型本身:

struct IntRange {
    step: i32,
    end: i32
}

两个迭代器:

struct IntRangeIter<'a> {
    range: &'a IntRange,
    current: i32,
}
struct IntRangeIntoIter {
    range: IntRange,
    current: i32,
}

两个迭代器实现:

impl Iterator for IntRangeIter<'_> {
    type Item = i32;
    fn next(&mut self) -> Option<Self::Item> {
        if self.current == self.range.end {
            return None;
        } else {
            let current = self.current;
            self.current += self.range.step;
            return Some(current);
        }
    }
}
impl Iterator for IntRangeIntoIter {
    type Item = i32;
    fn next(&mut self) -> Option<Self::Item> {
        if self.current == self.range.end {
            return None;
        } else {
            let current = self.current;
            self.current += self.range.step;
            return Some(current);
        }
    }
}

实现返回两种迭代器的 IntoIterator:

impl<'a> IntoIterator for &'a IntRange {
    type Item = i32;
    type IntoIter = IntRangeIter<'a>;
    fn into_iter(self) -> Self::IntoIter {
        IntRangeIter {
            range: self,
            current: 0
        }
    }
}
impl IntoIterator for IntRange {
    type Item = i32;
    type IntoIter = IntRangeIntoIter;
    fn into_iter(self) -> Self::IntoIter {
        IntRangeIntoIter {
            range: self,
            current: 0
        }
    }
}

使用它:

let range = IntRange { step: 1, end: 10 };
// 可以使用引用来进行 for 循环
for value in &range {
    println!("v: {}", value);
}
// 也可以直接对其进行 for 循环
for value in range {
    println!("v: {}", value);
}

切片对迭代的实现

我们知道, Rust 的切片有一个 iter 方法, 其实它就相当于对当前切片的引用调用 into_iter.

其实, 在调用切片引用的 into_iter 方法时, 本质上就是调用的其 iter 方法. 方法的实现是在 iter 内的.

let v = vec![1, 2, 3];
// 下面两个调用是等价的
let iter1 = v.iter();
let iter2 = (&v).into_iter();

如果你希望实现迭代变量可变的迭代器, 还可以为 &mut T 实现 into_iter, 当然, Rust 内部对于切片的实现, 也是这样的:

let mut v = vec![1, 2, 3];
// 下面两个调用是等价的
let mutIter = v.iter_mut();
let mutIter = (&mut v).into_iter();

总结

两种类型:

  • 对于一次性使用的类型, 可以直接对其实现迭代器 trait.
  • 对于容器, 不应该对容器本身直接实现迭代器, 而是应该单独创建迭代器类型, 然后对其本身实现 IntoIterator

为了方便用户使用, 调用之间的实现应该是这样:

  • 实现 T 的 IntoIterator
  • 实现 &T 的 iter 函数, 返回借用的迭代器.
  • 实训 &mut T 的 iter_mut 函数, 返回可变借用的迭代器.
  • 对 &T 和 &mut T 实现 into_iter 函数, 并在内部调用刚刚实现的 iter 和 iter_mut 函数.

这样, 用户就可以直接调用 iter 方法获得借用的迭代器, 然后使用 map, filter 等方法进行集合的复杂操作了

到此这篇关于Rust可迭代类型迭代器正确创建自定义可迭代类型的方法的文章就介绍到这了,更多相关Rust迭代器内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

相关文章

  • Rust Option类型基本使用详解

    Rust Option类型基本使用详解

    Rust的Option是一种强大的类型,用于处理可能为空的情况,避免了许多空值引起的运行时错误,本文介绍Rust Option类型详解,感兴趣的朋友一起看看吧
    2024-02-02
  • Rust如何进行模块化开发技巧分享

    Rust如何进行模块化开发技巧分享

    Rust模块化，模块化有助于代码的管理和层次逻辑的清晰，本文主要介绍了Rust如何进行模块化开发,结合实例代码给大家讲解的非常详细，需要的朋友可以参考下
    2023-01-01
  • rust中trait的使用方法详解

    rust中trait的使用方法详解

    trait用中文来讲就是特征,它就是一个标记,只不过这个标记被用在特定的地方,也就是类型参数的后面,下面我们就来学习一下trait的具体使用方法吧
    2023-12-12
  • 使用systemd部署r-nacos的操作方法

    使用systemd部署r-nacos的操作方法

    r-nacos是一个用rust实现的nacos服务,我们用它平替java nacos以降低服务占用内存,提升服务的稳定性,这篇文章主要介绍了使用systemd部署r-nacos,需要的朋友可以参考下
    2024-03-03
  • rust中间件actix_web在项目中的使用实战

    rust中间件actix_web在项目中的使用实战

    这篇文章主要介绍了rust中间件在项目中的使用实战,包括自定义中间件,日志中间件,Default headers,用户会话,错误处理的用法实例,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪
    2024-01-01
  • Rust生成随机数的项目实践

    Rust生成随机数的项目实践

    Rust标准库中并没有随机数生成器,常见的解决方案是使用rand包,本文主要介绍了Rust生成随机数的项目实践,具有一定的参考价值,感兴趣的可以了解一下
    2024-03-03
  • 在Rust中编写自定义Error的详细代码

    在Rust中编写自定义Error的详细代码

    Result<T, E> 类型可以方便地用于错误传导,Result<T, E>是模板类型,实例化后可以是各种类型,但 Rust 要求传导的 Result 中的 E 是相同类型的,所以我们需要编写自己的 Error 类型,本文给大家介绍了在Rust中编写自定义Error的详细代码,需要的朋友可以参考下
    2024-01-01
  • Rust突破编译器限制构造可修改的全局变量

    Rust突破编译器限制构造可修改的全局变量

    这篇文章主要为大家介绍了Rust突破编译器限制构造可修改的全局变量示例详解,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪
    2023-10-10
  • rust标准库std::env环境相关的常量

    rust标准库std::env环境相关的常量

    在本章节中, 我们探讨了Rust处理命令行参数的常见的两种方式和处理环境变量的两种常见方式, 抛开Rust的语法, 实际上在命令行参数的处理方式上, 与其它语言大同小异, 可能影响我们习惯的也就只剩下语法,本文介绍rust标准库std::env的相关知识,感兴趣的朋友一起看看吧
    2024-03-03
  • Rust中non_exhaustive的enum使用确保程序健壮性

    Rust中non_exhaustive的enum使用确保程序健壮性

    这篇文章主要为大家介绍了Rust中non_exhaustive的enum使用确保程序健壮性示例详解,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪
    2023-11-11

最新评论