struct 命名结构体 ​

核心概念 ​

命名结构体(Named-Field Struct)是 Rust 中最常用的自定义数据类型,用于将多个相关的数据字段组合在一起。每个字段都有名字和类型,通过字段名来访问数据。结构体是 Rust 面向数据编程的基础——数据(字段)和行为(方法)分开定义,字段在 struct 中声明,方法在 impl 块中定义。

rust
// 定义一个命名结构体
struct User {
    name: String,
    email: String,
    age: u32,
    active: bool,
}

fn main() {
    // 创建结构体实例
    let user = User {
        name: String::from("张三"),
        email: String::from("zhangsan@example.com"),
        age: 28,
        active: true,
    };

    // 通过字段名访问数据
    println!("姓名: {}", user.name);
    println!("邮箱: {}", user.email);
    println!("年龄: {}", user.age);
    println!("活跃: {}", user.active);
}

结构体定义语法 ​

rust
// 结构体名称使用 CamelCase(大驼峰)
struct Point {
    x: f64,
    y: f64,
}

// 字段可以是任意类型
struct Config {
    host: String,
    port: u16,
    max_connections: u32,
    debug: bool,
    tags: Vec<String>,
}

// 字段可以包含其他结构体
struct Address {
    city: String,
    street: String,
    zip_code: String,
}

struct Company {
    name: String,
    address: Address,    // 嵌套结构体
    employee_count: u32,
}

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

    let config = Config {
        host: String::from("localhost"),
        port: 8080,
        max_connections: 100,
        debug: true,
        tags: vec![String::from("web"), String::from("api")],
    };
    println!("{}:{}", config.host, config.port);

    let company = Company {
        name: String::from("Rust 公司"),
        address: Address {
            city: String::from("北京"),
            street: String::from("中关村大街"),
            zip_code: String::from("100080"),
        },
        employee_count: 50,
    };
    println!("{} 位于 {}", company.name, company.address.city);
}

可变性 ​

整个结构体实例要么可变要么不可变,Rust 不支持单个字段的可变性控制。

rust
struct Rectangle {
    width: f64,
    height: f64,
}

fn main() {
    // 不可变实例:所有字段都不能修改
    let rect = Rectangle { width: 10.0, height: 5.0 };
    // rect.width = 20.0;  // 编译错误:rect 是不可变的

    // 可变实例:所有字段都可以修改
    let mut rect2 = Rectangle { width: 10.0, height: 5.0 };
    rect2.width = 20.0;    // 合法
    rect2.height = 8.0;    // 合法
    println!("{}x{}", rect2.width, rect2.height);
}

常用 derive 宏 ​

rust
// derive 自动生成常用 trait 的实现
#[derive(Debug, Clone, PartialEq)]
struct Product {
    name: String,
    price: f64,
    in_stock: bool,
}

fn main() {
    let p1 = Product {
        name: String::from("键盘"),
        price: 299.0,
        in_stock: true,
    };

    // Debug:调试输出
    println!("{:?}", p1);
    println!("{:#?}", p1);  // 美化输出

    // Clone:克隆
    let p2 = p1.clone();

    // PartialEq:比较
    println!("相等: {}", p1 == p2);
}
derive 宏功能常见组合
Debug调试格式化输出几乎所有结构体
Clone克隆实例需要复制的类型
Copy隐式复制(需要 Clone)小型纯栈类型
PartialEq相等比较需要 == 的类型
Eq完全相等(需要 PartialEq)用作 HashMap 的 key
Hash哈希值(需要 Eq)用作 HashMap 的 key
Default默认值有合理默认值的类型

字段的可见性 ​

结构体的字段默认是私有的,只能在定义它的模块中访问。

rust
mod shapes {
    // 结构体本身是 pub 的
    pub struct Circle {
        pub radius: f64,    // 公开字段
        center_x: f64,      // 私有字段
        center_y: f64,      // 私有字段
    }

    impl Circle {
        // 关联函数(构造器):外部通过这个创建实例
        pub fn new(radius: f64, x: f64, y: f64) -> Circle {
            Circle {
                radius,
                center_x: x,
                center_y: y,
            }
        }

        // 公开方法访问私有字段
        pub fn center(&self) -> (f64, f64) {
            (self.center_x, self.center_y)
        }

        pub fn area(&self) -> f64 {
            std::f64::consts::PI * self.radius * self.radius
        }
    }
}

fn main() {
    let circle = shapes::Circle::new(5.0, 10.0, 20.0);
    println!("半径: {}", circle.radius);       // 公开字段可以访问
    // println!("{}", circle.center_x);        // 编译错误:私有字段
    println!("圆心: {:?}", circle.center());   // 通过方法访问
    println!("面积: {:.2}", circle.area());
}

基本示例 ​

用结构体建模一个学生管理系统:

rust
#[derive(Debug, Clone)]
struct Student {
    id: u32,
    name: String,
    grade: u8,
    scores: Vec<f64>,
}

impl Student {
    // 关联函数:创建新学生
    fn new(id: u32, name: &str, grade: u8) -> Student {
        Student {
            id,
            name: name.to_string(),
            grade,
            scores: Vec::new(),
        }
    }

    // 方法:添加成绩
    fn add_score(&mut self, score: f64) {
        self.scores.push(score);
    }

    // 方法:计算平均分
    fn average(&self) -> f64 {
        if self.scores.is_empty() {
            return 0.0;
        }
        let sum: f64 = self.scores.iter().sum();
        sum / self.scores.len() as f64
    }

    // 方法:获取最高分
    fn highest(&self) -> Option<f64> {
        self.scores.iter().cloned().reduce(f64::max)
    }

    // 方法:是否及格(所有成绩 >= 60)
    fn is_passing(&self) -> bool {
        !self.scores.is_empty() && self.scores.iter().all(|&s| s >= 60.0)
    }

    // 方法:显示信息
    fn display(&self) {
        println!("学号: {}, 姓名: {}, 年级: {}", self.id, self.name, self.grade);
        println!("  成绩: {:?}", self.scores);
        println!("  平均分: {:.1}", self.average());
        if let Some(h) = self.highest() {
            println!("  最高分: {:.1}", h);
        }
        println!("  全部及格: {}", if self.is_passing() { "是" } else { "否" });
    }
}

fn main() {
    let mut alice = Student::new(1001, "Alice", 3);
    alice.add_score(85.0);
    alice.add_score(92.0);
    alice.add_score(78.0);

    let mut bob = Student::new(1002, "Bob", 3);
    bob.add_score(55.0);
    bob.add_score(88.0);
    bob.add_score(72.0);

    alice.display();
    println!();
    bob.display();

    // 克隆学生记录
    let alice_backup = alice.clone();
    println!("\n备份: {:?}", alice_backup);
}

常见问题 ​

问题一:结构体字段用 String 还是 &str?

如果结构体拥有数据的所有权,用 String。如果结构体只是借用外部数据,用 &'a str(需要生命周期标注)。大多数情况下用 String 更简单,除非有明确的性能需求。

问题二:结构体可以没有字段吗?

可以,这叫做单元结构体(Unit Struct),如 struct Marker;。单元结构体不占内存,通常用于实现 trait 但不需要存储数据的场景。

问题三:结构体字段的顺序重要吗?

在定义中不重要(不影响语义),但编译器可能会重新排列字段以优化内存布局(除非使用 #[repr(C)] 属性)。创建实例时字段的顺序也不需要和定义一致。

问题四:结构体可以递归吗?

不能直接递归(大小无法确定),需要用 Box<T> 间接引用:

rust
struct TreeNode {
    value: i32,
    left: Option<Box<TreeNode>>,   // 用 Box 间接引用
    right: Option<Box<TreeNode>>,
}

适用场景 ​

  • 数据建模:表示实体(用户、商品、配置等)
  • API 设计:函数参数和返回值的结构化数据
  • 状态管理:维护程序或模块的状态
  • 组合模式:结构体嵌套构建复杂数据结构

注意事项 ​

  • 结构体名用 CamelCase,字段名用 snake_case
  • 字段默认私有,用 pub 公开
  • 整个实例要么可变要么不可变,不能单独控制某个字段
  • 创建实例时所有字段都必须赋值
  • 常用的 derive 宏:Debug、Clone、PartialEq
  • 直接递归结构体需要用 Box 包装
  • 结构体在离开作用域时所有字段都被销毁

总结 ​

命名结构体是 Rust 中最基本的自定义数据类型,通过命名字段将相关数据组合在一起。结构体的数据(字段)在 struct 中定义,行为(方法)在 impl 块中定义,两者分离。字段默认私有,通过 pub 控制可见性。创建实例时所有字段都必须赋值,整个实例的可变性由 let 或 let mut 决定。derive 宏可以自动生成 Debug、Clone、PartialEq 等常用 trait 的实现。结构体是 Rust 程序中数据建模的核心工具。