Rust 结构体

结构体是 Rust 中用于组合不同类型数据的自定义类型。本章节将介绍 Rust 结构体的定义和使用。

结构体定义

使用 struct 关键字定义结构体：

struct Person {
    name: String,
    age: u32,
    is_student: bool,
}

fn main() {
    let person = Person {
        name: String::from("Alice"),
        age: 25,
        is_student: true,
    };
    
    println!("Name: {}", person.name);
    println!("Age: {}", person.age);
    println!("Is student: {}", person.is_student);
}

结构体实例化

基本实例化

struct Point {
    x: f64,
    y: f64,
}

fn main() {
    let p1 = Point {
        x: 1.0,
        y: 2.0,
    };
    
    let p2 = Point {
        x: 3.0,
        y: 4.0,
    };
    
    println!("p1: ({}, {})", p1.x, p1.y);
    println!("p2: ({}, {})", p2.x, p2.y);
}

简化实例化

当变量名与字段名相同时，可以使用简化语法：

struct Person {
    name: String,
    age: u32,
}

fn main() {
    let name = String::from("Bob");
    let age = 30;
    
    let person = Person {
        name,
        age,
    };
    
    println!("Name: {}", person.name);
    println!("Age: {}", person.age);
}

从其他实例创建

可以使用 .. 语法从其他实例创建新实例：

struct Person {
    name: String,
    age: u32,
    is_student: bool,
}

fn main() {
    let person1 = Person {
        name: String::from("Alice"),
        age: 25,
        is_student: true,
    };
    
    let person2 = Person {
        name: String::from("Bob"),
        ..person1
    };
    
    println!("person1: Name={}, Age={}, Is student={}", 
             person1.name, person1.age, person1.is_student);
    println!("person2: Name={}, Age={}, Is student={}", 
             person2.name, person2.age, person2.is_student);
}

结构体方法

可以为结构体定义方法，使用 impl 关键字：

struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    // 关联函数，使用 :: 调用
    fn new(width: u32, height: u32) -> Self {
        Self {
            width,
            height,
        }
    }
    
    // 方法，使用 . 调用
    fn area(&self) -> u32 {
        self.width * self.height
    }
    
    fn perimeter(&self) -> u32 {
        2 * (self.width + self.height)
    }
    
    fn can_hold(&self, other: &Rectangle) -> bool {
        self.width > other.width && self.height > other.height
    }
}

fn main() {
    let rect1 = Rectangle::new(30, 50);
    let rect2 = Rectangle::new(10, 40);
    let rect3 = Rectangle::new(60, 45);
    
    println!("rect1 area: {}", rect1.area());
    println!("rect1 perimeter: {}", rect1.perimeter());
    println!("rect1 can hold rect2: {}", rect1.can_hold(&rect2));
    println!("rect1 can hold rect3: {}", rect1.can_hold(&rect3));
}

元组结构体

元组结构体是一种没有字段名的结构体：

struct Color(u8, u8, u8);
struct Point(f64, f64);

fn main() {
    let red = Color(255, 0, 0);
    let origin = Point(0.0, 0.0);
    
    println!("Red: ({}, {}, {})", red.0, red.1, red.2);
    println!("Origin: ({}, {})", origin.0, origin.1);
}

单元结构体

单元结构体是一种没有字段的结构体：

struct Unit;

fn main() {
    let unit = Unit;
    // 单元结构体没有字段，主要用于实现 trait
}

结构体的可变性

默认情况下，结构体的字段是不可变的。要使结构体可变，需要使用 mut 关键字：

struct Person {
    name: String,
    age: u32,
}

fn main() {
    let mut person = Person {
        name: String::from("Alice"),
        age: 25,
    };
    
    person.age = 26;
    println!("Name: {}, Age: {}", person.name, person.age);
}

总结

• 使用 struct 关键字定义结构体
• 结构体可以有字段和方法
• 使用 impl 关键字为结构体定义方法
• 元组结构体没有字段名
• 单元结构体没有字段
• 结构体默认不可变，需要使用 mut 关键字使其可变

通过本章节的学习，你应该已经掌握了 Rust 结构体的定义和使用方法，可以在你的程序中使用结构体来组织数据。