โปรแกรมตัวอย่างที่ใช้ 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 กัน