【Rust进阶】通过测试驱动开发学习：03_单链表的插入

已于 2024-03-12 13:12:18 修改
阅读量1k 收藏 10
点赞数 35
分类专栏： 实战 Rust 文章标签： rust 学习 开发语言
于 2024-03-12 13:11:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/KitSSang/article/details/136649260
版权

在具体代码实现之前，先将上一章节我们接触到的一些Rust语法做一些简答的说明。

Option

Option是Rust标准库中定义的一种枚举，它有两个变体：Some和None.

Some包装了一个具体的值，而None表示失败或缺少值。

在很多编程语言中会有空值（Null）这一个概念，但在Rust中并没有，因为容易因空指针引起一些不安全的问题。

当一个值可能有也可能没有的时候，在Rust中就需要你明确的处理这两种情况。

Box

在Rust中，Box是一种智能指针类型，用于在堆上分配内存并存储数据。

  • Box类型本身是一个智能指针，它存储在栈上。
  • Box里面指向的数据是存储在堆上。
let a = Box::new(1);

box

根据上述代码，可以看出来a只是一个存储在栈上的智能指针，如果我们想用里面的值，我们需要进行解引用Deref操作。

链表操作

单链表的使用都是默认带头结点的，你可以自己在练习的时候思考一下如果是不带头结点的链表如何实现这些基本操作，在不同的使用场景各有优劣，但对你来说更能加深对数据结构和Rust语法的理解。

1. 插入

1.1 头插法建立单链表
编写测试
  1. 新建链表
// linked_list/src/lib.rs

// Unit tests
#[cfg(test)]
mod test {
    use super::*;
  
  	// ......................................
		#[test]
  	fn test_list_insert_in_head() {
      let mut list: LinkedList<i32> = LinkedList::new(0);
      assert_eq!(list, LinkedList { head: Some(Box::new(LinkedNode { data: 0, next: None })) });
  }
}
运行测试

编译错误 ❌

image-20240312102733656

分析
  1. 我们的LinkedList结构体没有实现PartialEq这个trait，从而两个实例不能够进行相等性的比较。
解决方法
  1. 给LinkedList和LinkedNode添加上PartialEq这个trait。
// linked_list/src/lib.rs

// ......................................

#[derive(Debug,PartialEq)]
pub struct LinkedNode<T> {
    data: T,
    next: Option<Box<LinkedNode<T>>>,
}

#[derive(Debug,PartialEq)]
pub struct LinkedList<T> {
    head: Option<Box<LinkedNode<T>>>,
}
运行测试 ✅
编写测试
  1. 链表插入
// linked_list/src/lib.rs

// Unit tests
#[cfg(test)]
mod test {
    use super::*;
  
  	// ......................................
		#[test]
    fn test_list_insert_in_head() {
        let mut list: LinkedList<i32> = LinkedList::new(0);
        list.insert_head(1);
        assert_eq!(list, LinkedList { head: Some(Box::new(LinkedNode { data: 0, next: Some(Box::new(LinkedNode { data: 1, next: None })) })) });
    }
}
运行测试

编译错误 ❌

image-20240312103808564

分析
  1. 我们现在还没有定义这个插入方法
解决方法

  1. 先创建该插入方法，使其能够编译通过。

    我们不要想着一步到位，想着让其一下子就跑通，我们需要重复测试开发这几个环节，将我们的代码一点点完善起来。

// linked_list/src/lib.rs

impl<T> LinkedList<T> {

  // ......................................
  // insert node in this linked list head
    pub fn insert_head(&mut self, value: T) {
    
    }
}
运行测试

测试失败 ❌

image-20240312111939956

分析

目前我们已经修复了编译错误，代码可以进行测试了，但是测试失败，左右不相等，不符合我们的预期。

  1. 我们定义的头插法，里面还没有写具体的操作代码，将代码进行完善，使其测试通过。
解决方法
  1. 完善insert_head方法，注意链表是带头结点。
  2. 目前先不管头结点里面存放数据问题，先让插入能够在头结点之后正常插入。
// linked_list/src/lib.rs

impl<T> LinkedList<T> {
// ------------------------------------------
// insert node in this linked list head
    pub fn insert_head(&mut self, value: T) {
        let new_node = LinkedNode {
            data: value,
            next: self.head.as_mut().unwrap().next.take(),
        };

        self.head.as_mut().unwrap().next = Some(Box::new(new_node));
    }
}
代码说明
  1. 创建了一个新的链表结点，将头结点所指的next赋给新结点的next。
  2. 此时头结点的next指向None。
  3. 将头结点的next重新指向新结点。

list_insert_head

  1. as_mut

    在Rust中，可变引用允许对数据进行可变访问和修改。可变引用是一种指向数据的引用，允许在引用的生命周期内对数据进行更改。这种机制使得Rust能够在编译时确保内存安全，避免数据竞争和未定义行为。

    使用可变引用的主要作用包括：

    1. 修改数据：通过可变引用，可以在不转移所有权的情况下修改数据。这使得可以在程序中安全地进行数据的更改和更新。
    2. 避免数据竞争：Rust的借用规则确保了在同一时间只能有一个可变引用，从而避免了数据竞争的发生。这种限制使得在编译时就能够避免多线程并发访问数据时可能出现的问题。
    3. 内存安全：可变引用的使用受到Rust的借用规则的限制，确保了在编译时就能够预防空指针、野指针等内存安全问题。

    Option 类型的 as_mut 方法允许您将 Option 转换为包含可变引用的 Option。这意味着您可以在 Option 包含的值上进行可变操作，而不需要将值从 Option 中取出。

  2. take

    Option 类型的 take 方法允许您从 Option 中取出值，并将 Option 设置为 None。

​

运行测试 ✅
// linked_list/src/lib.rs

#[cfg(test)]
mod test {
  
// ---------------------------------------------
#[test]
    fn test_list_insert_in_head() {
        let mut list: LinkedList<i32> = LinkedList::new(0);
        list.insert_head(1);
        assert_eq!(
            list,
            LinkedList {
                head: Some(Box::new(LinkedNode {
                    data: 0,
                    next: Some(Box::new(LinkedNode {
                        data: 1,
                        next: None
                    }))
                }))
            }
        );
        list.insert_head(2);
        assert_eq!(
            list,
            LinkedList {
                head: Some(Box::new(LinkedNode {
                    data: 0,
                    next: Some(Box::new(LinkedNode {
                        data: 2,
                        next: Some(Box::new(LinkedNode {
                            data: 1,
                            next: None
                        }))
                    }))
                }))
            }
        );
        list.insert_head(3);
        assert_eq!(
            list,
            LinkedList {
                head: Some(Box::new(LinkedNode {
                    data: 0,
                    next: Some(Box::new(LinkedNode {
                        data: 3,
                        next: Some(Box::new(LinkedNode {
                            data: 2,
                            next: Some(Box::new(LinkedNode {
                                data: 1,
                                next: None
                            }))
                        }))
                    }))
                }))
            }
        );
    }
}

我们可以多添加几个测试案例，尤其一些特殊情况下的处理。

我在代码中还实现了Display方法，可以使用打印，来查看目前我们链表的结构，关于该方法后续再介绍。

这是带头结点的头插法，你快动手试试如何使用不带头结点的头插法。

image-20240312122313556

版本管理

当我们测试通过后，我们使用git将我们的代码添加到本地仓库中。

1.2 尾插法建立单链表

完成了头插法，我们接下来进行尾插法的代码编写，但是步骤有所区别，因为我们这里并不知道表尾在哪里。所以我们需要遍历一下链表，找到表尾，然后在其后面插入数据。

先不考虑这么多，我们还是采用TDD的开发方式，来进行一步步开发。

list_insert_tail

编写测试
// linked_list/src/lib.rs

#[cfg(test)]
mod test {
  // --------------------
  
  #[test]
    fn test_list_insert_in_tail() {
        let mut list = LinkedList::new(0);
        list.insert_tail(1);
        list.insert_tail(2);
        list.insert_tail(3);
        assert_eq!(
            list,
            LinkedList {
                head: Some(Box::new(LinkedNode {
                    data: 0,
                    next: Some(Box::new(LinkedNode {
                        data: 1,
                        next: Some(Box::new(LinkedNode {
                            data: 2,
                            next: Some(Box::new(LinkedNode {
                                data: 3,
                                next: None
                            }))
                        }))
                    }))
                }))
            }
        );
    }
}
运行测试

编译错误 ❌

分析
  1. 我们只编写了测试还没有编写该方法。
解决方法
  1. 编写insert_tail方法

这次我们将方法写完后再运行测试，你也可以根据头插法，先修复代码使其能够编译运行，测试不通过再通过修改添加代码功能来解决。

代码说明
  1. 从链表的第一个结点开始，遍历，直到找到最后一个结点**（指向None)**。
  2. 找到最后一个结点后，创建一个新的结点，并插入在已经找到的最后一个结点的后面。
// linked_list/src/lib.rs

impl<T> LinkedList<T> {

    // ------------------------------------------
  	// insert node in this linked list tail
    pub fn insert_tail(&mut self, value: T) {
        let mut current_node = &mut self.head;
        while let Some(node) = current_node {
            if node.next.is_none() {
                let new_node = LinkedNode {
                    data: value,
                    next: None,
                };
                node.next = Some(Box::new(new_node));
                return;
            }
            current_node = &mut node.next;
        }
    }
}
运行测试 ✅

image-20240312125727740

同时我们也可以看到，Cargo 默认会以多线程的方式运行多个测试。这意味着多个测试将会并行执行，以加快测试的运行速度并更快地提供反馈。

可以使用 --test-threads 标志并将线程数设置为 1。这样可以确保测试按顺序执行，避免测试之间相互干扰。

image-20240312125958846

版本管理

当我们测试通过后，我们使用git将我们的代码更新提交到到本地仓库中。

下一章讲介绍链表的查找和在某个位置插入操作。

SunsJay
关注
专栏目录
一个工具包，可以更快地创建更好的Rust设备驱动程序-Rust开发
05-27
用于创建更好的Rust设备驱动程序的工具包，更快的设备驱动程序工具包＃！[no_std]一种用于编写更好的设备驱动程序的工具包，可以更快地在Apache License 2.0版（LICENSE-APACHE或http：//www.apache）下获得许可。 org / licenses / LICENSE-2.0）MIT许可证（LICENSE-MIT或http://opensource.org/licenses/MIT），由您选择。 贡献除非您明确声明，否则，您有意提交以包含在Apache-2.0许可证中的内容由您包括在作品中的任何贡献均应如上所述获得双重许可，并且
11. Linux驱动 - Rust编写Linux驱动
笨笨D幸福 - 后花园
07-18 2993
Linux 中设备通常被分为三类，每个驱动模块通常实现为这三类中的其中一种： 字符设备。通常是指可以当作一个字节流来存取的设备（比如文件）。 块设备。通常是可以驻有文件系统的设备（比如磁盘），和字符设备类似，但块设备有一个请求缓冲区，因此它们可以选择响应请求的最佳顺序。 网络设备。通常是指能与其他主机交换数据的设备。 我们以编写一个简单的字符设备驱动为例，展示如何用 Rust 来编写内核驱动。 R4L 开发环境准备 为了方便，我们把 Rust for Linux 简称为 R4L。 首先，下载 Rust
【一起学Rust · 项目实战】命令行IO项目minigrep——测试驱动开发完善功能
热门推荐
广龙宇的博客
08-30 8万+
经过前面三节的学习，我们的小工具minigrep已经实现了读取指定文件内容，并且为了后期开发和测试的方便，重构了整个项目，使错误处理规整化，模块规范化。本次我们将采用测试驱动开发（以后简称TDD）的模式进行开发，为程序编写几个程序测试用例，测试程序搜索查询字符串并返回匹配的行示例的功能，这些功能会在后面开发过程中用到。测试驱动开发，英文全称Test-Driven Development，简称TDD，是一种不同于传统软件开发流程的新型的开发方法。.........
Rust之构建命令行程序(四)：用TDD(测试-驱动-开发)模式来开发库的功能
最新发布
wing的专栏
02-23 1268
Rust之构建命令行程序(四)：用TDD(测试-驱动-开发)模式来开发库的功能
微软开源 windows-drivers-rs，用 Rust 开发 Windows 驱动程序
csdn_linuxprobe的博客
10-11 1518
Microsoft Azure 首席技术官兼著名 Windows 软件开发人员 Mark Russinovich 在社交平台上宣布，启动了一个名为 windows-drivers-rs 的新开源项目。
Flamer-插入Flame :: start_guard（_）调用的程序宏-Rust开发
05-27
一个proc宏，用于插入适当的flame :: start_guard（_）调用（用于flame）。此proc宏需要Rust 1.30。 因为Flamer是proc宏，所以proc宏可以插入适当的flame :: start_guard（_）调用（用于Flame）。此proc宏需要Rust ...
leetcoderust-leetcode-rs::light_bulb:通过解决Leetcode问题来学习Rust:crab:
06-30
通过解决 Leetcode 问题来学习 Rust。 介绍 :thought_balloon: 我相信学习和提高技能的最好方法是练习，而最好的方法是解决问题，解决很多问题。 幸运的是，它们有很多，在这里我们尝试为这些问题提供（希望如此）...
基准：:input_latin_lowercase::female_sign::female_sign:下一代下一代级级级:female_sign::female_sign::female_sign::female_sign::female_sign::female_sign::female_sign::female_sign::female_sign::female_sign::female_sign::female_sign::female_sign:read read read read
01-31
理解编译器的工作原理对于优化代码性能、跨平台开发和深入学习底层机制至关重要。Rust编译器是特定于Rust编程语言的，Rust是一种系统级编程语言，强调安全、速度和并发性，其编译器支持丰富的类型系统和所有权模型，...
learn-rust-quicksilver::video_game:Rust游戏开发可与Quicksilver一起“试用”
03-17
:video_game: Rust的Quicksilver可以“试玩” Rust游戏开发 本地运行 该存储库包含许多板条箱，每个板条箱都在下面的“部分中定义。 您要做的就是在要使用的板条箱上运行cargo run ，并与应用程序进行交互。 板条...
witnet-rust：Rust:eye_selector::crab:中Witnet分散式oracle网络协议的开源实现
02-04
witnet-rust是用Rust编写的Witnet Decentralized Oracle Network协议的开源实现。组件witnet-rust实现了旨在在Witnet生态系统中工作的许多不同组件： ：一个完全验证和存档的Witnet区块链节点。 ：用于管理Witnet...
MogDB企业应用 之 Rust驱动
夏洛的克
09-02 691
Rust是一门系统编程语言，专注于安全，尤其是并发安全，支持函数式和命令式以及泛型等编程范式的多范式语言。Rust在语法上和类似C++，但是设计者想要在保证性能的同时提供更好的内存安全。Rust已经逐步开始进入企业应用和操作系统的内核开发，之前听过几次openEuler SIG组的双周会，一些内核模块已经或即将使用Rust进行开发，虽然一些现代的开发语言现在还很难撼动传统的C/C++ 地位。但是像go和Rust已经开始在一些领域里面崭露头角。go的目标是取代C，而Rust则号称是C++ 的最佳接班人。
Rust： 编译器驱动开发
Phodal's zenthink
07-06 1417
用 Rust 来写个应用，这个想法颇久了。之前呢，要么找不到合适的场景，要么觉得 Rust 门槛有些高。直到最近呢，刚好对底层编程有点想法，便想着用这门语言做点东西玩玩。考虑到，我用这门...
使用Rust开发操作系统(UEFI基本介绍)
VenmoSnake的博客
01-25 4499
在上一篇文章中我们编写一个基本的操作系统，但是这个操作系统只有很简单的字符输入和输出功能，没有调度，没有内存管理等，但是没关系我们会一一实现他们，现在我们需要解决系统引导启动问题，之前的章节中我们接住了``的Bootloader库来完成系统引导，但是BootLoader库只提供了最基本的功能，并且是BOIS引导启动，为了让我们的系统更具现代化一些，我们使用UEFI引导启动系统 关于UEFI 在本章...
rust实现一个mysql驱动_使用Rust编写用户态驱动程序
weixin_34282589的博客
02-03 906
概览在云计算技术的发展史上，如何提高单个服务器的并发度，一直是热门的研究课题。在20年前，就有著名的“C10K”问题，即如何利用单个服务器每秒应对10K个客户端的同时访问。这么多年大量的实践证明，异步处理和基于事件(即epoll，kqueue和iocp)的响应方式成为处理这类问题的事实上标准方法。不过，人类的追求是永无至今的。15年后，当摩尔定律在硬件上的理论提升有1000倍时，有人对并发数量提出...
J2EE书籍
杨争的专栏
08-28 3458
         这些书有的早已被业界人士强烈推荐，成为掌握EJB的必读书籍，有的是实践J2EE的优秀工具书。        下面的每一本书的电子版（English）我都有，做J2EE项目的时候时不时温习一遍，做做笔记。这些书看看书名就让人兴奋，读起来让人畅快。1、Core J2EE Patterns - Best Practices and Design Strategies        介绍
树莓派基于rust编写linux驱动模块
ZechariahZheng
03-25 2221
​ 最近一直在折腾rust编写linux驱动，这个是官方仓库。官方仓库提供了基本入门文档，也可以参考我之前的文章。网上也有一些，但是基本都是基于X86的。我这里提供一份基于嵌入式Linux的rust驱动编译模块模板：https://github.com/ZechariahZheng/rpi-linux-module-rust ​ 具体编译过程可以看项目中的README。 ​ 更多的例程在官方仓库中的sample/rust/目录下找到。 ​ 用rust写驱动的过程给我的感觉是，官方的例子不多，到头还是在重用C
使用Rust从零写操作系统 (2) —— 最小化内核
xiangxianghehe的博客
06-17 5381
本系列博客系转载，出处： 知乎专栏：从零开始写 OS 所有代码都在：https://github.com/LearningOS/rcore_step_by_step 本章代码对应 commit ：40ee051072e5a4b89ca188d5620e9b30f1b68b25 概要 本章我们将把上一章创建的 独立可执行程序 编译为内核，并和 bootloader 链接成为可以被 qemu 加载的...
用Rust开发Linux驱动？内核维护者表示愿意接受
09-05 775
我们曾报道过微软有意选择 Rust 作为 C 和 C++ 的安全替代方案，Rust 是由 Mozilla 主导的系统编程语言，专注于安全、速度和并发，它最初是 Mozil...
总结一下几个月驱动开发的需求
放狼的爷们
03-04 884
1. 产品要求裁剪KO，干掉了无用函数和变量，占内存大的数组变量改成了动态申请。感受：其实KO大了也有好处，静态申请效率高啊，KO的大小，大一点嘛，但是产品的需求。。2.产品要求出1G版本，裁剪内次哦，根据场景、业务，不需要用到的内存裁剪掉。对解码器来说，就是各种通路下面偶尔的内存，安全通路，私有通路，原生通路，还有解码帧存。以前解过很多BUG是性能不足然后通过增加帧存来解决，VP9，H265，H...
rust的std::ptr::copy_nonoverlapping怎么使用？
04-28
std::ptr::copy_nonoverlapping 是 Rust 标准库中的一种用于复制非重叠内存区域的函数。它的语法如下： ```rust unsafe fn copy_nonoverlapping(src: *const T, dst: *mut T, count: usize); ``` 其中，src 是源...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值