09:Rust中结构体

已于 2022-09-25 09:33:00 修改
阅读量407 收藏
点赞数
分类专栏： Rust程序设计基础学习笔记 文章标签： rust 开发语言 后端
于 2022-08-25 13:42:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sqzxr/article/details/126519631
版权

Rust中结构体定义和举例说明

  • 首先是结构体的定义和实例化
  • 这个是结构体的定义
struct User
{
	active: bool,
	username: String,
	email: String,
	sign_in_count: u64,
}
  • 接着是实例化
  • 使用key: value进行实例化，
struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

fn main() {
    let user1 = User {
        email: String::from("someone@example.com"),
        username: String::from("someusername123"),
        active: true,
        sign_in_count: 1,
    };
}
  • 创建可变实例可以改变字段值(字段指类似email之类的)
struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

fn main() {
    let mut user1 = User {
        email: String::from("someone@example.com"),
        username: String::from("someusername123"),
        active: true,
        sign_in_count: 1,
    };

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

接着是使用函数返回结构体中字段值:

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

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

fn main() {
    let user1 = build_user(
        String::from("someone@example.com"),
        String::from("someusername123"),
    );
}
  • 在变量和字段同名时，可以简写为:
struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

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

fn main() {
    let user1 = build_user(
        String::from("someone@example.com"),
        String::from("someusername123"),
    );
}
  • 接着是使用结构体实例创建新的实例。
struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

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

    let user1 = User {
        email: String::from("someone@example.com"),
        username: String::from("someusername123"),
        active: true,
        sign_in_count: 1,
    };

    let user2 = User {
        active: user1.active,
        username: user1.username,
        email: String::from("another@example.com"),
        sign_in_count: user1.sign_in_count,
    };
}
  • 这种代码可以使用语法糖优化，优化过后为:
struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

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

    let user1 = User {
        email: String::from("someone@example.com"),
        username: String::from("someusername123"),
        active: true,
        sign_in_count: 1,
    };

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

结构体更新语法像是带有’='的赋值，他会移动数据，user1中的username,email中的String字段会被移动到user2中，如果只是用user1中的active、sign_in_count值而不使用username、email值，则user1仍然可用，因为active、sign_in_count值是copy trait变量。

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

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

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


fn main() {
    struct Color(u8, u8, u8);
    struct Point(f64, f64);

    let black = Color(0, 0, 0);
    let origin = Point(0.0, 0.0);

    println!("black = ({}, {}, {})", black.0, black.1, black.2);
    println!("origin = ({}, {})", origin.0, origin.1);
}
  • 无命名字段的元组结构体如上段代码所示。对于不同的元组结构体不能混用，可以将元组结构体解构为单独部分(目前没找到相关描述)，也可以使用.加索引访问单独值。
  • 元组结构体与普通结构体在定义时存在是否使用";"的区别

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

struct AlwaysEqual;

fn main() {
    let subject = AlwaysEqual;
}
  • 要定义 AlwaysEqual，我们使用 struct 关键字，我们想要的名称，然后是一个分号。不需要花括号或圆括号！然后，我们可以以类似的方式在 subject 变量中获得 AlwaysEqual 的实例：使用我们定义的名称，不需要任何花括号或圆括号。想象一下，我们将实现这个类型的行为，即每个实例始终等于每一个其他类型的实例，也许是为了获得一个已知的结果以便进行测试。我们不需要任何数据来实现这种行为，你将在第十章中，看到如何定义特性并在任何类型上实现它们，包括类单元结构体。
    接下来是一段官方文档:
    在这里插入图片描述

示例程序（使用结构体）

  1. 使用不变值进行计算
fn main() {
    let width1 = 30;
    let height1 = 50;

    println!(
        "The area of the rectangle is {} square pixels.",
        area(width1, height1)
    );
}

fn area(width: u32, height: u32) -> u32 {
    width * height
}
  • 但是此时没有将width和height进行关联
  1. 使用元组重构
fn main() {
    let rect1 = (30, 50);

    println!(
        "The area of the rectangle is {} square pixels.",
        area(rect1)
    );
}

fn area(dimensions: (u32, u32)) -> u32 {
    dimensions.0 * dimensions.1
}
  1. 使用结构体重构
struct Rectangle {
    width: u32,
    height: u32,
}

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

    println!(
        "The area of the rectangle is {} square pixels.",
        area(&rect1)
    );
}

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

使用了结构体的引用，没有得到结构体的所有权。
4. 通过派生trait增加实用功能

  • println!默认使用display的方式打印，对于结构体，display应该使用{:?}或者{:#?}来表达，同时需要添加Debug输出格式，debug是一个trait，以一种方式打印结构体。
  • 所以同时需要添加显示选择功能，即外部属性#[derive(Debug)](注意derive(Debug)只能使用在struct、enum等之前，如果直接在文档开头填写，会报错)
#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

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

    println!("rect1 is {:?}", rect1);
}
  1. 另外使用dbg!宏也可以，dbg!宏会接收一个表达式所有权。这回打印到标准错误控制台流(stderr)而不是(stdout)，这个是println!()的输出位置。
#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

fn main() {
    let scale = 2;
    let rect1 = Rectangle {
    //dbg!返回表达式的值
        width: dbg!(30 * scale),
        height: 50,
    };

    dbg!(&rect1);
}

这里应该使用dbg(&rect1)，因为这样dbg!不会获得rect1的所有权。

方法语法

  • 方法和函数调用方式相同，使用fn关键字，具有参数和返回值，但是他们只会在结构体上下文中定义，是枚举或者trait对象的上下文，并且第一个参数总是self，代表调用该方法的结构体实例。
  • 定义方法
#[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!(
        "The area of the rectangle is {} square pixels.",
        rect1.area()
    );
}
  • Self类型是impl块类型的别名，方法的第一个参数必须有名为self的Self类型的参数，仍然需要使用&表示方法借用了Self实例，方法可以选择self、&self、& mut self等。
#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    fn width(&self) -> bool {
        self.width > 0
    }
}

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

    if rect1.width() {
        println!("The rectangle has a nonzero width; it is {}", rect1.width);
    }
}

Rust中正确使用self类型会自动将object.something()对应起来。
在这里插入图片描述

#[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
    }
}

fn main() {
    let rect1 = Rectangle {
        width: 30,
        height: 50,
    };
    let rect2 = Rectangle {
        width: 10,
        height: 40,
    };
    let rect3 = Rectangle {
        width: 60,
        height: 45,
    };

    println!("Can rect1 hold rect2? {}", rect1.can_hold(&rect2));
    println!("Can rect1 hold rect3? {}", rect1.can_hold(&rect3));
}
  • 方法签名中可以在self之后添加多个参数。

关联函数

  • 关联函数中不以self作为第一参数，但是仍然使用impl块定义，所以它不是方法。String::from就是这样一个函数。
    下面是创建正方形的构造函数:
#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

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

fn main() {
    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
    }
}

fn main() {
    let rect1 = Rectangle {
        width: 30,
        height: 50,
    };
    let rect2 = Rectangle {
        width: 10,
        height: 40,
    };
    let rect3 = Rectangle {
        width: 60,
        height: 45,
    };

    println!("Can rect1 hold rect2? {}", rect1.can_hold(&rect2));
    println!("Can rect1 hold rect3? {}", rect1.can_hold(&rect3));
}
  • 这里每个方法有其自己的impl块。
SUPBJT
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
llvm-ir:自然 Rust 数据结构中的 LLVM IR
05-30
同样，像 、 和这样的类型应该是包含尽可能多信息的 Rust 结构体。 与其他安全的 LLVM 绑定（例如 ， llvm-ir不依赖于对 LLVM API 的连续 FFI。 它仅在其初始解析步骤中使用 LLVM API，以提取构建其丰富的 LLVM IR...
Rust结构体详解：定义、使用及方法
最新发布
一起coding，一起嗨。
02-13 888
Rust结构体详解：定义、使用及方法
【Rust 基础篇】Rust 结构体详解
繁依Fanyi的博客
06-28 1356
在Rust中，我们可以使用struct关键字定义一个结构体。结构体允许我们定义多个字段（Fields），每个字段都有自己的类型和名称。通过将字段组合在一起，我们可以创建自己的数据类型，以便更好地表示和操作数据。在上述示例中，我们定义了一个名为Point的结构体，它具有两个字段x和y，分别是i32类型的整数。本篇博客详细介绍了Rust中结构体的概念、定义语法、实例化、方法、关联函数以及相关特性。结构体是Rust中一种重要且强大的数据类型，它允许我们将多个相关的值组合在一起，形成更复杂的数据结构。
聊一聊Rust的结构体
readlnh的博客
01-18 6160
聊一聊Rust的结构体 因为最近在接触rust语言，所以随便记录下学习过程中遇到的一些有意思的点。实际上结构体在很多语言中都存在。rust的结构体和c/c++语言的结构体其实也是非常类似的。假如我们要定义一个存储帐号信息的结构体 struct User { username: String, email: String, sign_in_count: u64, ac...
Rust 结构体
muyouking
06-19 191
fn main(){ /// 实例化结构体 let width = 1024; let height = 576; let image = GrayscaleMap{ pixels: vec![0;width * height], size:(width, height) }; println!("{:?}",image.size); let hokey = Boom{ name: "Hokey".
Rust的结构体类型的使用
ylh的博客
09-17 935
结构体让你可以创建出在你的领域中有意义的自定义类型。通过结构体，我们可以将相关联的数据片段联系起来并命名它们，这样可以使得代码更加清晰。在 impl 块中，你可以定义与你的类型相关联的函数，而方法是一种相关联的函数，让你指定结构体的实例所具有的行为。但结构体并不是创建自定义类型的唯一方法：让我们转向 Rust 的枚举功能，为你的工具箱再添一个工具。
c2rust：将C代码迁移到Rust
02-05
C2Rust帮助您将符合C99的代码迁移到Rust。 （或编译器）生成不安全的Rust代码，该代码紧密地镜像了输入的C代码。 转换器的主要目标是保留... 该手册仍在开发中，因此，如果您找不到任何内容，请告知我们。安装先决条件
rust-sshkeys：用于读取OpenSSH公共密钥和证书的Rust库
02-04
rust-sshkeys：用于读取OpenSSH公共密钥和证书的Rust库
rust中实现的 各种寻路算法_rust_代码_下载
06-11
在 rust 中实现各种寻路算法的实验来源。目前处于非常 wip 的状态 提供表示两点之间路径的 Route 结构体和用于计算两点之间最短路径的每个算法的函数
rust-delegate:使用较少样板的 Rust 方法委托
08-04
这个 crate 删除了一些结构体的样板，这些结构体只是将它们的一些方法委托给它们的一个或多个字段。 它给你delegate! 宏，它将方法调用委托给选定的表达式（通常是内部字段）。 例子： 通过委托使用内部 Vec 实现...
Rust - 元组结构体和单元结构体
nhb687095的博客
05-01 810
除了定义常规的结构体之外，也可以定义与元组类似的结构体，称为），元组结构体的主要特征是没有字段名，只有字段类型，当我们想给整个元组取一个名字，并使元组成为与其他元组不同的类型时，元组结构体是很有用的，这时像常规结构体那样为每个字段命名就显得多余和形式化了，比如定义颜色的RGB和坐标。要定义元组结构体，以struct关键字和结构体名开头并后跟元组中的类型。例如，下面是两个分别叫做Color和Point需要注意black和origin值的类型不同，因为它们是不同的元组结构体的实例。
Rust权威指南之结构体
学习和工作总结，共勉！
11-18 1004
本文来源于阅读《Rust权威指南》第五章：使用结构体来组织相关联的数据的读书笔记。快速了解Rust的结构体相关知识。
Python使用struct处理二进制
09-22 2675
有的时候需要用python处理二进制数据，比如，存取文件，socket操作时.这时候，可以使用python的struct模块来完成.可以用 struct来处理c语言中的结构体. struct模块中最重要的三个函数是pack(), unpack(), calcsize() pack(fmt, v1, v2, ...) 按照给定的格式(fmt)，把数据封装成字符串(实际上是类似...
【Rust】6. 结构体与方法
newCraftsman的博客
01-31 607
r
Rust打印结构体
刘振兴的博客
01-21 1459
#[derive(Debug)] struct Node { name: String, age: u8, } fn main() { let node = Node { name: String::from("你瞅啥"), age:19 }; println!("{:#?}",node) }
【C语言】[图文] 详解结构体，详细分析结构体对齐
七月.cc的博客
04-23 1113
结构体 1. 结构体 ​ 结构体是一些值的集合，这些值成为成员变量。结构的每个成员可以是不同类型的变量。结构体属于自定义类型。 1.1 结构体声明 1.1.1 标准声明 struct User { char Name[20]; char Sex[10]; }; 此结构体的类型就是 struct User User 是结构体标签(tag) 1.1.2 特殊声明(不完全声明) struct { char Name[20]; char Sex[10]; int age; .
C 结构体操作
车前猛跑
08-16 325
学完oc再学c #include #include #include struct User { int id; char name[16]; struct User* next; }; struct User user_header = {0}; void addToHeader(struct User* user) { user->next = user_head
Rust：模式解构
OceanStar的博客
12-25 1559
文章目录条件判断if-else if -else在 let 语句中使用 if循环代码loop循环while循环for遍历集合 条件判断 if-else if -else fn main() { let number = 3; if number < 7{ println!("smaller") }else if 7 &
rust在结构体方法中创建一个静态结构体实例
06-01
在 Rust 中，在结构体方法中创建一个静态结构体实例与在任何其他函数中创建它的方式是相同的。你可以使用 `static` 关键字定义一个静态变量来持有结构体实例，并在结构体方法中访问该变量。 以下是一个示例代码，展示了在结构体方法中创建静态结构体实例的方式： ```rust struct MyStruct { field1: u32, field2: String, field3: bool, } impl MyStruct { fn do_something(&self) { let static_struct = MyStaticStruct { field1: 456, field2: String::from("world"), field3: false, }; // 在这里使用静态结构体实例 println!("{} {}", self.field2, static_struct.field2); } } struct MyStaticStruct { field1: u32, field2: String, field3: bool, } static MY_STATIC_STRUCT: MyStaticStruct = MyStaticStruct { field1: 123, field2: String::from("hello"), field3: true, }; fn main() { let my_struct = MyStruct { field1: 789, field2: String::from("foo"), field3: true, }; my_struct.do_something(); } ``` 在这个示例中，我们定义了一个名为 `MyStruct` 的结构体，并为它实现了一个名为 `do_something` 的方法。在 `do_something` 方法中，我们创建了一个 `MyStaticStruct` 的实例，并在其中使用了 `MY_STATIC_STRUCT` 静态变量的字段。最后在 `main` 函数中，我们创建了一个 `MyStruct` 实例，并调用了它的 `do_something` 方法。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值