struct

和其他语言类似

rust

struct User
{
    username:String,
    email:String,
    telephone:i32,
}

怎么访问其中的字段呢

很简单

rust

let mut test = User
{
    username:String::from("123"),
    email:String::from("123@qq.com"),
    telephone:110,
};
let user1_name = &test.username;//好麻烦啊 还要克隆或者引用

字段初始化简写

当字段名与字段值对应的变量名相同时可以使用字段初始化简写的方式

rust

fn temp(email:String,usingname:String)->User
{
    User{
        email,//可以把email:email,简写成email,
        username,//同上 简化username:username,
        sign_in_count:1,
    }
}

STRUCT更新语法

当你想基于某个struct实例创建一个新的实例时，可以用更新语法

rust

let user2 = User{
    email:String::from("another@example.com"),
    username:String::from("anotherusername"),
    //active:user1.active,
    //sign_in_count:user1.sigin_in_count,
    //很明显上面两行是沿用的user1的信息这时可以进行简写
    ..user1
};

Tuple struct

–适用于：想给整个tuple起名，并让它不同于其他tuple,而且又不需要给每个元素起名

rust

struct Color(i32,i32,i32);
struct Point(i32,i32,i32);
let black = Color(0,0,0);
let origin = Point(0,0,0);

black 和 origin是不同的类型

Unit-Like Struct(类单元结构体)

~~空结构体~~

与()类似

rust

struct test;
fn main()
{
    let a = test
}

特点

特性	说明
零大小类型 (ZST)	不占用内存，`std::mem::size_of::<MyMarker>() == 0`
无字段	只有类型名，没有数据
编译期优化	运行时被完全优化掉，零开销
可实现 trait	可以像普通类型一样实现方法

println!有多种打印方法其中有

std::fmt::Display和std::fmt:Debug两种~~目前已知~~

#[derive(Debug)]让自定义的类型可以派生于Debug

用{:?}和{:#?}两种方式进行输出

栗子

rust

#[derive(Debug)]
struct Rectangle {
    width: u32,
    length: u32,
}
fn main()
{
    let rect = Rectangle
    {
        width:30,
        length: 50,
    };
    println!("{}",area(&rect));
    
    println!("{:#?}", rect);
}
fn area(rect: &Rectangle) -> u32
{
    rect.width * rect.length
}

rust没有->这样的运算符号在调用方法的时候rust会根据情况自动添加& &mut 或 *

也就是说

p1.distance(&p2); == (&p1).distance(&p2);

这两个是等价的

impl

impl就相当于给指定的类型创建一个方法函数

rust

struct Person { name: String }  // 只有数据，没有行为

impl Person {                   // 现在给 Person 附加方法
    fn say_hi(&self) { ... }    // 实例方法
    fn new() -> Self { ... }    // 关联函数（类似构造器/静态方法）
}

关联函数

可以在impl里定义不把self作为第一个参数的函数不是方法

–例如: String::from()

每个struct允许有多个impl模块

rust

#[derive(Debug)]
struct Rectangle {
    width: u32,
    length: u32,
}
impl Rectangle{ //你也可以吧下面这几个fn分到两个impl里 都一样
    fn area(&self) -> u32
    {
        self.width * self.length
    }
    fn can_hold(&self,other:&Rectangle) -> bool{
        self.length >= other.length && self.width >= other.width
    }
    fn square(size:u32) -> Rectangle
    {
        Rectangle{
            width:size,
            length:size
        }
    }
}
fn main()
{
    let s = Rectangle::square(30);
    let rect1 = Rectangle
    {
        width:30,
        length: 50,
    };

     let rect2 = Rectangle
    {
        width:20,
        length: 40,
    };

     let rect3 = Rectangle
    {
        width:40,
        length: 60,
    };

    println!("{}",rect1.can_hold(&rect2));
    println!("{}",rect1.can_hold(&rect3));
    println!("{}",rect1.can_hold(&s));
    //println!("{:#?}", rect);
}