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

โปรแกรมตัวอย่างที่ใช้ struct

เพื่อให้เข้าใจว่าในสถานการณ์ใดที่เราควรนำ struct มาใช้งาน เรามาลองเขียนโปรแกรมสำหรับคำนวณพื้นที่ของรูปสี่เหลี่ยมผืนผ้ากัน โดยเราจะเริ่มต้นจากการใช้ตัวแปรเดี่ยวๆ แยกกันก่อน แล้วค่อยๆ ปรับปรุงโครงสร้างโค้ด (refactor) ไปเรื่อยๆ จนกระทั่งเปลี่ยนมาใช้ struct แทน

ให้สร้างโปรเจกต์แบบไบนารีใหม่ด้วย Cargo ในชื่อ rectangles ซึ่งจะรับค่าความกว้างและความสูงของสี่เหลี่ยมผืนผ้าในหน่วยพิกเซล แล้วนำไปคำนวณหาพื้นที่ ลิสติ้ง 5-8 แสดงโปรแกรมสั้นๆ ที่ใช้วิธีการพื้นฐานนี้ในไฟล์ src/main.rs

fn main() {
    let width1 = 30;
    let height1 = 50;

    println!(
        "The area of the rectangle is {} square pixels.",
        area(width1, height1)
    );
}

fn area(width: u32, height: u32) -> u32 {
    width * height
}

ตอนนี้ ให้ลองสั่งรันโปรแกรมนี้ด้วยคำสั่ง cargo run:

$ cargo run
   Compiling rectangles v0.1.0 (file:///projects/rectangles)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.42s
     Running `target/debug/rectangles`
The area of the rectangle is 1500 square pixels.

โค้ดนี้สามารถคำนวณพื้นที่ของสี่เหลี่ยมผืนผ้าได้ถูกต้องสมบูรณ์โดยการเรียกใช้ฟังก์ชัน area พร้อมส่งขนาดของแต่ละด้านเข้าไป แต่เรายังสามารถทำให้โค้ดนี้มีความชัดเจนและอ่านเข้าใจได้ง่ายยิ่งขึ้นกว่านี้

ปัญหาของโค้ดชุดนี้ปรากฏให้เห็นอย่างชัดเจนในลายเซ็น (signature) ของฟังก์ชัน area:

fn main() {
    let width1 = 30;
    let height1 = 50;

    println!(
        "The area of the rectangle is {} square pixels.",
        area(width1, height1)
    );
}

fn area(width: u32, height: u32) -> u32 {
    width * height
}

เป้าหมายของฟังก์ชัน area คือการคำนวณพื้นที่ของสี่เหลี่ยมผืนผ้ารูปหนึ่ง แต่ฟังก์ชันที่เราเขียนกลับรับพารามิเตอร์ 2 ตัวแยกกัน และไม่มีส่วนใดในโปรแกรมที่สื่อให้เห็นว่าพารามิเตอร์ทั้งสองมีความเกี่ยวข้องกัน การรวมความกว้างและความสูงเข้าเป็นกลุ่มเดียวกันจะช่วยให้โค้ดอ่านง่ายและจัดการได้สะดวกขึ้น ซึ่งวิธีหนึ่งที่เราเคยเรียนรู้ไปแล้วในหัวข้อ “ชนิดทูเพิล” ในบทที่ 3 ก็คือการใช้ทูเพิล

การรีแฟกเตอร์ด้วยทูเพิล

ลิสติ้ง 5-9 แสดงโปรแกรมอีกเวอร์ชันหนึ่งที่ปรับมาใช้ทูเพิล:

fn main() {
    let rect1 = (30, 50);

    println!(
        "The area of the rectangle is {} square pixels.",
        area(rect1)
    );
}

fn area(dimensions: (u32, u32)) -> u32 {
    dimensions.0 * dimensions.1
}

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

ในการคำนวณหาพื้นที่ การสลับตำแหน่งระหว่างความกว้างและความสูงอาจไม่ส่งผลกระทบต่อผลลัพธ์ แต่หากเราต้องนำขนาดเหล่านี้ไปใช้วาดรูปสี่เหลี่ยมลงบนหน้าจอย่อมส่งผลแน่นอน! เราจะต้องคอยจำให้ได้ว่า width คือดัชนี 0 และ height คือดัชนี 1 ของทูเพิล ซึ่งหากผู้อื่นต้องนำโค้ดของเราไปพัฒนาต่อ ก็จะยิ่งเข้าใจและจดจำได้ยากขึ้น และการที่โค้ดไม่ได้สื่อความหมายของข้อมูลอย่างชัดเจน ย่อมเปิดช่องให้เกิดข้อผิดพลาดได้ง่ายขึ้น

การรีแฟกเตอร์ด้วย struct

เราสามารถใช้ struct เพื่อเพิ่มความหมายให้กับข้อมูลด้วยการตั้งชื่อกำกับ โดยแปลงทูเพิลที่ใช้อยู่ให้กลายเป็น struct ที่มีชื่อของชนิดข้อมูลกำกับทั้งชุด และมีชื่อกำกับสมาชิกในแต่ละฟิลด์ ดังแสดงในลิสติ้ง 5-10

struct Rectangle {
    width: u32,
    height: u32,
}

fn main() {
    let rect1 = Rectangle {
        width: 30,
        height: 50,
    };

    println!(
        "The area of the rectangle is {} square pixels.",
        area(&rect1)
    );
}

fn area(rectangle: &Rectangle) -> u32 {
    rectangle.width * rectangle.height
}

ในที่นี้ เราได้นิยาม struct และตั้งชื่อว่า Rectangle โดยภายในวงเล็บปีกกา เราได้กำหนดฟิลด์ชื่อ width และ height ซึ่งทั้งคู่เป็นชนิดข้อมูล u32 จากนั้นในฟังก์ชัน main เราจึงสร้างอินสแตนซ์ของ Rectangle ขึ้นมาโดยมีความกว้าง 30 และความสูง 50

ฟังก์ชัน area ของเราในตอนนี้ถูกนิยามให้รับพารามิเตอร์เพียงตัวเดียว โดยเราตั้งชื่อว่า rectangle ซึ่งมีชนิดข้อมูลเป็นการยืมแบบแก้ไขไม่ได้ (immutable borrow) ของอินสแตนซ์ struct Rectangle ดังที่เราได้เรียนรู้ไปแล้วในบทที่ 4 ว่าเราควรยืม struct มาใช้งานแทนที่จะย้ายความเป็นเจ้าของเข้ามา เพื่อให้ฟังก์ชัน main ยังคงถือครองความเป็นเจ้าของและสามารถนำตัวแปร rect1 ไปใช้งานต่อได้ เราจึงใส่เครื่องหมาย & ไว้ในลายเซ็นของฟังก์ชันและในจุดที่เรียกใช้ฟังก์ชัน

ฟังก์ชัน area จะเข้าถึงฟิลด์ width และ height ของอินสแตนซ์ Rectangle (โปรดสังเกตว่าการเข้าถึงฟิลด์ของอินสแตนซ์ struct ที่ถูกยืมมา จะไม่ได้ทำการย้ายค่าของฟิลด์นั้นออกไป ซึ่งเป็นเหตุผลว่าทำไมคุณจึงมักเห็นการส่ง struct ด้วยการยืมอยู่เสมอ) ในตอนนี้ ลายเซ็นของฟังก์ชัน area ได้สื่อความหมายตรงตามที่เราต้องการอย่างสมบูรณ์แบบ นั่นคือ การคำนวณพื้นที่ของ Rectangle โดยใช้ข้อมูลจากฟิลด์ width และ height ของมัน ซึ่งช่วยสื่อให้เห็นอย่างชัดเจนว่าความกว้างและความสูงมีความเกี่ยวข้องกัน พร้อมทั้งระบุชื่อที่ชัดเจนให้กับค่าเหล่านั้น แทนที่จะต้องใช้ตัวเลขดัชนี 0 และ 1 ของทูเพิล ถือเป็นชัยชนะในด้านความชัดเจนของโค้ดอย่างแท้จริง

การเพิ่มความสามารถด้วยเทรตที่ derive ได้

ในระหว่างการดีบักโปรแกรม คงจะสะดวกไม่น้อยหากเราสามารถพิมพ์ค่าของอินสแตนซ์ Rectangle ออกมาเพื่อตรวจสอบค่าในทุกๆ ฟิลด์ได้ ลิสติ้ง 5-11 จึงลองใช้ มาโคร println! ตามที่เราเคยใช้งานในบทก่อนๆ แต่ทว่าวิธีนี้กลับใช้ไม่ได้:

struct Rectangle {
    width: u32,
    height: u32,
}

fn main() {
    let rect1 = Rectangle {
        width: 30,
        height: 50,
    };

    println!("rect1 is {rect1}");
}

เมื่อเราคอมไพล์โค้ดนี้ จะพบกับข้อผิดพลาดโดยมีใจความสำคัญดังนี้:

error[E0277]: `Rectangle` doesn't implement `std::fmt::Display`

มาโคร println! รองรับการจัดรูปแบบการแสดงผลได้หลากหลายรูปแบบ โดยตามค่าเริ่มต้น เครื่องหมายวงเล็บปีกกา {} จะสั่งให้ println! ใช้การจัดรูปแบบที่เรียกว่า Display ซึ่งมีไว้สำหรับแสดงผลข้อความให้ผู้ใช้งานปลายทางอ่านโดยตรง ชนิดข้อมูลพื้นฐานต่างๆ ที่เราเคยเห็นมาล้วนอิมพลีเมนต์ Display ไว้ตั้งแต่แรกแล้ว เพราะมีรูปแบบการแสดงผลที่ชัดเจนแน่นอน เช่น ตัวเลข 1 แต่สำหรับ struct แล้ว รูปแบบการแสดงผลที่เหมาะสมนั้นไม่สามารถคาดเดาได้ เพราะมีความเป็นไปได้หลากหลาย เช่น คุณต้องการให้มีเครื่องหมายจุลภาคคั่นหรือไม่? ต้องการให้พิมพ์วงเล็บปีกกาด้วยไหม? หรือควรจะแสดงข้อมูลครบทุกฟิลด์หรือไม่? ด้วยความไม่แน่นอนนี้ Rust จึงไม่พยายามเดาใจเรา และไม่ได้เตรียมการอิมพลีเมนต์ Display เริ่มต้นไว้ให้กับ struct สำหรับใช้งานกับตัวแทนข้อความ {} ใน println!

แต่หากเราอ่านข้อความแจ้งข้อผิดพลาดต่อไป เราจะพบคำแนะนำที่เป็นประโยชน์อย่างยิ่ง:

help: the trait `std::fmt::Display` is not implemented for `Rectangle`
  --> src/main.rs:1:1

เรามาลองทำตามคำแนะนำกัน! โดยเปลี่ยนคำสั่งในมาโครเป็น println!("rect1 is {rect1:?}"); การใส่ตัวระบุ :? ไว้ภายในวงเล็บปีกกาจะบอกให้ println! ทราบว่าเราต้องการใช้รูปแบบการแสดงผลที่เรียกว่า Debug ซึ่งเทรต Debug นี้ถูกออกแบบมาเพื่อให้นักพัฒนาสามารถพิมพ์ข้อมูลของ struct ออกมาตรวจสอบได้อย่างสะดวกในระหว่างการพัฒนาและดีบักโค้ด

ลองคอมไพล์โค้ดหลังจากแก้ไขดู… แต่ก็ยังคงพบข้อผิดพลาดอยู่ดี:

error[E0277]: `Rectangle` doesn't implement `Debug`

ทว่าคอมไพเลอร์ก็ได้ให้คำแนะนำที่เป็นประโยชน์อีกครั้ง:

   |                        required by this formatting parameter
   |

ความจริงแล้ว Rust มี ฟังก์ชันสำหรับพิมพ์ข้อมูลเพื่อการดีบักเตรียมไว้ให้อยู่แล้ว เพียงแต่เราต้องเปิดใช้งานความสามารถนี้ให้กับ struct ของเราอย่างชัดเจน โดยการเพิ่มแอตทริบิวต์ #[derive(Debug)] ไว้เหนือการนิยาม struct ดังแสดงในลิสติ้ง 5-12

#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

fn main() {
    let rect1 = Rectangle {
        width: 30,
        height: 50,
    };

    println!("rect1 is {rect1:?}");
}

คราวนี้เมื่อเราสั่งรันโปรแกรม จะไม่มีข้อผิดพลาดเกิดขึ้นอีก และเราจะได้ผลลัพธ์ดังนี้:

$ cargo run
   Compiling rectangles v0.1.0 (file:///projects/rectangles)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.48s
     Running `target/debug/rectangles`
rect1 is Rectangle { width: 30, height: 50 }

ยอดเยี่ยมมาก! แม้ว่ารูปแบบที่พิมพ์ออกมาอาจจะไม่ได้สวยงามสะดุดตา แต่ก็แสดงค่าของทุกฟิลด์ในอินสแตนซ์นี้ออกมาให้เห็นอย่างครบถ้วน ซึ่งมีประโยชน์อย่างยิ่งในการดีบัก และเมื่อเราทำงานกับ struct ที่มีขนาดใหญ่ขึ้น การจัดรูปแบบให้อ่านง่ายเป็นระเบียบยิ่งขึ้นก็จะมีประโยชน์มาก ซึ่งในกรณีเช่นนี้ เราสามารถเปลี่ยนมาใช้ {:#?} แทน {:?} ในสตริงของ println! ได้ และผลลัพธ์จะออกมาในรูปแบบที่สวยงามเป็นระเบียบดังนี้:

$ cargo run
   Compiling rectangles v0.1.0 (file:///projects/rectangles)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.48s
     Running `target/debug/rectangles`
rect1 is Rectangle {
    width: 30,
    height: 50,
}

อีกวิธีหนึ่งในการพิมพ์ค่าเพื่อการตรวจสอบผ่านรูปแบบ Debug คือการใช้ มาโคร dbg! ซึ่งต่างจาก println! ที่รับเรเฟอเรนซ์ตรงที่ มาโคร dbg! จะรับความเป็นเจ้าของของนิพจน์นั้นไป พิมพ์ชื่อไฟล์และหมายเลขบรรทัดที่คำสั่ง dbg! ทำงานออกมา พร้อมกับค่าผลลัพธ์ของนิพจน์นั้น แล้วส่งมอบความเป็นเจ้าของของค่านั้นคืนกลับมาให้ใช้งานต่อ

หมายเหตุ: การเรียกใช้มาโคร dbg! จะพิมพ์ข้อมูลไปยังสตรีมข้อผิดพลาดมาตรฐาน (stderr) ของคอนโซล ซึ่งต่างจาก println! ที่พิมพ์ไปยังสตรีมเอาต์พุตมาตรฐาน (stdout) เราจะได้เรียนรู้เพิ่มเติมเกี่ยวกับ stderr และ stdout ใน หัวข้อ “การเปลี่ยนเส้นทางข้อผิดพลาดไปยังข้อผิดพลาดมาตรฐาน” ในบทที่ 12

ตัวอย่างต่อไปนี้แสดงการใช้งาน dbg! กับทั้งนิพจน์ที่กำหนดให้กับฟิลด์ width และกับค่าของ struct ทั้งตัวใน rect1:

#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

fn main() {
    let scale = 2;
    let rect1 = Rectangle {
        width: dbg!(30 * scale),
        height: 50,
    };

    dbg!(&rect1);
}

เราสามารถครอบนิพจน์ 30 * scale ด้วย dbg! ได้โดยตรง และเนื่องจาก dbg! จะคืนความเป็นเจ้าของของค่านั้นกลับมา ฟิลด์ width จึงได้รับค่าที่ถูกต้องเช่นเดียวกับตอนที่ไม่ได้เรียกใช้ dbg! และเนื่องจากเราไม่ต้องการให้ dbg! ยึดความเป็นเจ้าของของ rect1 ไป เราจึงส่งเรเฟอเรนซ์ &rect1 เข้าไปในการเรียกใช้ครั้งถัดไป ผลลัพธ์จากการรันตัวอย่างนี้จะเป็นดังนี้:

$ cargo run
   Compiling rectangles v0.1.0 (file:///projects/rectangles)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.61s
     Running `target/debug/rectangles`
[src/main.rs:10:16] 30 * scale = 60
[src/main.rs:14:5] &rect1 = Rectangle {
    width: 60,
    height: 50,
}

เราจะเห็นว่าเอาต์พุตส่วนแรกมาจากบรรทัดที่ 10 ของไฟล์ src/main.rs ซึ่งเรากำลังตรวจสอบค่านิพจน์ 30 * scale และได้ผลลัพธ์เป็น 60 (เนื่องจากการจัดรูปแบบ Debug ของจำนวนเต็มคือการพิมพ์เฉพาะค่าตัวเลข) และการเรียกใช้ dbg! ในบรรทัดที่ 14 จะพิมพ์ค่าของ &rect1 ซึ่งเป็น struct Rectangle ออกมาในรูปแบบ Debug ที่จัดย่อหน้าอย่างสวยงาม มาโคร dbg! จึงเป็นเครื่องมือที่มีประโยชน์และคล่องตัวอย่างยิ่งเมื่อคุณต้องการตรวจสอบการทำงานภายในโค้ดของคุณ!

นอกจากเทรต Debug แล้ว Rust ยังจัดเตรียมเทรตมาตรฐานอีกเป็นจำนวนมากให้เรานำมาใช้ร่วมกับแอตทริบิวต์ derive เพื่อเพิ่มพฤติกรรมที่มีประโยชน์ให้กับชนิดข้อมูลที่เรากำหนดขึ้นเองได้ โดยรายการเทรตและพฤติกรรมทั้งหมดได้ระบุไว้ใน ภาคผนวก C และเราจะไปเรียนรู้วิธีการอิมพลีเมนต์พฤติกรรมเหล่านี้ด้วยตนเอง ตลอดจนการสร้างเทรตขึ้นมาใหม่ในบทที่ 10 นอกจากนี้ Rust ยังมีแอตทริบิวต์รูปแบบอื่นๆ อีกมากมาย ซึ่งสามารถศึกษาเพิ่มเติมได้จาก หัวข้อ “Attributes” ใน Rust Reference

สำหรับฟังก์ชัน area ของเราในตอนนี้ยังคงมีลักษณะเฉพาะเจาะจงมาก เพราะคำนวณได้เฉพาะพื้นที่ของสี่เหลี่ยมผืนผ้าเท่านั้น จะดีกว่าไหมหากเราสามารถผูกพฤติกรรมการคำนวณนี้เข้าเป็นส่วนหนึ่งของ struct Rectangle ได้โดยตรง เพื่อให้โค้ดมีความเป็นกลุ่มก้อนชัดเจนยิ่งขึ้น ในหัวข้อถัดไปเราจะมาดูวิธีรีแฟกเตอร์ฟังก์ชัน area ให้กลายเป็น เมธอด (method) บนชนิดข้อมูล Rectangle กัน