4. Ownership และการยืม
เรื่องที่ทำให้ Rust ต่างจากทุกภาษา อ่านช้า ๆ ไม่ต้องรีบ
ปัญหาที่ Rust แก้
ทุกโปรแกรมต้องขอหน่วยความจำมาใช้ และต้องคืนเมื่อใช้เสร็จ ภาษาอย่าง C ให้โปรแกรมเมอร์คืนเอง ลืมคืนก็เปลือง คืนซ้ำหรือใช้หลังคืนก็พัง ภาษาอย่าง C# หรือ Java มีตัวเก็บขยะ (garbage collector) คอยตามเก็บ แต่ต้องแลกด้วยความเร็วและการหยุดชะงักเป็นระยะ
Rust ใช้วิธีที่สาม: กฎความเป็นเจ้าของ ที่คอมไพเลอร์ตรวจตอน build จึงคืนหน่วยความจำได้ถูกจังหวะเสมอ โดยไม่ต้องมีตัวเก็บขยะ
กฎสามข้อ
- ค่าแต่ละค่ามีเจ้าของหนึ่งคน (คือตัวแปร)
- ในเวลาหนึ่งมีเจ้าของได้คนเดียว
- เมื่อเจ้าของหมดอายุ (ออกจาก
{ }ที่มันอยู่) ค่านั้นถูกคืนทันที
การย้าย (move)
นึกถึงหนังสือหนึ่งเล่ม ถ้าผมให้หนังสือคุณ หนังสือก็เป็นของคุณ ผมไม่มีแล้ว
let a = String::from("หนังสือ");
let b = a; // ย้ายความเป็นเจ้าของจาก a ไป b
println!("{b}"); // ได้
println!("{a}"); // error: borrow of moved value: `a`
ส่งให้ฟังก์ชันก็คือการย้ายเหมือนกัน:
fn read(book: String) {
println!("อ่าน {book}");
} // book หมดอายุตรงนี้ หนังสือถูกคืน
fn main() {
let mine = String::from("นิยาย");
read(mine);
// println!("{mine}"); // error: mine ถูกย้ายไปแล้ว
}
i32, f64, bool, char ไม่ถูกย้าย แต่ถูกคัดลอก เพราะคัดลอกถูกมาก let b = a; แล้วใช้ a ต่อได้ตามปกติการยืม (borrow) ด้วย &
ส่วนใหญ่เราไม่ได้อยากยกหนังสือให้ใคร แค่ให้ยืมอ่าน แล้วเขาก็คืน ใน Rust เขียนด้วย &
fn read(book: &String) { // ยืม ไม่ได้เอาไป
println!("อ่าน {book}");
}
fn main() {
let mine = String::from("นิยาย");
read(&mine); // ให้ยืม
read(&mine); // ให้ยืมอีกก็ได้
println!("ยังเป็นของฉัน: {mine}");
}
ยืมไปแก้ด้วย &mut
fn add_note(book: &mut String) {
book.push_str(" (มีโน้ต)");
}
fn main() {
let mut mine = String::from("สมุด");
add_note(&mut mine);
println!("{mine}"); // สมุด (มีโน้ต)
}
กฎของการยืม
ในช่วงเวลาหนึ่ง เลือกได้อย่างเดียว:
- ยืมอ่าน (
&) กี่คนก็ได้ หรือ - ยืมแก้ (
&mut) ได้คนเดียว และระหว่างนั้นห้ามคนอื่นยืมเลย
เหมือนเอกสารบนโต๊ะ หลายคนอ่านพร้อมกันได้ แต่ถ้ามีคนกำลังแก้ คนอื่นต้องรอ ไม่อย่างนั้นจะมีคนอ่านเจอข้อความที่แก้ไปครึ่งเดียว กฎนี้แหละที่ทำให้ Rust ป้องกันบั๊กประเภท "ข้อมูลเปลี่ยนใต้มือ" ได้ตั้งแต่ตอนคอมไพล์
let mut list = vec![1, 2, 3];
let first = &list[0]; // ยืมอ่าน
list.push(4); // error: ยืมแก้ ขณะที่ first ยังยืมอ่านอยู่
println!("{first}");
ทำไมถึงห้าม? เพราะ push อาจทำให้รายการย้ายไปอยู่ที่ใหม่ในหน่วยความจำ แล้ว first จะชี้ไปที่ที่ว่างเปล่า ภาษาอื่นปล่อยให้พังตอนรัน Rust ไม่ยอมให้ build
เมื่อติดเรื่อง ownership ทำอย่างไร
- ฟังก์ชันแค่อ่านค่า: รับเป็น
&(สำหรับข้อความ ใช้&strดีกว่า&String) - ฟังก์ชันต้องแก้ค่า: รับเป็น
&mut - อยากได้สำเนาแยกจริง ๆ:
.clone()(ใช้ได้ ไม่ผิด แค่เปลืองกว่านิดหน่อย มือใหม่ใช้ไปก่อนได้) - อ่านข้อความ error ให้จบ คอมไพเลอร์มักบอกวิธีแก้ไว้ท้ายข้อความ ดูบทที่ 10
- เขียน
fn shout(text: &str) -> Stringคืนข้อความเป็นตัวพิมพ์ใหญ่ (text.to_uppercase()) เรียกสองครั้งด้วยตัวแปรเดิม - เขียน
fn double_all(numbers: &mut Vec<i32>)ที่คูณทุกตัวด้วย 2 (ใช้for n in numbers.iter_mut() { *n *= 2; }) - ลองเขียนโค้ดที่ผิดกฎในหน้านี้ แล้วอ่าน error ที่ได้