4. Ownership และการยืม

เรื่องที่ทำให้ Rust ต่างจากทุกภาษา อ่านช้า ๆ ไม่ต้องรีบ

ปัญหาที่ Rust แก้

ทุกโปรแกรมต้องขอหน่วยความจำมาใช้ และต้องคืนเมื่อใช้เสร็จ ภาษาอย่าง C ให้โปรแกรมเมอร์คืนเอง ลืมคืนก็เปลือง คืนซ้ำหรือใช้หลังคืนก็พัง ภาษาอย่าง C# หรือ Java มีตัวเก็บขยะ (garbage collector) คอยตามเก็บ แต่ต้องแลกด้วยความเร็วและการหยุดชะงักเป็นระยะ

Rust ใช้วิธีที่สาม: กฎความเป็นเจ้าของ ที่คอมไพเลอร์ตรวจตอน build จึงคืนหน่วยความจำได้ถูกจังหวะเสมอ โดยไม่ต้องมีตัวเก็บขยะ

กฎสามข้อ

  1. ค่าแต่ละค่ามีเจ้าของหนึ่งคน (คือตัวแปร)
  2. ในเวลาหนึ่งมีเจ้าของได้คนเดียว
  3. เมื่อเจ้าของหมดอายุ (ออกจาก { } ที่มันอยู่) ค่านั้นถูกคืนทันที

การย้าย (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}");   // สมุด (มีโน้ต)
}

กฎของการยืม

ในช่วงเวลาหนึ่ง เลือกได้อย่างเดียว:

เหมือนเอกสารบนโต๊ะ หลายคนอ่านพร้อมกันได้ แต่ถ้ามีคนกำลังแก้ คนอื่นต้องรอ ไม่อย่างนั้นจะมีคนอ่านเจอข้อความที่แก้ไปครึ่งเดียว กฎนี้แหละที่ทำให้ Rust ป้องกันบั๊กประเภท "ข้อมูลเปลี่ยนใต้มือ" ได้ตั้งแต่ตอนคอมไพล์

let mut list = vec![1, 2, 3];
let first = &list[0];   // ยืมอ่าน
list.push(4);           // error: ยืมแก้ ขณะที่ first ยังยืมอ่านอยู่
println!("{first}");

ทำไมถึงห้าม? เพราะ push อาจทำให้รายการย้ายไปอยู่ที่ใหม่ในหน่วยความจำ แล้ว first จะชี้ไปที่ที่ว่างเปล่า ภาษาอื่นปล่อยให้พังตอนรัน Rust ไม่ยอมให้ build

เมื่อติดเรื่อง ownership ทำอย่างไร

  1. เขียน fn shout(text: &str) -> String คืนข้อความเป็นตัวพิมพ์ใหญ่ (text.to_uppercase()) เรียกสองครั้งด้วยตัวแปรเดิม
  2. เขียน fn double_all(numbers: &mut Vec<i32>) ที่คูณทุกตัวด้วย 2 (ใช้ for n in numbers.iter_mut() { *n *= 2; })
  3. ลองเขียนโค้ดที่ผิดกฎในหน้านี้ แล้วอ่าน error ที่ได้