Rust 语言中的结构体

1、结构体

struct，或者 structure，是一个自定义数据类型，允许你包装和命名多个相关的值，从而形成一个有意义的组合。如果你熟悉一门面向对象语言，struct 就像对象中的属性。

2、结构体的定义和实例化

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

定义结构体，需要使用

struct

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

我们看一下示例：

   struct people {
        name: String,
        age: u64,
    }

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

key: value

键 - 值对的形式提供字段，其中 key 是字段的名字，value 是需要存储在字段中的数据值。实例中字段的顺序不需要和它们在结构体中声明的顺序一致。换句话说，结构体的定义就像一个类型的通用模板，而实例则会在这个模板中放入特定数据来创建这个类型的值。

看一下示例：

   let user = People {
    name: String::from("zhou"),
    age: 23,
   };

为了从结构体中获取某个特定的值，可以使用点号。例如，我们获取一个用户对应的姓名和年龄，我们看下示例：

fn main() {
    struct People {
        name: String,
        age: u64,
    }
   let user = People {
    name: String::from("zhou"),
    age: 23,
   };
    println!("{} {} ", user.name, user.age)
} 

运行一下代码，看下是否可以获取对应的结果：

我们也可以通过方法传参，来返回一个初始化的实例：

fn user(name: String, age:u64) -> People {
    People {
        name: name,
        age: age
    }
}

2.1 使用字段初始化简写语法

参数名与字段名都完全相同，我们可以使用 字段初始化简写语法，示例如下所示：

fn user(name: String, age:u64) -> People {
    People {
        name,
        age
    }
}

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

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

我们可以看下如下示例：

fn main() {
    struct People {
        name: String,
        age: u64,
    }

fn user(name: String, age:u64) -> People {
    People {
        name,
        age
    }
}
let u = user(String::from("wangwu"), 12);
println!("{} {} ", u.name, u.age);   // wangwu 12 
let u1 = user(u.name, 34);           // wangwu 34 
println!("{} {} ", u1.name, u1.age);
}

可以使用u1中的一个值来创建一个新的People示例，如下所示：

fn main() {
    struct People {
        name: String,
        age: u64,
    }

let u1 = People {
        name: String::from("zhou"),
        age: 12,
    };

println!("{} {} ", u1.name, u1.age);   // zhou 12
let u2 = People {name: String::from("wangwu"),..u1};  // wangwu 12
println!("{} {} ", u2.name, u2.age);
}

使用结构体更新语法，我们可以通过更少的代码来达到相同的效果，

..

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

通过以上代码，我们可以知道u2创建了一个新的实例，实例中的name字段与u1实例中的name不一样，而其余的值则是与u1中字段一样，..u1必须放在最后，用来指定剩下的字段值都从u1中获取，而结构体字段的顺序是可以任意的。

2.3 没有命名字段的元组结构体

也可以定义与元组类似的结构体，称为 元组结构体（tuple structs）。元组结构体有着结构体名称提供的含义，但没有具体的字段名，只有字段的类型。当你想给整个元组取一个名字，并使元组成为与其他元组不同的类型时，元组结构体是很有用的。

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

值的类型不同，因为它们是不同的元组结构体的实例。你定义的每一个结构体有其自己的类型，即使结构体中的字段可能有着相同的类型。

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

我们也可以定义一个没有任何字段的结构体！它们被称为 类单元结构体（unit-like structs）因为它们类似于

()

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

struct Color;
fn main() {
    let black = Color;
}

注意：之前定义结构体，我们使用了自身拥有所有权的

String

类型而不是

&str

字符串 slice 类型。这是一个有意而为之的选择，因为我们想要这个结构体拥有它所有的数据，为此只要整个结构体是有效的话其数据也是有效的。

可以使结构体存储被其他对象拥有的数据的引用，不过这么做的话需要用上 生命周期（lifetimes）

2.5 结构体示例程序

如果写一个计算长方形面积的方法，简单实现，可能会如下所示：

fn main() {
let w = 100;
let h = 200;
let result = area(w, h);
    println!("area is {:?}", result);
}

fn area (w: u64, h: u64) -> u64 {
    w * h
}

可以使用结构体，看起来更加语义化，如下所示：

struct AreaStruct {
    w: u64,
    h: u64
} 
fn main() {
    let a = AreaStruct {
        w: 100,
        h: 200
    };
let result = area(a);
    println!("area is {}", result);
}

fn area (a: AreaStruct) -> u64 {
    a.w * a.h
}

为了调试，我们可能会打印结构体里的属性，能，不过我们必须为结构体显式选择这个功能。为此，在结构体定义之前加上外部属性

#[derive(Debug)]，如下所示：

#[derive(Debug)]
struct AreaStruct {
    w: u64,
    h: u64
} 
fn main() {
    let a = AreaStruct {
        w: 100,
        h: 200
    };
    println!("{:?}", a)
}

运行一下代码，看下打印结果，如下所示：

另一种使用

Debug

格式打印数值的方法是使用 dbg!宏。

dbg!

宏接收一个表达式的所有权（与

println!

宏相反，后者接收的是引用），打印出代码中调用 dbg! 宏时所在的文件和行号，以及该表达式的结果值，并返回该值的所有权。

示例如下所示：

#[derive(Debug)]

struct AreaStruct {
    w: u64,
    h: u64
} 
fn main() {
    let a = AreaStruct {
        w: 100,
        h: 200
    };
    dbg!(a);
}

运行代码，看一下打印结果：

3、方法

方法（method）与函数类似：它们使用

fn

关键字和名称声明，可以拥有参数和返回值，同时包含在某处调用该方法时会执行的代码。不过方法与函数是不同的，因为它们在结构体的上下文中被定义，并且它们第一个参数总是

self

，它代表调用该方法的结构体实例。

这是一个示例，如下所示：

#[derive(Debug)]
#[warn(dead_code)]

struct AreaStruct {
    w: u64,
    h: u64
} 
impl AreaStruct {
    fn area_me(&self) -> u64 {
        &self.w * &self.h
    }
    
}
fn main() {
    let a = AreaStruct {
        w: 100,
        h:100,
    };
    println!("value is {}", a.area_me())
}

在 C/C++ 语言中，有两个不同的运算符来调用方法：

.

直接在对象上调用方法，而

->

在一个对象的指针上调用方法，这时需要先解引用（dereference）指针。换句话说，如果

object

是一个指针，那么

object->something()

就像

(*object).something()

一样。

Rust 并没有一个与

->

等效的运算符；相反，Rust 有一个叫 自动引用和解引用（automatic referencing and dereferencing）的功能。方法调用是 Rust 中少数几个拥有这种行为的地方。

3.1 关联函数

所有在

impl

块中定义的函数被称为 关联函数（associated functions），因为它们与

impl

后面命名的类型相关。我们可以定义不以

self

为第一参数的关联函数（因此不是方法），因为它们并不作用于一个结构体的实例。

不是方法的关联函数经常被用作返回一个结构体新实例的构造函数。这些函数的名称通常为

new

，但

new

并不是一个关键字。

示例如下所示：

struct AreaStruct {
    w: u64,
    h: u64
} 
impl AreaStruct {
    fn square(size: u64) -> Self {
        Self {
            w: size,
            h: size,
        }
    }
    
}

这样可以通过这个方法，返回一个新的实例。

3.2 多个 impl 块

结果体是允许有多个impl的实现的。我们可以写一个示例，如下所示：

#[derive(Debug)]
struct AreaStruct {
    w: u64,
    h: u64
} 
impl AreaStruct {
    fn area_me(&self) -> u64 {
        &self.w * &self.h
    }
}
impl AreaStruct {
    fn area_length(&self) -> u64 {
        &self.w * 2 +  &self.h * 2
    }
}
fn main() {
    let a = AreaStruct {
        w: 100,
        h:100,
    };
    println!("value is {}", a.area_length())
}