Rust结构体

数组用于表示同类型值的集合，类似地，结构体是Rust中可用的另一种用户定义的数据类型，它使我们能够组合不同类型的数据项，包括另一种结构体。

结构体将数据定义为键值对。

语法-声明结构体

struct关键字用于声明结构，由于结构是静态类型的，因此结构中的每个字段都必须与数据类型相关联。

结构的命名规则和变量类似，结构块必须以分号结尾。

struct Name_of_structure {
    field1:data_type,
    field2:data_type,
    field3:data_type
};

语法-初始化结构体

声明结构体后，应为每个字段分配一个值，这称为初始化。

let instance_name = Name_of_structure {
    field1:value1,
    field2:value2,
    field3:value3
}; 
//注意分号
语法: Accessing values in a structure
Use the dot notation to access value of a specific field.
instance_name.field1
Illustration
struct Employee {
    name:String,
    company:String,
    age:u32
}
fn main() {
    let emp1 = Employee {
        company:String::from("newbiego"),
        name:String::from("Mohtashim"),
        age:50
    };
    println!("Name is :{} company is {} age is {}",emp1.name,emp1.company,emp1.age);
}

上面的示例声明了一个具有三个字段的结构Employee：name，company和age。 main()初始化结构体，它使用println!宏以打印结构体中定义的字段的值。

Name is :Mohtashim company is newbiego age is 50

修改结构体实例

要修改实例，应将实例变量标记为可变的。下面的示例声明并初始化一个名为Employee的结构体，然后修改 age 字段从50增加到40：

let mut emp1 = Employee {
    company:String::from("newbiego"),
    name:String::from("Mohtashim"),
    age:50
};
emp1.age = 40;
println!("Name is :{} company is {} age is 
{}",emp1.name,emp1.company,emp1.age);

Name is :Mohtashim company is newbiego age is 40

将结构传递给函数

以下示例显示如何将struct实例作为参数传递，display()函数将Employee实例作为参数并打印详细信息。

fn display( emp:Employee) {
    println!("Name is :{} company is {} age is
    {}",emp.name,emp.company,emp.age);
}

这是完整的程序：

//声明一个结构
struct Employee {
    name:String,
    company:String,
    age:u32
}
fn main() {
    //初始化结构
    let emp1 = Employee {
        company:String::from("newbiego"),
        name:String::from("Mohtashim"),
        age:50
    };
    let emp2 = Employee{
        company:String::from("newbiego"),
        name:String::from("Kannan"),
        age:32
    };
    //将emp1和emp2传递给display()
    display(emp1);
    display(emp2);
}
//使用
//运算符并将其打印到控制台
fn display( emp:Employee){
    println!("Name is :{} company is {} age is
    {}",emp.name,emp.company,emp.age);
}

Name is :Mohtashim company is newbiego age is 50
Name is :Kannan company is newbiego age is 32

从函数返回结构体

让我们考虑一个函数 who_is_elder() ，该函数会比较两名员工的年龄并返回其中一位年龄较大的员工。

fn who_is_elder (emp1:Employee,emp2:Employee)->Employee {
    if emp1.age>emp2.age {
        return emp1;
    } else {
        return emp2;
    }
}

这是完整的程序：

fn main() {
    //初始化结构
    let emp1 = Employee{
        company:String::from("newbiego"),
        name:String::from("Mohtashim"),
        age:50
    };
    let emp2 = Employee {
        company:String::from("newbiego"),
        name:String::from("Kannan"),
        age:32
    };
    let elder = who_is_elder(emp1,emp2);
    println!("elder is:");

    //打印上级员工的详细信息
    display(elder);
}
//接受员工结构的实例并比较他们的年龄
fn who_is_elder (emp1:Employee,emp2:Employee)->Employee {
    if emp1.age>emp2.age {
        return emp1;
    } else {
        return emp2;
    }
}
//显示员工的姓名，公司名称和年龄
fn display( emp:Employee) {
    println!("Name is :{} company is {} age is {}",emp.name,emp.company,emp.age);
}
//声明一个结构
struct Employee {
    name:String,
    company:String,
    age:u32
}

elder is:
Name is :Mohtashim company is newbiego age is 50

结构体方法

方法就像函数，它们是编程语句的逻辑组，方法用fn关键词定义，方法的范围在结构体内。

方法在结构块外部声明，impl关键字用于在结构体的上下文中定义方法，方法的第一个参数将始终为self，代表结构体的调用实例，方法对结构体的数据成员进行操作。

要调用方法，我们需要首先实例化结构体，可以使用结构体的实例调用该方法：

语法

struct My_struct {}
impl My_struct { 
    //设置方法的上下文
    fn method_name() {
        //定义一个方法
    }
}

例子

以下示例定义了一个结构体Rectangle带有字段： width 和 height ，一个方法 area()  在结构体的上下文中定义，area()方法通过 self 关键字并计算矩形的面积。

//定义矩形的尺寸
struct Rectangle {
    width:u32, height:u32
}

//计算矩形面积的逻辑
impl Rectangle {
    fn area(&self)->u32 {
        // 使用 。运算符通过self关键字获取字段的值
        self.width * self.height
    }
}

fn main() {
    //实例化结构
    let small = Rectangle {
        width:10,
        height:20
    };
    //打印矩形的区域
    println!("width is {} height is {} area of Rectangle
    is {}",small.width,small.height,small.area());
}

width is 10 height is 20 area of Rectangle is 200

结构中的静态方法

静态方法可用作实用程序方法，这些方法甚至在实例化结构之前就已经存在。静态方法使用结构体的名称调用，并且无需实例即可访问，与普通方法不同，静态方法不需要&self。

语法-声明静态方法

诸如函数之类的静态方法和其他方法可以选择包含参数。

impl Structure_Name {
    //创建Point结构对象的静态方法
    fn method_name(param1: datatype, param2: datatype) -> return_type {
        //逻辑在这里
    }
}

语法-调用静态方法

structure_name::语法用于访问静态方法。

structure_name::method_name(v1,v2)

例子

以下示例使用 getInstance 作为工厂类的方法，该方法创建并返回结构的实例 Point 。

//声明一个结构
struct Point {
    x: i32,
    y: i32,
}
impl Point {
    //创建Point结构对象的静态方法
    fn getInstance(x: i32, y: i32) -> Point {
        Point { x: x, y: y }
    }
    //显示结构字段的值
    fn display(&self){
        println!("x ={} y={}",self.x,self.y );
    }
}
fn main(){
    //调用静态方法
    let p1 = Point::getInstance(10,20);
    p1.display();
}

x =10 y=20