เรเฟอเรนซ์และการยืม
ปัญหาของโค้ดทูเพิลในลิสติ้ง 4-5 คือเราจำเป็นต้องคืนค่า String กลับมายังฟังก์ชันผู้เรียก เพื่อให้เรายังสามารถนำ String นั้นไปใช้งานต่อได้หลังจากการเรียกใช้ calculate_length เพราะความเป็นเจ้าของของ String ได้ถูกย้ายเข้าไปใน calculate_length ไปแล้ว แต่เราสามารถส่ง การอ้างอิง หรือ เรเฟอเรนซ์ (reference) ไปยังค่าของ String แทนได้ เรเฟอเรนซ์ทำงานคล้ายกับพอยน์เตอร์ (pointer) ตรงที่เป็นการเก็บที่อยู่ (address) ในหน่วยความจำที่เราสามารถตามไปเข้าถึงข้อมูลจริงที่ถูกจัดเก็บไว้ ณ ตำแหน่งนั้นได้ โดยที่ข้อมูลนั้นยังคงเป็นของตัวแปรอื่นอยู่ แต่สิ่งที่แตกต่างจากพอยน์เตอร์ทั่วไปคือ เรเฟอเรนซ์ใน Rust ได้รับการรับประกันว่าจะชี้ไปยังค่าที่ถูกต้องและมีตัวตนอยู่จริงของชนิดข้อมูลนั้นๆ เสมอตลอดอายุขัยของเรเฟอเรนซ์
ตัวอย่างต่อไปนี้แสดงวิธีนิยามและเรียกใช้งานฟังก์ชัน calculate_length โดยรับเรเฟอเรนซ์ของออบเจกต์เป็นพารามิเตอร์ แทนที่จะต้องย้ายความเป็นเจ้าของของค่าเข้ามา:
fn main() {
let s1 = String::from("hello");
let len = calculate_length(&s1);
println!("The length of '{s1}' is {len}.");
}
fn calculate_length(s: &String) -> usize {
s.len()
}
ประการแรก โปรดสังเกตว่าโค้ดส่วนทูเพิลทั้งหมดในการประกาศตัวแปรและค่าคืนกลับของฟังก์ชันหายไปแล้ว ประการที่สอง สังเกตว่าเราส่ง &s1 เข้าไปยัง calculate_length และในนิยามของฟังก์ชัน เราระบุชนิดข้อมูลเป็น &String แทนที่จะเป็น String เครื่องหมายแอมเพอร์แซนด์ (&) เหล่านี้แทนการสร้างเรเฟอเรนซ์ ซึ่งช่วยให้คุณสามารถอ้างอิงถึงค่าใดค่าหนึ่งได้โดยไม่ต้องถือครองความเป็นเจ้าของค่านั้น แผนภาพในรูปที่ 4-6 แสดงแนวคิดนี้ได้อย่างชัดเจน
รูปที่ 4-6: แผนภาพของ &String s ที่ชี้ไปยัง String s1
หมายเหตุ: การทำงานที่ตรงกันข้ามกับการอ้างอิงด้วย
&คือ การดีเรเฟอเรนซ์ (dereferencing) ซึ่งทำได้โดยใช้ตัวดำเนินการ*เราจะได้เห็นการใช้งานตัวดำเนินการดีเรเฟอเรนซ์ในบทที่ 8 และจะลงลึกรายละเอียดในบทที่ 15
ลองมาพิจารณาการเรียกใช้ฟังก์ชันในจุดนี้อย่างละเอียดขึ้น:
fn main() {
let s1 = String::from("hello");
let len = calculate_length(&s1);
println!("The length of '{s1}' is {len}.");
}
fn calculate_length(s: &String) -> usize {
s.len()
}
ไวยากรณ์ &s1 ช่วยให้เราสร้างเรเฟอเรนซ์ที่ อ้างถึง ค่าของ s1 โดยไม่ได้เป็นเจ้าของค่านั้น และเนื่องจากเรเฟอเรนซ์ไม่ได้เป็นเจ้าของ ข้อมูลที่มันชี้ไปจึงจะไม่ถูกทำลายทิ้ง (drop) เมื่อเรเฟอเรนซ์นี้หมดอายุการใช้งาน
ในทำนองเดียวกัน ลายเซ็นของฟังก์ชันจะใช้เครื่องหมาย & เพื่อระบุว่าพารามิเตอร์ s เป็นเรเฟอเรนซ์ ลองมาดูคำอธิบายประกอบในโค้ดนี้:
fn main() {
let s1 = String::from("hello");
let len = calculate_length(&s1);
println!("The length of '{s1}' is {len}.");
}
fn calculate_length(s: &String) -> usize { // s is a reference to a String
s.len()
} // Here, s goes out of scope. But because s does not have ownership of what
// it refers to, the String is not dropped.
ขอบเขตที่ตัวแปร s มีผลใช้งานได้นั้นเหมือนกับขอบเขตของพารามิเตอร์ในฟังก์ชันทั่วไป แต่ค่าที่เรเฟอเรนซ์ชี้ไปจะไม่ถูกทำลายทิ้งเมื่อ s หลุดออกจากขอบเขต เพราะ s ไม่ได้เป็นเจ้าของข้อมูลนั้น เมื่อฟังก์ชันรับพารามิเตอร์เป็นเรเฟอเรนซ์แทนที่จะเป็นค่าจริง เราจึงไม่จำเป็นต้องคืนค่านั้นกลับมาเพื่อส่งมอบความเป็นเจ้าของคืน เพราะเราไม่เคยได้รับความเป็นเจ้าของมาตั้งแต่แรก
เราเรียกกระบวนการสร้างเรเฟอเรนซ์นี้ว่า การยืม (borrowing) เช่นเดียวกับในชีวิตจริง หากสิ่งของเป็นของใครสักคน คุณสามารถขอยืมจากเขามาใช้ได้ และเมื่อใช้เสร็จแล้ว คุณก็ต้องคืนสิ่งนั้นกลับไป โดยที่คุณไม่ได้เป็นเจ้าของสิ่งนั้น
แล้วจะเกิดอะไรขึ้นหากเราพยายามแก้ไขสิ่งที่เรากำลังยืมมา? ลองดูโค้ดในลิสติ้ง 4-6 (ขอเตือนไว้ก่อนล่วงหน้าเลยว่า โค้ดนี้จะคอมไพล์ไม่ผ่าน!):
fn main() {
let s = String::from("hello");
change(&s);
}
fn change(some_string: &String) {
some_string.push_str(", world");
}
และนี่คือข้อความแจ้งข้อผิดพลาด:
$ cargo run
Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0596]: cannot borrow `*some_string` as mutable, as it is behind a `&` reference
--> src/main.rs:8:5
|
8 | some_string.push_str(", world");
| ^^^^^^^^^^^ `some_string` is a `&` reference, so it cannot be borrowed as mutable
|
help: consider changing this to be a mutable reference
|
7 | fn change(some_string: &mut String) {
| +++
For more information about this error, try `rustc --explain E0596`.
error: could not compile `ownership` (bin "ownership") due to 1 previous error
เช่นเดียวกับตัวแปรที่แก้ไขไม่ได้ (immutable) โดยค่าเริ่มต้น เรเฟอเรนซ์ก็เป็นเช่นเดียวกัน กล่าวคือเราไม่ได้รับอนุญาตให้แก้ไขข้อมูลใดๆ ที่เราถือเพียงแค่เรเฟอเรนซ์ไปยังข้อมูลนั้น
เรเฟอเรนซ์แบบเปลี่ยนแปลงได้
เราสามารถปรับแก้โค้ดจากลิสติ้ง 4-6 เพื่อให้สามารถแก้ไขค่าที่ถูกยืมมาได้ ด้วยการปรับเปลี่ยนเพียงเล็กน้อยโดยหันมาใช้ เรเฟอเรนซ์แบบเปลี่ยนแปลงได้ (mutable reference) แทน ดังนี้:
fn main() {
let mut s = String::from("hello");
change(&mut s);
}
fn change(some_string: &mut String) {
some_string.push_str(", world");
}
ประการแรก เราเปลี่ยนการประกาศ s ให้เป็นตัวแปรแบบ mut จากนั้นจึงสร้างเรเฟอเรนซ์แบบเปลี่ยนแปลงได้ด้วยคำสั่ง &mut s ในจุดที่เราเรียกฟังก์ชัน change และปรับลายเซ็นของฟังก์ชันให้รับเรเฟอเรนซ์แบบเปลี่ยนแปลงได้ด้วย some_string: &mut String ซึ่งทำให้เห็นได้อย่างชัดเจนว่าฟังก์ชัน change จะเข้าไปแก้ไขค่าที่มันขอยืมมา
อย่างไรก็ดี เรเฟอเรนซ์แบบเปลี่ยนแปลงได้มีข้อจำกัดที่สำคัญอย่างยิ่งหนึ่งข้อคือ: หากคุณมีเรเฟอเรนซ์แบบเปลี่ยนแปลงได้ไปยังค่าใดค่าหนึ่งอยู่แล้ว คุณจะไม่สามารถมีเรเฟอเรนซ์อื่นใดไปยังค่านั้นได้อีกเลย โค้ดที่พยายามสร้างเรเฟอเรนซ์แบบเปลี่ยนแปลงได้สองตัวพร้อมกันไปยัง s ต่อไปนี้จะคอมไพล์ไม่ผ่าน:
fn main() {
let mut s = String::from("hello");
let r1 = &mut s;
let r2 = &mut s;
println!("{r1}, {r2}");
}
นี่คือข้อผิดพลาดที่เกิดขึ้น:
$ cargo run
Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0499]: cannot borrow `s` as mutable more than once at a time
--> src/main.rs:5:14
|
4 | let r1 = &mut s;
| ------ first mutable borrow occurs here
5 | let r2 = &mut s;
| ^^^^^^ second mutable borrow occurs here
6 |
7 | println!("{r1}, {r2}");
| -- first borrow later used here
For more information about this error, try `rustc --explain E0499`.
error: could not compile `ownership` (bin "ownership") due to 1 previous error
ข้อผิดพลาดนี้ระบุว่าโค้ดทำงานไม่ได้เพราะเราไม่สามารถยืม s แบบเปลี่ยนแปลงได้มากกว่าหนึ่งครั้งในเวลาเดียวกัน การยืมแบบเปลี่ยนแปลงได้ครั้งแรกเกิดขึ้นที่ตัวแปร r1 และยังคงต้องมีผลใช้งานอยู่จนถึงจุดที่ถูกนำไปใช้ใน println! แต่ในระหว่างการสร้างเรเฟอเรนซ์ดังกล่าวกับการนำไปใช้งานจริง เรากลับพยายามสร้างเรเฟอเรนซ์แบบเปลี่ยนแปลงได้อีกตัวหนึ่งใน r2 เพื่อขอยืมข้อมูลชุดเดียวกันกับ r1
ข้อจำกัดที่ป้องกันไม่ให้มีเรเฟอเรนซ์แบบเปลี่ยนแปลงได้หลายตัวไปยังข้อมูลเดียวกันในเวลาเดียวกันนี้ ช่วยให้การแก้ไขข้อมูลเป็นไปอย่างรัดกุมและปลอดภัย ซึ่งอาจเป็นเรื่องที่ผู้เริ่มเขียน Rust ต้องปรับตัว เนื่องจากภาษาโปรแกรมส่วนใหญ่ยอมให้คุณแก้ไขข้อมูลได้ทุกที่ทุกเวลา แต่ข้อดีอย่างมหาศาลของข้อจำกัดนี้คือ Rust สามารถป้องกันปัญหา ดาต้าเรซ (data race) ได้ตั้งแต่ตอนคอมไพล์ ปัญหาดาต้าเรซคล้ายคลึงกับภาวะแย่งชิงทรัพยากร (race condition) และจะเกิดขึ้นเมื่อมีพฤติกรรมทั้ง 3 ข้อต่อไปนี้เกิดขึ้นพร้อมกัน:
- มีพอยน์เตอร์ตั้งแต่สองตัวขึ้นไปเข้าถึงข้อมูลชุดเดียวกันในเวลาเดียวกัน
- มีพอยน์เตอร์อย่างน้อยหนึ่งตัวที่กำลังถูกใช้เพื่อเขียนข้อมูล
- ไม่ได้ใช้กลไกการซิงโครไนซ์ใดๆ ในการควบคุมการเข้าถึงข้อมูลนั้น
ดาต้าเรซจะทำให้เกิดพฤติกรรมที่ไม่สามารถคาดเดาได้ (undefined behavior) และมักจะเป็นปัญหาที่ยากมากในการตรวจหาและแก้ไขในระหว่างรันไทม์ Rust ขจัดปัญหานี้ให้หมดสิ้นโดยการปฏิเสธที่จะคอมไพล์โค้ดที่อาจก่อให้เกิดดาต้าเรซ!
เช่นเคย เราสามารถใช้วงเล็บปีกกาเพื่อสร้างขอบเขตใหม่ ซึ่งช่วยให้เราสามารถมีเรเฟอเรนซ์แบบเปลี่ยนแปลงได้หลายตัวได้ ตราบใดที่พวกมันไม่ได้คงอยู่ พร้อมกัน:
fn main() {
let mut s = String::from("hello");
{
let r1 = &mut s;
} // r1 goes out of scope here, so we can make a new reference with no problems.
let r2 = &mut s;
}
นอกจากนี้ Rust ยังบังคับใช้กฎในลักษณะเดียวกันสำหรับการใช้งานเรเฟอเรนซ์แบบเปลี่ยนแปลงได้ร่วมกับเรเฟอเรนซ์แบบเปลี่ยนแปลงไม่ได้ โค้ดต่อไปนี้จะทำให้เกิดข้อผิดพลาดในการคอมไพล์:
fn main() {
let mut s = String::from("hello");
let r1 = &s; // no problem
let r2 = &s; // no problem
let r3 = &mut s; // BIG PROBLEM
println!("{r1}, {r2}, and {r3}");
}
นี่คือข้อผิดพลาดที่เกิดขึ้น:
$ cargo run
Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0502]: cannot borrow `s` as mutable because it is also borrowed as immutable
--> src/main.rs:6:14
|
4 | let r1 = &s; // no problem
| -- immutable borrow occurs here
5 | let r2 = &s; // no problem
6 | let r3 = &mut s; // BIG PROBLEM
| ^^^^^^ mutable borrow occurs here
7 |
8 | println!("{r1}, {r2}, and {r3}");
| -- immutable borrow later used here
For more information about this error, try `rustc --explain E0502`.
error: could not compile `ownership` (bin "ownership") due to 1 previous error
นั่นคือเรา ไม่สามารถ มีเรเฟอเรนซ์แบบเปลี่ยนแปลงได้ ในขณะที่ยังคงมีเรเฟอเรนซ์แบบเปลี่ยนแปลงไม่ได้ชี้ไปยังค่าเดียวกันอยู่
ผู้ที่กำลังใช้งานเรเฟอเรนซ์แบบเปลี่ยนแปลงไม่ได้ย่อมไม่คาดคิดว่าค่าที่ตนกำลังอ่านอยู่จะถูกใครอื่นแอบเปลี่ยนแปลงไปอย่างกะทันหัน! อย่างไรก็ตาม เราสามารถมีเรเฟอเรนซ์แบบเปลี่ยนแปลงไม่ได้หลายตัวพร้อมกันได้โดยไม่มีปัญหา เพราะการอ่านข้อมูลเพียงอย่างเดียวย่อมไม่ส่งผลกระทบต่อผู้อื่นที่กำลังอ่านข้อมูลชุดเดียวกัน
โปรดสังเกตว่าขอบเขตของเรเฟอเรนซ์จะเริ่มต้นจากจุดที่มันถูกประกาศ และสิ้นสุดลง ณ จุดสุดท้ายที่มีการนำเรเฟอเรนซ์นั้นไปใช้งานจริง ตัวอย่างเช่น โค้ดต่อไปนี้จะคอมไพล์ผ่านได้อย่างสมบูรณ์ เพราะการใช้งานครั้งสุดท้ายของเรเฟอเรนซ์แบบเปลี่ยนแปลงไม่ได้อยู่ใน println! ซึ่งเกิดขึ้นก่อนที่จะมีการสร้างเรเฟอเรนซ์แบบเปลี่ยนแปลงได้:
fn main() {
let mut s = String::from("hello");
let r1 = &s; // no problem
let r2 = &s; // no problem
println!("{r1} and {r2}");
// Variables r1 and r2 will not be used after this point.
let r3 = &mut s; // no problem
println!("{r3}");
}
ขอบเขตของเรเฟอเรนซ์แบบเปลี่ยนแปลงไม่ได้ r1 และ r2 สิ้นสุดลงทันทีหลังบรรทัด println! ที่พวกมันถูกเรียกใช้งานเป็นครั้งสุดท้าย ซึ่งเป็นตำแหน่งก่อนที่เรเฟอเรนซ์แบบเปลี่ยนแปลงได้ r3 จะถูกสร้างขึ้นมา ขอบเขตการทำงานของทั้งสองกลุ่มจึงไม่ได้ทับซ้อนกัน โค้ดนี้จึงได้รับอนุญาตให้ทำงานได้ เนื่องจากคอมไพเลอร์สามารถตรวจสอบได้ว่าเรเฟอเรนซ์เดิมไม่ได้ถูกนำมาใช้งานต่ออีกแล้ว ณ จุดดังกล่าวก่อนจะสิ้นสุดบล็อก
แม้ว่ากฎเรื่องการยืมอาจสร้างความหงุดหงิดให้บ้างในบางครั้ง แต่ขอให้ตระหนักไว้เสมอว่า คอมไพเลอร์ของ Rust กำลังช่วยชี้จุดที่อาจเกิดบั๊กขึ้นได้ล่วงหน้าตั้งแต่เนิ่นๆ (ตั้งแต่ตอนคอมไพล์แทนที่จะไปเกิดข้อผิดพลาดตอนรันจริง) พร้อมระบุตำแหน่งของปัญหาให้อย่างชัดเจน ทำให้คุณไม่ต้องเสียเวลาตามหาว่าทำไมข้อมูลของคุณจึงไม่เป็นไปตามที่คาดหวังในภายหลัง
เรเฟอเรนซ์ที่ชี้ไปยังหน่วยความจำที่ถูกคืนแล้ว
ในภาษาโปรแกรมที่มีพอยน์เตอร์ เป็นเรื่องง่ายมากที่จะเผลอสร้าง พอยน์เตอร์ที่ชี้ไปยังหน่วยความจำที่ถูกคืนแล้ว (dangling pointer) ซึ่งเป็นพอยน์เตอร์ที่อ้างอิงไปยังตำแหน่งในหน่วยความจำที่อาจถูกคืนหรือถูกจัดสรรให้กับข้อมูลอื่นไปแล้ว โดยเกิดจากการสั่งคืนหน่วยความจำในขณะที่ยังมีพอยน์เตอร์ชี้ค้างไว้อยู่ ในทางตรงกันข้าม สำหรับภาษา Rust คอมไพเลอร์จะรับประกันอย่างเด็ดขาดว่าจะไม่มีเรเฟอเรนซ์ใดกลายเป็นเรเฟอเรนซ์ที่ชี้ไปยังหน่วยความจำที่ถูกคืนแล้ว: หากคุณมีเรเฟอเรนซ์ไปยังข้อมูลชุดหนึ่ง คอมไพเลอร์จะตรวจสอบให้มั่นใจเสมอว่าข้อมูลจริงนั้นจะไม่หลุดออกจากขอบเขตก่อนที่เรเฟอเรนซ์ที่ชี้ไปยังข้อมูลนั้นจะหมดอายุการใช้งาน
ลองมาทดลองสร้างเรเฟอเรนซ์ที่ชี้ไปยังหน่วยความจำที่ถูกคืนแล้ว เพื่อดูว่า Rust ป้องกันปัญหานี้ผ่านข้อผิดพลาดตอนคอมไพล์อย่างไร:
fn main() {
let reference_to_nothing = dangle();
}
fn dangle() -> &String {
let s = String::from("hello");
&s
}
นี่คือข้อผิดพลาดที่เกิดขึ้น:
$ cargo run
Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0106]: missing lifetime specifier
--> src/main.rs:5:16
|
5 | fn dangle() -> &String {
| ^ expected named lifetime parameter
|
= help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from
help: consider using the `'static` lifetime, but this is uncommon unless you're returning a borrowed value from a `const` or a `static`
|
5 | fn dangle() -> &'static String {
| +++++++
help: instead, you are more likely to want to return an owned value
|
5 - fn dangle() -> &String {
5 + fn dangle() -> String {
|
For more information about this error, try `rustc --explain E0106`.
error: could not compile `ownership` (bin "ownership") due to 1 previous error
ข้อความข้อผิดพลาดนี้ได้อ้างอิงถึงฟีเจอร์ที่เรายังไม่ได้พูดถึง นั่นก็คือเรื่องอายุขัย (lifetime) ซึ่งเราจะได้เรียนรู้เรื่องไลฟ์ไทม์อย่างละเอียดในบทที่ 10 แต่แม้จะมองข้ามส่วนของไลฟ์ไทม์ไป ข้อความแจ้งเตือนนี้ก็ได้ระบุใจความสำคัญของปัญหาไว้อย่างชัดเจน:
this function's return type contains a borrowed value, but there is no value
for it to be borrowed from
ลองมาดูสิ่งที่เกิดขึ้นในแต่ละขั้นตอนของฟังก์ชัน dangle อย่างละเอียดกัน:
fn main() {
let reference_to_nothing = dangle();
}
fn dangle() -> &String { // dangle returns a reference to a String
let s = String::from("hello"); // s is a new String
&s // we return a reference to the String, s
} // Here, s goes out of scope and is dropped, so its memory goes away.
// Danger!
เนื่องจากตัวแปร s ถูกสร้างขึ้นภายในฟังก์ชัน dangle เมื่อฟังก์ชัน dangle ทำงานจบลง หน่วยความจำของ s จึงถูกคืนกลับไปทันที แต่เรากลับพยายามส่งเรเฟอเรนซ์ที่ชี้ไปยังตัวมันกลับออกไป นั่นหมายความว่าเรเฟอเรนซ์นี้จะกลายเป็นเรเฟอเรนซ์ที่ชี้ไปยัง String ที่ไม่มีตัวตนอยู่อีกต่อไป ซึ่งเป็นสิ่งที่ไม่ถูกต้องอย่างยิ่ง! และ Rust จะไม่อนุญาตให้เราทำเช่นนี้อย่างแน่นอน
ทางออกสำหรับกรณีนี้คือการส่งคืนค่า String ออกไปโดยตรง:
fn main() {
let string = no_dangle();
}
fn no_dangle() -> String {
let s = String::from("hello");
s
}
โค้ดชุดนี้ทำงานได้โดยไม่มีข้อผิดพลาดใดๆ เพราะความเป็นเจ้าของถูกส่งมอบออกไปนอกฟังก์ชัน และไม่มีหน่วยความจำส่วนใดถูกคืนทิ้งก่อนเวลาอันควร
กฎของเรเฟอเรนซ์
เรามาสรุปกฎสำคัญเกี่ยวกับเรเฟอเรนซ์กันอีกครั้ง:
- ณ เวลาใดเวลาหนึ่ง คุณสามารถมีเรเฟอเรนซ์แบบเปลี่ยนแปลงได้เพียงหนึ่งตัว หรือ มีเรเฟอเรนซ์แบบเปลี่ยนแปลงไม่ได้กี่ตัวก็ได้
- เรเฟอเรนซ์จะต้องชี้ไปยังข้อมูลที่ถูกต้องและมีตัวตนอยู่เสมอ
ในหัวข้อถัดไป เราจะมาดูเรเฟอเรนซ์อีกรูปแบบหนึ่ง นั่นก็คือ สไลซ์ (slice)