PricingLoginStart free
Swift Academy · บทเรียน

สแตกกับฮีป: ค่าต่าง ๆ อยู่ที่ใด

เรียนรู้ว่าโครงสร้างอยู่บนสแตกและคลาสอยู่บนฮีปอย่างไร รวมถึงผลต่อประสิทธิภาพ

บทเรียน 1 จาก 412 ขั้นตอน

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

ยินดีต้อนรับ

การเข้าใจว่าค่าของ Swift อยู่ที่ใดในหน่วยความจำ — สแตกหรือฮีป — เป็นสิ่งสำคัญสำหรับการเขียนโค้ดที่มีประสิทธิภาพและคาดเดาพฤติกรรมได้

สแตก

สแตกคือบล็อกหน่วยความจำที่ต่อเนื่องกันและได้รับการจัดการโดยอัตโนมัติ: • ตัวแปรภายในฟังก์ชันและพารามิเตอร์จะอยู่ที่นี่ • การจัดสรรหน่วยความจำมีความซับซ้อน O(1) — เพียงเลื่อนตัวชี้ • จะถูกคืนหน่วยความจำโดยอัตโนมัติเมื่อขอบเขตสิ้นสุด • เป็นหน่วยความจำเฉพาะเธรด — แต่ละเธรดมีสแตกของตนเอง

ฮีป

ฮีปคือพื้นที่หน่วยความจำร่วมสำหรับการจัดสรรที่มีอายุการใช้งานยาวนาน: • ออบเจ็กต์จะอยู่ที่นี่เมื่ออายุการใช้งานยาวเกินกว่าหนึ่งขอบเขต • การจัดสรรต้องค้นหาหน่วยความจำว่าง — จึงมีค่าใช้จ่ายสูงกว่า • คลาสได้รับการจัดการโดย ARC • ใช้ร่วมกันระหว่างเธรด — จึงต้องมีการทำให้ทำงานสอดคล้องกัน

โครงสร้างอยู่บนสแตก

```swift func compute() { var pt = CGPoint(x: 3, y: 4) // on the stack pt.x += 1 } // pt freed automatically ``` โครงสร้างขนาดเล็กจะถูกส่งผ่านด้วยการคัดลอก — ไม่มีค่าใช้จ่ายจากฮีป

คลาสอยู่บนฮีป

```swift class Dog { var name: String init(name: String) { self.name = name } } var d = Dog(name: "Rex") // Dog instance on heap // 'd' is a pointer on the stack ```

โครงสร้างขนาดใหญ่อาจใช้ฮีป

โครงสร้างขนาดใหญ่ (อาร์เรย์ สตริง และชนิดค่าอื่น ๆ ที่มีขนาดใหญ่) ใช้ COW และพื้นที่จัดเก็บบนฮีปภายใน แม้จะทำงานเป็นชนิดค่าก็ตาม: ```swift var arr = [Int](repeating: 0, count: 10_000) // The array's buffer is on the heap; 'arr' itself is a stack value ```

การจับค่าในคลอสเชอร์

เมื่อคลอสเชอร์จับตัวแปรชนิดค่าที่ต้องมีอายุยืนกว่าขอบเขต Swift จะห่อมันไว้บนฮีป: ```swift var count = 0 let increment = { count += 1 } // count captured in a heap box increment() print(count) // 1 ```

การห่อชนิดนามธรรมของโปรโตคอล

การจัดเก็บชนิดค่าขนาดเล็กไว้ในตัวแปร `any Protocol` อาจทำให้เกิดการจัดสรรบนฮีป (การห่อชนิดนามธรรม): ```swift var shape: any Shape = Circle(radius: 5) // may allocate on heap ``` ชนิดข้อมูลขนาดเล็ก (ไม่เกิน 3 คำ) จะถูกจัดเก็บโดยตรง ส่วนชนิดข้อมูลที่ใหญ่กว่าจะถูกห่อ

การวัดการจัดสรรหน่วยความจำ

ใช้แม่แบบ Allocations ของ Instruments เพื่อดูการจัดสรรหน่วยความจำบนฮีป: 1. Profile > Allocations 2. กรองตามคลาสหรือหมวดหมู่ 3. ติดตามจำนวน `alloc` เทียบกับ `dealloc` จำนวนการจัดสรรที่สูงในลูปมักบ่งชี้ว่ามีการห่อค่าโดยไม่คาดคิด

ผลกระทบต่อการออกแบบ

• เลือกใช้โครงสร้างสำหรับชนิดข้อมูลที่เก็บข้อมูลและมีอายุสั้น — ความเร็วของสแตก • ใช้คลาสเมื่อต้องการตัวตนหรือสถานะที่ใช้ร่วมกัน • หลีกเลี่ยงการจัดสรรหน่วยความจำในลูปที่ทำงานถี่ — จัดสรรล่วงหน้าด้วย `reserveCapacity` • ทำการวัดประสิทธิภาพก่อนปรับให้เหมาะสม — การปรับให้เหมาะสมก่อนเวลาอันควรทำให้เสียเวลา

ตรวจสอบอย่างรวดเร็ว

หน่วยความจำชนิดใดจะถูกคืนโดยอัตโนมัติเมื่อขอบเขตของฟังก์ชันสิ้นสุด
ตอบคำถามในบทเรียนแบบโต้ตอบ

สรุป

ประเด็นสำคัญ: • สแตก: ราคาถูก จัดการอัตโนมัติ เฉพาะเธรด และใช้กับชนิดค่า • ฮีป: ยืดหยุ่น จัดการโดย ARC และใช้กับชนิดอ้างอิง • โครงสร้างขนาดใหญ่ใช้บัฟเฟอร์บนฮีปภายใน (COW) • คลอสเชอร์ที่จับตัวแปรจะห่อบรรจุตัวแปรเหล่านั้นไว้บนฮีป • ใช้ Instruments Allocations เพื่อตรวจหาการใช้ฮีปที่สูงโดยไม่คาดคิด ถัดไป: การเปลี่ยนค่า การใช้ร่วมกัน และการอ้างอิงร่วมที่ไม่คาดคิด
เริ่มต้นได้ฟรี

เรียนรู้ Swift ด้วย AI tutor — ฟรี

เขียนและเรียกใช้โค้ดจริงในเบราว์เซอร์ของคุณ รับความช่วยเหลือทันทีจาก AI tutor 24/7 และเรียนรู้ต่อจากที่คุณหยุดบนเว็บหรือในแอป

คอร์ส
122
บทเรียน
409
เริ่มเรียนฟรีดูหลักสูตรเต็ม

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

บทเรียน “สแตกกับฮีป: ค่าต่าง ๆ อยู่ที่ใด” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “สแตกกับฮีป: ค่าต่าง ๆ อยู่ที่ใด” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Swift Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Swift Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “สแตกกับฮีป: ค่าต่าง ๆ อยู่ที่ใด”

เรียนรู้ว่าโครงสร้างอยู่บนสแตกและคลาสอยู่บนฮีปอย่างไร รวมถึงผลต่อประสิทธิภาพ คุณปฏิบัติ Swift Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

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

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

บทเรียน “สแตกกับฮีป: ค่าต่าง ๆ อยู่ที่ใด” ใช้เวลานานแค่ไหน

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

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

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

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

  1. สแตกกับฮีป: ค่าต่าง ๆ อยู่ที่ใด
  2. การเปลี่ยนแปลง การใช้ร่วมกัน และการอ้างชื่อที่ไม่คาดคิด
  3. กราฟที่มีทั้งค่าและการอ้างอิง
  4. การออกแบบ API ตามความหมายของค่า
← กลับไปที่ Swift Academy