Rust学习笔记之结构体

最新推荐文章于 2024-11-05 09:43:01 发布
最新推荐文章于 2024-11-05 09:43:01 发布
阅读量66 收藏
点赞数
文章标签： rust
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52884694/article/details/132629714
版权

我并不算金子，我是光本身

大家好，我是柒八九。

今天，我们继续Rust学习笔记的探索。我们来谈谈关于结构体的相关知识点。

如果，想了解该系列的文章，可以参考我们已经发布的文章。如下是往期文章。

文章list

  1. Rust学习笔记之Rust环境配置和入门指南
  2. Rust学习笔记之基础概念
  3. Rust学习笔记之所有权

你能所学到的知识点

  1. 认识Rust结构体 推荐阅读指数 ⭐️⭐️⭐️⭐️
  2. 如何使用结构体 推荐阅读指数 ⭐️⭐️⭐️⭐️⭐️
  3. Rust中使用方法 推荐阅读指数 ⭐️⭐️⭐️⭐️

好了，天不早了，干点正事哇。

struct，或者 structure，是一个自定义数据类型，允许你命名和包装多个相关的值，从而形成一个有意义的组合。

定义并实例化结构体

结构体和元组类似。和元组一样，结构体的每一部分可以是不同类型。但不同于元组，结构体需要命名各部分数据以便能清楚的表明其值的意义。由于有了这些名字，结构体比元组更灵活：不需要依赖顺序来指定或访问实例中的值。

定义结构体，需要使用 struct 关键字并为整个结构体提供一个名字。结构体的名字需要描述它所组合的数据的意义。接着，在大括号中，定义每一部分数据的名字和类型，我们称为 {字段|field}。

struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

一旦定义了结构体后，为了使用它，通过为每个字段指定具体值来创建这个结构体的实例。创建一个实例需要以结构体的名字开头，接着在大括号中使用 key: value 键-值对的形式提供字段

  • key 是字段的名字
  • value 是需要存储在字段中的数据值

实例中字段的顺序不需要和它们在结构体中声明的顺序一致。换句话说，结构体的定义就像一个类型的通用模板，而实例则会在这个模板中放入特定数据来创建这个类型的值。

struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

fn main() {
    let user1 = User {
        email: String::from("acb@example.com"),
        username: String::from("前端柒八九"),
        active: true,
        sign_in_count: 1,
    };
}

为了从结构体中获取某个特定的值，可以使用点号。如果我们只想要用户的邮箱地址，可以用 user1.email。

要更改结构体中的值，如果结构体的实例是可变的，我们可以使用点号并为对应的字段赋值。

fn main() {
    let mut user1 = User {
        email: String::from("abc@example.com"),
        username: String::from("前端柒八九"),
        active: true,
        sign_in_count: 1,
    };

    user1.email = String::from("789@example.com");
}

整个实例必须是可变的；Rust 并不允许只将某个字段标记为可变。

可以在函数体的最后一个表达式中构造一个结构体的新实例，来隐式地返回这个实例。

fn build_user(email: String, username: String) -> User {
    User {
        email: email,
        username: username,
        active: true,
        sign_in_count: 1,
    }
}

变量与字段同名时的字段初始化简写语法

参数名与字段名都完全相同，我们可以使用{字段初始化简写|field init shorthand}语法来重写 build_user，这样其行为与之前完全相同，不过无需重复 email 和 username 了

fn build_user(email: String, username: String) -> User {
    User {
        email,
        username,
        active: true,
        sign_in_count: 1,
    }
}

使用结构体更新语法从其他实例创建实例

使用旧实例的大部分值但改变其部分值来创建一个新的结构体实例通常很有用。这可以通过{结构体更新语法|struct update syntax}实现。

fn main() {
    // --snip--

    let user1 = User {
        email: String::from("abc@example.com"),
        username: String::from("前端柒八九"),
        active: true,
        sign_in_count: 1,
    };

    let user2 = User {
        active: user1.active,
        username: user1.username,
        email: String::from("789@example.com"),
        sign_in_count: user1.sign_in_count,
    };
}

我们为 email 设置了新的值，其他值则使用了实例中创建的 user1 中的同名值。

.. 语法指定了剩余未显式设置值的字段应有与给定实例对应字段相同的值。

fn main() {
    let user1 = User {
        email: String::from("abc@example.com"),
        username: String::from("前端柒八九"),
        active: true,
        sign_in_count: 1,
    };

    let user2 = User {
        email: String::from("789@example.com"),
        ..user1
    };
}

在 user2 中创建了一个新实例，其有不同的 email 值，不过 username、 active 和 sign_in_count 字段的值与 user1 相同。把..user1 必须放在最后，以指定其余的字段应从 user1 的相应字段中获取其值。

使用没有命名字段的元组结构体来创建不同的类型

也可以定义与元组类似的结构体，称为{元组结构体|tuple struct}。元组结构体有着结构体名称提供的含义，但没有具体的字段名，只有字段的类型。

当你想给整个元组取一个名字，并使元组成为与其他元组不同的类型时，元组结构体是很有用的，这时像常规结构体那样为每个字段命名就显得多余和形式化了。

要定义元组结构体，以 struct 关键字和结构体名开头并后跟元组中的类型。

struct Color(i32, i32, i32);
struct Point(i32, i32, i32);

fn main() {
    let black = Color(0, 0, 0);
    let origin = Point(0, 0, 0);
}

black 和 origin 值的类型不同，因为它们是不同的元组结构体的实例。

定义的每一个结构体有其自己的类型，即使结构体中的字段有着相同的类型

没有任何字段的类单元结构体

也可以定义一个没有任何字段的结构体！它们被称为{类单元结构体|unit-like structs}，因为它们类似于 ()。

类单元结构体常常在你想要在某个类型上实现 trait 但不需要在类型中存储数据的时候发挥作用。

struct AlwaysEqual;

fn main() {
    let subject = AlwaysEqual;
}

如何使用结构体

我们编写一个计算长方形面积的程序。我们会从单独的变量开始，接着重构程序直到使用结构体替代他们为止。

使用单独变量

fn main() {
    let width1 = 30;
    let height1 = 50;

    println!(
        "长方形面积为{}",
        area(width1, height1)
    );
}

fn area(width: u32, height: u32) -> u32 {
    width * height
}

使用元组重构

fn main() {
    let rect1 = (30, 50);

    println!(
         "长方形面积为{}",
        area(rect1)
    );
}

fn area(dimensions: (u32, u32)) -> u32 {
    dimensions.0 * dimensions.1
}

元组帮助我们增加了一些结构性，并且现在只需传一个参数。不过在另一方面，这个版本却有一点不明确了：元组并没有给出元素的名称，所以计算变得更费解了，因为不得不使用索引来获取元组的每一部分。

使用结构体重构

使用结构体为数据命名来为其赋予意义。我们可以将我们正在使用的元组转换成一个有整体名称而且每个部分也有对应名字的数据类型。

struct Rectangle {
    width: u32,
    height: u32,
}

fn main() {
    let rect1 = Rectangle {
        width: 30,
        height: 50,
    };

    println!(
       "长方形面积为{}",
        area(&rect1)
    );
}

fn area(rectangle: &Rectangle) -> u32 {
    rectangle.width * rectangle.height
}

定义了一个结构体并称其为 Rectangle。在大括号中定义了字段 width 和 height，类型都是 u32。接着在 main 中，我们创建了一个具体的 Rectangle 实例，它的宽是 30，高是 50。

函数 area 现在被定义为接收一个名叫 rectangle 的参数，其类型是一个结构体 Rectangle 实例的不可变借用。希望借用结构体而不是获取它的所有权，这样 main 函数就可以保持 rect1 的所有权并继续使用它，所以这就是为什么在函数签名和调用的地方会有 &。

通过派生 trait 增加实用功能

如果能够在调试程序时打印出 Rectangle 实例来查看其所有字段的值就更好了。尝试使用 println! 宏。但这并不行。

println! 宏能处理很多类型的格式，不过，{} 默认告诉 println! 使用被称为 Display 的格式：意在提供给直接终端用户查看的输出。目前为止见过的基本类型都默认实现了 Display，因为它就是向用户展示或其他任何基本类型的唯一方式。不过对于结构体，println! 应该用来输出的格式是不明确的，因为这有更多显示的可能性：

  • 是否需要逗号？
  • 需要打印出大括号吗？
  • 所有字段都应该显示吗？

由于这种不确定性，Rust 不会尝试猜测我们的意图，所以结构体并没有提供一个 Display 实现。

不过，可以在 {} 中加入 :? 指示符告诉 println! 我们想要使用叫做 Debug 的输出格式。Debug 是一个 trait，它允许我们以一种对开发者有帮助的方式打印结构体，以便当我们调试代码时能看到它的值。

Rust 确实包含了打印出调试信息的功能，不过我们必须为结构体显式选择这个功能。为此，在结构体定义之前加上外部属性 #[derive(Debug)]。

#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

fn main() {
    let rect1 = Rectangle {
        width: 30,
        height: 50,
    };

    println!("rect1 结构为 {:?}", rect1);
}

答应结果为

为了能够更好的显示数据结构，此可以使用 {:#?} 替换 println! 字符串中的 {:?}。如果在这个例子中使用了 {:#?} 风格的话，输出会看起来像这样

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

另一种使用 Debug 格式打印数值的方法是使用 dbg! 宏。dbg! 宏接收一个表达式的所有权，打印出代码中调用 dbg! 宏时所在的文件和行号，以及该表达式的结果值，并返回该值的所有权。调用 dbg! 宏会打印到标准错误控制台流（stderr），而不是 println!，后者会打印到标准输出控制台流（stdout）。

#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

fn main() {
    let scale = 2;
    let rect1 = Rectangle {
        width: dbg!(30 * scale),
        height: 50,
    };

    dbg!(&rect1);
}

输出结果为

方法语法

方法与函数类似：它们使用 fn 关键字和名称声明，可以拥有参数和返回值，同时包含在某处调用该方法时会执行的代码。

不过方法与函数是不同的，因为它们在结构体的上下文中被定义，并且它们第一个参数总是 self，它代表调用该方法的结构体实例。

定义方法

实现一个定义于 Rectangle 结构体上的 area 方法。

#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    fn area(&self) -> u32 {
        self.width * self.height
    }
}

fn main() {
    let rect1 = Rectangle {
        width: 30,
        height: 50,
    };

    println!(
        "长方形面积为{}",
        rect1.area()
    );
}

为了使函数定义于 Rectangle 的上下文中，使用 impl 块（impl 是 implementation 的缩写），这个 impl 块中的所有内容都将与 Rectangle 类型相关联。

接着将 area 函数移动到 impl 大括号中，并将签名中的第一个参数和函数体中其他地方的对应参数改成 self。然后在 main 改成使用{方法语法|method syntax}在 Rectangle 实例上调用 area 方法。方法语法获取一个实例并加上一个点号，后跟方法名、圆括号以及任何参数。

在一个 impl 块中，Self 类型是 impl 块的类型的别名。方法的第一个参数必须有一个名为 self 的 Self 类型的参数，所以 Rust 让你在第一个参数位置上只用 self 这个名字来缩写。

使用方法替代函数，除了可使用方法语法和不需要在每个函数签名中重复 self 的类型之外，其主要好处在于组织性。

Rust 有一个叫 {自动引用和解引用|automatic referencing and dereferencing}的功能。方法调用是 Rust 中少数几个拥有这种行为的地方。

它是这样工作的：当使用 object.something() 调用方法时，Rust 会自动为 object 添加 &、&mut 或 * 以便使 object 与方法签名匹配。

也就是说，这些代码是等价的：

rect1.area()
(&rect1).area();

带有更多参数的方法

让一个 Rectangle 的实例获取另一个 Rectangle 实例，如果 self 能完全包含第二个长方形则返回 true；否则返回 false。

#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    fn area(&self) -> u32 {
        self.width * self.height
    }

    fn can_hold(&self, other: &Rectangle) -> bool {
        self.width > other.width 
        && self.height > other.height
    }
}

在方法签名中，可以在 self 后增加多个参数，而且这些参数就像函数中的参数一样工作。

关联函数

所有在 impl 块中定义的函数被称为{关联函数|associated function}，因为它们与 impl 后面命名的类型相关。我们可以定义不以 self 为第一参数的关联函数（因此不是方法），因为它们并不作用于一个结构体的实例。

关联函数经常被用作返回一个结构体新实例的构造函数。

impl Rectangle {
    fn square(size: u32) -> Rectangle {
        Rectangle {
            width: size,
            height: size,
        }
    }
}

fn main() {
    let sq = Rectangle::square(3);
}

使用结构体名和 :: 语法来调用这个关联函数：比如 let sq = Rectangle::square(3);。这个方法位于结构体的命名空间中：:: 语法用于关联函数和模块创建的命名空间。

多个 impl 块

每个结构体都允许拥有多个 impl 块。

#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    fn area(&self) -> u32 {
        self.width * self.height
    }
}

impl Rectangle {
    fn can_hold(&self, other: &Rectangle) -> bool {
        self.width > other.width 
        && self.height > other.height
    }
}

后记

分享是一种态度。

参考资料：《Rust权威指南》

全文完，既然看到这里了，如果觉得不错，随手点个赞和“在看”吧。

前端小魔女
关注
[rust学习笔记]结构体
q435201823的博客
08-10 547
定义并实例化结构体 使用struct定义结构体，在花括号中声明数据名字和类型： struct User { username: String, email: String, sign_in_count: u64, active: bool, } 结构体的实例化（赋值）： let user1 = User { email: String::from("someone@example.com"), username: String::fr
如何在结构体里面套结构体_Rust 学习笔记-13 Rust 结构体
weixin_39561431的博客
12-04 1650
什么是结构体数组用于表示值的同构集合。类似地，结构体是Rust中另一个用户定义的数据类型，它允许我们组合不同类型的数据项，包括另一个结构体。结构体将数据定义为键值对.定义一个结构体struct 关键字用于声明结构体。由于结构体是静态类型的，因此结构体中的每个字段都必须与数据类型相关联。结构的命名规则和约定类似于变量。结构块必须以分号结尾.语法如下:struct Name_of_structure ...
Rust学习笔记005：结构体 struct
ResumeProject的博客
12-31 941
下面是一个简单的例子，展示了如何定义和使用struct// 定义一个结构体x: f64,y: f64,// 使用结构体// 创建 Point 结构体的实例// 访问结构体的字段println!println!// 创建可变的结构体实例，并修改字段的值// 结构体的解构println!
Rust学习笔记 3.2 结构体
Star_tears的博客
07-23 269
为引用，但默认是不可变的，如果希望可变，需要加。
Rust学习笔记
qq_59294755的博客
02-27 1673
​这是我观看杨旭老师的Rust教程的笔记，笔记中省略了一些细节部分，如有不理解的请大家观看杨旭老师的视频。
学习笔记 20240809 Rust语言-结构体自引用以及解决方法
qq_51181223的博客
08-09 1092
基于Rust语言圣经的学习笔记之结构体自引用以及解决方法
Rust语言学习笔记
2401_84009192的博客
04-21 923
for (i, d) in s.char_indices() {//s.char_indices()返回迭代器(index, char)fn calculate_length(s: &String) -> usize { // s 是 String 的引用。//方式2 dbg!ChangeColor((i32, i32, i32),(i8,i8)),//包含两个元组。//通过函数返回一个结构体的实例，以及初始化简写(字段名和值名一样，可以简写，顺序无关)(30 * scale),//打印过程值，便于调试。
Rust 学习笔记4
It_Ray的博客
11-30 1109
Rust学习笔记4
Rust学习笔记000：安装
ResumeProject的博客
12-31 946
rust学习笔记
Rust 学习笔记.zip
09-24
"Rust 学习笔记.zip"是一个开源项目，旨在为学习Rust的开发者提供详尽的教程和实践案例。在rust-notes-master这个目录中，你将找到一系列关于Rust编程的知识点和实践指南。 1. **Rust基础**：Rust的基础语法与许多...
Rust新手学习笔记，主要记录一些常见的编程例子和Rust库的基本使用
03-16
Rust是一种系统级编程语言，以其安全性、并发性以及高性能而闻名。对于初学者来说，了解Rust的基础和常见编程实例至关重要。...记得不断练习，多参考官方文档和社区资源，这将对你的Rust学习之路大有裨益。
Rust 学习笔记
qq_32303495的博客
09-15 1389
Rust 学习笔记，包括对于 Rustlings 习题的思考。
【Rust中的迭代器】
最新发布
m0_37719524的博客
11-05 760
迭代是指，在一个过程中反复重复，不断推进。在计算机领域，迭代是重复执行某一个过程的方法，每一次执行都基于上一次执行的结果。迭代器用于接入和迭代数据结构中的元素,通过"指向"他们，在几乎所有编程语言中，迭代器的功效均是如此。迭代器可定制化,通常用于数据结构的迭代遍历,有很多方便的方法使用用以实现不同的目的,可以参考rust std.“我们都无法确定选择是否正确,只是努力把选择变得正确.”
2024 Rust现代实用教程 closures闭包
喜欢打篮球的普通人
11-04 432
闭包的语法相对简洁灵活，同时也具有强大的功能。闭包在 Rust 中被广泛用于函数式编程、并发编程以及简化代码等方面。2．结构体会声明一个cal丨function,而闭包就是函数，cal丨function会包含闭包的所有代码。你可以将闭包分配给一个变量，然后使用该变量，就像它是一个函数名，来调用闭包。Fn继承至FnMut，FnMut继承至FnOnce。3．结构体会生产一些属性去捕获闭包外的参数。闭包是一种可以捕获其环境中变量的匿名函数。1．Rust编译器将闭包放入一个结构体。2．可变引用FnMut。
2024 Rust现代实用教程Generic泛型
喜欢打篮球的普通人
11-01 537
在Rust中，泛型也可以用于函数，使得函数能够处理多种类型的参数，提高代码的重用性和灵活性。泛型是一种编程语言的特性，它允许在代码中使用参数化类型，以便在不同地方使用。相同的代码逻辑处理多种数据类型，而无需为每种类型编写单独的代码！1．泛型定义结构体\枚举。2．泛型与结构体中的方法。1．提高代码的重用性。2．提高代码的可读性。3．提高代码的抽象度。
Rust异步运行时框架tokio保姆级教程
2301_78960337的博客
11-04 383
Tokio 是一个用于构建高性能异步应用程序的 Rust 异步运行时框架。它提供了基本的异步 I/O 操作、任务调度、定时器等功能，适合于构建网络服务器、客户端等。Tokio 提供了强大的工具来进行异步编程。使用它，可以轻松构建高性能的网络应用。
Rust 力扣 - 1984. 学生分数的最小差值
https://github.com/zm50
11-03 307
假设当前遍历的下标为i则，以 i 下标为最小值的学生分数的最小差值为nums[i + k - 1] - nums[i]原数组 nums 排序，遍历nums中下标为[0, nums.len() - k]的学生分数。取最小差值的最小值即为本题结果。
Rust 力扣 - 1461. 检查一个字符串是否包含所有长度为 K 的二进制子串
https://github.com/zm50
11-01 443
长度为k的二进制子串所有取值的集合为[0, sum(k)]，其中sum(k)为1 + 2 + 4 + …+ 1
auxm 注册多个router参数时报错
jioulongzi的专栏
11-03 416
最近手上有个活，打算用点新东西开发。刚好最近学习了rust开发。于是心里想：就他了。因为是web项目，网上一搜索，rust web框架auxm还不错。打开官网就开始搭建demo。最开始肯定是先写简单的demo函数，get/post路径传参，json传参，form表单传参等等。以上都很简单，有手就行。接着就整合数据库，使用了sqlx。根据auxm官网资料， auxm整合sqlx需要先初始化实例，然后注册到路由上下文中，这样就可以动态注入了。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值