struct 命名结构体
核心概念
命名结构体(Named-Field Struct)是 Rust 中最常用的自定义数据类型,用于将多个相关的数据字段组合在一起。每个字段都有名字和类型,通过字段名来访问数据。结构体是 Rust 面向数据编程的基础——数据(字段)和行为(方法)分开定义,字段在 struct 中声明,方法在 impl 块中定义。
// 定义一个命名结构体
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);
}结构体定义语法
// 结构体名称使用 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 不支持单个字段的可变性控制。
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 宏
// 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 | 默认值 | 有合理默认值的类型 |
字段的可见性
结构体的字段默认是私有的,只能在定义它的模块中访问。
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());
}基本示例
用结构体建模一个学生管理系统:
#[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> 间接引用:
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 程序中数据建模的核心工具。