[เล่นเพลง]
>> DOUG LLOYD: OK เพื่อให้ข้อเสนอแนะ ก่อนที่จะเริ่มที่นี่
หากคุณยังไม่ได้ดูวิดีโอบน คำแนะนำที่คุณอาจต้องการที่จะทำครั้งแรก
เพราะวิดีโอนี้เป็นอีกหนึ่ง วิธีการทำงานกับคำแนะนำ
>> ดังนั้นมันเป็นไปที่จะพูดคุย เกี่ยวกับแนวความคิดบางอย่าง
ที่เราจะกล่าวถึงใน ตัวชี้วิดีโอและเรา
จะปัดสวะพวกเขาตอนนี้ สมมติว่าพวกเขาอยู่แล้ว
การเรียงลำดับของความเข้าใจ
เพื่อให้เป็นเพียงแค่เตือนของคุณ ว่าถ้าคุณเห็นวิดีโอนี้
และคุณยังไม่เห็น วิดีโอชี้มันอาจเรียงลำดับของ
บินอยู่เหนือหัวของคุณนิด ๆ หน่อย ๆ
และดังนั้นจึงอาจจะดีกว่า ดูในลำดับที่
>> ดังนั้นเราจึงได้เห็นแล้วหนึ่ง วิธีการที่จะทำงานร่วมกับตัวชี้
ซึ่งเป็นที่เราประกาศ ตัวแปรและจากนั้นเรา
ประกาศตัวแปรอีกตัวชี้ ตัวแปรที่ชี้ไป
ดังนั้นเราจึงได้สร้าง ตัวแปรที่มีชื่อเราได้
สร้างตัวแปรที่สองที่มีชื่อ และเราชี้ว่าตัวแปรที่สอง
ที่แรกที่
ซึ่งการจัดเรียงของมี ปัญหา แต่เพราะ
เราต้องรู้ว่า หน่วยความจำเท่าใดเรา
จะต้องขณะนี้ โปรแกรมของเราจะรวบรวม
>> ว่าเป็นเพราะเหตุใด
เพราะเราจะต้องสามารถที่จะตั้งชื่อหรือ ระบุทั้งหมดของตัวแปรที่เป็นไปได้
เราอาจพบ
เราอาจจะมีอาร์เรย์ที่อาจจะเป็น สามารถที่จะถือจำนวนมากของข้อมูล
แต่ก็ยังคงไม่ได้ ว่ามีความแม่นยำพอ
ถ้าเราไม่ทราบว่า สิ่งที่ถ้าเราไม่มีความคิด
ว่าเราจะต้องรวบรวมเวลา?
หรือสิ่งที่ถ้าโปรแกรมของเราจะ ทำงานเป็นเวลานานจริงๆ
การยอมรับการใช้งานต่างๆ ข้อมูลและเราไม่สามารถจริงๆ
ประมาณว่าเรากำลัง จะต้อง 1,000 หน่วย?
>> มันไม่เหมือนที่เราสามารถทำได้ บอกว่าที่บรรทัดคำสั่ง
ใส่จำนวนรายการ คุณคิดว่าคุณจะต้อง
ดีสิ่งที่คาดเดาว่าเป็นสิ่งที่ผิด?
แบบไดนามิกจัดสรรหน่วยความจำ การเรียงลำดับของช่วยให้เราทาง
จะได้รับการแก้ไขปัญหานี้โดยเฉพาะอย่างยิ่ง
และวิธีที่มันไม่ได้ โดยใช้ตัวชี้
>> เราสามารถใช้ตัวชี้ไปยัง ได้รับการเข้าถึงแบบไดนามิก
จัดสรรหน่วยความจำหน่วยความจำที่มีอยู่ จัดสรรเป็นโปรแกรมของคุณทำงาน
มันไม่ได้รับการจัดสรรที่รวบรวมเวลา
เมื่อคุณแบบไดนามิกจัดสรร หน่วยความจำมาจากสระว่ายน้ำ
ของหน่วยความจำที่รู้จักกันเป็นกอง
ก่อนหน้านี้หน่วยความจำทั้งหมดที่เราได้ ได้ทำงานร่วมกับในหลักสูตร
ได้รับมาจากสระว่ายน้ำ ของหน่วยความจำที่รู้จักกันเป็นกอง
วิธีที่ดีในทั่วไป เก็บไว้ใน mind-- และกฎนี้
ไม่เคยถือจริง แต่เกือบจะสวยมาก
มักจะถือ true-- เป็นที่ใด เวลาที่คุณให้ชื่อตัวแปรมัน
อาจจะมีชีวิตอยู่ในกอง
และทุกครั้งที่คุณทำไม่ได้ ให้ตัวแปรชื่อ
ซึ่งคุณสามารถทำกับหน่วยความจำแบบไดนามิก การจัดสรรก็อาศัยอยู่ในกอง
>> ตอนนี้ฉันชนิดของที่นำเสนอนี้เป็น ถ้ามีทั้งสองสระว่ายน้ำของหน่วยความจำ
แต่คุณอาจจะได้เห็นนี้ แผนภาพซึ่งโดยทั่วไป
ตัวแทนของ สิ่งที่หน่วยความจำที่มีลักษณะเหมือน
และเราจะไม่เกี่ยวกับการดูแลทั้งหมด สิ่งที่ด้านบนและด้านล่าง
สิ่งที่เราดูแลเกี่ยวกับการเป็นส่วนหนึ่งในเรื่องนี้ กลางที่นี่กองและสแต็ค
ที่คุณสามารถดูโดย กำลังมองหาที่แผนภาพนี้
เหล่านี้จริงไม่ได้สอง สระว่ายน้ำที่แยกต่างหากจากหน่วยความจำ
มันเป็นหนึ่งในสระว่ายน้ำที่ใช้ร่วมกันของหน่วยความจำ ที่คุณเริ่มในภาพนี้
คุณเริ่มต้นที่ด้านล่าง และเริ่มเติมขึ้น
จากด้านล่างกับสแต็คและคุณ เริ่มต้นที่ด้านบนและเริ่มต้นการเติมขึ้น
จากด้านบนลงกับกอง
แต่จริงๆมันเป็น สระว่ายน้ำเหมือนกันก็เพียง
จุดที่แตกต่างกันสถานที่ต่างกัน ในความทรงจำที่มีการจัดสรร
และคุณสามารถวิ่งออกมาจาก หน่วยความจำโดยมี
กองไปตลอดทาง ไปที่ด้านล่างหรือมี
สแต็คไปตลอดทางไปด้านบน หรือมีกองและสแต็ค
พบกับแต่ละอื่น ๆ
ทุกคนสามารถเป็นเงื่อนไข ที่ก่อให้เกิดโปรแกรมของคุณ
ที่จะวิ่งออกจากหน่วยความจำ
ดังนั้นเก็บที่ในใจ
เมื่อเราพูดถึง กองและกอง
เราเป็นจริงๆพูดคุยเกี่ยวกับ ก้อนเดียวกันทั่วไปของหน่วยความจำเพียง
ส่วนที่แตกต่างกันของหน่วยความจำที่
>> ดังนั้นวิธีการที่เราจะได้รับแบบไดนามิก จัดสรรหน่วยความจำในสถานที่แรก?
วิธีการที่ไม่ได้รับโปรแกรมของเรา หน่วยความจำที่มันทำงานอยู่หรือไม่
ดีซีมีฟังก์ชั่นที่เรียกว่า malloc, จัดสรรหน่วยความจำซึ่ง
คุณโทรไปและคุณผ่านใน จำนวนไบต์หน่วยความจำที่คุณต้องการ
ดังนั้นถ้าโปรแกรมของคุณทำงาน และคุณต้องการรันไทม์จำนวนเต็ม
คุณอาจ Mallock สี่ไบต์ หน่วยความจำ malloc วงเล็บสี่
>> Mallock จะผ่านไป มองผ่านกอง
เพราะเราแบบไดนามิก การจัดสรรหน่วยความจำ
และจะกลับมาที่คุณ ตัวชี้ไปยังหน่วยความจำที่
มันไม่ได้ทำให้คุณ memory-- ว่า ก็ไม่ได้ให้ชื่อ
จะช่วยให้คุณเป็นตัวชี้ไป
และนั่นเป็นเหตุผลที่ผมกล่าวอีกครั้ง ว่ามันเป็นสิ่งสำคัญที่จะอาจจะ
ได้ดูตัวชี้วิดีโอ ก่อนที่เราจะได้รับมากเกินไปที่จะเป็นแบบนี้
ดังนั้น malloc จะ ให้คุณกลับตัวชี้
>> หาก Mallock ไม่สามารถให้การใด ๆ หน่วยความจำเพราะคุณได้หมด
มันจะทำให้คุณกลับชี้โมฆะ
คุณจำสิ่งที่เกิดขึ้นถ้าเรา และพยายาม dereference ตัวชี้โมฆะ?
เราประสบความผิด seg ใช่มั้ย?
ที่อาจไม่ดี
>> ดังนั้นเวลาที่คุณโทรออกทุก เพื่อ malloc คุณเสมอเสมอ
ต้องตรวจสอบหรือไม่ ตัวชี้มันทำให้คุณกลับมาเป็นโมฆะ
ถ้าเป็นคุณจะต้องจบโปรแกรมของคุณ เพราะถ้าคุณพยายาม dereference
ตัวชี้ null ที่คุณกำลังจะ ที่จะประสบความผิดของการแบ่งส่วน
และโปรแกรมของคุณ จะผิดพลาดอยู่แล้ว
ดังนั้นวิธีการที่เราทำแบบคงที่ ได้รับจำนวนเต็ม?
>> int x
เราได้ทำอาจจะเป็นที่ พวงครั้งใช่มั้ย?
นี้จะสร้างตัวแปรที่เรียกว่า x ที่อาศัยอยู่ในกอง
เราทำแบบไดนามิกได้รับจำนวนเต็มอย่างไร
px ดาว Int เท่ากับ malloc 4
>> หรือมากกว่าอย่างเหมาะสม เราจะบอกว่า int ดาว px
เท่ากับขนาดของ malloc int, เพียงเพื่อโยนบางน้อย
หมายเลขมายากลรอบโปรแกรมของเรา
นี้เป็นไปเพื่อให้ได้สำหรับเรา สี่ไบต์ของหน่วยความจำจากกอง
และตัวชี้ที่เราได้รับ กลับไปจะเรียกว่าพิกเซล
และจากนั้นก็เช่นเดียวกับเราได้ เราทำก่อนหน้านี้
สามารถ dereference px ไป เข้าถึงหน่วยความจำที่
เราจะได้รับจำนวนเต็มจากผู้ใช้อย่างไร
เราสามารถพูดได้ int x เท่ากับได้รับ int
นั่นคือตรงไปตรงสวย
ถ้าเราต้องการที่จะสร้างอาร์เรย์ ของ x ลอยที่อาศัยอยู่ในกอง?
ลอย stack_array-- ที่ชื่อ ของวงเล็บของเรา array-- x
ที่จะสร้างให้เราอาร์เรย์ ของ x ลอยที่อาศัยอยู่ในกอง
เราสามารถสร้างอาร์เรย์ของลอย ที่อาศัยอยู่ในกองด้วย
ไวยากรณ์อาจดู เล็ก ๆ น้อย ๆ ที่ยุ่งยากมากขึ้น
แต่เราสามารถพูดลอย heap_array ดาวเท่ากับ
malloc ครั้ง x ขนาดของลอย
ฉันต้องมีห้องพอที่จะถือ x ลอยค่าจุด
เพื่อบอกว่าฉันต้อง 100 ลอยลอยหรือ 1000
ดังนั้นในกรณีที่ว่ามันจะเป็น 400 ไบต์ 100 ลอย
หรือ 4,000 ไบต์ 1,000 ลอย เพราะแต่ละคนจะขึ้นลอย
สี่ไบต์ของพื้นที่
>> หลังจากทำเช่นนี้ฉันสามารถใช้ ไวยากรณ์วงเล็บเหลี่ยมบน heap_array
ขณะที่ผมจะอยู่บน stack_array ผม สามารถเข้าถึงองค์ประกอบของรายบุคคล
ใช้ heap_array ศูนย์ heap_array หนึ่ง
แต่จำเหตุผลที่เราสามารถทำอย่างนั้น เป็นเพราะชื่อของอาร์เรย์ใน C ที่
เป็นจริงชี้ไปยัง องค์ประกอบแรกของอาร์เรย์ที่
ดังนั้นความจริงที่ว่าเรากำลังประกาศที่ อาร์เรย์ของลอยในกองที่นี่
เป็นจริงบิตทำให้เข้าใจผิด
จริงๆเราอยู่ใน บรรทัดที่สองของรหัสมี
ยังมีการสร้างตัวชี้ไปยังก้อนของ หน่วยความจำที่เราก็ทำผลงานบางคนที่มี
>> นี่คือปัญหาใหญ่กับการเป็น หน่วยความจำจัดสรรแบบไดนามิกแม้ว่า
และนี่คือเหตุผลที่มันเป็นจริงๆ สิ่งสำคัญที่จะพัฒนานิสัยที่ดีบางอย่าง
เมื่อคุณกำลังทำงานกับมัน
ซึ่งแตกต่างจากการประกาศแบบคงที่ หน่วยความจำหน่วยความจำของคุณ
จะไม่ส่งคืนโดยอัตโนมัติไปยัง เมื่อระบบการทำงานของคุณจะทำ
ดังนั้นหากเรามีหลักและ หลักเรียกฟังก์ชั่น
ฉเมื่อเสร็จสิ้นฉสิ่งที่มันทำ และผลตอบแทนการควบคุมของโปรแกรม
กลับไปที่หลักทั้งหมดของหน่วยความจำ ฉใช้ที่จะได้รับกลับมา
มันสามารถนำมาใช้อีกครั้ง โดยบางส่วนโปรแกรมอื่น ๆ
หรือฟังก์ชั่นอื่น ๆ ที่ ได้รับการเรียกในภายหลังในหลัก
มันสามารถใช้หน่วยความจำเดียวกันกับที่อีกครั้ง
>> หากคุณแบบไดนามิก แม้ว่าจัดสรรหน่วยความจำ
คุณต้องบอกอย่างชัดเจน ระบบที่คุณกำลังทำกับมัน
มันจะถือเข้ามันสำหรับคุณที่จะทำได้ นำไปสู่​​การแก้ไขปัญหาของคุณทำงานออก
ของหน่วยความจำ
และในความเป็นจริงบางครั้งเราดู ถึงนี้เป็นหน่วยความจำรั่ว
และบางครั้งการรั่วไหลของหน่วยความจำเหล่านี้ จริงสามารถทำลายล้างจริงๆ
สำหรับการทำงานของระบบ
>> หากคุณเป็นผู้ใช้อินเทอร์เน็ตที่พบบ่อย คุณอาจใช้เว็บเบราเซอร์บางอย่าง
และฉันจะไม่ได้ชื่อชื่อที่นี่ แต่ มีบางเว็บเบราเซอร์ออกมี
ที่มีชื่อเสียงมีจริง การรั่วไหลของหน่วยความจำที่ไม่ได้รับการแก้ไข
และถ้าคุณออกจากเบราว์เซอร์ของคุณเปิด เป็นระยะเวลานานมากเวลาวัน
และวันหรือสัปดาห์ที่ผ่านมาบางครั้งคุณ อาจสังเกตเห็นว่าระบบของคุณ
กำลังทำงานจริงๆช้า
และเหตุผลที่ว่าก็คือ เบราว์เซอร์ได้จัดสรรหน่วยความจำ
แต่แล้วก็ไม่ได้บอกระบบ ว่ามันทำกับมัน
และเพื่อที่จะทิ้งหน่วยความจำน้อย ใช้ได้สำหรับทุกโปรแกรมอื่น ๆ ของคุณ
ที่จะมีการร่วมกันเพราะคุณ leaking-- เว็บเบราเซอร์ที่
โปรแกรมมีการรั่วซึมของหน่วยความจำ
เราจะทำอย่างไรให้หน่วยความจำกลับ เมื่อเรากำลังทำกับมันได้หรือไม่
โชคดีที่มันเป็น วิธีที่ง่ายมากที่จะทำมัน
เราเพียงแค่มันฟรี
มีฟังก์ชั่นที่เรียกว่าเป็นฟรี จะยอมรับตัวชี้ไปยังหน่วยความจำ
และเราจะดีไป
>> ดังนั้นขอบอกว่าเราอยู่ใน ตรงกลางของโปรแกรมของเรา
เราต้องการที่จะ malloc 50 ตัวอักษร
เราต้องการที่จะ malloc อาร์เรย์ที่สามารถ สามารถถือ 50 ตัวอักษร
และเมื่อเราได้รับตัวชี้กลับไปที่ ที่ชื่อของตัวชี้ที่คำว่า
เราทำสิ่งที่เรากำลัง จะทำอย่างไรกับคำ
และจากนั้นเมื่อเราอยู่ ทำเราก็เป็นอิสระ
และตอนนี้เราได้กลับมาเหล่านั้น 50 ไบต์หน่วยความจำกลับไปยังระบบ
บางฟังก์ชั่นอื่น ๆ ที่สามารถใช้พวกเขา
เราไม่ต้องกังวลเกี่ยวกับความทุกข์ หน่วยความจำรั่วเพราะเราได้ปลดปล่อยคำ
เราได้หน่วยความจำกลับ ดังนั้นเราจึงเสร็จสิ้นการทำงานกับมัน
ดังนั้นมีสาม กฎทองที่ควร
เก็บไว้ในใจเมื่อใดก็ตามที่คุณ แบบไดนามิกจัดสรรหน่วยความจำ
กับ malloc
บล็อกของหน่วยความจำทุกที่ คุณ malloc ต้องได้รับการปลดปล่อย
ก่อนที่โปรแกรมของคุณประสบความสำเร็จในการทำงาน
ตอนนี้อีกครั้งในเครื่องหรือใน IDE นี้เรียงลำดับของการเกิดขึ้นสำหรับคุณอยู่แล้ว
เมื่อ you-- นี้จะเกิดขึ้นต่อไป เมื่อโปรแกรมของคุณจะถูกยกเลิก
หน่วยความจำทั้งหมดจะได้รับการปล่อยตัว
แต่โดยทั่วไปการเขียนโปรแกรมที่ดี การปฏิบัติเสมอเมื่อคุณทำเสร็จแล้ว
ฟรีสิ่งที่คุณได้ mallocd
>> ที่กล่าวว่าสิ่งเดียวที่ คุณได้ mallocd ควรจะได้รับการปลดปล่อย
หากคุณคงประกาศ จำนวนเต็ม int x กึ่งลำไส้ใหญ่
ที่อาศัยอยู่ในกองคุณ แล้วไม่ได้ต้องการที่จะเป็นอิสระ x
สิ่งเดียวเพื่อให้คุณได้ mallocd ควรจะได้รับการปลดปล่อย
>> และสุดท้ายจะทำสิ่งที่ไม่ฟรีครั้งที่สอง
ที่สามารถนำไปสู่​​การ อีกสถานการณ์ที่แปลก
ดังนั้นทุกอย่างที่คุณได้ mallocd จะต้องมีการปลดปล่อย
สิ่งเดียวที่คุณได้ malloc ควรจะได้รับการปลดปล่อย
และทำสิ่งที่ไม่ฟรีครั้งที่สอง
>> ถ้าอย่างนั้นเราไปผ่านตัวอย่างที่นี่ ของสิ่งที่บางคนจัดสรรแบบไดนามิก
หน่วยความจำอาจมีลักษณะผสม กับบางหน่วยความจำแบบคงที่
สิ่งที่อาจจะเกิดขึ้นที่นี่?
ดูว่าคุณสามารถทำตาม พร้อมและคาดเดาสิ่งที่
ที่จะเกิดขึ้นในขณะที่เราไป ผ่านสายเหล่านี้ทั้งหมดของรหัส
>> ดังนั้นเราจึงบอกว่า int เมตร
เกิดขึ้นที่นี่คืออะไร?
อย่างนี้ตรงไปตรงสวย
ฉันสร้างตัวแปรจำนวนเต็มเรียกว่าม.
ผมสีมันสีเขียว เนื่องจากว่าเป็นสี
ที่ผมใช้เมื่อผมพูด เกี่ยวกับตัวแปรจำนวนเต็ม
มันเป็นกล่อง
มันเรียกว่าม. และคุณสามารถ ร้านจำนวนเต็มภายในของมัน
>> เกิดอะไรขึ้นถ้าฉันแล้วพูดว่า int ดาว?
ดีที่สวยเหมือนกัน
ฉันสร้างกล่องที่เรียกว่า
มันเป็นความสามารถในการถือครอง int ดาวตัวชี้ไปยังจำนวนเต็ม
ดังนั้นฉันมันสีเขียว ish เช่นกัน
>> ฉันรู้ว่ามันมีบางสิ่งบาง จะทำอย่างไรกับจำนวนเต็ม
แต่ก็ไม่ได้ตัวเองจำนวนเต็ม
แต่ก็สวยมากความคิดเดียวกัน
เราได้สร้างกล่อง
ทั้งสิทธิเหล่านี้ ตอนนี้อยู่ในกอง
ฉันได้ให้แก่พวกเขาทั้งสองชื่อ
>> int ดาวขเท่ากับขนาดของ malloc int
หนึ่งในนี้อาจจะยุ่งยากเล็กน้อย
สละเวลาให้คิดเกี่ยวกับสิ่งที่คุณ คาดว่าจะเกิดขึ้นในแผนภาพนี้
int ดาวขเท่ากับขนาดของ malloc int
>> อย่างนี้ไม่ได้เพียงแค่สร้างกล่องหนึ่ง
นี้จะสร้างสองกล่อง
และความสัมพันธ์ก็ยังกำหนด จุดในความสัมพันธ์
เราได้จัดสรรหนึ่งช่วงตึก ของหน่วยความจำในกอง
ขอให้สังเกตว่ากล่องด้านบนขวา มีไม่ได้มีชื่อ
>> เรา mallocd มัน
มันมีอยู่ในกอง
แต่ขมีชื่อ
มันเป็นตัวแปรตัวชี้ที่เรียกว่าข
ที่อาศัยอยู่ในกอง
>> ดังนั้นจึงเป็นชิ้นส่วนของหน่วยความจำ ที่ชี้ไปยังอีกคนหนึ่ง
ขมีอยู่ ของบล็อกของหน่วยความจำที่
มันไม่ได้มีชื่อเป็นอย่างอื่น
แต่มันชี้ไปที่มัน
ดังนั้นเมื่อเราพูด int ดาวขเท่ากับ ขนาดของ malloc int ที่มีสิทธิ์
ลูกศรที่โผล่ขึ้นมาใน ด้านขวามีว่าสิ่งที่ทั้ง
ฉันจะต้องปรากฏ อีกครั้งเป็นสิ่งที่เกิดขึ้น
ทั้งหมดที่เกิดขึ้นใน ที่บรรทัดเดียวของรหัส
ตอนนี้เราจะได้รับน้อยมาก ตรงไปตรงมาอีกครั้ง
เท่ากับเครื่องหมายเมตร
คุณจำสิ่งที่ เท่ากับม. เครื่องหมายคืออะไร?
ดีที่ได้รับของที่อยู่ม.
หรือใส่มากขึ้น diagrammatically, จุดที่จะม
>> เท่ากับข
ตกลงดังนั้นนี่คืออีกคนหนึ่ง
เท่ากับข
สิ่งที่จะเกิดขึ้น แผนภาพเวลานี้?
>> ดีจำได้ว่า ผู้ประกอบการที่ได้รับมอบหมายงาน
โดยการกำหนดค่าที่ สิทธิที่จะได้ค่าด้านซ้าย
ดังนั้นแทนที่จะชี้เพื่อเมตรในขณะนี้ ชี้ไปที่สถานที่เดียวกันกับที่จุดข
ไม่ได้ชี้ไปที่ b เป็น จุดที่จุดข
>> ถ้าชี้ขที่จะ ได้รับเครื่องหมายเท่ากับข
แต่แทนที่จะเท่ากับขเพียง หมายความว่าและ b เป็นตอนนี้
ชี้ไปยังที่อยู่เหมือนกันเพราะ ภายในของขเป็นเพียงที่อยู่
และตอนนี้ภายในเป็นที่อยู่เดียวกัน
ม. เท่ากับ 10 น่าจะเป็น ส่วนใหญ่สิ่งที่ตรงไปตรงมา
เราได้ทำในนิด ๆ หน่อย ๆ
10 ใส่ในกล่อง
ขดาวเท่ากับม. บวก 2 จำจาก ตัวชี้วิดีโอของเราสิ่งที่ดาวหมายถึงข
เรากำลังจะไป dereference ขและใส่ ค่าบางอย่างในสถานที่ของหน่วยความจำที่
ในกรณีนี้ 12
>> ดังนั้นเมื่อเรา dereference จุดของ จำได้เราก็เดินทางลงลูกศร
หรือใส่อีกทางหนึ่งเรา ไปที่ที่อยู่หน่วยความจำที่
และเราจัดการกับมันในทางใดทางหนึ่ง
เราใส่ค่าบางอย่างในการมี
ดาวในกรณีนี้ข เท่ากับม. บวก 2 เป็นเพียง
ไปที่ตัวแปรที่ชี้ไปตามข ไปที่หน่วยความจำที่ชี้ไปตามข
และนำม. บวก 2 ในนั้น 12
>> ตอนนี้ผมเป็นอิสระข
จะเกิดอะไรขึ้นเมื่อฉันเป็นอิสระ B หรือไม่?
โปรดจำไว้ว่าสิ่งที่ผมพูดหมายถึงฟรี
สิ่งที่ฉันพูดเมื่อฉันเป็นอิสระ B หรือไม่?
>> ฉันทำทำงานกับมันใช่มั้ย?
ฉันเป็นหลักให้ขึ้นหน่วยความจำ
ฉันจะให้มันกลับไปที่ระบบ
ฉันไม่จำเป็นต้องนี้อีกต่อไปคือ สิ่งที่ฉันบอกพวกเขา, OK?
>> ตอนนี้ถ้าผมบอกว่าดาว เท่ากับ 11 คุณอาจจะสามารถ
แล้วบอกอะไรบางอย่างที่ไม่ดีที่ ที่จะเกิดขึ้นที่นี่ใช่มั้ย?
และแน่นอนถ้าฉันพยายามที่ฉันอาจ จะประสบความผิดของการแบ่งส่วน
เพราะตอนนี้แม้ว่า ก่อนหน้านี้ก้อนของหน่วยความจำที่
เป็นสิ่งที่ผมมี การเข้าถึงที่จุดนี้
ตอนนี้ฉันเข้าถึงหน่วยความจำที่ ไม่ได้ตามกฎหมายสำหรับผมที่จะเข้าถึง
>> และในขณะที่เราอาจจะ จำได้เมื่อเราเข้าถึงหน่วยความจำ
ที่เราไม่ควรที่จะสัมผัส นั่นเป็นสาเหตุที่พบบ่อยที่สุด
ของการแบ่งส่วน ความผิด และเพื่อให้โปรแกรมของฉัน
จะผิดพลาดถ้าผมพยายามที่จะทำเช่นนี้
ดังนั้นอีกครั้งมันเป็นความคิดที่ดีที่จะได้รับที่ดี การปฏิบัติและนิสัยที่ดีติดตัว
เมื่อทำงานกับ malloc และฟรี เพื่อที่คุณจะไม่ประสบการแบ่งส่วน
ความผิดพลาดและที่คุณใช้ คุณจัดสรรแบบไดนามิก
หน่วยความจำที่มีความรับผิดชอบ
>> ฉันลอยด์ดั๊กนี้ CS50