ใช้ Box<T> ชี้ไปยังข้อมูลบนฮีป
สมาร์ตพอยน์เตอร์ (smart pointer) ที่เข้าใจง่ายและตรงไปตรงมาที่สุดก็คือบ็อกซ์ (box) ซึ่งเขียนแทนด้วยชนิดข้อมูล Box<T> โดย บ็อกซ์ ช่วยให้คุณสามารถเก็บข้อมูลไว้บนฮีป (heap) แทนที่จะเป็นบนสแตก (stack) สิ่งที่ยังคงอยู่บนสแตกจะมีเพียงแค่พอยน์เตอร์ที่ชี้ไปยังข้อมูลบนฮีปเท่านั้น หากต้องการทบทวนความแตกต่างระหว่างสแตกและฮีป สามารถย้อนกลับไปอ่านได้ในบทที่ 4
บ็อกซ์แทบไม่มีต้นทุนประสิทธิภาพส่วนเกิน (overhead) นอกเหนือจากการนำข้อมูลไปจัดเก็บไว้บนฮีปแทนที่จะเป็นบนสแตก แต่ในขณะเดียวกัน บ็อกซ์ก็ไม่ได้มีความสามารถพิเศษเพิ่มเติมมากมายนักเช่นกัน โดยคุณมักจะได้ใช้งานบ็อกซ์บ่อยที่สุดในสถานการณ์ดังต่อไปนี้:
- เมื่อคุณมีชนิดข้อมูลที่ไม่สามารถทราบขนาดได้ในขณะคอมไพล์ และคุณต้องการนำค่าของชนิดข้อมูลนั้นไปใช้ในบริบทที่ต้องการขนาดของหน่วยความจำที่แน่นอน
- เมื่อคุณมีข้อมูลขนาดใหญ่มาก และต้องการโอนย้ายสิทธิ์ความเป็นเจ้าของ แต่ต้องการรับประกันว่าข้อมูลจะไม่ถูกคัดลอกซ้ำซ้อน
- เมื่อคุณต้องการครอบครองค่าหนึ่ง และสนใจเพียงแค่ว่าค่านั้นต้องเป็นชนิดข้อมูลที่อิมพลีเมนต์เทรต (trait) ตัวใดตัวหนึ่ง มากกว่าที่จะเจาะจงชนิดข้อมูลที่แท้จริง
เราจะแสดงให้เห็นสถานการณ์แรกใน “การเปิดใช้ชนิดข้อมูลแบบเรียกซ้ำด้วยบ็อกซ์” ส่วนกรณีที่สอง การโอนย้ายสิทธิ์ความเป็นเจ้าของข้อมูลขนาดใหญ่อาจใช้เวลานานหากข้อมูลต้องถูกคัดลอกไปมาบนสแตก เพื่อปรับปรุงประสิทธิภาพในกรณีนี้ เราสามารถนำข้อมูลขนาดใหญ่นั้นไปเก็บไว้บนฮีปภายในบ็อกซ์ ซึ่งจะทำให้มีเพียงข้อมูลพอยน์เตอร์ขนาดเล็กเท่านั้นที่ถูกคัดลอกไปมาบนสแตก ในขณะที่ตัวข้อมูลจริงยังคงอยู่ที่เดิมบนฮีป สำหรับกรณีที่สามนั้นเรียกว่า เทรตออบเจกต์ (trait object) ซึ่งหัวข้อ “การใช้เทรตออบเจกต์เพื่อนามธรรมพฤติกรรมร่วม” ในบทที่ 18 ได้อุทิศเนื้อหาให้กับเรื่องนี้โดยเฉพาะ ดังนั้นสิ่งที่คุณได้เรียนรู้ที่นี่ จะได้นำไปต่อยอดใช้อีกครั้งในบทนั้น!
การเก็บข้อมูลบนฮีป
ก่อนที่เราจะพูดคุยถึงกรณีการใช้งานการเก็บข้อมูลบนฮีปของ Box<T> เราจะมาดูไวยากรณ์และวิธีเข้าถึงค่าที่เก็บอยู่ภายใน Box<T> กันก่อน
ลิสติ้ง 15-1 แสดงวิธีใช้บ็อกซ์เพื่อเก็บค่า i32 ไว้บนฮีป
fn main() {
let b = Box::new(5);
println!("b = {b}");
}
เรากำหนดตัวแปร b ให้มีค่าเป็น Box ที่ชี้ไปยังค่า 5 ซึ่งได้รับการจัดสรรไว้บนฮีป โปรแกรมนี้จะพิมพ์ b = 5 ออกมา ในกรณีนี้ เราสามารถเข้าถึงข้อมูลภายในบ็อกซ์ได้คล้ายกับตอนที่ข้อมูลอยู่บนสแตก และเช่นเดียวกับค่าที่มีความเป็นเจ้าของทั่วไป เมื่อบ็อกซ์หลุดออกจากขอบเขต (scope) เหมือนที่ตัวแปร b หลุดออกจากขอบเขตเมื่อสิ้นสุดฟังก์ชัน main มันก็จะถูกคืนหน่วยความจำ (deallocate) โดยการคืนหน่วยความจำนี้จะเกิดขึ้นทั้งกับตัวบ็อกซ์เอง (ที่เก็บอยู่บนสแตก) และข้อมูลที่มันชี้ไป (ที่เก็บอยู่บนฮีป)
การนำค่าเดี่ยว ๆ เพียงค่าเดียวไปไว้บนฮีปนั้นไม่ได้มีประโยชน์มากนัก คุณจึงไม่ค่อยได้ใช้บ็อกซ์โดด ๆ ในลักษณะนี้บ่อยเท่าใด การเก็บค่าอย่าง i32 เพียงค่าเดียวไว้บนสแตกตามค่าเริ่มต้นนั้นเหมาะสมกว่าในสถานการณ์ส่วนใหญ่ คราวนี้มาดูสถานการณ์ที่บ็อกซ์ช่วยให้เราสามารถนิยามชนิดข้อมูลที่ไม่สามารถนิยามได้หากไม่มีบ็อกซ์กัน
การเปิดใช้ชนิดข้อมูลแบบเรียกซ้ำด้วยบ็อกซ์
ค่าของ_ชนิดข้อมูลแบบเรียกซ้ำ (recursive type)_ สามารถมีค่าอื่นที่เป็นชนิดเดียวกันเป็นส่วนประกอบภายในตัวมันเองได้ แต่ชนิดข้อมูลแบบเรียกซ้ำจะก่อให้เกิดปัญหา เพราะ Rust จำเป็นต้องรู้ตั้งแต่ตอนคอมไพล์ว่าชนิดข้อมูลนั้น ๆ ต้องใช้พื้นที่หน่วยความจำเท่าใด ทว่าการซ้อนทับกันของค่าในชนิดข้อมูลแบบเรียกซ้ำอาจเกิดขึ้นต่อไปเรื่อย ๆ ได้อย่างไม่สิ้นสุดในทางทฤษฎี ทำให้ Rust ไม่สามารถรู้ได้ว่าค่านั้นต้องใช้พื้นที่เท่าใด แต่เนื่องจากบ็อกซ์มีขนาดที่แน่นอนและทราบได้ล่วงหน้าเสมอ เราจึงสามารถเปิดใช้ชนิดข้อมูลแบบเรียกซ้ำได้โดยการแทรกบ็อกซ์เข้าไปในนิยามของชนิดข้อมูลนั้น
ในฐานะตัวอย่างของชนิดข้อมูลแบบเรียกซ้ำ เรามาลองศึกษา cons list กัน นี่คือโครงสร้างข้อมูลที่พบได้ทั่วไปในภาษาโปรแกรมเชิงฟังก์ชัน (functional programming) โดยชนิดข้อมูล cons list ที่เราจะนิยามนั้นมีโครงสร้างที่ตรงไปตรงมามาก เว้นแต่เพียงส่วนที่มีการเรียกซ้ำเท่านั้น ดังนั้นแนวคิดจากตัวอย่างนี้จะมีประโยชน์อย่างยิ่งเมื่อใดก็ตามที่คุณต้องเผชิญกับสถานการณ์ที่ซับซ้อนยิ่งขึ้นซึ่งเกี่ยวข้องกับชนิดข้อมูลแบบเรียกซ้ำ
การทำความเข้าใจ Cons List
cons list เป็นโครงสร้างข้อมูลที่มาจากภาษาโปรแกรม Lisp และภาษาในตระกูลของมัน ซึ่งประกอบขึ้นจากคู่ข้อมูล (pairs) ซ้อนกัน และเทียบได้กับลิงก์ลิสต์ (linked list) ในเวอร์ชันของ Lisp โดยชื่อของมันมาจากฟังก์ชัน cons (ย่อมาจาก construct function) ใน Lisp ที่ใช้สร้างคู่ข้อมูลใหม่ขึ้นมาจากอาร์กิวเมนต์สองตัว การเรียกฟังก์ชัน cons ซ้อนกันโดยส่งค่าและคู่อื่นเข้าไป ทำให้เราสามารถสร้าง cons list ที่ประกอบด้วยคู่ข้อมูลแบบเรียกซ้ำได้
ตัวอย่างเช่น ซูโดโค้ดด้านล่างนี้แสดง cons list ที่เก็บลิสต์ 1, 2, 3 โดยแต่ละคู่จะอยู่ในวงเล็บ:
(1, (2, (3, Nil)))
แต่ละไอเท็มใน cons list จะประกอบด้วยสององค์ประกอบ ได้แก่ ค่าของไอเท็มปัจจุบัน และไอเท็มตัวถัดไป ส่วนไอเท็มสุดท้ายในลิสต์จะมีเพียงค่าที่เรียกว่า Nil โดยไม่มีไอเท็มตัวถัดไป cons list ถูกสร้างขึ้นจากการเรียกฟังก์ชัน cons ซ้ำ ๆ โดยชื่อมาตรฐานที่ใช้แสดงกรณีฐาน (base case) เพื่อหยุดการเรียกซ้ำคือ Nil โปรดสังเกตว่าสิ่งนี้ไม่เหมือนกับแนวคิดเรื่อง “null” หรือ “nil” ที่เราพูดถึงในบทที่ 6 ซึ่งหมายถึงค่าที่ไม่ถูกต้องหรือการไม่มีค่า
cons list ไม่ใช่โครงสร้างข้อมูลที่นิยมใช้กันทั่วไปใน Rust เพราะเวลาส่วนใหญ่ที่คุณต้องการเก็บรายการของสิ่งต่าง ๆ ใน Rust ชนิดข้อมูล Vec<T> จะเป็นตัวเลือกที่ดีและเหมาะสมกว่า โครงสร้างข้อมูลแบบเรียกซ้ำชนิดอื่น ๆ ที่ซับซ้อนกว่านี้_มี_ประโยชน์ในสถานการณ์ต่าง ๆ แต่การเริ่มต้นด้วย cons list ในบทนี้จะช่วยให้เราเห็นภาพได้ชัดเจนว่าบ็อกซ์ช่วยให้เรานิยามชนิดข้อมูลแบบเรียกซ้ำได้อย่างไรโดยไม่ทำให้เนื้อหาซับซ้อนเกินไป
ลิสติ้ง 15-2 แสดงนิยามของ enum สำหรับ cons list โปรดสังเกตว่าโค้ดนี้จะยังคอมไพล์ไม่ผ่าน เนื่องจากชนิดข้อมูล List ยังไม่ทราบขนาดที่แน่นอน ซึ่งเราจะสาธิตให้เห็นต่อไป
enum List {
Cons(i32, List),
Nil,
}
fn main() {}
หมายเหตุ: ในตัวอย่างนี้เรากำลังสร้าง cons list ที่เก็บเฉพาะค่า
i32แต่จริง ๆ แล้วเราสามารถอิมพลีเมนต์โดยใช้เจเนอริก (generics) ดังที่เราได้เรียนรู้ในบทที่ 10 เพื่อสร้างชนิดข้อมูล cons list ที่สามารถเก็บค่าของชนิดข้อมูลใดก็ได้
การนำชนิดข้อมูล List ไปใช้เก็บลิสต์ 1, 2, 3 จะมีหน้าตาดังโค้ดในลิสติ้ง 15-3
enum List {
Cons(i32, List),
Nil,
}
// --snip--
use crate::List::{Cons, Nil};
fn main() {
let list = Cons(1, Cons(2, Cons(3, Nil)));
}
ค่า Cons ตัวแรกเก็บ 1 และค่า List อีกค่าหนึ่ง ซึ่งค่า List นี้ก็คือค่า Cons อีกตัวที่เก็บ 2 และค่า List อีกค่าหนึ่ง และค่า List นั้นก็คือค่า Cons อีกตัวที่เก็บ 3 และค่า List ตัวสุดท้าย ซึ่งก็คือ Nil อันเป็นวาเรียนต์แบบไม่เรียกซ้ำที่ทำหน้าที่บอกจุดสิ้นสุดของลิสต์
หากเราพยายามคอมไพล์โค้ดในลิสติ้ง 15-3 เราจะพบข้อผิดพลาดดังที่แสดงในลิสติ้ง 15-4
$ cargo run
Compiling cons-list v0.1.0 (file:///projects/cons-list)
error[E0072]: recursive type `List` has infinite size
--> src/main.rs:1:1
|
1 | enum List {
| ^^^^^^^^^
2 | Cons(i32, List),
| ---- recursive without indirection
|
help: insert some indirection (e.g., a `Box`, `Rc`, or `&`) to break the cycle
|
2 | Cons(i32, Box<List>),
| ++++ +
For more information about this error, try `rustc --explain E0072`.
error: could not compile `cons-list` (bin "cons-list") due to 1 previous error
ข้อผิดพลาดระบุว่าชนิดข้อมูลนี้ “มีขนาดไม่สิ้นสุด (has infinite size)” สาเหตุก็เพราะเราได้นิยาม List ด้วยวาเรียนต์ที่มีการเรียกซ้ำ นั่นคือมันเก็บค่าชนิดเดียวกันไว้ภายในตัวเองโดยตรง ส่งผลให้ Rust ไม่สามารถคำนวณได้ว่าต้องใช้พื้นที่หน่วยความจำเท่าใดในการเก็บค่า List เรามาแยกย่อยวิเคราะห์กันว่าทำไมจึงเกิดข้อผิดพลาดนี้ โดยเริ่มจากการดูว่าปกติแล้ว Rust คำนวณขนาดหน่วยความจำสำหรับชนิดข้อมูลที่ไม่เรียกซ้ำอย่างไร
การคำนวณขนาดของชนิดข้อมูลที่ไม่เรียกซ้ำ
ลองนึกย้อนกลับไปถึง enum Message ที่เราเคยนิยามไว้ในลิสติ้ง 6-2 ตอนที่เราพูดคุยเรื่องนิยาม enum ในบทที่ 6:
enum Message {
Quit,
Move { x: i32, y: i32 },
Write(String),
ChangeColor(i32, i32, i32),
}
fn main() {}
ในการกำหนดว่าจะต้องจัดสรรพื้นที่หน่วยความจำเท่าใดสำหรับค่า Message นั้น Rust จะไล่ดูแต่ละวาเรียนต์เพื่อดูว่าวาเรียนต์ใดต้องการพื้นที่มากที่สุด Rust จะพบว่า Message::Quit ไม่จำเป็นต้องใช้พื้นที่เก็บข้อมูลใด ๆ, Message::Move ต้องใช้พื้นที่เพียงพอสำหรับเก็บค่า i32 สองค่า เป็นต้น และเนื่องจากในเวลาใดเวลาหนึ่งจะมีเพียงวาเรียนต์เดียวเท่านั้นที่ถูกใช้งาน พื้นที่หน่วยความจำมากที่สุดที่ค่า Message จะต้องใช้จึงเท่ากับพื้นที่ที่ใช้เก็บวาเรียนต์ที่มีขนาดใหญ่ที่สุดของมัน
คราวนี้ลองเปรียบเทียบกับสิ่งที่เกิดขึ้นเมื่อ Rust พยายามคำนวณพื้นที่สำหรับชนิดข้อมูลแบบเรียกซ้ำอย่าง enum List ในลิสติ้ง 15-2 ดูบ้าง คอมไพเลอร์จะเริ่มจากการดูวาเรียนต์ Cons ซึ่งเก็บค่าชนิด i32 และค่าชนิด List ดังนั้น Cons จึงต้องใช้พื้นที่เท่ากับขนาดของ i32 บวกกับขนาดของ List และในการคำนวณว่าชนิด List ต้องใช้หน่วยความจำเท่าใด คอมไพเลอร์ก็ต้องกลับไปดูแต่ละวาเรียนต์อีกครั้ง โดยเริ่มจาก Cons ซึ่ง Cons ก็เก็บ i32 และ List ต่อไปอีกเรื่อย ๆ กระบวนการนี้จึงดำเนินไปอย่างไม่สิ้นสุด ดังที่แสดงในรูปที่ 15-1
รูปที่ 15-1: List ที่ไม่สิ้นสุดซึ่งประกอบด้วยวาเรียนต์ Cons ที่ไม่สิ้นสุด
การได้มาซึ่งชนิดข้อมูลแบบเรียกซ้ำที่มีขนาดที่รู้ได้
เนื่องจาก Rust ไม่สามารถคำนวณได้ว่าต้องจัดสรรพื้นที่เท่าใดสำหรับชนิดข้อมูลที่นิยามแบบเรียกซ้ำ คอมไพเลอร์จึงแจ้งข้อผิดพลาดพร้อมคำแนะนำที่เป็นประโยชน์นี้:
help: insert some indirection (e.g., a `Box`, `Rc`, or `&`) to break the cycle
|
2 | Cons(i32, Box<List>),
| ++++ +
ในคำแนะนำนี้ คำว่า การชี้ทางอ้อม (indirection) หมายความว่าแทนที่จะเก็บค่าไว้โดยตรง เราควรปรับโครงสร้างข้อมูลให้เก็บค่าทางอ้อมด้วยการเก็บพอยน์เตอร์ที่ชี้ไปยังค่านั้นแทน
เนื่องจาก Box<T> มีสถานะเป็นพอยน์เตอร์ตัวหนึ่ง Rust จึงรู้ขนาดที่แน่นอนของ Box<T> เสมอ เพราะขนาดของพอยน์เตอร์จะไม่เปลี่ยนแปลงไปตามปริมาณข้อมูลที่มันชี้ไป นั่นหมายความว่าเราสามารถใส่ Box<T> ไว้ข้างในวาเรียนต์ Cons แทนที่จะเก็บค่า List อีกค่าหนึ่งโดยตรงได้ โดย Box<T> จะชี้ไปยังค่า List ถัดไปซึ่งถูกนำไปวางไว้บนฮีปแทนที่จะอยู่ภายในวาเรียนต์ Cons ในเชิงมโนทัศน์แล้ว เราก็ยังคงมีลิสต์ที่เกิดจากการซ้อนกันของลิสต์อื่น ๆ อยู่เช่นเดิม เพียงแต่การอิมพลีเมนต์ในลักษณะนี้จะเหมือนกับการนำไอเท็มมาวางเคียงข้างกัน มากกว่าที่จะนำมาบรรจุซ้อนไว้ข้างในกัน
เราสามารถแก้ไขนิยามของ enum List ในลิสติ้ง 15-2 และการใช้งาน List ในลิสติ้ง 15-3 ให้เป็นโค้ดในลิสติ้ง 15-5 ซึ่งจะสามารถคอมไพล์ผ่านได้อย่างสมบูรณ์
enum List {
Cons(i32, Box<List>),
Nil,
}
use crate::List::{Cons, Nil};
fn main() {
let list = Cons(1, Box::new(Cons(2, Box::new(Cons(3, Box::new(Nil))))));
}
ตอนนี้วาเรียนต์ Cons จะต้องการพื้นที่เท่ากับขนาดของ i32 บวกกับพื้นที่สำหรับเก็บข้อมูลพอยน์เตอร์ของบ็อกซ์ ส่วนวาเรียนต์ Nil ไม่ได้เก็บค่าใด ๆ จึงใช้พื้นที่บนสแตกน้อยกว่าวาเรียนต์ Cons ตอนนี้เราจึงรู้ได้แน่นอนแล้วว่าค่า List ใด ๆ จะใช้พื้นที่เท่ากับขนาดของ i32 บวกกับขนาดพอยน์เตอร์ของบ็อกซ์ การใช้บ็อกซ์ช่วยตัดวงจรการเรียกซ้ำที่ไม่สิ้นสุดลง ทำให้คอมไพเลอร์สามารถคำนวณขนาดที่แน่นอนสำหรับจัดเก็บค่า List ได้ รูปที่ 15-2 แสดงให้เห็นว่าโครงสร้างของวาเรียนต์ Cons มีหน้าตาเป็นอย่างไรในตอนนี้
รูปที่ 15-2: List ที่ไม่ได้มีขนาดไม่สิ้นสุด เพราะ Cons เก็บ Box
บ็อกซ์ทำหน้าที่เพียงแค่ชี้ทางอ้อมและจัดสรรหน่วยความจำบนฮีปเท่านั้น โดยไม่มีความสามารถพิเศษอื่นใดเหมือนอย่างที่เราจะได้เห็นในสมาร์ตพอยน์เตอร์ชนิดอื่น ๆ แต่ในขณะเดียวกัน มันก็ไม่มีต้นทุนประสิทธิภาพส่วนเกินที่ความสามารถพิเศษเหล่านั้นต้องแลกมาด้วย บ็อกซ์จึงมีประโยชน์อย่างยิ่งในกรณีเช่น cons list ซึ่งการชี้ทางอ้อมเป็นเพียงสิ่งเดียวที่เราต้องการ เราจะได้เห็นกรณีการใช้งานบ็อกซ์เพิ่มเติมในบทที่ 18
ชนิดข้อมูล Box<T> ถือเป็นสมาร์ตพอยน์เตอร์เพราะมันอิมพลีเมนต์เทรต Deref ซึ่งอนุญาตให้ค่า Box<T> ถูกใช้งานเสมือนเป็นเรเฟอเรนซ์ และเมื่อค่า Box<T> หลุดออกจากขอบเขต ข้อมูลบนฮีปที่บ็อกซ์ชี้ไปก็จะถูกคืนหน่วยความจำและเก็บกวาดให้โดยอัตโนมัติเนื่องจากการอิมพลีเมนต์เทรต Drop เทรตทั้งสองนี้จะยิ่งมีความสำคัญมากขึ้นไปอีกในสมาร์ตพอยน์เตอร์ชนิดอื่น ๆ ที่เราจะพูดถึงในส่วนที่เหลือของบทนี้ มาศึกษาเทรตทั้งสองนี้อย่างละเอียดกันต่อเลย