Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

ใช้ 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

รายการ Cons ที่ไม่สิ้นสุด: สี่เหลี่ยมที่ติดป้าย 'Cons' แบ่งออกเป็นสี่เหลี่ยมเล็กกว่าสองรูป สี่เหลี่ยมเล็กกว่ารูปแรกมีป้าย 'i32' และสี่เหลี่ยมเล็กกว่ารูปที่สองมีป้าย 'Cons' และเวอร์ชันที่เล็กกว่าของสี่เหลี่ยม 'Cons' ชั้นนอก สี่เหลี่ยม 'Cons' เหล่านี้ยังคงบรรจุเวอร์ชันของตัวเองที่เล็กลงเรื่อยๆ จนกระทั่งสี่เหลี่ยมที่เล็กที่สุดที่มีขนาดพอเหมาะบรรจุสัญลักษณ์อินฟินิตี้ ซึ่งบ่งชี้ว่าการซ้ำนี้ดำเนินต่อไปตลอดกาล

รูปที่ 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 มีหน้าตาเป็นอย่างไรในตอนนี้

สี่เหลี่ยมที่ติดป้าย 'Cons' แบ่งออกเป็นสี่เหลี่ยมเล็กกว่าสองรูป สี่เหลี่ยมเล็กกว่ารูปแรกมีป้าย 'i32' และสี่เหลี่ยมเล็กกว่ารูปที่สองมีป้าย 'Box' พร้อมกับสี่เหลี่ยมภายในหนึ่งรูปที่บรรจุป้าย 'usize' ซึ่งเป็นตัวแทนของขนาดจำกัดของพอยน์เตอร์ของบ็อกซ์

รูปที่ 15-2: List ที่ไม่ได้มีขนาดไม่สิ้นสุด เพราะ Cons เก็บ Box

บ็อกซ์ทำหน้าที่เพียงแค่ชี้ทางอ้อมและจัดสรรหน่วยความจำบนฮีปเท่านั้น โดยไม่มีความสามารถพิเศษอื่นใดเหมือนอย่างที่เราจะได้เห็นในสมาร์ตพอยน์เตอร์ชนิดอื่น ๆ แต่ในขณะเดียวกัน มันก็ไม่มีต้นทุนประสิทธิภาพส่วนเกินที่ความสามารถพิเศษเหล่านั้นต้องแลกมาด้วย บ็อกซ์จึงมีประโยชน์อย่างยิ่งในกรณีเช่น cons list ซึ่งการชี้ทางอ้อมเป็นเพียงสิ่งเดียวที่เราต้องการ เราจะได้เห็นกรณีการใช้งานบ็อกซ์เพิ่มเติมในบทที่ 18

ชนิดข้อมูล Box<T> ถือเป็นสมาร์ตพอยน์เตอร์เพราะมันอิมพลีเมนต์เทรต Deref ซึ่งอนุญาตให้ค่า Box<T> ถูกใช้งานเสมือนเป็นเรเฟอเรนซ์ และเมื่อค่า Box<T> หลุดออกจากขอบเขต ข้อมูลบนฮีปที่บ็อกซ์ชี้ไปก็จะถูกคืนหน่วยความจำและเก็บกวาดให้โดยอัตโนมัติเนื่องจากการอิมพลีเมนต์เทรต Drop เทรตทั้งสองนี้จะยิ่งมีความสำคัญมากขึ้นไปอีกในสมาร์ตพอยน์เตอร์ชนิดอื่น ๆ ที่เราจะพูดถึงในส่วนที่เหลือของบทนี้ มาศึกษาเทรตทั้งสองนี้อย่างละเอียดกันต่อเลย