SparksFly
/
learning-rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
learning-rust/part4/struct练习题.md

1687 lines
41 KiB
Markdown
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

# Rust 结构体（Struct）练习题
> 建议先手动写出每道题的答案，再运行代码验证。
## 目录
- [一、基础题：判断正误](#一基础题判断正误)
- [二、填空题：补充代码](#二填空题补充代码)
- [三、找出并修复错误](#三找出并修复错误)
- [四、编程题](#四编程题)
- [五、综合思考题](#五综合思考题)
- [参考答案](#参考答案)
---
## 一、基础题：判断正误
判断以下代码能否通过编译。如果可以，说明原因；如果不能，指出错误原因。
### 题目 1-1
```rust
struct User {
username: String,
email: String,
active: bool,
}
fn main() {
let user1 = User {
email: String::from("alice@example.com"),
username: String::from("alice"),
active: true,
};
println!("{}", user1.username);
}
```
> 答: 可以通过编译,结构体变量类型都正确,使用方式正确
### 题目 1-2
```rust
struct Point(f64, f64);
fn main() {
let p = Point(3.0, 4.0);
println!("x = {}, y = {}", p.0, p.1);
}
```
> 答: 可以通过编译,结构体变量类型都正确,使用方式正确
### 题目 1-3
```rust
struct User {
username: String,
email: String,
active: bool,
}
fn main() {
let mut user1 = User {
email: String::from("alice@example.com"),
username: String::from("alice"),
active: true,
};
user1.email = String::from("new_email@example.com");
println!("{}", user1.email);
}
```
> 答: 可以通过编译,定义了一个可变结构体,可变结构体变量可以修改
### 题目 1-4
```rust
struct User {
username: String,
email: String,
active: bool,
}
fn main() {
let user1 = User {
email: String::from("alice@example.com"),
username: String::from("alice"),
active: true,
};
user1.email = String::from("new@example.com"); // user1 是不可变的
}
```
> 答: 不可以通过编译,定义的`user1`是不可变的,不能修改
### 题目 1-5
```rust
struct User {
username: String,
email: String,
active: bool,
}
fn main() {
let user1 = User {
email: String::from("alice@example.com"),
username: String::from("alice"),
active: true,
};
let user2 = User {
email: String::from("bob@example.com"),
..user1
};
println!("user1: {}", user1.username);
println!("user2: {}", user2.username);
}
```
> **[批注] 回答正确但原因有误。** "user1 是不可变的"与所有权转移无关——即使 `user1` 是 `mut`，`..user1` 同样会移动非 Copy 字段。真正原因：结构体更新语法 `..user1` 会将 `user1` 中未显式赋值的非 Copy 字段（`username`）移动到 `user2`，导致 `user1` 整体无法再使用。
### 题目 1-6
```rust
struct User {
username: String,
email: String,
active: bool,
}
fn main() {
let user1 = User {
email: String::from("alice@example.com"),
username: String::from("alice"),
active: true,
};
let user2 = User {
email: String::from("bob@example.com"),
..user1
};
println!("user1 email: {}", user1.email);
println!("user2 email: {}", user2.email);
}
```
> 答: 可以通过编译,没有再次使用`user1.username`
### 题目 1-7
```rust
#[derive(Debug)]
struct Rectangle {
width: u32,
height: u32,
}
fn main() {
let rect = Rectangle {
width: 30,
height: 50,
};
println!("{:?}", rect);
}
```
> 答: 可以通过编译,使用`#[derive(Debug)]`宏,打印结构体变量
### 题目 1-8
```rust
struct Color(i32, i32, i32);
fn main() {
let black = Color(0, 0, 0);
let white = Color(255, 255, 255);
println!("black R: {}, white R: {}", black.0, white.0);
}
```
> 答: 可以通过编译,定义和使用方式都正确
---
## 二、填空题：补充代码
补全下列代码使其能通过编译并达到期望输出。
### 题目 2-1：定义结构体并实例化
```rust
// 填空：定义一个名为 Book 的结构体，包含 title(String)、author(String)、pages(u32)
fn main() {
let book = ________ {
title: String::from("深入浅出 Rust"),
________: String::from("张三"),
pages: 320,
};
println!("《{}》作者：{}，共 {} 页", book.title, book.author, book.pages);
// 期望输出：《深入浅出 Rust》作者：张三，共 320 页
}
```
答:
```rust
struct Book {
title: String,
author: String,
pages: u32,
}
fn main() {
let book = Book {
title: String::from("深入浅出 Rust"),
author: String::from("张三"),
pages: 320,
};
println!(
"《{}》作者：{}，共 {} 页",
book.title, book.author, book.pages
);
}
```
### 题目 2-2：元组结构体
```rust
// 填空：定义一个元组结构体 RGB，包含三个 u8 值（红、绿、蓝）
struct RGB(________, ________, ________);
fn main() {
let red = RGB(255, 0, 0);
let green = RGB(0, 255, 0);
println!("红色: ({}, {}, {})", red.0, red.1, ________);
println!("绿色: ({}, {}, {})", green.0, green.1, green.2);
}
```
答:
```rust
struct RGB(u8, u8, u8);
fn main() {
let red = RGB(255, 0, 0);
let green = RGB(0, 255, 0);
println!("红色: ({}, {}, {})", red.0, red.1, red.2);
println!("绿色: ({}, {}, {})", green.0, green.1, green.2);
}
```
### 题目 2-3：结构体更新语法
```rust
#[derive(Debug)]
struct Student {
name: String,
age: u32,
score: u32,
}
fn main() {
let s1 = Student {
name: String::from("小明"),
age: 18,
score: 85,
};
let s2 = Student {
name: String::from("小红"),
________ // 填空：使用结构体更新语法，其余字段从 s1 复制
};
println!("s1: {:?}, s2: {:?}", s1, s2);
// 注意：s1.score 和 s1.age 在更新后是否还能使用？为什么？
}
```
答:
```rust
#[derive(Debug)]
struct Student {
name: String,
age: u32,
score: u32,
}
fn main() {
let s1 = Student {
name: String::from("小明"),
age: 18,
score: 85,
};
let s2 = Student {
name: String::from("小红"),
..s1 // 填空：使用结构体更新语法，其余字段从 s1 复制
};
println!("s1: {:?}, s2: {:?}", s1, s2);
// 注意：s1.score 和 s1.age 在更新后是否还能使用？为什么？
// s1.score 和 s1.age 在更新时所有权没有转移，所以仍然可以使用
}
```
### 题目 2-4：定义方法
```rust
struct Rectangle {
width: u32,
height: u32,
}
impl Rectangle {
// 填空：定义一个 area 方法，计算矩形的面积
fn ________(&self) -> ________ {
self.width ________ self.height
}
// 填空：定义一个 can_hold 方法，判断当前矩形能否容纳另一个矩形
fn can_hold(&self, other: ________) -> bool {
self.width > other.width && self.height > other.height
}
}
fn main() {
let rect1 = Rectangle { width: 30, height: 50 };
let rect2 = Rectangle { width: 10, height: 40 };
let rect3 = Rectangle { width: 60, height: 45 };
println!("rect1 面积: {}", rect1.area()); // 期望输出：1500
println!("rect1 能容纳 rect2: {}", rect1.can_hold(&rect2)); // 期望输出：true
println!("rect1 能容纳 rect3: {}", rect1.can_hold(&rect3)); // 期望输出：false
}
```
答:
```rust
struct Rectangle {
width: u32,
height: u32,
}
impl Rectangle {
// 填空：定义一个 area 方法，计算矩形的面积
fn area(&self) -> u32 {
self.width * self.height
}
// 填空：定义一个 can_hold 方法，判断当前矩形能否容纳另一个矩形
fn can_hold(&self, other: &Rectangle) -> bool {
self.width > other.width && self.height > other.height
}
}
fn main() {
let rect1 = Rectangle { width: 30, height: 50 };
let rect2 = Rectangle { width: 10, height: 40 };
let rect3 = Rectangle { width: 60, height: 45 };
println!("rect1 面积: {}", rect1.area()); // 期望输出：1500
println!("rect1 能容纳 rect2: {}", rect1.can_hold(&rect2)); // 期望输出：true
println!("rect1 能容纳 rect3: {}", rect1.can_hold(&rect3)); // 期望输出：false
}
```
### 题目 2-5：关联函数
```rust
struct Rectangle {
width: u32,
height: u32,
}
impl Rectangle {
// 填空：定义一个关联函数 square，接收一个边长参数，返回一个正方形 Rectangle
fn ________(size: u32) -> ________ {
Rectangle {
width: size,
height: ________,
}
}
}
fn main() {
let square = Rectangle::square(10);
println!("正方形: {} x {}", square.width, square.height);
// 期望输出：正方形: 10 x 10
}
```
答:
```rust
struct Rectangle {
width: u32,
height: u32,
}
impl Rectangle {
// 填空：定义一个关联函数 square，接收一个边长参数，返回一个正方形 Rectangle
fn square(size: u32) -> Rectangle {
Rectangle {
width: size,
height: size,
}
}
}
fn main() {
let square = Rectangle::square(10);
println!("正方形: {} x {}", square.width, square.height);
// 期望输出：正方形: 10 x 10
}
```
### 题目 2-6：self / &self / &mut self
```rust
struct Counter {
count: u32,
}
impl Counter {
// A：创建新的 Counter，初始值为 0
fn new() -> Counter {
Counter { count: 0 }
}
// B：只读取计数值 —— 参数应该是什么？
fn value(________) -> u32 {
self.count
}
// C：计数 +1 —— 参数应该是什么？
fn increment(________) {
self.count += 1;
}
// D：消费 Counter，返回最终值 —— 参数应该是什么？
fn into_value(________) -> u32 {
self.count
}
}
fn main() {
let mut counter = Counter::new();
counter.increment();
counter.increment();
println!("当前值: {}", counter.value()); // 期望输出：2
println!("最终值: {}", counter.into_value()); // 期望输出：2
// println!("{}", counter.value()); // 如果取消注释会怎样？
}
```
答:
```rust
struct Counter {
count: u32,
}
impl Counter {
// A：创建新的 Counter，初始值为 0
fn new() -> Counter {
Counter { count: 0 }
}
// B：只读取计数值 —— 参数应该是什么？
fn value(&self) -> u32 {
self.count
}
// C：计数 +1 —— 参数应该是什么？
fn increment(&mut self) {
self.count += 1;
}
// D：消费 Counter，返回最终值 —— 参数应该是什么？
fn into_value(self) -> u32 {
self.count
}
}
fn main() {
let mut counter = Counter::new();
counter.increment();
counter.increment();
println!("当前值: {}", counter.value()); // 期望输出：2
println!("最终值: {}", counter.into_value()); // 期望输出：2
// println!("{}", counter.value()); // 如果取消注释会怎样？
}
```
---
## 三、找出并修复错误
以下每段代码都有编译错误，请指出错误并写出修正后的代码。
### 题目 3-1
```rust
struct User {
username: &str,
email: &str,
active: bool,
}
fn main() {
let user = User {
username: "alice",
email: "alice@example.com",
active: true,
};
println!("{}", user.username);
}
```
```rust
> **[批注] 原分析的诊断不准确。** "定义结构体不能使用引用类型"是错误的——Rust 完全允许结构体包含引用字段，但必须标注**生命周期参数（lifetime）**。原代码 `username: &str` 缺少生命周期标注 `'a`。两种修复：
> 1. 加生命周期：`struct User<'a> { username: &'a str, email: &'a str, active: bool }`
> 2. 改用 String（无需生命周期，推荐初学者使用）
struct User {
username: String,
email: String,
active: bool,
}
fn main() {
let user = User {
username: String::from("alice"),
email: String::from("alice@example.com"),
active: true,
};
println!("{}", user.username);
}
```
### 题目 3-2
```rust
#[derive(Debug)]
struct Point {
x: i32,
y: i32,
}
fn main() {
let p = Point { x: 10, y: 20 };
println!("{}", p); // 想要打印 p
}
```
```rust
// 编译错误,打印要使用{:?}
#[derive(Debug)]
struct Point {
x: i32,
y: i32,
}
fn main() {
let p = Point { x: 10, y: 20 };
println!("{:?}", p); // 想要打印 p
}
```
### 题目 3-3
```rust
struct Rectangle {
width: u32,
height: u32,
}
impl Rectangle {
fn area(&self) -> u32 {
self.width * self.height
}
}
fn main() {
let rect = Rectangle { width: 30, height: 50 };
let a = rect::area(); // 尝试调用方法
println!("面积: {}", a);
}
```
```rust
// 错误，方法调用需要使用.
struct Rectangle {
width: u32,
height: u32,
}
impl Rectangle {
fn area(&self) -> u32 {
self.width * self.height
}
}
fn main() {
let rect = Rectangle { width: 30, height: 50 };
let a = rect.area(); // 尝试调用方法
println!("面积: {}", a);
}
```
### 题目 3-4
```rust
struct User {
name: String,
age: u32,
}
impl User {
fn greet(self) {
println!("你好，我是 {}，今年 {} 岁", self.name, self.age);
}
}
fn main() {
let user = User {
name: String::from("小明"),
age: 18,
};
user.greet();
user.greet(); // 第二次调用
}
```
```rust
// 错误,第二次调用user.greet()之前，user的所有权已转移
struct User {
name: String,
age: u32,
}
impl User {
fn greet(&self) {
println!("你好，我是 {}，今年 {} 岁", self.name, self.age);
}
}
fn main() {
let user = User {
name: String::from("小明"),
age: 18,
};
user.greet();
user.greet(); // 第二次调用
}
```
### 题目 3-5
```rust
struct Container {
value: i32,
}
impl Container {
fn get_value(&self) -> &i32 {
&self.value
}
fn set_value(&mut self, new_value: i32) {
self.value = new_value;
}
}
fn main() {
let mut c = Container { value: 10 };
let v = c.get_value();
c.set_value(20);
println!("v = {}", v);
}
```
```rust
// 错误,调用c.set_value(20)之前存在一个不可变引用,不能同时存在不可变引用和可变引用,因此将println提前,使得v的作用域提前结束
struct Container {
value: i32,
}
impl Container {
fn get_value(&self) -> &i32 {
&self.value
}
fn set_value(&mut self, new_value: i32) {
self.value = new_value;
}
}
fn main() {
let mut c = Container { value: 10 };
let v = c.get_value();
println!("v = {}", v);
c.set_value(20);
}
```
---
## 四、编程题
### 题目 4-1：学生管理系统基础结构
定义一个 `Student` 结构体，包含 `name`（String）、`id`（u32）、`grades`（Vec\<u32\>），并实现以下方法：
```rust
struct Student {
name: String,
id: u32,
grades: Vec<u32>,
}
impl Student {
// 1. 关联函数 new：创建一个新学生（成绩列表为空）
fn new(name: String, id: u32) -> Student {
// 你的代码
}
// 2. 添加一门成绩
fn add_grade(&mut self, grade: u32) {
// 你的代码
}
// 3. 计算平均成绩，如果没有成绩则返回 0.0
fn average_grade(&self) -> f64 {
// 你的代码
}
// 4. 判断是否及格（平均分 >= 60）
fn is_passing(&self) -> bool {
// 你的代码
}
}
fn main() {
let mut student = Student::new(String::from("小明"), 1001);
student.add_grade(85);
student.add_grade(92);
student.add_grade(78);
println!("{} 的平均分: {:.1}", student.name, student.average_grade()); // 期望：85.0
println!("{} 是否及格: {}", student.name, student.is_passing()); // 期望：true
let student2 = Student::new(String::from("小红"), 1002);
student2.add_grade(55);
student2.add_grade(58);
println!("{} 是否及格: {}", student2.name, student2.is_passing()); // 期望：false
}
```
```rust
struct Student {
name: String,
id: u32,
grades: Vec<u32>,
}
impl Student {
// 1. 关联函数 new：创建一个新学生（成绩列表为空）
fn new(name: String, id: u32) -> Student {
Student {
name,
id,
grades: Vec::new(),
}
}
// 2. 添加一门成绩
fn add_grade(&mut self, grade: u32) {
self.grades.push(grade);
}
// 3. 计算平均成绩，如果没有成绩则返回 0.0
fn average_grade(&self) -> f64 {
if self.grades.is_empty() {
return 0.0;
}
self.grades.iter().sum::<u32>() as f64 / self.grades.len() as f64
}
// 4. 判断是否及格（平均分 >= 60）
fn is_passing(&self) -> bool {
self.average_grade() >= 60.0
}
}
fn main() {
let mut student = Student::new(String::from("小明"), 1001);
student.add_grade(85);
student.add_grade(92);
student.add_grade(78);
println!("{} 的平均分: {:.1}", student.name, student.average_grade()); // 期望：85.0
println!("{} 是否及格: {}", student.name, student.is_passing()); // 期望：true
let mut student2 = Student::new(String::from("小红"), 1002);
student2.add_grade(55);
student2.add_grade(58);
println!("{} 是否及格: {}", student2.name, student2.is_passing()); // 期望：false
}
```
### 题目 4-2：几何图形
定义一个 `Circle` 结构体和 `Rectangle` 结构体，为它们分别实现 `area` 和 `perimeter` 方法。
```rust
use std::f64::consts::PI;
struct Circle {
radius: f64,
}
struct Rectangle {
width: f64,
height: f64,
}
// 你的代码：为 Circle 实现 area 和 perimeter
// 你的代码：为 Rectangle 实现 area 和 perimeter
fn main() {
let circle = Circle { radius: 5.0 };
println!("圆面积: {:.2}, 圆周长: {:.2}", circle.area(), circle.perimeter());
// 期望：圆面积: 78.54, 圆周长: 31.42
let rect = Rectangle { width: 3.0, height: 4.0 };
println!("矩形面积: {:.2}, 矩形周长: {:.2}", rect.area(), rect.perimeter());
// 期望：矩形面积: 12.00, 矩形周长: 14.00
}
```
```rust
use std::f64::consts::PI;
struct Circle {
radius: f64,
}
struct Rectangle {
width: f64,
height: f64,
}
// 为 Circle 实现 area 和 perimeter
impl Circle {
fn area(&self) -> f64 {
PI * self.radius * self.radius
}
fn perimeter(&self) -> f64 {
2.0 * PI * self.radius
}
}
// 为 Rectangle 实现 area 和 perimeter
impl Rectangle {
fn area(&self) -> f64 {
self.width * self.height
}
fn perimeter(&self) -> f64 {
2.0 * (self.width + self.height)
}
}
fn main() {
let circle = Circle { radius: 5.0 };
println!(
"圆面积: {:.2}, 圆周长: {:.2}",
circle.area(),
circle.perimeter()
);
// 期望：圆面积: 78.54, 圆周长: 31.42
let rect = Rectangle {
width: 3.0,
height: 4.0,
};
println!(
"矩形面积: {:.2}, 矩形周长: {:.2}",
rect.area(),
rect.perimeter()
);
// 期望：矩形面积: 12.00, 矩形周长: 14.00
}
```
### 题目 4-3：温度转换器
使用元组结构体实现温度类型，使不同类型的温度之间不会混淆。
```rust
// 定义三个元组结构体：Celsius(f64)、Fahrenheit(f64)、Kelvin(f64)
// 你的代码
impl Celsius {
// 转换为华氏度
fn to_fahrenheit(&self) -> Fahrenheit {
// °F = °C × 9/5 + 32
}
// 转换为开尔文
fn to_kelvin(&self) -> Kelvin {
// K = °C + 273.15
}
}
impl Fahrenheit {
// 转换为摄氏度
fn to_celsius(&self) -> Celsius {
// °C = (°F - 32) × 5/9
}
}
fn main() {
let temp_c = Celsius(100.0);
let temp_f = temp_c.to_fahrenheit();
let temp_k = temp_c.to_kelvin();
println!("{}°C = {}°F = {}K", temp_c.0, temp_f.0, temp_k.0);
// 期望：100°C = 212°F = 373.15K
let temp_f2 = Fahrenheit(32.0);
let temp_c2 = temp_f2.to_celsius();
println!("{}°F = {}°C", temp_f2.0, temp_c2.0);
// 期望：32°F = 0°C
}
```
```rust
use std::ops::Mul;
// 定义三个元组结构体：Celsius(f64)、Fahrenheit(f64)、Kelvin(f64)
struct Celsius(f64);
struct Fahrenheit(f64);
struct Kelvin(f64);
// 你的代码
impl Celsius {
// 转换为华氏度
fn to_fahrenheit(&self) -> Fahrenheit {
// °F = °C × 9/5 + 32
Fahrenheit(self.0 * 9.0 / 5.0 + 32.0)
}
// 转换为开尔文
fn to_kelvin(&self) -> Kelvin {
// K = °C + 273.15
Kelvin(self.0 + 273.15)
}
}
impl Fahrenheit {
// 转换为摄氏度
fn to_celsius(&self) -> Celsius {
// °C = (°F - 32) × 5/9
Celsius((self.0 - 32.0).mul(5.0 / 9.0))
}
}
fn main() {
let temp_c = Celsius(100.0);
let temp_f = temp_c.to_fahrenheit();
let temp_k = temp_c.to_kelvin();
println!("{}°C = {}°F = {}K", temp_c.0, temp_f.0, temp_k.0);
// 期望：100°C = 212°F = 373.15K
let temp_f2 = Fahrenheit(32.0);
let temp_c2 = temp_f2.to_celsius();
println!("{}°F = {}°C", temp_f2.0, temp_c2.0);
// 期望：32°F = 0°C
}
```
### 题目 4-4：链表节点
使用结构体实现一个单向链表的节点，要求展示你对 `Box` 和所有权机制的理解。
```rust
// 定义一个 ListNode 结构体，包含 value(i32) 和 next(Option<Box<ListNode>>)
// 你的代码
impl ListNode {
// 创建一个新节点
fn new(value: i32) -> ListNode {
// 你的代码
}
// 在链表末尾追加一个节点（递归实现）
fn append(&mut self, value: i32) {
// 你的代码
}
// 将所有节点的值收集到一个 Vec 中
fn collect(&self) -> Vec<i32> {
// 你的代码
}
}
fn main() {
let mut head = ListNode::new(1);
head.append(2);
head.append(3);
let values = head.collect();
println!("链表元素: {:?}", values);
// 期望：链表元素: [1, 2, 3]
}
```
```rust
// 定义一个 ListNode 结构体，包含 value(i32) 和 next(Option<Box<ListNode>>)
struct ListNode {
value: i32,
next: Option<Box<ListNode>>,
}
// 你的代码
impl ListNode {
// 创建一个新节点
fn new(value: i32) -> ListNode {
ListNode {
value,
next: Option::None,
}
}
// 在链表末尾追加一个节点（递归实现）
fn append(&mut self, value: i32) {
match self.next {
Some(ref mut next_node) => next_node.append(value),
None => self.next = Some(Box::new(ListNode::new(value))),
}
}
// 将所有节点的值收集到一个 Vec 中
fn collect(&self) -> Vec<i32> {
let mut values = vec![self.value];
let mut current = &self.next;
while let Some(node) = current {
values.push(node.value);
current = &node.next;
}
values
}
}
fn main() {
let mut head = ListNode::new(1);
head.append(2);
head.append(3);
let values = head.collect();
println!("链表元素: {:?}", values);
// 期望：链表元素: [1, 2, 3]
}
```
> **[批注] 原 `append` 和 `collect` 实现有严重错误，已在上方代码中修正：**
> - `append` 原实现 `self.next = Some(...)` 每次都覆盖 next，第二次 append 会丢掉第一次加的值。正确做法是用 `match self.next` 递归到尾节点再插入。
> - `collect` 原实现只 push 了 `self.value` 一个值，遗漏后续所有节点。正确做法是遍历链表。
### 题目 4-5：购物车
定义一个 `ShoppingCart` 结构体，包含商品列表（Vec），设计合理的所有权和借用关系。
```rust
#[derive(Debug, Clone)]
struct Item {
name: String,
price: f64,
quantity: u32,
}
impl Item {
fn new(name: &str, price: f64, quantity: u32) -> Item {
// 你的代码
}
// 计算该商品总价（单价 × 数量）
fn total(&self) -> f64 {
// 你的代码
}
}
struct ShoppingCart {
items: Vec<Item>,
}
impl ShoppingCart {
// 创建空购物车
fn new() -> ShoppingCart {
// 你的代码
}
// 添加商品
fn add_item(&mut self, item: Item) {
// 你的代码
}
// 计算购物车中所有商品的总价
fn total(&self) -> f64 {
// 你的代码
}
// 获取商品种类数量
fn item_count(&self) -> usize {
// 你的代码
}
// 打印购物车明细（消耗购物车所有权）
fn print_receipt(self) {
// 你的代码：遍历所有商品，打印名称、单价、数量、小计
// 最后打印总价
}
}
fn main() {
let mut cart = ShoppingCart::new();
cart.add_item(Item::new("键盘", 299.0, 1));
cart.add_item(Item::new("鼠标", 159.0, 2));
cart.add_item(Item::new("显示器", 1899.0, 1));
println!("商品种类: {}", cart.item_count()); // 期望：3
println!("总价: {:.2}", cart.total()); // 期望：2516.00
cart.print_receipt();
// 期望输出：
// === 购物明细 ===
// 键盘 × 1 @ 299.00 = 299.00
// 鼠标 × 2 @ 159.00 = 318.00
// 显示器 × 1 @ 1899.00 = 1899.00
// ----------------------
// 总计: 2516.00
// ======================
// println!("{:?}", cart.item_count()); // 如果取消注释会怎样？为什么？
}
```
```rust
#[derive(Debug, Clone)]
struct Item {
name: String,
price: f64,
quantity: u32,
}
impl Item {
fn new(name: &str, price: f64, quantity: u32) -> Item {
Item {
name: name.to_string(),
price,
quantity,
}
}
// 计算该商品总价（单价 × 数量）
fn total(&self) -> f64 {
self.price * self.quantity as f64
}
}
struct ShoppingCart {
items: Vec<Item>,
}
impl ShoppingCart {
// 创建空购物车
fn new() -> ShoppingCart {
ShoppingCart { items: Vec::new() }
}
// 添加商品
fn add_item(&mut self, item: Item) {
self.items.push(item);
}
// 计算购物车中所有商品的总价
fn total(&self) -> f64 {
self.items.iter().map(|item| item.total()).sum::<f64>()
}
// 获取商品种类数量
fn item_count(&self) -> usize {
self.items.len()
}
// [批注] 原实现了 fn print_receipt(&self)，但题目要求 fn print_receipt(self) 消耗所有权
fn print_receipt(self) {
// 你的代码：遍历所有商品，打印名称、单价、数量、小计
// 最后打印总价
println!("=== 购物明细 ===");
for item in self.items.iter() {
println!(
"{} × {} @ {:.2} = {:.2}",
item.name,
item.quantity,
item.price,
item.total()
);
}
println!("----------------------");
println!("总价: {:.2}", self.total());
}
}
fn main() {
let mut cart = ShoppingCart::new();
cart.add_item(Item::new("键盘", 299.0, 1));
cart.add_item(Item::new("鼠标", 159.0, 2));
cart.add_item(Item::new("显示器", 1899.0, 1));
println!("商品种类: {}", cart.item_count()); // 期望：3
println!("总价: {:.2}", cart.total()); // 期望：2516.00
cart.print_receipt();
// println!("{:?}", cart.item_count()); // 如果取消注释会怎样？为什么？
}
```
---
## 五、综合思考题
### 题目 5-1
以下代码为什么能通过编译？`user1` 的 `active` 字段是 `bool` 类型（实现 Copy），而 `username` 和 `email` 是 `String` 类型（未实现 Copy），使用结构体更新语法后，各自的可用性如何？
```rust
struct User {
username: String,
email: String,
active: bool,
}
fn main() {
let user1 = User {
email: String::from("alice@example.com"),
username: String::from("alice"),
active: true,
};
let user2 = User {
email: String::from("bob@example.com"),
..user1
};
// 下面哪些行可以取消注释？为什么？
// println!("{}", user1.username);
// println!("{}", user1.email);
// println!("{}", user1.active);
}
```
> 答:
> // println!("{}", user1.email);
> // println!("{}", user1.active);
> 可以取消注释，使用结构体更新语法后，user1的username失效，email和active有效
### 题目 5-2
对比以下三种设计。在什么场景下分别应该使用哪种？
```rust
// 设计 A：所有字段都是 String（自有类型）
struct UserA {
name: String,
email: String,
}
// 设计 B：所有字段都是 &str（借用）
struct UserB<'a> {
name: &'a str,
email: &'a str,
}
// 设计 C：混合
struct UserC {
name: String,
email: String,
cached_display: Option<String>, // 缓存
}
```
> **[批注] 原答太简略，只描述了"是什么"没回答"什么时候用"。**
> - **设计 A（全部 String）**：结构体拥有数据，适合需要独立生命周期、长期持有数据的场景（如从函数返回、存入集合）。额外 heap 分配开销。
> - **设计 B（全部 `&'a str`）**：仅仅借用外部数据，zero-copy，但受限于引用的生命周期 `'a`，结构体不能比它借用的数据活得更久。适合临时视图、解析器的 AST 节点等。
> - **设计 C（混合 + 缓存）**：String 拥有核心数据，`cached_display` 作为惰性计算的缓存。适合需要性能优化但保留所有权的场景。
### 题目 5-3
分析以下代码，回答:
1. `self`、`&self`、`&mut self` 三者在调用时的区别是什么？
> 答：self：方法接收一个结构体的所有权，方法调用结束后，结构体将不再可用；&self：方法接收结构体的引用，方法调用结束后，结构体仍然可用；&mut self：方法接收结构体的可变引用，方法调用结束后，结构体仍然可用，并且允许修改结构体的字段。
2. 当调用完 `into_value()` 之后，`counter` 是否还能使用？为什么？
> **[批注] 基本正确，但表述可更精确：** `into_value()` 的参数是 `self`（不是引用），调用时 `counter` 的所有权被**移入**方法，方法结束 `self` 被 drop，返回的 `u32` 是 Copy 类型独立于原结构体。"返回所有权"的说法容易混淆——方法不是返回所有权，而是**接收**所有权。
```rust
struct Counter {
count: u32,
}
impl Counter {
fn value(&self) -> u32 {
self.count
}
fn increment(&mut self) {
self.count += 1;
}
fn reset(&mut self) {
self.count = 0;
}
fn into_value(self) -> u32 {
self.count
}
}
fn main() {
let mut counter = Counter { count: 0 };
counter.increment();
counter.increment();
println!("value: {}", counter.value());
let n = counter.into_value();
println!("final: {}", n);
}
```
### 题目 5-4
下面的代码涉及 struct、impl 和模块的组合。有两个 struct 都定义了 `area` 方法，Rust 通过什么机制区分它们？
> **[批注] 原答错误。** "通过 self 参数区分"没有回答编译器如何做方法分派。正确答案：Rust 根据**方法接收者的类型**分派——`c.area()` 中 `c` 的类型是 `Circle`，编译器调用 `Circle::area`；`r.area()` 中 `r` 的类型是 `Rectangle`，编译器调用 `Rectangle::area`。`impl Circle` 和 `impl Rectangle` 是两个独立的 impl 块，各自的方法只属于各自的类型，不会混淆。这是编译期静态分派，与 self 无关。
```rust
struct Circle {
radius: f64,
}
struct Rectangle {
width: f64,
height: f64,
}
impl Circle {
fn area(&self) -> f64 {
std::f64::consts::PI * self.radius * self.radius
}
}
impl Rectangle {
fn area(&self) -> f64 {
self.width * self.height
}
}
fn main() {
let c = Circle { radius: 3.0 };
let r = Rectangle { width: 4.0, height: 5.0 };
println!("圆面积: {:.2}", c.area()); // Circle::area(&c)
println!("矩形面积: {:.2}", r.area()); // Rectangle::area(&r)
}
```
### 题目 5-5
元组结构体 `struct Point(i32, i32)` 和普通元组 `(i32, i32)` 有什么区别？在什么场景下应该使用元组结构体而不是普通元组？
> **[批注] 原答有多处错误。**
> 1. "元组结构体的字段顺序不要求与定义一致，使用命名即可" — **错误**，元组结构体没有命名字段，只能用索引 `.0` `.1` 访问。这是与普通结构体的核心区别。
> 2. "元组结构体的字段是可变的，普通元组字段是只读的" — **错误**，可变性与类型无关，取决于 `let mut`。
>
> **正确区分**：
> - 元组结构体 `struct Point(i32, i32)` 是一个**具名的新类型**，与 `struct Vector(i32, i32)` 是不同型别，不能互相赋值，提供类型安全。可以在其上 `impl` 方法和 trait。
> - 普通元组 `(i32, i32)` 是匿名类型，任何 `(i32, i32)` 都可互相赋值，没有类型区分能力。
---
## 参考答案
> 请独立完成再查看答案。
<details>
<summary>点击展开答案</summary>
### 一、基础题
**1-1**：✅ 通过编译。结构体中的字段顺序不要求与定义一致，使用命名即可。
**1-2**：✅ 通过编译。元组结构体使用 `.索引` 方式访问字段。
**1-3**：✅ 通过编译。`mut` 修饰的结构体实例，其所有字段都是可变的。
**1-4**：❌ 编译错误。`user1` 不是 `mut` 的，不能修改其字段。Rust 中可变性是整个结构体级别的，不能只标记某个字段为 `mut`。
**1-5**：❌ 编译错误。结构体更新语法 `..user1` 会移动 `user1` 中未实现 Copy 的字段（`username` 和 `email`）。`user1.username` 已被移动到 `user2`，`user1` 不再可用。
**1-6**：✅ 通过编译。`..user1` 展开时，显式赋值的 `email` 不会从 `user1` 移动，只有未显式赋值的非 Copy 字段（`username`）会被移动。`user1.email` 仍然有效，`user1.active`（Copy）也有效。但 `user1` 整体已部分移动，不能整体使用。
> **[批注] 此答案修正了原隐藏答案的错误（原答说 ❌ 编译错误）。** 结构体更新语法在显式覆盖字段时不会移动该字段。但若 `user1.username` 已移动，`user1` 作为一个整体不能再传递给其他函数。
**1-7**：✅ 通过编译。`#[derive(Debug)]` 自动为结构体实现了 `Debug` trait，允许使用 `{:?}` 格式化打印。
**1-8**：✅ 通过编译。元组结构体的实例各自独立，互不影响。
### 二、填空题
**2-1**：
```rust
struct Book {
title: String,
author: String,
pages: u32,
}
let book = Book {
title: String::from("深入浅出 Rust"),
author: String::from("张三"),
pages: 320,
};
```
**2-2**：
```rust
struct RGB(u8, u8, u8);
println!("红色: ({}, {}, {})", red.0, red.1, red.2);
```
**2-3**：
```rust
let s2 = Student {
name: String::from("小红"),
..s1
};
// s1.score 和 s1.age 在更新后是否还能使用？
// — 如果字段类型是 Copy 的（u32），可以继续使用
// — 如果字段类型不是 Copy 的（String），已被移动，不能使用
// 这里 age 和 score 都是 u32（Copy），所以 s1.score 和 s1.age 仍然可用
```
**2-4**：
```rust
fn area(&self) -> u32 {
self.width * self.height
}
fn can_hold(&self, other: &Rectangle) -> bool {
self.width > other.width && self.height > other.height
}
```
**2-5**：
```rust
fn square(size: u32) -> Rectangle {
Rectangle {
width: size,
height: size,
}
}
```
**2-6**：
```rust
fn value(&self) -> u32 { self.count } // 不可变借用
fn increment(&mut self) { self.count += 1; } // 可变借用
fn into_value(self) -> u32 { self.count } // 获取所有权
// 最后一行取消注释会报错：into_value() 消费了 counter，之后不能再使用
```
### 三、修复错误
**3-1**：结构体使用了引用字段但没有标注生命周期。修复：
```rust
struct User<'a> {
username: &'a str,
email: &'a str,
active: bool,
}
```
或者改用 `String` 类型（推荐给初学者）：
```rust
struct User {
username: String,
email: String,
active: bool,
}
```
**3-2**：`println!("{}", p)` 需要 `Display` trait，但只 derive 了 `Debug`。修复：
```rust
println!("{:?}", p); // 使用 Debug 格式化
// 或 println!("{}", p) 行不通 → 需改为 println!("{:?}", p)
```
**3-3**：方法调用语法错误。`rect::area()` 应改为 `rect.area()`。`::` 用于关联函数，`.` 用于方法调用。
**3-4**：`greet(self)` 获取了所有权，第一次调用后 `user` 被消费。修复：
```rust
fn greet(&self) { // 改为不可变引用
println!("你好，我是 {}，今年 {} 岁", self.name, self.age);
}
```
**3-5**：`get_value` 的不可变借用和 `set_value` 的可变借用存在生命周期重叠。修复：让 `v` 在 `c.set_value` 之前结束使用：
```rust
fn main() {
let mut c = Container { value: 10 };
let v = c.get_value();
println!("v = {}", v); // 先使用 v
c.set_value(20); // v 不再使用，可以创建可变借用
}
```
### 四、编程题
**4-1**：
```rust
fn new(name: String, id: u32) -> Student {
Student { name, id, grades: Vec::new() }
}
fn add_grade(&mut self, grade: u32) {
self.grades.push(grade);
}
fn average_grade(&self) -> f64 {
if self.grades.is_empty() {
0.0
} else {
self.grades.iter().sum::<u32>() as f64 / self.grades.len() as f64
}
}
fn is_passing(&self) -> bool {
self.average_grade() >= 60.0
}
```
**4-2**：
```rust
impl Circle {
fn area(&self) -> f64 {
PI * self.radius * self.radius
}
fn perimeter(&self) -> f64 {
2.0 * PI * self.radius
}
}
impl Rectangle {
fn area(&self) -> f64 {
self.width * self.height
}
fn perimeter(&self) -> f64 {
2.0 * (self.width + self.height)
}
}
```
**4-3**：
```rust
struct Celsius(f64);
struct Fahrenheit(f64);
struct Kelvin(f64);
impl Celsius {
fn to_fahrenheit(&self) -> Fahrenheit {
Fahrenheit(self.0 * 9.0 / 5.0 + 32.0)
}
fn to_kelvin(&self) -> Kelvin {
Kelvin(self.0 + 273.15)
}
}
impl Fahrenheit {
fn to_celsius(&self) -> Celsius {
Celsius((self.0 - 32.0) * 5.0 / 9.0)
}
}
```
**4-4**：
```rust
struct ListNode {
value: i32,
next: Option<Box<ListNode>>,
}
impl ListNode {
fn new(value: i32) -> ListNode {
ListNode { value, next: None }
}
fn append(&mut self, value: i32) {
match &mut self.next {
Some(next_node) => next_node.append(value),
None => self.next = Some(Box::new(ListNode::new(value))),
}
}
fn collect(&self) -> Vec<i32> {
let mut result = vec![self.value];
let mut current = &self.next;
while let Some(node) = current {
result.push(node.value);
current = &node.next;
}
result
}
}
```
**4-5**：
```rust
impl Item {
fn new(name: &str, price: f64, quantity: u32) -> Item {
Item { name: String::from(name), price, quantity }
}
fn total(&self) -> f64 {
self.price * self.quantity as f64
}
}
impl ShoppingCart {
fn new() -> ShoppingCart {
ShoppingCart { items: Vec::new() }
}
fn add_item(&mut self, item: Item) {
self.items.push(item);
}
fn total(&self) -> f64 {
self.items.iter().map(|item| item.total()).sum()
}
fn item_count(&self) -> usize {
self.items.len()
}
fn print_receipt(self) {
println!("=== 购物明细 ===");
for item in &self.items {
println!("{} × {} @ {:.2} = {:.2}", item.name, item.quantity, item.price, item.total());
}
println!("----------------------");
println!("总计: {:.2}", self.total());
println!("======================");
}
}
// print_receipt(self) 消耗了购物车所有权，之后再调用 item_count() 会报错
```
### 五、综合思考题
**5-1**：
- `user1.username`（String）— 已被 `..user1` 移动到 `user2`，**不可用**
- `user1.email`（String）— 在 `user2` 中被显式赋予新值，**未被移动，可用**
- `user1.active`（bool，Copy 类型）— 被复制，**可用**
> **[批注] 此答案修正了原隐藏答案关于 user1.email 的错误。** 显式覆盖的字段不会从原结构体移动。
**5-2**：
- **设计 A**：适合需要拥有数据的场景，如从函数返回新结构体、需要独立生命周期、长期持有的数据
- **设计 B**：适合临时借用、只读引用外部数据、需要避免堆分配的场景；缺点是结构体受限于引用的生命周期
- **设计 C**：适合需要高性能 + 灵活性的场景，但增加了维护缓存的复杂性
**5-3**：
- `&self`：不可变借用，只读，可多次调用，调用后实例仍可用
- `&mut self`：可变借用，可修改，同时只能有一个，调用后实例仍可用
- `self`：获取所有权，可修改或消费，调用后实例被 drop，不可再用
- `into_value()` 获取了 `counter` 的所有权，调用后 `counter` 不再可用
**5-4**：Rust 通过**方法调用的接收者类型**来区分。`c.area()` 的接收者是 `Circle`，调用 `Circle::area`；`r.area()` 的接收者是 `Rectangle`，调用 `Rectangle::area`。
**5-5**：
- 元组结构体 `Point(i32, i32)` 是一个**命名类型**，与 `Vec2(i32, i32)` 是不同的类型，不能互相赋值，提供了类型安全
- 普通元组 `(i32, i32)` 是匿名类型，任何 `(i32, i32)` 都可以互相赋值
- 使用元组结构体的场景：需要类型安全地区分语义不同的同构数据（如 `Celsius(f64)` vs `Fahrenheit(f64)`），或为特定类型实现方法和 trait
</details>
Reference in New Issue View Git Blame Copy Permalink