ลักษณะเด่นของภาษาเชิงวัตถุ
ในแวดวงการเขียนโปรแกรมไม่มีความเห็นพ้องกันว่าภาษาหนึ่ง ๆ ต้องมีฟีเจอร์อะไรบ้างจึงจะถือว่าเป็นภาษาเชิงวัตถุ Rust ได้รับอิทธิพลจากกระบวนทัศน์การเขียนโปรแกรมหลายแบบ รวมถึงการเขียนโปรแกรมเชิงวัตถุ (OOP) ตัวอย่างเช่น เราได้สำรวจฟีเจอร์ที่มาจากการเขียนโปรแกรมเชิงฟังก์ชัน (functional programming) ในบทที่ 13 เราอาจกล่าวได้ว่าภาษา OOP นั้นมีคุณลักษณะร่วมบางประการ ได้แก่ ออบเจกต์ (object), การห่อหุ้ม (encapsulation) และการสืบทอด (inheritance) ลองมาดูกันว่าคุณลักษณะแต่ละอย่างหมายถึงอะไร และ Rust รองรับสิ่งเหล่านั้นหรือไม่
ออบเจกต์บรรจุข้อมูลและพฤติกรรม
หนังสือ Design Patterns: Elements of Reusable Object-Oriented Software โดย Erich Gamma, Richard Helm, Ralph Johnson และ John Vlissides (Addison-Wesley, 1994) ซึ่งมักเรียกกันทั่วไปว่าหนังสือ The Gang of Four ถือเป็นแคตตาล็อกรวบรวมแบบแผนการออกแบบเชิงวัตถุ (design patterns) หนังสือเล่มนี้นิยาม OOP ไว้ดังนี้:
โปรแกรมเชิงวัตถุนั้นประกอบขึ้นจากออบเจกต์ โดย ออบเจกต์ จะรวมทั้งข้อมูลและกระบวนการทำงานที่กระทำกับข้อมูลนั้นไว้ด้วยกัน กระบวนการเหล่านี้มักถูกเรียกว่า เมธอด (method) หรือ การดำเนินการ (operation)
หากใช้คำนิยามนี้ Rust ก็ถือเป็นภาษาเชิงวัตถุได้: ทั้ง struct และ enum ต่างมีข้อมูล และบล็อก impl ก็จัดเตรียมเมธอดให้แก่ struct และ enum เหล่านั้น แม้ว่า struct และ enum ที่มีเมธอดจะไม่ได้ถูก_เรียกว่า_ออบเจกต์ตรง ๆ แต่ก็มีฟังก์ชันการทำงานแบบเดียวกันตามคำนิยามออบเจกต์ของ Gang of Four
การห่อหุ้มที่ซ่อนรายละเอียดการอิมพลีเมนต์
อีกแง่มุมหนึ่งที่มักเชื่อมโยงกับ OOP คือแนวคิดเรื่อง_การห่อหุ้ม_ (encapsulation) ซึ่งหมายความว่าโค้ดภายนอกที่เรียกใช้ออบเจกต์จะไม่สามารถเข้าถึงรายละเอียดการอิมพลีเมนต์ภายในออบเจกต์นั้นได้ ดังนั้น วิธีเดียวในการมีปฏิสัมพันธ์กับออบเจกต์คือผ่านทาง public API ของมัน โค้ดที่ใช้ออบเจกต์จึงไม่สามารถล้วงเข้าไปแก้ไขข้อมูลหรือพฤติกรรมภายในของออบเจกต์ได้โดยตรง สิ่งนี้ช่วยให้โปรแกรมเมอร์สามารถปรับเปลี่ยนและรีแฟกเตอร์กลไกภายในของออบเจกต์ได้ โดยไม่จำเป็นต้องแก้ไขโค้ดส่วนอื่นที่เรียกใช้ออบเจกต์นั้น
เราได้พูดถึงวิธีควบคุมการห่อหุ้มไปแล้วในบทที่ 7: เราใช้คีย์เวิร์ด pub ในการกำหนดว่ามอดูล ชนิดข้อมูล ฟังก์ชัน และเมธอดใดในโค้ดควรเปิดเป็นสาธารณะ (public) และโดยดีฟอลต์สิ่งอื่น ๆ ทั้งหมดจะเป็นแบบส่วนตัว (private) ตัวอย่างเช่น เราสามารถนิยาม struct AveragedCollection ที่มีฟิลด์เก็บเวกเตอร์ของค่า i32 และยังมีอีกฟิลด์หนึ่งที่เก็บค่าเฉลี่ยของข้อมูลในเวกเตอร์นั้น ซึ่งหมายความว่าเราไม่จำเป็นต้องคำนวณค่าเฉลี่ยใหม่ทุกครั้งที่ต้องการใช้งาน กล่าวอีกนัยหนึ่งคือ AveragedCollection จะแคชค่าเฉลี่ยที่คำนวณไว้แล้วให้เรา ลิสติ้ง 18-1 แสดงนิยามของ struct AveragedCollection
pub struct AveragedCollection {
list: Vec<i32>,
average: f64,
}
struct นี้ถูกระบุเป็น pub เพื่อให้โค้ดส่วนอื่นสามารถเรียกใช้ได้ แต่ฟิลด์ภายใน struct ยังคงเป็นแบบไพรเวต (private) ซึ่งมีความสำคัญในกรณีนี้ เพราะเราต้องการให้แน่ใจว่า เมื่อใดก็ตามที่มีการเพิ่มหรือลบค่าออกจากรายการ ค่าเฉลี่ยจะได้รับการอัปเดตตามไปด้วยเสมอ เราทำเช่นนี้ได้ด้วยการอิมพลีเมนต์เมธอด add, remove และ average ให้กับ struct ดังแสดงในลิสติ้ง 18-2
pub struct AveragedCollection {
list: Vec<i32>,
average: f64,
}
impl AveragedCollection {
pub fn add(&mut self, value: i32) {
self.list.push(value);
self.update_average();
}
pub fn remove(&mut self) -> Option<i32> {
let result = self.list.pop();
match result {
Some(value) => {
self.update_average();
Some(value)
}
None => None,
}
}
pub fn average(&self) -> f64 {
self.average
}
fn update_average(&mut self) {
let total: i32 = self.list.iter().sum();
self.average = total as f64 / self.list.len() as f64;
}
}
พับลิกเมธอดอย่าง add, remove และ average เป็นหนทางเดียวในการเข้าถึงหรือแก้ไขข้อมูลในอินสแตนซ์ของ AveragedCollection เมื่อมีการเพิ่มสมาชิกเข้าไปใน list ผ่านเมธอด add หรือลบออกด้วยเมธอด remove โค้ดของแต่ละเมธอดจะเรียกใช้เมธอดไพรเวต update_average ซึ่งคอยจัดการอัปเดตฟิลด์ average ให้เสมอ
เราปล่อยให้ฟิลด์ list และ average เป็นไพรเวต เพื่อไม่ให้โค้ดภายนอกสามารถเพิ่มหรือลบสมาชิกในฟิลด์ list ได้โดยตรง มิฉะนั้น ฟิลด์ average อาจไม่สอดคล้องกับความเป็นจริงเมื่อ list เกิดการเปลี่ยนแปลง เมธอด average จะคืนค่าในฟิลด์ average ออกไป ทำให้โค้ดภายนอกอ่านค่า average ได้แต่ไม่สามารถแก้ไขได้
เนื่องจากเราได้ห่อหุ้มรายละเอียดการอิมพลีเมนต์ของ struct AveragedCollection ไว้แล้ว ในอนาคตเราจึงปรับเปลี่ยนโครงสร้างภายใน เช่น โครงสร้างข้อมูล ได้อย่างง่ายดาย ตัวอย่างเช่น เราสามารถเปลี่ยนไปใช้ HashSet<i32> แทน Vec<i32> สำหรับฟิลด์ list ได้ โดยตราบใดที่ลายเซ็น (signature) ของพับลิกเมธอด add, remove และ average ยังคงเดิม โค้ดภายนอกที่เรียกใช้ AveragedCollection ก็ไม่จำเป็นต้องแก้ไขอะไรเลย แต่ถ้าหากเราเปิด list ให้เป็นพับลิก ผลลัพธ์อาจไม่เป็นเช่นนั้น เพราะ HashSet<i32> และ Vec<i32> มีเมธอดในการเพิ่มและลบสมาชิกที่แตกต่างกัน โค้ดภายนอกจึงอาจต้องแก้ตามหากมีการเข้าถึงและดัดแปลง list โดยตรง
หากการห่อหุ้มเป็นคุณสมบัติจำเป็นที่ทำให้ภาษาหนึ่งถือเป็นภาษาเชิงวัตถุได้ Rust ก็ตอบโจทย์ข้อกำหนดนั้นอย่างแน่นอน การเลือกระบุหรือไม่ระบุ pub ให้กับส่วนต่าง ๆ ของโค้ด ช่วยให้เราสามารถห่อหุ้มรายละเอียดการอิมพลีเมนต์ได้อย่างสมบูรณ์
การสืบทอดในฐานะระบบชนิดข้อมูลและในฐานะการแบ่งปันโค้ด
การสืบทอด (inheritance) เป็นกลไกที่ออบเจกต์หนึ่งสามารถสืบทอดองค์ประกอบจากนิยามของอีกออบเจกต์หนึ่งได้ ทำให้ได้รับข้อมูลและพฤติกรรมของออบเจกต์แม่มาโดยที่คุณไม่ต้องนิยามซ้ำอีกรอบ
หากภาษานั้นจำเป็นต้องมีการสืบทอดจึงจะนับเป็นภาษาเชิงวัตถุได้ Rust ก็ไม่ใช่ภาษานั้น เพราะไม่มีวิธีใดที่จะนิยาม struct ให้สืบทอดฟิลด์และการอิมพลีเมนต์เมธอดจาก struct แม่ได้โดยไม่พึ่งพามาโคร
อย่างไรก็ดี หากคุณคุ้นเคยกับการใช้การสืบทอดในการเขียนโปรแกรม คุณก็สามารถเลือกใช้วิธีแก้ปัญหาแบบอื่นใน Rust ได้ ขึ้นอยู่กับเหตุผลที่คุณเลือกหยิบการสืบทอดมาใช้ตั้งแต่แรก
ปกติแล้วคุณจะเลือกใช้การสืบทอดด้วยเหตุผลหลักสองประการ เหตุผลแรกคือการนำโค้ดกลับมาใช้ใหม่ (code reuse): คุณสามารถอิมพลีเมนต์พฤติกรรมบางอย่างให้กับชนิดข้อมูลหนึ่ง แล้วใช้การสืบทอดเพื่อนำการอิมพลีเมนต์นั้นไปใช้ซ้ำกับชนิดข้อมูลอื่นได้ คุณสามารถทำสิ่งนี้ในโค้ด Rust ได้ในขอบเขตหนึ่ง โดยใช้การอิมพลีเมนต์เมธอดแบบดีฟอลต์ของเทรต ดังที่คุณได้เห็นในลิสติ้ง 10-14 เมื่อเราเพิ่มการอิมพลีเมนต์ดีฟอลต์ของเมธอด summarize ไว้ในเทรต Summary ชนิดข้อมูลใดก็ตามที่อิมพลีเมนต์เทรต Summary ก็จะมีเมธอด summarize ให้ใช้งานได้ทันทีโดยไม่ต้องเขียนโค้ดเพิ่ม ซึ่งคล้ายกับคลาสแม่ที่มีการอิมพลีเมนต์เมธอดไว้ และคลาสลูกที่สืบทอดไปก็จะได้การอิมพลีเมนต์เมธอดนั้นไปด้วย นอกจากนี้เรายังสามารถเขียนทับ (override) การอิมพลีเมนต์ดีฟอลต์ของเมธอด summarize เมื่อเราอิมพลีเมนต์เทรต Summary ได้เช่นกัน ซึ่งเทียบได้กับคลาสลูกที่ override เมธอดที่สืบทอดมาจากคลาสแม่
อีกเหตุผลหนึ่งในการใช้การสืบทอดเกี่ยวข้องกับระบบชนิดข้อมูล: นั่นคือเพื่อให้ชนิดข้อมูลลูกสามารถนำไปใช้ในตำแหน่งเดียวกับชนิดข้อมูลแม่ได้ สิ่งนี้เรียกว่า_พอลิมอร์ฟิซึม_ (polymorphism) ซึ่งหมายถึงการที่คุณสามารถใช้ออบเจกต์หลายตัวแทนที่กันได้ ณ ตอนรันไทม์หากพวกมันมีลักษณะเฉพาะบางอย่างร่วมกัน
พอลิมอร์ฟิซึม
สำหรับหลาย ๆ คน พอลิมอร์ฟิซึมมักถูกมองว่ามีความหมายเหมือนกับการสืบทอด แต่ความจริงแล้วมันเป็นแนวคิดที่กว้างกว่านั้น โดยหมายถึงโค้ดที่สามารถทำงานร่วมกับข้อมูลได้หลากหลายชนิด สำหรับการสืบทอด ชนิดข้อมูลเหล่านั้นมักจะเป็นคลาสย่อย (subclass)
ในทางกลับกัน Rust เลือกใช้เจเนอริก (generics) เพื่อสร้างนามธรรมครอบคลุมชนิดข้อมูลที่เป็นไปได้ต่าง ๆ และใช้ข้อกำหนดเทรต (trait bounds) ในการจำกัดว่าชนิดข้อมูลเหล่านั้นต้องมีความสามารถหรือพฤติกรรมอะไรบ้าง ซึ่งบางครั้งเรียกว่า_พอลิมอร์ฟิซึมแบบพาราเมตริกที่มีขอบเขต_ (bounded parametric polymorphism)
Rust เลือกข้อแลกเปลี่ยนที่แตกต่างออกไปโดยไม่เปิดให้มีการสืบทอด เนื่องจากการสืบทอดมักมีความเสี่ยงที่จะแชร์โค้ดมากเกินความจำเป็น โดยคลาสลูกไม่จำเป็นต้องมีคุณลักษณะทั้งหมดของคลาสแม่เสมอไป แต่การสืบทอดจะบังคับให้ต้องรับมาทั้งหมด สิ่งนี้ทำให้การออกแบบโปรแกรมมีความยืดหยุ่นน้อยลง ทั้งยังเพิ่มความเสี่ยงที่จะเกิดการเรียกใช้เมธอดบนคลาสลูกซึ่งไม่สมเหตุสมผลหรือไม่เข้ากับบริบท จนนำไปสู่ข้อผิดพลาดได้ นอกจากนี้ บางภาษายังอนุญาตให้มีเฉพาะ_การสืบทอดเชิงเดี่ยว_ (single inheritance) เท่านั้น (หมายความว่าคลาสลูกสามารถสืบทอดได้จากคลาสเดียวเท่านั้น) ซึ่งยิ่งจำกัดความยืดหยุ่นในการออกแบบโปรแกรมลงไปอีก
ด้วยเหตุผลเหล่านี้ Rust จึงเลือกใช้แนวทางที่แตกต่าง โดยนำเทรตออบเจกต์ (trait object) มาใช้แทนการสืบทอดเพื่อสร้างพอลิมอร์ฟิซึม ณ ตอนรันไทม์ ลองมาดูกันว่าเทรตออบเจกต์ทำงานอย่างไร