Learn Rust Coding · บทเรียน

ทำความเข้าใจแบบจำลองความเป็นเจ้าของของ Rust

ทำความเข้าใจกฎหลักของความเป็นเจ้าของ ความหมายของการย้ายค่า และวิธีที่สิ่งเหล่านี้ป้องกันข้อผิดพลาดด้านหน่วยความจำทั่วไป เช่น การคืนหน่วยความจำซ้ำสองครั้ง

ทำความเข้าใจแบบจำลองความเป็นเจ้าของของ Rust เป็นบทเรียน Learn Rust Coding ฟรีบน CoddyKit นี่คือบทเรียนที่ 1 จากทั้งหมด 3 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Learn Rust Coding และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Learn Rust Coding มีบทเรียนทั้งหมด 3 บทเรียน

ระบบการเป็นเจ้าของของ Rust คืออะไร

ระบบการเป็นเจ้าของของ Rust คือชุดกฎที่จัดการวิธีที่โปรแกรมใช้หน่วยความจำ แนวคิดหลักนี้ช่วยให้ Rust มีความปลอดภัยด้านหน่วยความจำโดยไม่ต้องใช้ตัวเก็บขยะ

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

Rust ตรวจสอบกฎเหล่านี้ขณะคอมไพล์

หน่วยความจำสแตกเทียบกับฮีป

โปรแกรมใช้พื้นที่หน่วยความจำหลักสองส่วน ได้แก่ สแตกและฮีป

สแตก: ข้อมูลขนาดคงที่และเข้าถึงได้รวดเร็ว (เช่น จำนวนเต็ม ค่าบูลีน และชนิดข้อมูลที่ทราบขนาด) ข้อมูลจะถูกเพิ่มและนำออกตามลำดับ
ฮีป: ข้อมูลขนาดเปลี่ยนแปลงได้และเข้าถึงได้ช้ากว่า (เช่น String, Vec) ตัวจัดสรรหน่วยความจำจะจัดสรรและคืนข้อมูลให้

ระบบการเป็นเจ้าของจะจัดการข้อมูลบนฮีปเป็นหลัก เพื่อให้มั่นใจว่าสามารถใช้งานและล้างข้อมูลได้อย่างปลอดภัย

กฎข้อที่ 1: ทุกค่ามีเจ้าของ

กฎข้อแรกของการเป็นเจ้าของนั้นเรียบง่าย: ค่าแต่ละค่าใน Rust มีตัวแปรหนึ่งตัวที่เรียกว่าเจ้าของ

ลองนึกภาพว่าเป็นป้ายชื่อบนกล่อง ตัวแปร s ด้านล่างคือเจ้าของข้อความ "hello"

fn main() {
  let s = String::from("hello"); // s owns "hello"
  println!("{}", s);
}

กฎข้อที่ 2: มีเจ้าของได้เพียงหนึ่งรายในแต่ละครั้ง

กฎข้อที่สองระบุว่า ในช่วงเวลาใดเวลาหนึ่ง ค่าหนึ่งค่าจะมีเจ้าของได้เพียงรายเดียว กฎนี้สำคัญอย่างยิ่งต่อการป้องกันปัญหาหน่วยความจำ

เมื่อคุณกำหนดค่าที่ซับซ้อน (เช่น String ซึ่งอยู่บนฮีป) จากตัวแปรหนึ่งไปยังอีกตัวแปรหนึ่ง การเป็นเจ้าของจะถูกย้าย ไม่ได้ถูกคัดลอก

การโอนการเป็นเจ้าของในการใช้งานจริง

ดูว่าจะเกิดอะไรขึ้นเมื่อกำหนดค่าของ s1 ให้กับ s2 ลองเรียกใช้โค้ดนี้

fn main() {
  let s1 = String::from("Hello, CoddyKit!");
  let s2 = s1; // Ownership of the String data moves from s1 to s2

  // println!("{}", s1); // This line would cause a compile-time error!
  println!("{}", s2);
}

ทำความเข้าใจความหมายของ "การย้าย"

หลังจาก let s2 = s1; แล้ว s1 จะไม่ถือว่าถูกต้องอีกต่อไป Rust จึงป้องกันไม่ให้คุณใช้ s1 อีก

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

ระบบการเป็นเจ้าของของ Rust ป้องกันปัญหานี้ขณะคอมไพล์

การเป็นเจ้าของกับการเรียกใช้ฟังก์ชัน

การส่งค่าให้ฟังก์ชันทำงานคล้ายกับการกำหนดค่าให้ตัวแปรอีกตัวหนึ่ง: การเป็นเจ้าของจะถูกย้ายเข้าไปในฟังก์ชัน

เมื่อฟังก์ชันทำงานเสร็จ เจ้าของค่า (พารามิเตอร์ของฟังก์ชัน) จะออกจากขอบเขต และค่านั้นจะถูกทิ้ง

สาธิตการเป็นเจ้าของในฟังก์ชัน

สังเกตว่าค่า String ถูกย้ายเข้าไปใน takes_ownership อย่างไร และจากนั้น gives_ownership ส่งค่า String ใหม่กลับมาอย่างไร

fn takes_ownership(some_string: String) {
  println!("Inside takes_ownership: {}", some_string);
} // some_string goes out of scope and `drop` is called.

fn gives_ownership() -> String {
  let some_string = String::from("returned string");
  some_string // Ownership is moved out of the function
}

fn main() {
  let s1 = String::from("hello");
  takes_ownership(s1); // s1's value moves into takes_ownership
  // println!("{}", s1); // Error: s1 is no longer valid here!

  let s2 = gives_ownership(); // s2 gets ownership of the returned String
  println!("After gives_ownership: {}", s2);
}

กฎข้อที่ 3: ขอบเขตและการทิ้งค่า

กฎข้อสุดท้ายคือ เมื่อเจ้าของออกจากขอบเขต ค่านั้นจะถูกทิ้ง

ขอบเขตคือช่วงภายในโปรแกรมที่สมาชิกหนึ่งรายการยังใช้งานได้ โดยมักกำหนดด้วยวงเล็บปีกกา {}
เมื่อตัวแปรออกจากขอบเขต Rust จะเรียกฟังก์ชันพิเศษที่ชื่อ drop โดยอัตโนมัติ

สิ่งนี้ช่วยให้หน่วยความจำถูกล้างโดยอัตโนมัติอย่างปลอดภัย และไม่ต้องใช้ตัวเก็บขยะ

การป้องกันข้อผิดพลาดด้านหน่วยความจำ

กฎการเป็นเจ้าของทำงานร่วมกันเพื่อรับประกันความปลอดภัยของหน่วยความจำ:

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

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

ตรวจสอบการเป็นเจ้าของ

พิจารณาโค้ด Rust ต่อไปนี้ จะเกิดอะไรขึ้นเมื่อคุณพยายามคอมไพล์และเรียกใช้โค้ด

fn main() {
  let message = String::from("Rust is fun!");
  let greeting = message;
  println!("{}", message);
}

ทบทวน: พื้นฐานการเป็นเจ้าของ

ทำได้ดีมาก คุณได้เรียนรู้กฎพื้นฐานของระบบการเป็นเจ้าของใน Rust แล้ว:

ทุกค่ามีเจ้าของ
ในแต่ละครั้งจะมีเจ้าของได้เพียงรายเดียว
เมื่อเจ้าของออกจากขอบเขต ค่านั้นจะถูกทิ้ง

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

คำถามที่พบบ่อย

บทเรียน “ทำความเข้าใจแบบจำลองความเป็นเจ้าของของ Rust” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “ทำความเข้าใจแบบจำลองความเป็นเจ้าของของ Rust” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Learn Rust Coding ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Learn Rust Coding มีบทเรียนทั้งหมด 3 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “ทำความเข้าใจแบบจำลองความเป็นเจ้าของของ Rust”

ทำความเข้าใจกฎหลักของความเป็นเจ้าของ ความหมายของการย้ายค่า และวิธีที่สิ่งเหล่านี้ป้องกันข้อผิดพลาดด้านหน่วยความจำทั่วไป เช่น การคืนหน่วยความจำซ้ำสองครั้ง คุณปฏิบัติ Learn Rust Coding ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Learn Rust Coding หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Learn Rust Coding บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 1 จากทั้งหมด 3 บทเรียน

บทเรียน “ทำความเข้าใจแบบจำลองความเป็นเจ้าของของ Rust” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Learn Rust Coding นี้ได้ไหม

ได้ บทเรียน Learn Rust Coding ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

ทำความเข้าใจแบบจำลองความเป็นเจ้าของของ Rust
อธิบายการอ้างอิงและการยืม
อายุการใช้งานสำหรับการอ้างอิงที่ปลอดภัย

← กลับไปที่ Learn Rust Coding