2.7RustStructs

原作者: [db:作者] 来自: [db:来源] 收藏邀请

A struct, or structure, is a custom data type that lets you name and package together multiple related values that make up a meaningful group.

Defining and Instantiating Structs

相比元组，struct中的属性是无序的

To define a struct, we enter the keyword struct and name the entire struct. A struct’s name should describe the significance of the pieces of data being grouped together. Then, inside curly brackets, we define the names and types of the pieces of data, which we call fields.

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

let user1 = User {
    email: String::from("[email protected]"),
    username: String::from("someusername123"),
    active: true,
    sign_in_count: 1,
};

如果其属性可能被修改，那么其实例必须声明为mut可变类型

let mut user1 = User {
    email: String::from("[email protected]"),
    username: String::from("someusername123"),
    active: true,
    sign_in_count: 1,
};

user1.email = String::from("[email protected]");

Note that the entire instance must be mutable; Rust doesn’t allow us to mark only certain fields as mutable. As with any expression, we can construct a new instance of the struct as the last expression in the function body to implicitly return that new instance.

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

we can use the field init shorthand syntax to rewrite build_user so that it behaves exactly the same but doesn’t have the repetition of email and username

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

Creating Instances From Other Instances With Struct Update Syntax

It’s often useful to create a new instance of a struct that uses most of an old instance’s values but changes some. You’ll do this using struct update syntax.

let user2 = User {
    email: String::from("[email protected]"),
    username: String::from("anotherusername567"),
    active: user1.active,
    sign_in_count: user1.sign_in_count,
};

The syntax .. specifies that the remaining fields not explicitly set should have the same value as the fields in the given instance.

let user2 = User {
    email: String::from("[email protected]"),
    username: String::from("anotherusername567"),
    ..user1
};

完整示例

fn main() {
    println!("Hello, struct!");
    update_user();
    let user2: User = build_user("[email protected]".to_string(),"mysql".to_string());
    print_user(&user2);

    let user3: User = User{
        username: "[email protected]".to_string(),
        email: "[email protected]".to_string(),
        ..user2
    };
    print_user(&user3);
}

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

fn print_user(user1: &User){

    println!("{},{},{},{}",user1.username,user1.email,user1.userid,user1.active);
}

fn update_user(){
    let mut user1 = User{
        username: String::from("用户名"),
        email: String::from("[email protected]"),
        userid: 1,
        active: true,
    };
    user1.active = false;

    print_user(&user1)
}

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

　　运行结果

    Finished dev [unoptimized + debuginfo] target(s) in 0.01s
     Running `target/debug/b_struct`
Hello, struct!
用户名,[email protected],1,false
mysql,[email protected],1,true
[email protected],[email protected],1,true

Using Tuple Structs without Named Fields to Create Different Types

元组结构体，无字段名称，有元组的特性

fn test_tu(){
    let _tup: (i32, f64, u8) = (500, 6.4, 1);
    let _aa = (1,2.3,"wa ka ka ");
    let (_x,_y,_z) = _aa;
    println!("The value of z is:{}",_z);

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

    let black = Color(0, 0, 0);
    let origin = Point(0, 0, 0);
    println!("color:{},{},{}",black.0,black.1,black.2);
    println!("origin:{},{},{}",origin.0,origin.1,origin.2);
}

输出

The value of z is:wa ka ka 
color:0,0,0
origin:0,0,0

ownership,引用只能作用于struct对象，不能作用于其属性

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
}

输出整个struct

fn main() {
    println!("Hello, struct!");
    test_user();
}


#[derive(Debug)]
struct User{
    username: String,
    email: String,
    userid: u64,
    active: bool,
}

fn test_user(){
    let u1 = User{
        username: "败者千千万，胜者唯一人".to_string(),
        email: "[email protected]".to_string(),
        userid: 123,
        active: false,
    };
    println!("user:{:?}",u1);
}

输出

Hello, sturct!
user:User { username: "败者千千万，胜者唯一人", email: "[email protected]", userid: 123, active: false }

fn main() {
    println!("Hello, struct!");
    test_user();
}


#[derive(Debug)]
struct User{
    username: String,

    email: String,
    userid: u64,
    active: bool,
}

fn test_user(){
    let u1 = User{
        username: "败者千千万，胜者唯一人".to_string(),
        email: "[email protected]".to_string(),
        userid: 123,
        active: false,
    };
    println!("user:{:#?}",u1);
}

输出

Hello, struct!
user:User {
    username: "败者千千万，胜者唯一人",
    email: "[email protected]",
    userid: 123,
    active: false,
}

结构体方法

分两类：Methods、Associated Functions

Methods：实例相关，第一个参数必须为&self或&mut self，调用方式为实例.方法名

Associated Functions：struct相关，无须传入self参数，跟实例没关系，是关联在struct上的，相当基于Java语言中的静态方法，调用方式为 struct名称::方法名

Methods

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

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

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

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

In the signature for area, we use &self instead of rectangle: &Rectangle because Rust knows the type of self is Rectangle due to this method’s being inside the impl Rectangle context. Note that we still need to use the & before self, just as we did in &Rectangle. Methods can take ownership of self, borrow self immutably as we’ve done here, or borrow self mutably, just as they can any other parameter.

We’ve chosen &self here for the same reason we used &Rectangle in the function version: we don’t want to take ownership, and we just want to read the data in the struct, not write to it. If we wanted to change the instance that we’ve called the method on as part of what the method does, we’d use &mut self as the first parameter. Having a method that takes ownership of the instance by using just self as the first parameter is rare; this technique is usually used when the method transforms self into something else and you want to prevent the caller from using the original instance after the transformation.

Rust自动处理了对象对其方法或属性的调用

上面的例子中，方法传入的参数&self是引用类型，但其调用属性的时候使用的是self.width，其等价于(&self).width

In C and C++, two different operators are used for calling methods: you use . if you’re calling a method on the object directly and -> if you’re calling the method on a pointer to the object and need to dereference the pointer first. In other words, if object is a pointer, object->something() is similar to (*object).something().

Rust doesn’t have an equivalent to the -> operator; instead, Rust has a feature called automatic referencing and dereferencing. Calling methods is one of the few places in Rust that has this behavior.

Here’s how it works: when you call a method with object.something(), Rust automatically adds in &, &mut, or * so object matches the signature of the method. In other words, the following are the same:

p1.distance(&p2);
(&p1).distance(&p2);
The first one looks much cleaner. This automatic referencing behavior works because methods have a clear receiver—the type of self. Given the receiver and name of a method, Rust can figure out definitively whether the method is reading (&self), mutating (&mut self), or consuming (self). The fact that Rust makes borrowing implicit for method receivers is a big part of making ownership ergonomic in practice.

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

impl Rectangle {  //impl -> implementation
    fn area(&self) -> u32 {   //self -> rectangle: &Rectangle
        (&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 };

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

    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));

}

输出

The area of the rectangle is 1500 square pixels.
Can rect1 hold rect2? true
Can rect1 hold rect3? false

Associated Functions

Another useful feature of impl blocks is that we’re allowed to define functions within impl blocks that don’t take self as a parameter. These are called associated functions because they’re associated with the struct. They’re still functions, not methods, because they don’t have an instance of the struct to work with. You’ve already used the String::from associated function.

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

To call this associated function, we use the :: syntax with the struct name; let sq = Rectangle::square(3); is an example. This function is namespaced by the struct: the :: syntax is used for both associated functions and namespaces created by modules.

struct方法的首个参数必须是&self，或者self

&self以引用的方式使用，不涉及ownership

self 会生发ownership转移，调用一次后，不能再使用该对象

推荐使用&self

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

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

    fn init(&mut self, w: u32,h: u32) {
        self.width = w;
        self.height = h;
    }

}


pub fn test1() {
    let mut r1 = Rectangle {width:10, height:30};
    println!(
        "area:{}",
        r1.area()
    );

    r1.init(10,20);
    println!(
        "area:{}",
        r1.area()
    );

}

鲜花

握手

雷人

路过

鸡蛋

该文章已有0人参与评论

请发表评论

全部评论

专题导读

More+

10-27 六六分期app的软件客服如何联系？(六六分期

11-06 可心卡盟:win10系统火狐flash插件崩溃怎么

11-06 亲亲特价:怎么删除回收站图标

11-06 济南大学虚拟社区:鲁大师节能降温的具体办

11-06 xlueops.exe:无线网络安装向导

11-06 女斗合众国:win7系统cf与主机连接不稳定怎

11-06 0xc000022-[cf烟雾头]cf怎么调烟雾头

11-06 qizideyouhuo:应用程序无法正常启动0xc0000

11-06 ipz-185:win7系统vcf文件怎么打开

11-06 傻哥蹦迪:win10系统s4怎么打开usb调试

11-06 八神浩树gtaste:回收站清空了怎么恢复

11-06 妖尾之黑色守护:win10系统电脑没有1440x900

11-06 校园至尊魔王小说:win7系统浏览网页时字体

11-06 女斗合众国:win10系统访问共享文件夹提示请

11-06 tokyo hot n0654:恢复win7系统默认字体一招

11-06 雨酷仙境:设置win7系统转移临时文件夹腾出

11-06 阿穆纳伊之杖:win7系统开始菜单在右边还原

11-06 tunespotting:win10系统火狐flash插件总是

11-06 甘尔葛分析师：计谋网站seo关键词暴涨有什

11-06 蔡贵霖: 计谋网站seo关键词暴涨有什么秘密

11-06 博益网首页:ao3网页版进入不了解决方法

11-06 漏斗子专栏: 网站数据分析小白易懂精华篇

11-06 见证双虹怎么做:win7系统开启telnet命令的

11-06 颾狐蝶蜋:系统资源不足无法完成请求的服务

11-06 国光中学校歌:提交网站到alexa查询详细步骤

11-06 西安有情天:静态网页和动态网页的区别

11-06 红木雅尚斋:外部链接构造对网站的好处

11-06 前官礼遇：防止域名劫持–增强域安全性的10

11-06 密传二转答案: 中文分词算法有哪些

11-06 金泉家园邮编:百度快照劫持的表现及应对方

Matlab连接Sql server数据库发布时间：2022-07-18

学习笔记49—matlab FDR校正发布时间：2022-07-18

剪的笔顺,诠释剪的笔画,认识剪的部首

1 六六分期app的软件客服如何联系？(六六分期

六六分期app的软件客服如何联系？不知道吗？加qq群【895510560】即可！标题：六六分期

阅读：19277|2023-10-27

2 可心卡盟:win10系统火狐flash插件崩溃怎么

今天小编告诉大家如何处理win10系统火狐flash插件总是崩溃的问题，可能很多用户都不知

阅读：10015|2022-11-06

3 亲亲特价:怎么删除回收站图标

今天小编告诉大家如何对win10系统删除桌面回收站图标进行设置，可能很多用户都不知道

阅读：8341|2022-11-06

4 济南大学虚拟社区:鲁大师节能降温的具体办

今天小编告诉大家如何对win10系统电脑设置节能降温的设置方法，想必大家都遇到过需要

阅读：8710|2022-11-06

5 xlueops.exe:无线网络安装向导

我们在使用xp系统的过程中,经常需要对xp系统无线网络安装向导设置进行设置，可能很多

阅读：8655|2022-11-06

6 女斗合众国:win7系统cf与主机连接不稳定怎

今天小编告诉大家如何处理win7系统玩cf老是与主机连接不稳定的问题，可能很多用户都不

阅读：9684|2022-11-06

7 0xc000022-[cf烟雾头]cf怎么调烟雾头

电脑对日常生活的重要性小编就不多说了，可是一旦碰到win7系统设置cf烟雾头的问题，很

阅读：8643|2022-11-06

8 qizideyouhuo:应用程序无法正常启动0xc0000

我们在日常使用电脑的时候，有的小伙伴们可能在打开应用的时候会遇见提示应用程序无法

阅读：8011|2022-11-06

9 ipz-185:win7系统vcf文件怎么打开

今天小编告诉大家如何对win7系统打开vcf文件进行设置，可能很多用户都不知道怎么对win

阅读：8680|2022-11-06

10 傻哥蹦迪:win10系统s4怎么打开usb调试

今天小编告诉大家如何对win10系统s4开启USB调试模式进行设置，可能很多用户都不知道怎

阅读：7547|2022-11-06

客服电话

电子邮件

2.7RustStructs

Defining and Instantiating Structs

Creating Instances From Other Instances With Struct Update Syntax

Using Tuple Structs without Named Fields to Create Different Types

结构体方法

Methods

Associated Functions

请发表评论

全部评论

上一篇：

下一篇：

stevenliuyi/latex-alpha2: LaTeX package

librespeed/speedtest: Self-hosted Speedt

avehtari/BDA_m_demos: Bayesian Data Anal

四维彩超怎么看性别？四维看男孩女孩诀窍

medfreeman/markdown-it-toc-and-anchor: m

剪的笔顺,诠释剪的笔画,认识剪的部首

六六分期app的软件客服如何联系？(六六分期

florent37/ViewAnimator: A fluent Android

florent37/Shrine-MaterialDesign2: implem

CVE-2020-36276

SimpleSoftwareIO/simple-sms: Send and re

关于我们

产品与服务

解决方案

139-2527-9053