Rust 结构体(struct)_编码文章

Rust 结构体是由一组数据组合而成的一种数据类型。
组成结构体的每项数据称为结构体的“成员”。
Rust 语言中定义结构体的关键字是 struct。

// Rust 结构体定义的语法
// Rust 结构体是一个 复合类型。
// 结构体中的所有元素/字段必须明确指明它的数据类型。(可以是基本类型，也可以是另一个结构体)
struct Employee {
    name: String,
    company: String,
    age: u32,
}

// 创建结构体的实例
// 创建结构体的实例或者说结构体初始化本质上就是创建一个变量。
// 使用 let 关键字创建一个变量。
// let instance_name = Name_of_structure {
//     field1:value1,
//     field2:value2,
//     field3:value3
// };
// 结构体初始化，其实就是对 结构体中的各个元素进行赋值。
// 注意：千万不要忘记结尾的分号 ;

fn main() {
    // 访问结构体的实例
    // 如果要访问结构体实例的某个元素，我们可以使用 元素访问符，也就是 点号 ( . )
    let emp1 = Employee {
        company: String::from("baidu"),
        name: String::from("hello"),
        age: 50,
    };
    println!(
        "Name is {} - company is {} - age is {}",
        emp1.name, emp1.company, emp1.age
    );
    // 输出：Name is hello - company is baidu - age is 50

    // 修改结构体的实例
    // 修改结构体实例就是对结构体的个别元素 重新赋值。
    // 结构体实例默认是 不可修改的，因为结构体实例也是一个使用 let 定义的变量。
    // 如果要修改结构体实例，就必须在创建时添加 mut 关键字，让它变成可修改的。
    let mut emp2 = Employee {
        company: String::from("taobao"),
        name: String::from("world"),
        age: 50,
    };
    emp2.age = 66;
    println!(
        "Name is {} - company is {} - age is {}",
        emp2.name, emp2.company, emp2.age
    );
    // 输出：Name is world - company is taobao - age is 66

    // 结构体作为函数的参数
    // 结构体的用途之一就是可以作为参数传递给函数。
    // 定一个结构体参数和定义其它类型的参数的语法是一样的。
    display(emp1);
    // 输出：Name is hello - company is baidu - age is 50 
    display(emp2);
    // 输出：Name is world - company is taobao - age is 66

    // 结构体实例作为函数的返回值
    let older = who_is_older(emp1, emp2);
    println!("older is ");
    display(older);
    // 输出
    // older is Name is world - company is taobao - age is 66
}

// 定义了一个函数 display ，它接受一个 Employee 结构体实例作为参数并输出结构体的所有元素
fn display(emp:Employee){
    println!(
        "Name is {} - company is {} - age is {}",
        emp.name, emp.company, emp.age
    );
}

// 结构体实例作为函数的返回值
// 在 箭头 -> 后面指定结构体作为一个返回参数。
// 在函数的内部返回 结构体的实例
fn who_is_older(emp1:Employee,emp2:Employee)->Employee{
    if emp1.age > emp2.age{
        return emp1;
    }else{
        return emp2;
    }
}

// 结构体中的方法
// Rust 中的结构体可以定义 方法 ( method )。
// 方法 ( method ) 是一段代码的 逻辑组合，用于完成某项特定的任务或实现某项特定的功能。
// 方法（ method ） 和 函数（ function） 有什么不同之处呢？
// 1.函数（ function） 没有属主，也就是归属于谁，因此可以直接调用。
// 2.方法（ method ） 是有属主的，调用的时候必须指定 属主。
// 3.函数（ function） 没有属主，同一个程序不可以出现两个相同签名的函数。
// 4.方法（ method ） 有属主，不同的属主可以有着相同签名的方法。

// 结构体方法的 作用域 仅限于 结构体内部。
// Rust 中的结构体方法只能定义在结构体的外面。
// 在定义结构体方法时需要使用 impl 关键字。
// struct my_struct {}
// impl my_struct {
//    // 属于结构体的所有其它代码
// }
// impl 关键字最重要的作用，就是定义上面我们所说的 方法的属主。
// 结构体的普通方法时，第一个参数永远是 &self 关键字。
struct Mystruct {
    width: u32,
    height: u32,
}
// 实现结构体
impl Mystruct {
    fn area(&self) -> u32 {
        self.width * self.height
    }
}

// 结构体的静态方法
// 静态方法可以直接通过结构体名调用而无需先实例化。
// 结构体的静态方法定义方式和普通方法类似，唯一的不同点是 不需要使用 &self 作为参数。
struct Point{
    x:i32,
    y:i32
}
impl Point {
    // 用于创建 Point 实例的静态方法
    fn get_instance(x:i32,y:i32)->Point{
        Point { x: x, y: y }
    }
    // 用于显示结构体元素的普通方法
    fn display(&self){
        println!("x={} - y={}",self.x,self.y);
    }
}

fn main() {
    // 创建 Mystruct 结构体的一个实例
    let small = Mystruct {
        width: 10,
        height: 20,
    };
    println!("area of Mystruct is {}", small.area());
    // 输出：area of Mystruct is 200

    // 调用静态方法
    let p1 = Point::get_instance(10, 20);
    p1.display();
    // 输出：x=10 - y=20
}

Rust 结构体(struct)

相关文章