>> [เล่นเพลง]
>> [วิดีโอเล่นภาพ]
>> -เขาโกหก.
>> -เกี่ยวกับอะไร?
>> -I ไม่ทราบ
>> งั้นสิ่งที่เรารู้หรือไม่?
>> ใช่หรือไม่เพราะที่ 09:15 เรย์ Santoya อยู่ที่ตู้เอทีเอ็ม
-Yeah
ดังนั้นคำถามคือสิ่งที่ เขาก็ทำอยู่ที่ 09:16?
>> -Shooting 9 มิลลิเมตรที่บางสิ่งบางอย่าง
บางทีเขาอาจจะเห็นมือปืน
>> -Or ได้ทำงานร่วมกับเขา
>> cmd- รอ
กลับหนึ่ง
>> -คุณเห็นอะไร?
>> -Bring ใบหน้าของเขาขึ้นมาแบบเต็มหน้าจอ
>> แว่นตา -His
>> -There สะท้อนเป็น
>> -It เป็นทีมเบสบอล Nuevitas
นั่นเป็นโลโก้ของพวกเขา
>> และอื่นเขาพูดคุยกับ ใครก็ตามที่สวมแจ็คเก็ตที่
>> [จบเล่นภาพ]
>> DAVID ลัน: สิทธิทั้งหมด
นี่คือ CS50 และนี่คืออีกเล็กน้อย ของ [ไม่ได้ยิน] กับที่คุณ
เล่นน้ำที่มีปัญหาตั้งสี่
วันนี้เราเริ่มมองเล็ก ๆ น้อย ๆ อย่างลึกซึ้งในสิ่งเหล่านี้เรียกว่าตัวชี้
ซึ่งแม้ว่าจะเป็น หัวข้อความลับสวย
ปรากฎว่ามันจะ จะเป็นวิธีการที่เรา
สามารถเริ่มต้นสร้างและประกอบ โปรแกรมที่มีความซับซ้อนมากขึ้น
แต่เราไม่ได้ในวันพุธ โดยวิธีการ claymation บางครั้งแรก
ดังนั้นการเรียกคืนเป็น บิงกี้และเราใช้เขา
ที่จะดูที่โปรแกรมที่ ไม่ได้จริงๆทำอะไรที่น่าสนใจ
แต่มันก็แสดงให้เห็นถึงปัญหาที่เกิดขึ้นไม่กี่
เพื่อที่จะเริ่มต้นในวันนี้ทำไมเราไม่เดิน ได้อย่างรวดเร็วผ่านไม่กี่ขั้นตอนเหล่านี้
พยายามที่จะสกัดลงในแง่ของมนุษย์ ว่าสิ่งที่เกิดขึ้นที่นี่
และเหตุผลนี้ไม่ดีและจากนั้นย้ายไป และที่จริงเริ่มต้นสร้างบางสิ่งบางอย่าง
ด้วยเทคนิคนี้หรือไม่?
ดังนั้นเหล่านี้เป็นครั้งแรก สองบรรทัดในโปรแกรมนี้
และในแง่คนธรรมดาของสิ่งที่ กำลังทั้งสองสายทำ?
คนที่สะดวกสบายพอสมควร กับสิ่งที่ประกาศบนหน้าจอ?
สิ่งที่ทั้งสองสายทำ?
มันไม่ได้ทั้งหมดที่ แตกต่างจากหนึ่งสัปดาห์
แต่มีบางสัญลักษณ์พิเศษใหม่
ใช่?
มีกลับ
>> ผู้ชม: ประกาศตัวชี้?
DAVID ลัน: Say อีกครั้งหรือไม่
ผู้ชม: ประกาศตัวชี้?
DAVID ลัน: ชี้และประกาศ ขอปรับแก้นิด ๆ หน่อย ๆ
ผู้ชม: [ไม่ได้ยิน] ที่อยู่ x y ที่แล้ว
DAVID ลัน: และแล้วอยู่
ดังนั้นเฉพาะสิ่งที่เรากำลังทำ คือเราจะประกาศตัวแปรทั้งสอง
ตัวแปรเหล่านี้แม้ว่าจะ จะเป็นชนิด int ดาวซึ่ง
มากขึ้นโดยเฉพาะหมายถึง พวกเขาจะไปจัดเก็บ
ที่อยู่ของ int ที่, ตามลำดับ x และ y
ตอนนี้จะมีค่าใด ๆ
มีที่อยู่ที่แท้จริงใด ๆ ในเหล่านี้ สองตัวแปรที่จุดในเวลานี้หรือไม่?
เลขที่
มันเป็นเพียงแค่สิ่งที่เรียกว่าค่าขยะ
หากคุณไม่ได้จริงกำหนด ตัวแปรสิ่งที่อยู่ในหน่วยความจำ
ก่อนหน้านี้เป็นไปเพื่อเติมเลขศูนย์ และคนทั้งสองตัวแปรเหล่านั้น
แต่เรายังไม่ทราบ สิ่งที่พวกเขาและนั่นคือ
จะเป็นกุญแจสำคัญในการทำไมบิงกี้ หายไปหัวของเขาเมื่อสัปดาห์ที่แล้ว
>> ดังนั้นนี่เป็น claymation ชาตินี้
โดยคุณมีเวลาเพียงสองตัวแปร ชิ้นวงกลมเล็ก ๆ น้อย ๆ ของดิน
ที่สามารถจัดเก็บตัวแปร แต่เป็น ลูกศรห่อแนะนำ
พวกเขาไม่ได้จริงชี้ ไปทุกที่ที่รู้จักกันต่อ
ดังนั้นแล้วเรามีบรรทัดนี้และนี้ เป็นสัปดาห์ที่ผ่านมาใหม่ malloc สำหรับหน่วยความจำ
การจัดสรรซึ่งเป็นเพียงวิธีแฟนซี บอกระบบปฏิบัติการลีนุกซ์
หรือ Mac OS หรือ Windows, เดี๋ยวก่อนให้ฉันหน่วยความจำบางส่วน
และสิ่งที่คุณต้องบอก ระบบปฏิบัติการ
คือสิ่งที่เมื่อถามมันสำหรับหน่วยความจำ
มันจะไม่สนใจสิ่งที่ คุณจะทำอย่างไรกับมัน
แต่คุณไม่จำเป็นต้องบอกปฏิบัติการ สิ่งที่ระบบโดยวิธีการ malloc
ใช่?
>> ผู้ชม: เท่าไหร่?
DAVID ลัน: เท่าไหร่?
เท่าไหร่ในไบต์และเป็นเช่นนี้อีกครั้ง เป็นตัวอย่างที่วางแผนไว้เป็นเพียงแค่ว่า
ให้ฉันขนาดของ int ที่
ตอนนี้ขนาดของ int ที่ สี่ไบต์หรือ 32 บิต
ดังนั้นนี่เป็นเพียงวิธีการของ ว่าเดี๋ยวก่อนระบบปฏิบัติการ
ให้ฉันสี่ไบต์ของหน่วยความจำ ที่ฉันสามารถใช้ในการกำจัดของฉัน
และโดยเฉพาะสิ่งที่ไม่ ผลตอบแทน malloc ด้วยความเคารพ
เพื่อก้อนสี่ไบต์ที่?
ผู้ชม: อยู่?
DAVID ลัน: ที่อยู่
ที่อยู่ของก้อนสี่ไบต์ที่
ที่แน่นอน
และเพื่อให้เป็นสิ่งที่เก็บไว้ในท้ายที่สุดได้ ใน x และที่ว่าทำไมเราทำไม่ได้จริงๆ
สนใจสิ่งที่จำนวนว่า ที่อยู่ไม่ว่าจะเป็น OX1 หรือ OX2
หรือบางคนที่อยู่เลขฐานสิบหกที่เป็นความลับ
เพียงแค่เราดูแล pictorially ที่ตัวแปร x ที่ตอนนี้
ชี้ไปที่ก้อนของหน่วยความจำที่
ดังนั้นลูกศรหมายถึงตัวชี้หรือ โดยเฉพาะอย่างยิ่งที่อยู่หน่วยความจำ
แต่อีกครั้งที่เราไม่สนใจโดยทั่วไป สิ่งที่เกิดขึ้นจริงที่อยู่เหล่านี้
ตอนนี้สายนี้กล่าวว่า สิ่งที่ในแง่ของคนธรรมดา?
ได้รับดาว x 42 อัฒภาค
สิ่งนี้หมายความว่า?
คุณต้องการไป?
และไม่ควรเกาคอของคุณ
>> ผู้ชม: อยู่ของ x อยู่ที่ 42
>> DAVID ลัน: อยู่ของ x อยู่ที่ 42
ไม่มาก
เพื่อให้ใกล้เคียง แต่ไม่มากเพราะมี ดาวที่ prefixing x นี้
ดังนั้นเราจึงต้องปรับแต่งนิด ๆ หน่อย ๆ
ใช่?
>> ผู้ชม: ค่าที่ได้ ตัวชี้ x จะชี้ไปที่ 42
DAVID ลัน: OK
ค่าที่ x เป็นตัวชี้ ชี้ไปที่สมมติว่าจะเป็น 42,
หรือใส่อีกทางหนึ่งดาว x บอกว่าให้ไปที่สิ่งที่อยู่
อยู่ใน x ไม่ว่าจะเป็นฟอร์ด 1 ถนนหรือ 33 Oxford Street
หรือ OX1 ox33 หรืออะไรก็ตาม ว่าที่อยู่ที่เป็นตัวเลขคือ
ดาว x เป็น dereferencing ของ x
เพื่อไปที่ที่อยู่และ แล้วใส่หมายเลข 42 มี
เพื่อที่จะเป็น วิธีที่เทียบเท่ากับการบอกว่า
ดังนั้นนั่นคือทั้งหมดที่ดีและจากนั้น เราจะเป็นตัวแทนของภาพ
ดังต่อไปนี้ที่เราได้เพิ่ม 42 ไปก้อนที่สี่
ไบต์บนด้านขวามือ แต่ บรรทัดนี้เป็นสิ่งที่ผิดพลาดไป
และหัวหน้าของบิงกี้โผล่ ออกที่จุดนี้
เพราะสิ่งที่ไม่ดีเกิดขึ้นเมื่อ คุณ dereference ค่าขยะ
หรือคุณ dereference ที่ไม่ถูกต้อง ชี้และผมพูดไม่ถูกต้อง
เพราะที่จุดในนี้ เรื่องสิ่งที่อยู่ภายในของ Y?
มีอะไรค่า y ตาม ในไม่กี่ขั้นตอนที่ผ่านมา?
ใช่?
นั่นอะไร?
>> ผู้ชม: อยู่
DAVID ลัน: อยู่
มันควรจะอยู่ แต่ผมเริ่มต้นได้หรือไม่
ดังนั้นผมจึงยังไม่ได้
ดังนั้นสิ่งที่เป็นที่รู้จักกันที่จะอยู่ในที่นั่น?
มันเป็นเพียงค่าขยะบางอย่าง
มันอาจจะเป็นที่อยู่ใด ๆ จากศูนย์ถึง 2 พันล้านถ้าคุณมีสองกิ๊กแรม
หรือศูนย์ถึง 4 พันล้านถ้าคุณได้ มีสี่กิกะไบต์แรม
มันเป็นค่าขยะบางอย่าง แต่ปัญหาคือ
ที่ระบบปฏิบัติการ ถ้ามันไม่ได้ให้คุณ
ก้อนของหน่วยความจำที่เฉพาะ ว่าคุณกำลังพยายามที่จะไปถึง
โดยทั่วไปก็จะทำให้เกิดสิ่งที่ เราได้เห็นเป็นความผิดส่วน
ดังนั้นในความเป็นจริงใด ๆ ของคุณที่มี พยายามที่ปัญหาในเวลาทำการ
หรือปัญหาที่มากขึ้น โดยทั่วไปกับการพยายามที่จะคิดออก
ความผิดส่วนหนึ่ง ที่โดยทั่วไปหมายถึง
คุณจะสัมผัสส่วนของ หน่วยความจำที่คุณไม่ควรจะ
คุณสัมผัสหน่วยความจำที่ ระบบปฏิบัติการที่ไม่ได้
ได้รับอนุญาตให้คุณไปสัมผัสไม่ว่าจะเป็น โดยไปไกลเกินไปในอาร์เรย์ของคุณ
หรือเริ่มต้นในขณะนี้ไม่ว่าจะเป็น มันเป็นเพราะคุณสัมผัส
หน่วยความจำที่เป็นเพียงแค่ค่าขยะบางอย่าง
>> ดังนั้นการทำดาว x นี่ การเรียงลำดับของพฤติกรรมที่ไม่ได้กำหนด
คุณไม่ควรทำเพราะราคาต่อรอง มีการโปรแกรมที่เพิ่งจะผิดพลาด
เพราะคุณกำลังจะบอกว่า ไปยังที่อยู่นี้
และคุณมีความคิดที่ไม่มี ที่อยู่ที่เป็นจริง
ดังนั้นระบบปฏิบัติการที่มีแนวโน้ม จะผิดพลาดโปรแกรมของคุณ
เป็นผลมาและแน่นอนว่าเป็น สิ่งที่เกิดขึ้นมีการบิงกี้
ดังนั้นในท้ายที่สุดคงบิงกี้ ปัญหานี้กับเรื่องนี้
ดังนั้นโปรแกรมเองว่ามีข้อบกพร่อง
แต่ถ้าคุณเรียงลำดับของการเคลื่อนไปข้างหน้า และดำเนินการสายนี้แทน
ปีเท่ากับ x ก็หมายความว่าสิ่งที่ อยู่เป็น x ยังวางไว้ในปี
>> และเพื่อ pictorially เราได้ เป็นตัวแทนของทั้งสองนี้กับลูกศร
จาก x และ y ที่ชี้จาก ไปยังสถานที่เดียวกัน
ดังนั้นความหมาย x เท่ากับ จะวายเพราะทั้งสองของคนเหล่านั้น
เก็บเดียวกัน ที่อยู่เพราะฉะนั้นชี้ไปที่ 42,
และตอนนี้เมื่อคุณบอกว่าดาว y ที่ไปอยู่ใน Y,
นี้มีผลข้างเคียงที่น่าสนใจ
ดังนั้นที่อยู่ใน y ที่เป็น สิ่งเดียวกับที่อยู่ใน x
ดังนั้นถ้าคุณพูดไปยังที่อยู่ที่ ใน Y และเปลี่ยนค่าเป็น 13
ใครได้รับผลกระทบ?
X คือ D จุดเพื่อที่จะพูด ควรจะได้รับผลกระทบเช่นกัน
>> และแน่นอนว่านิควาดภาพนี้ ใน claymation เป็นสิ่งที่
แม้ว่าเราทำตามตัวชี้ y ที่เราจบลงด้วยการอยู่ในสถานที่เดียวกัน
และอื่น ๆ ถ้าเราจะพิมพ์ ออก x หรือ y ที่ pointee ของ
แล้วเราจะเห็นคุณค่าของ 13
ตอนนี้ผมพูด pointee จะเป็น สอดคล้องกับวิดีโอ
โปรแกรมเมอร์ของฉัน ความรู้ไม่จริง
pointee พูดคำว่า ที่ซึ่งเป็นแหลม
ที่ แต่เพื่อความมั่นคง กับวิดีโอที่ตระหนักถึง
นั่นคือทั้งหมดที่ได้รับ หมายความว่าในสถานการณ์ที่
ดังนั้นคำถามใด ๆ เกี่ยวกับ claymation หรือคำแนะนำหรือ malloc เพียงหรือยัง
ไม่ได้หรือไม่
ทั้งหมดขวา
>> โดยไม่ต้องต่อไป ความกังวลใจให้มาดู
ในที่นี้มีจริง ถูกนำมาใช้เป็นบางครั้ง
ดังนั้นเราจึงได้มีนี้ห้องสมุด CS50 ที่มีทั้งหมดของฟังก์ชันเหล่านี้
เราได้ใช้ GetInt มาก GetString, อาจ GetLongLong ก่อนหน้านี้
ใน PSet ของฉันหนึ่งหรือมากกว่านั้น แต่ สิ่งที่ถูกจริงที่เกิดขึ้น?
ดีลองมาดูอย่างรวดเร็ว เครื่องดูดควันที่อยู่ภายใต้โปรแกรมที่
เป็นแรงบันดาลใจเหตุผลที่เราให้คุณ CS50 ห้องสมุดและแน่นอนขณะที่สัปดาห์ที่ผ่านมา
เราเริ่มต้นการเหล่านั้น ล้อการฝึกอบรมออก
ดังนั้นนี้จะถูกจัดเรียงในขณะนี้ ของการชันสูตรศพของสิ่งที่
มีเกิดขึ้น ภายในห้องสมุด CS50,
แม้ว่าตอนนี้เราจะเริ่มต้นการย้าย ห่างจากมันสำหรับโปรแกรมส่วนใหญ่
>> ดังนั้นนี้เป็นโปรแกรมที่เรียกว่า scanf 0
มันสั้นสุด
มันก็มีเส้นเหล่านี้ แต่ แนะนำฟังก์ชั่นที่เรียกว่า scanf
ที่เรากำลังจริงจะเห็นใน ขณะที่ด้านในของห้องสมุด CS50 ที่
แม้ว่าในรูปแบบที่แตกต่างกันเล็กน้อย
ดังนั้นโปรแกรมนี้ในบรรทัดที่ 16 มีการประกาศตัวแปร x
ดังนั้นให้ฉันสี่ไบต์เป็น int
จะได้รับการบอกเล่าของผู้ใช้ จำนวนโปรดแล้ว
นี้เป็นสายที่น่าสนใจที่ จริงความสัมพันธ์ร่วมกันเมื่อสัปดาห์ที่แล้ว
และนี่.
scanf และจากนั้นแจ้งให้ทราบว่าจะใช้เวลา สตริงรูปแบบเช่นเดียวกับ printf,
ฉันหมายถึง% int แล้วจะใช้เวลา อาร์กิวเมนต์ที่สองซึ่งมีลักษณะเล็ก ๆ น้อย ๆ
ขี้ขลาด
มันเป็นเครื่องหมาย x และจำ เราจะเห็นในครั้งนี้เมื่อสัปดาห์ที่แล้ว
สิ่งที่ไม่แสดงเครื่องหมาย x?
สิ่งที่ไม่ทำเครื่องหมายใน C?
ใช่?
>> ผู้ชม: ที่อยู่ของ
DAVID ลัน: ที่อยู่ของ
ดังนั้นจึงเป็นตรงข้าม ของผู้ประกอบการดาว
ในขณะที่ผู้ประกอบการที่ดาวบอกว่าให้ไปที่ ที่อยู่นี้ผู้ประกอบเครื่องหมาย
กล่าวว่าคิดออก ที่อยู่ของตัวแปรนี้
และดังนั้นนี้เป็นกุญแจสำคัญเพราะ วัตถุประสงค์ scanf ในชีวิต
คือการสแกนของผู้ใช้ การป้อนข้อมูลจากแป้นพิมพ์
ขึ้นอยู่กับสิ่งที่เขาหรือเธอ ประเภทแล้วอ่านการป้อนข้อมูลของผู้ใช้นั้น
ลงในตัวแปร แต่เรา เห็นในสองสัปดาห์ที่ผ่านมา
ที่ฟังก์ชั่นที่เราแลกเปลี่ยน พยายามที่จะดำเนินการได้อย่างง่ายดาย
ถูกทำลายเพียง
จำได้ว่ามีฟังก์ชั่แลกเปลี่ยน, ถ้าเราเพียงแค่ประกาศ A และ B เป็น ints,
เราไม่ประสบความสำเร็จสลับ สองตัวแปรภายในของการแลกเปลี่ยน
เช่นเดียวกับนมและ OJ, แต่ทันทีที่สลับกลับ
สิ่งที่เป็นผลมาด้วยความเคารพ เพื่อ x และ y ค่าเดิม?
ไม่มีอะไร
ใช่
ไม่มีอะไรเกิดขึ้นในช่วงเวลานั้นเพราะ แลกเปลี่ยนเปลี่ยนเฉพาะสำเนาเฉพาะของตน
ซึ่งก็คือการพูดว่าทั้งหมด เวลานี้เมื่อใดก็ตามที่เราได้
รับการผ่านในการขัดแย้ง ฟังก์ชั่นเรา
เพียงแค่ผ่านสำเนาของข้อโต้แย้งเหล่านั้น
คุณสามารถทำอะไรกับที่ สิ่งที่คุณต้องการกับพวกเขา
แต่พวกเขากำลังจะมีไม่มี ผลกระทบต่อค่าเดิม
ดังนั้นนี่คือปัญหาถ้าคุณ ต้องการที่จะมีฟังก์ชั่นเช่น scanf
ในชีวิตที่มีวัตถุประสงค์ในการสแกน การป้อนข้อมูลของผู้ใช้จากแป้นพิมพ์
แล้วกรอกในช่องว่างเพื่อที่จะ พูดที่ให้ตัวแปรเช่น x
ค่าเพราะถ้าฉันเป็น เพียงแค่ผ่าน x เพื่อ scanf,
ถ้าคุณพิจารณาเหตุผลของการที่ผ่านมา สัปดาห์ scanf สามารถทำสิ่งที่มันต้องการ
สำเนา x แต่มันทำไม่ได้ เปลี่ยนแปลงอย่างถาวร x ยกเว้นกรณีที่เราให้
scanf แผนที่สมบัติเพื่อที่จะพูด ที่ x เครื่องหมายจุดโดย
เราผ่านในที่อยู่ของ x เพื่อให้ scanf สามารถไปที่นั่นและการเปลี่ยนแปลงจริง
ค่าของ x
และเพื่อให้จริงทั้งหมด ว่าโปรแกรมนี้ไม่
ถ้าผมทำ scanf 0 ในแหล่งที่มาของฉัน ไดเรกทอรี 5m ให้ scanf 0,
จุดเฉือน scanf จำนวน โปรด 50 ขอบคุณสำหรับ 50
>> ดังนั้นจึงเป็นที่น่าสนใจไม่ได้ทั้งหมดว่า แต่สิ่งที่เกิดขึ้นจริง
คือว่าเร็วที่สุดเท่าที่ผมเรียกว่า scanf นี่ค่าของ x
จะถูกเปลี่ยนไปอย่างถาวร
ตอนนี้ดูเหมือนว่าดีและ ที่ดีและในความเป็นจริงมัน
ดูเหมือนว่าเราไม่จำเป็นต้องใช้จริงๆ ห้องสมุด CS50 ที่ทุกคนอีกต่อไป
ยกตัวอย่างเช่นเรามาทำงาน ครั้งนี้เพิ่มเติมได้ที่นี่
ผมขอเปิดใหม่อีกครั้งเป็นครั้งที่สอง
ลองจำนวนและกรุณ​​า แทนที่จะพูดว่า 50 เหมือนก่อน
ขอเพียงแค่บอกว่าไม่มี
ตกลงที่แปลก ๆ
ตกลง.
และเพียงแค่เรื่องไร้สาระบางอย่างที่นี่
ดังนั้นจึงไม่ได้ดูเหมือนจะ จัดการกับสถานการณ์ที่ผิดพลาด
ดังนั้นเราจึงจำเป็นที่จะต้องเริ่มต้นที่น้อยที่สุด เพิ่มบางข้อผิดพลาดการตรวจสอบ
เพื่อให้แน่ใจว่าผู้ใช้มี พิมพ์ในจำนวนที่เกิดขึ้นจริงเช่น 50,
เพราะเห็นได้ชัดว่าการพิมพ์คำ ไม่ได้ตรวจพบว่าเป็นปัญหา
แต่มันอาจจะ
>> ลองดูที่รุ่นนี้ตอนนี้ที่ ความพยายามของฉันที่จะ reimplement GetString
หาก scanf มีทั้งหมดนี้ ฟังก์ชั่นในตัว
เหตุผลที่เราได้รับการเล่นน้ำกับสิ่งเหล่านี้ ล้อการฝึกอบรมเช่น GetString?
ดีที่นี่อาจจะเป็นของตัวเอง รุ่นที่เรียบง่ายของ GetString
โดยสัปดาห์ที่ผ่านมาผมอาจจะได้กล่าวว่า ให้ฉันสตริงและเรียกว่าบัฟเฟอร์
วันนี้ฉันจะเริ่มต้นเพียง บอกว่าดาวถ่านซึ่งการเรียกคืน
มันเป็นเพียงความหมายเหมือนกัน
มันดูน่ากลัว แต่ก็ สิ่งเดียวที่แน่นอน
ดังนั้นให้ฉันตัวแปรที่เรียกว่าบัฟเฟอร์ ที่เกิดขึ้นในการจัดเก็บสตริง
บอกสตริงผู้ใช้โปรด แล้วเช่นเดียวกับก่อน
ลองยืมบทเรียนนี้ scanf % s เวลานี้แล้วผ่านในบัฟเฟอร์
ตอนนี้การตรวจสอบสติอย่างรวดเร็ว
ทำไมฉันไม่ได้บอกว่า เครื่องหมาย buffer ครั้งนี้หรือไม่
สรุปจากตัวอย่างก่อนหน้านี้
ผู้ชม: Char ดาวเป็นตัวชี้
DAVID ลัน: แน่นอน, เพราะเวลานี้ถ่าน
ดาวที่มีอยู่แล้วตัวชี้ที่อยู่ โดยความหมายของดาวที่อยู่ที่นั่น
และถ้า scanf คาดว่าที่อยู่ มันพอเพียงเพียงเพื่อให้ผ่านในบัฟเฟอร์
ฉันไม่ต้องการที่จะพูดบัฟเฟอร์เครื่องหมาย
สำหรับการอยากรู้อยากเห็นที่คุณสามารถทำได้ ทำอะไรเช่นนี้
มันจะมีความหมายที่แตกต่างกัน
นี้จะให้คุณเป็นตัวชี้ ที่จะเป็นตัวชี้ที่เป็นจริง
เป็นสิ่งที่ถูกต้องใน C แต่สำหรับ ตอนนี้ขอให้มันง่าย
และเก็บเรื่องที่สอดคล้องกัน
ฉันแค่จะผ่านใน บัฟเฟอร์และที่ถูกต้อง
ปัญหาที่เกิดขึ้นนี้ว่าเป็น
ให้ฉันไปข้างหน้าและทำงานนี้ โปรแกรมหลังจากที่รวบรวม
ทำให้ scanf 1
ประณามมันคอมไพเลอร์ของฉัน จับข้อผิดพลาดของฉัน
ให้ฉันคนที่สอง
ทำเสียงดังกราว
สมมติว่า scanf-1.c
ตกลง.
เราจะไปที่นั่น.
ฉันต้องการมัน.
ID CS50 มีต่างๆ การตั้งค่า
ที่ปกป้องคุณกับตัวเอง
ฉันต้องการที่จะปิดการใช้งานเหล่านั้นด้วย ทำงานเสียงดังกราวด้วยตนเองในครั้งนี้
ดังนั้นโปรดสตริง
ฉันจะไปข้างหน้าและพิมพ์ ในโลกสวัสดีที่ชื่นชอบ
ตกลง null
นั่นไม่ใช่สิ่งที่ผมพิมพ์
ดังนั้นจึงเป็นตัวบ่งชี้ของ บางสิ่งบางอย่างที่ไม่ถูกต้องเป็น
ให้ฉันไปข้างหน้าและพิมพ์ ในสายยาวจริงๆ
ขอบคุณสำหรับการเป็นโมฆะและผมไม่ทราบว่า ถ้าฉันจะสามารถที่จะผิดพลาดมัน
ลองสำเนาเล็ก ๆ น้อย ๆ วางและดูว่านี้จะช่วยให้
เพียงแค่วางจำนวนมากนี้
มันแน่นอนที่ใหญ่กว่า สตริงกว่าปกติ
ขอเพียงเขียนมันจริงๆ
เลขที่
ประณามมัน
ไม่พบคำสั่ง.
เพื่อให้เป็นที่ไม่เกี่ยวข้อง
นั่นเป็นเพราะผมวาง บางตัวอักษรที่ไม่ดี
แต่จะเปิดออกไม่ได้ไปทำงาน
>> ลองครั้งนี้มากขึ้นเพราะ มันสนุกมากขึ้นถ้าเราจริงมันผิดพลาด
ลองพิมพ์นี้และตอนนี้ฉัน จะคัดลอกสายยาวจริงๆ
และตอนนี้เรามาดูว่าเรา สามารถผิดพลาดสิ่งนี้
ผมสังเกตเห็นช่องว่างและละเว้น สายใหม่และอัฒภาค
และตัวละครขี้ขลาดทั้งหมด
เข้าสู่
และตอนนี้เครือข่ายเป็นเพียงแค่ช้า
ผมจัดลงคำสั่ง V นานเกินไปอย่างเห็นได้ชัด
ประณามมัน!
ไม่พบคำสั่ง.
>> ตกลง.
ดีประเด็นก็คือ แต่ต่อไปนี้
ดังนั้นสิ่งที่เป็นจริงที่เกิด กับประกาศนี้
ของบัฟเฟอร์ดาวถ่านในบรรทัดที่ 16?
ดังนั้นสิ่งที่ฉันได้รับ เมื่อผมประกาศตัวชี้?
ทั้งหมดที่ฉันได้รับเป็นค่าสี่ไบต์ เรียกว่าบัฟเฟอร์ แต่สิ่งที่ภายในของมัน
ในตอนนี้?
มันเป็นเพียงค่าขยะบางอย่าง
เพราะเวลาที่คุณประกาศตัวแปร ใน C ก็เพียงบางค่าขยะ
และเรากำลังเริ่ม การเดินทางมากกว่าความเป็นจริงนี้
ตอนนี้เมื่อฉันบอก scanf, ไปยังที่อยู่นี้
และนำสิ่งที่ประเภทของผู้ใช้ใน
ถ้าผู้ใช้ชนิดในสวัสดี โลกดีที่ฉันจะใส่มันได้หรือไม่
บัฟเฟอร์คือค่าขยะ
>> เพื่อให้เป็นชนิดเช่นลูกศร ที่ชี้ให้ผู้รู้ที่
บางทีมันอาจจะชี้ ขวาที่นี่ในความทรงจำของฉัน
ดังนั้นเมื่อผู้ใช้ ชนิดในโลกสวัสดี
โปรแกรมพยายามที่จะนำ สตริงสวัสดีเครื่องหมายโลก 0
ในก้อนของหน่วยความจำที่
แต่มีโอกาสสูง แต่ น่าจะเป็นอย่างชัดเจนไม่ได้ 100%
คอมพิวเตอร์เป็นไปแล้วผิดพลาด โปรแกรมเพราะเรื่องนี้ไม่ได้
หน่วยความจำที่ฉันควรจะได้รับอนุญาตให้สัมผัส
ดังนั้นในระยะสั้นโปรแกรมนี้ มีข้อบกพร่องตรงด้วยเหตุผลที่ว่า
ฉันพื้นฐานไม่ได้ทำอะไร
ขั้นตอนสิ่งที่ฉันได้มองข้ามเช่นเดียวกับ เรามองข้ามกับตัวอย่างแรกของบิงกี้?
ใช่?
>> ผู้ชม: การจัดสรรหน่วยความจำ?
>> DAVID ลัน: การจัดสรรหน่วยความจำ
ผมยังไม่ได้รับการจัดสรรจริง หน่วยความจำสำหรับสตริงที่ใด ๆ
ดังนั้นเราจึงสามารถแก้ไขปัญหานี้ในสองวิธี
หนึ่งเราสามารถให้มันง่าย และในความเป็นจริงตอนนี้คุณ
จะเริ่มเห็นเบลอ ของเส้นระหว่างสิ่งที่เป็น
อาร์เรย์คือสิ่งที่สตริงเป็นสิ่งที่ ดาวถ่านคือสิ่งที่อาร์เรย์ของตัวอักษร
คือ.
นี่เป็นตัวอย่างที่สองคือ ที่เกี่ยวข้องกับสายและแจ้งให้ทราบล่วงหน้า
ทั้งหมดที่ฉันได้ทำในบรรทัด 16 แทนที่จะพูดว่า
บัฟเฟอร์ที่เป็นไปได้ถ่าน ดาวตัวชี้ไปยังก้อนของหน่วยความจำ,
ฉันจะไปในเชิงรุกให้มาก ตัวเองบัฟเฟอร์ 16 ตัวอักษร
และในความเป็นจริงถ้าคุณคุ้นเคย บัฟเฟอร์กับคำว่า
อาจจะมาจากโลกของวิดีโอ วิดีโอที่เป็นบัฟเฟอร์บัฟเฟอร์
บัฟเฟอร์
ดีสิ่งที่การเชื่อมต่อที่นี่?
ดีภายใน YouTube และภายในของผู้เล่นวิดีโอ
โดยทั่วไปอาร์เรย์ ที่มีขนาดใหญ่กว่า 16
มันอาจจะมีอาร์เรย์ขนาดหนึ่ง เมกะไบต์อาจจะ 10 เมกะไบต์
และเข้าแถวที่ไ​​ม่เบราว์เซอร์ของคุณ ดาวน์โหลดทั้งกลุ่มของไบต์
ทั้งกลุ่มของเมกะไบต์ วิดีโอและเล่นวิดีโอ
ของ YouTube หรือใครก็ตามที่เป็นเริ่มต้น อ่านไบต์จากแถวนั้น
และทุกครั้งที่คุณเห็น บัฟเฟอร์คำบัฟเฟอร์
นั่นหมายความว่าผู้เล่นที่มี อากาศไปยังปลายแถวว่า
เครือข่ายช้าเพื่อให้มันไม่ได้ เติมอาร์เรย์กับไบต์
และเพื่อให้คุณจะออกจากบิต ที่จะแสดงให้กับผู้ใช้
>> บัฟเฟอร์ดังนั้นเป็นคำที่มีแนวโน้มในการที่นี่ มันเป็นเพียงแค่อาร์เรย์ก้อนของหน่วยความจำ
และสิ่งนี้จะแก้ไขได้ เพราะมันจะเปิดออก
ที่คุณสามารถรักษาอาร์เรย์ราวกับว่า พวกเขาจะอยู่ถึงแม้ว่าบัฟเฟอร์
เป็นเพียงสัญลักษณ์มันเป็น ลำดับของตัวอักษรบัฟเฟอร์
ที่มีประโยชน์สำหรับฉันโปรแกรมเมอร์ คุณสามารถส่งชื่อไปรอบ ๆ
ราวกับว่ามันเป็น ตัวชี้ราวกับว่ามัน
เป็นที่อยู่ของก้อนที่ หน่วยความจำ 16 ตัวอักษร
เพื่อที่จะบอกว่าผมสามารถผ่าน scanf ว่าคำว่า
และอื่น ๆ ตอนนี้ถ้าผมทำโปรแกรมนี้ ทำให้ scanf 2 เฉือนจุด scanf 2
และพิมพ์สวัสดีโลก ใส่ time-- ว่า
>> อืมสิ่งที่เกิดขึ้น?
String โปรด
ฉันทำผิดอะไร?
สวัสดีชาวโลกบัฟเฟอร์
สวัสดีชาวโลก.
โอ้ฉันรู้ว่าสิ่งที่มันทำ
ตกลง.
ดังนั้นจึงอ่าน จนพื้นที่แรก
ดังนั้นขอโกงเพียงสักครู่และ บอกว่าผมแค่อยากจะพิมพ์อะไรบางอย่าง
จริงๆยาวเช่นนี้เป็นประโยคยาว ที่หนึ่งสองสามสี่ห้า
หกเจ็ดแปดเก้า 10, 11, 12, 13, 14, 15, 16
ตกลง.
มันย่อมเป็นประโยคยาว
ดังนั้นประโยคนี้คือ นานกว่า 16 ตัวอักษร
และดังนั้นเมื่อผมกด Enter, สิ่งที่จะเกิดขึ้น?
ดีในกรณีนี้ เรื่องที่ผมได้ประกาศบัฟเฟอร์
ที่จริงเป็นอาร์เรย์ 16 ตัวอักษรพร้อมที่จะไป
ดังนั้นหนึ่งสองสามสี่ห้าหก เจ็ดแปดเก้า, 10, 11, 12, 13, 14
15, 16
ดังนั้น 16 ตัวอักษรและตอนนี้เมื่อฉัน อ่านในบางสิ่งบางอย่างเช่นนี้เป็นเวลานาน
ประโยคสิ่งที่จะเกิดขึ้นคือ ที่ฉันจะอ่านในนี้เป็นเวลานาน
S-E-N-T-E-N-C-E, ประโยค
>> ดังนั้นนี่คือจงใจ สิ่งที่ไม่ดีที่ฉัน
ให้เขียนเกิน ขอบเขตของอาเรย์ของฉัน
เกินขอบเขตของบัฟเฟอร์ของฉัน
ฉันจะได้รับโชคดีและโปรแกรม จะเก็บไว้ในการทำงานและไม่สนใจ
แต่โดยทั่วไปพูดนี้ ก็จะผิดพลาดโปรแกรมของฉัน
และมันเป็นปัญหาที่เกิดของฉัน รหัสขณะที่ฉันก้าว
เกินขอบเขต ของอาร์เรย์ที่เพราะผม
ไม่ทราบว่าเป็น จำเป็นต้องไปผิดพลาด
หรือถ้าฉันแค่จะได้รับโชคดี
ดังนั้นนี่คือปัญหาเพราะใน กรณีนี้ก็ไม่ดูเหมือนจะทำงาน
และขอลองเสี่ยงดวงที่นี่แม้ว่า IDE ที่ดูเหมือนว่าจะทนไม่น้อย
of--
>> เราจะไปที่นั่น.
ในที่สุด
ดังนั้นฉันเพียงคนเดียวที่สามารถมองเห็นได้
ดังนั้นผมก็มีจำนวนมากสนุกพิมพ์ จากวลีที่เกิดขึ้นจริงนานจริงๆ
ว่ามันเกินอย่างแน่นอน 16 ไบต์เพราะผม
พิมพ์ลงในนี้บ้านานหลายสาย วลีและแจ้งให้ทราบแล้วว่าเกิดอะไรขึ้น
โปรแกรมที่พยายามพิมพ์ และหลังจากนั้นก็แบ่งส่วนความผิด
และความผิดพลาดของการแบ่งส่วนคือเมื่อ บางสิ่งบางอย่างเช่นนี้เกิดขึ้น
และระบบปฏิบัติการกล่าวว่า ไม่มีไม่สามารถสัมผัสหน่วยความจำที่
เรากำลังจะไปฆ่า โปรแกรมทั้งหมด
>> ดังนั้นปัญหานี้ดูเหมือนว่า
ผมได้ปรับปรุงโปรแกรมโดย อย่างน้อยมีหน่วยความจำบางส่วน
แต่ตอนนี้ดูเหมือนจะ จำกัด GetString ฟังก์ชั่นในการรับ
บางสายมีความยาว 16 จำกัด
ดังนั้นหากคุณต้องการให้การสนับสนุนอีกต่อไป ประโยคกว่า 16 ตัวอักษร
คุณทำอะไร?
ดีที่คุณสามารถเพิ่ม ขนาดของบัฟเฟอร์ 32 นี้
หรือที่ดูเหมือนว่าชนิดสั้น
ทำไมเราไม่เพียงให้ มัน 1000 แต่ดันกลับ
อะไรตอบสนองอย่างสังหรณ์ใจของ เพียงแค่หลีกเลี่ยงปัญหานี้โดยการทำ
บัฟเฟอร์ของฉันที่ใหญ่กว่าเช่น 1,000 ตัวอักษร?
โดยการดำเนินการ getString วิธีนี้
มีอะไรดีหรือไม่ดีอยู่ที่นี่?
ใช่?
ผู้ชม: ถ้าคุณผูกขึ้นมาก ของพื้นที่และคุณไม่ได้ใช้มัน
แล้วคุณจะไม่สามารถจัดสรรพื้นที่นั้น
DAVID ลัน: แน่นอน
มันสิ้นเปลืองเท่าถ้าคุณทำไม่ได้ จริงต้อง 900 ไบต์เหล่านั้น
และยังที่คุณขอ 1,000 รวมแล้ว
คุณเพียงแค่การบริโภคหน่วยความจำเพิ่มเติมเกี่ยวกับ คอมพิวเตอร์ของผู้ใช้มากกว่าที่คุณต้องการไป
และหลังจากทั้งหมดบางส่วนของ คุณพบแล้ว
ในชีวิตที่เมื่อคุณอยู่ ทำงานจำนวนมากของโปรแกรม
และพวกเขากำลังรับประทานจำนวนมากของหน่วยความจำ นี้จริงสามารถส่งผลกระทบต่อผลการดำเนินงาน
และประสบการณ์ของผู้ใช้ บนคอมพิวเตอร์.
เพื่อให้เป็นชนิดของการแก้ปัญหาขี้เกียจ สำหรับการตรวจสอบและตรงกันข้าม
มันไม่เพียง แต่สิ้นเปลืองสิ่งที่เป็นปัญหา ยังคงอยู่แม้ว่าฉันจะทำให้บัฟเฟอร์ของฉัน
1000?
ใช่?
>> ผู้ชม: สตริงคือความยาว 1,001
DAVID ลัน: แน่นอน
ถ้าสายของคุณคือความยาว 1,001, คุณมีปัญหาเดียวกันแน่นอน
และข้อโต้แย้งของฉันฉันจะ เพียงแค่นั้นก็ทำให้มันเป็นปี 2000
แต่คุณไม่ทราบ ความก้าวหน้าของวิธีการใหญ่มันควรจะเป็น
และยังฉันจะมีการรวบรวมโปรแกรมของฉัน ก่อนที่จะให้คนใช้และดาวน์โหลด
มัน
ดังนั้นตรงนี้เป็นชนิดของ สิ่งที่ห้องสมุด CS50 พยายาม
ที่จะช่วยให้เรามีและเราจะได้อย่างรวดเร็วเท่านั้น ที่บางส่วนของการดำเนินงานภายใต้
ที่นี่ แต่นี้เป็นจุด CS50 ซีนี้ ไฟล์ที่ได้รับใน CS50 IDE
สัปดาห์ที่ผ่านมาทั้งหมดเหล่านี้ที่คุณได้ใช้
มันก่อนรวบรวมและคุณได้ ได้ใช้มันโดยอัตโนมัติ
โดยธรรมชาติของการมี รีบธง L CS50 กับเสียงดังกราว,
แต่ถ้าผมเลื่อนลงผ่านทุก ฟังก์ชั่นเหล่านี้ที่นี่ GetString,
และเพียงแค่ให้คุณ รสชาติของสิ่งที่เกิดขึ้น
ลองมาดูอย่างรวดเร็วที่ ความซับซ้อนญาติ
มันไม่ได้เป็นซุปเปอร์ยาว ฟังก์ชั่น แต่เราไม่ได้
ต้องคิดหนักเกี่ยวกับทุก ว่าจะไปเกี่ยวกับการรับสาย
>> ดังนั้นนี่คือบัฟเฟอร์ของฉันและฉัน เห็นได้ชัดว่ามันเริ่มต้นให้เป็นโมฆะ
นี้แน่นอนคือ สิ่งเดียวกับดาวถ่าน,
แต่ผมตัดสินใจ การใช้ห้องสมุด CS50
ว่าถ้าเรากำลังจะไป เป็นแบบไดนามิกอย่างสมบูรณ์
ผมไม่ทราบล่วงหน้าว่าขนาดใหญ่ของ ผู้ใช้สตริงจะต้องการที่จะได้รับ
ดังนั้นฉันจะเริ่มต้น มีเพียงสตริงที่ว่างเปล่า
และฉันจะที่จะสร้างขึ้นเป็นอย่างมาก หน่วยความจำที่ฉันต้องการเพื่อให้เหมาะสมกับผู้ใช้สตริง
และถ้าฉันไม่ได้มี พอฉันจะถาม
ระบบปฏิบัติการสำหรับหน่วยความจำมากขึ้น
ฉันจะย้ายสตริงของพวกเขา เป็นก้อนที่ใหญ่กว่าของหน่วยความจำ
และฉันจะปล่อยหรือฟรี ก้อนขนาดใหญ่ของหน่วยความจำไม่เพียงพอ
และเรากำลังจะ การทำเช่นนี้ซ้ำ
>> ดังนั้นอย่างรวดเร็ว, นี่เป็นเพียงตัวแปร
ที่ฉันจะติดตาม ของความจุของบัฟเฟอร์ของฉัน
วิธีการหลายไบต์ฉันสามารถใส่?
นี่เป็น n ตัวแปรที่มี ซึ่งผมจะให้
ติดตามจำนวนไบต์เป็นจริงใน บัฟเฟอร์หรือว่าผู้ใช้มีพิมพ์
หากคุณไม่เห็นนี้มาก่อนคุณ สามารถระบุว่าตัวแปรเช่น int ต์
คือไม่ได้ลงนามซึ่งเป็นชื่อที่แนะนำ หมายความว่ามันไม่เป็นลบและทำไมจะ
ที่ฉันเคยต้องการรบกวนระบุ ที่ int ไม่ได้เป็นเพียง int,
แต่มันเป็น int ไม่ได้ลงนาม?
มันเป็น int ไม่ใช่เชิงลบ
ไม่ว่าสิ่งที่ [ไม่ได้ยิน] หมายความว่าอย่างไร
>> ผู้ชม: มันอธิบายจำนวนเงิน หน่วยความจำที่สามารถ [ไม่ได้ยิน]
>> DAVID ลัน: ใช่
ดังนั้นถ้าผมพูดไม่ได้ลงนามนี้เป็นจริง ให้คุณหนึ่งบิตของหน่วยความจำเสริม
และดูเหมือนว่าชนิดของโง่ แต่ถ้าคุณ มีหนึ่งบิตของหน่วยความจำเพิ่มเติมที่
หมายความว่าคุณมีสองครั้งเป็นจำนวนมาก ค่าที่คุณสามารถเป็นตัวแทน
เพราะมันอาจจะเป็น 0 หรือ 1
ดังนั้นโดยค่าเริ่มต้น int สามารถประมาณ เชิงลบ 2000000000 ตลอดทาง
บวกถึง 2 พันล้าน
ผู้ที่มีช่วงใหญ่ แต่ ก็ยังคงเป็นชนิดของการสิ้นเปลือง
ถ้าคุณดูแลเกี่ยวกับ ขนาดที่เพิ่งสังหรณ์ใจ
ควรจะไม่เป็นลบหรือ บวกหรือ 0, ดีนั้น
ทำไมคุณเสีย 2 พันล้าน ค่าที่เป็นไปในเชิงลบสำหรับตัวเลข
ถ้าคุณไม่เคยไปใช้พวกเขา?
ดังนั้นโดยกล่าวว่าได้ลงนามตอนนี้ฉันสามารถ int อยู่ระหว่าง 0 ถึงประมาณ 4 พันล้าน
>> ดังนั้นนี่เป็นเพียง C int สำหรับเหตุผลที่ เราจะไม่ได้เป็นเพียงแค่ตอนนี้เป็น
ทำไมมัน int แทน ของถ่าน แต่ที่นี่คือ
สรุปสาระสำคัญของสิ่งที่เกิดขึ้น บนและบางส่วนของคุณ
อาจจะใช้สำหรับตัวอย่างเช่น ฟังก์ชั่น fgetc แม้ใน PSet สี่
หรือหลังจากนั้นเราจะเห็นมัน ปัญหาที่เกิดขึ้นอีกครั้งในการตั้งห้า
fgetc เป็นสิ่งที่ดีเพราะเป็นชื่อที่ ชนิดของการเรียงลำดับของ arcanely แนะนำ
มันเป็นฟังก์ชั่นที่ ได้รับตัวอักษรและเป็นเช่นนั้น
สิ่งที่แตกต่างกัน เกี่ยวกับสิ่งที่เรากำลังทำอยู่ใน GetString
คือเราไม่ได้ใช้ scanf ในทางเดียวกัน
เราเป็นเพียงแค่คืบคลานไปตามขั้นตอนโดยขั้นตอน มากกว่าสิ่งที่ผู้ใช้มีการพิมพ์ใน
เพราะเรามักจะสามารถจัดสรรหนึ่ง ถ่านและเพื่อให้เราสามารถเสมอได้อย่างปลอดภัย
ดูถ่านหนึ่งที่เวลาและ มายากลเริ่มที่จะเกิดขึ้นที่นี่
ฉันจะเลื่อนลงไป ตรงกลางของฟังก์ชั่นนี้
เพียงเวลาสั้น ๆ ที่จะแนะนำฟังก์ชั่นนี้
เหมือนมี ฟังก์ชั่น malloc มี
ฟังก์ชั่นที่ realloc realloc ช่วยให้คุณสามารถจัดสรรก้อนของหน่วยความจำ
และทำให้มันมีขนาดใหญ่หรือเล็ก
เรื่องยาวดังนั้นในระยะสั้นและมี คลื่นของมือของฉันสำหรับวันนี้
รู้ว่าสิ่งที่ GetString จะทำคือมันเรียงลำดับ
อย่างน่าอัศจรรย์ของการเจริญเติบโตหรือ การหดตัวกันชนเป็นผู้ใช้
ประเภทในสายของเขาหรือเธอ
>> ดังนั้นหากผู้ใช้ที่ สตริงสั้นรหัสนี้
จัดสรรพอเพียง หน่วยความจำเพื่อให้พอดีกับสตริง
หากผู้ใช้ช่วยให้การพิมพ์ ตามที่ผมได้อีกครั้งและอีกครั้ง
และอีกครั้งที่ดีถ้า บัฟเฟอร์ของครั้งแรกที่ยิ่งใหญ่นี้
และโปรแกรมการตระหนักในการ รอสักครู่ฉันออกจากพื้นที่
มันจะเป็นสองเท่า ขนาดของบัฟเฟอร์
แล้วสองเท่าของขนาดของบัฟเฟอร์ และรหัสที่ไม่เป็นสองเท่าที่
ถ้าเรามองไปที่มันที่นี่ก็ เพียงแค่นี้ฉลาดหนึ่งซับ
คุณอาจไม่ได้เห็นรูปแบบนี้ ก่อน แต่ถ้าคุณบอกว่าดาวเท่ากับ
นี่คือสิ่งเดียวกับ บอกว่ากำลังการผลิตครั้งที่ 2
ดังนั้นมันก็ช่วยเป็นสองเท่า ความจุของบัฟเฟอร์
แล้วบอก realloc ที่จะให้ ตัวเองว่าหน่วยความจำมากขึ้น
>> ตอนนี้เป็นกันมี มีฟังก์ชั่นอื่น ๆ ที่นี่
ว่าเราจะได้ดูในรายละเอียดใด ๆ อื่น ๆ นอกเหนือจากที่จะแสดงใน GetInt,
ที่เราใช้ใน GetString GetInt
เราตรวจสอบว่ามันเป็นไม่ได้ null ซึ่งการเรียกคืน
เป็นค่าพิเศษที่ หมายถึงสิ่งที่ผิดพลาดไป
เราจะออกจากหน่วยความจำ
การตรวจสอบที่ดีกว่าสำหรับการที่
และเรากลับค่าแมวมอง
แต่ฉันจะเลื่อนการแสดงความคิดเห็นเป็นไป แล้วทำไมเราจะใช้ญาติห่าง ๆ ของ scanf นี้
เรียกว่า sscanf และมันจะเปิดออก ที่ sscanf หรือ scanf สตริง
ช่วยให้คุณดูที่บรรทัดที่ ผู้ใช้มีการพิมพ์ในและแจ้งให้คุณ
วิเคราะห์เป็นหลักและสิ่งที่ฉัน ทำอะไรที่นี่เป็นที่ฉันบอก sscanf,
วิเคราะห์สิ่งที่ผู้ใช้มี พิมพ์ในและให้แน่ใจว่า% i,
มีจำนวนเต็มในนั้นและเราจะไม่ ได้รับในวันนี้ว่าทำไมยังมี
% ที่คที่นี่ แต่ในที่สั้นช่วยให้ เราในการตรวจสอบหากผู้ใช้พิมพ์
ในบางสิ่งบางอย่างหลังจากที่ปลอมจำนวน
ดังนั้นเหตุผลที่ GetInt และ GetString บอกให้คุณลอง, ลอง, ลองใหม่อีกครั้ง
เป็นเพราะทั้งหมดของ รหัสที่เราได้เขียน
เป็นประเภทของการมองที่การป้อนข้อมูลของผู้ใช้ ในการทำให้แน่ใจว่ามันเป็นตัวเลขทั้งหมด
หรือมันเป็นลอยที่เกิดขึ้นจริง ค่าจุดหรือเหมือน
ขึ้นอยู่กับสิ่งที่มีค่า ทำงานที่คุณกำลังใช้
>> ว๊าย
ตกลง.
นั่นคือคำหนึ่ง แต่จุดที่นี่คือ
ว่าเหตุผลที่เรามี ผู้ที่ล้อการฝึกอบรมใน
เป็นเพราะอยู่ในระดับต่ำสุด มีเพียงสิ่งหลายอย่างที่
สามารถไปผิดที่เราต้องการ ที่จะจัดการกับ preemptively
สิ่งเหล่านั้นอย่างแน่นอนใน สัปดาห์แรกของการเรียน
แต่ตอนนี้มี PSet สี่และห้า PSet เกินกว่าที่คุณจะเห็นว่ามันมากขึ้นแก่
คุณ แต่คุณกำลังความสามารถมากขึ้น ของการแก้ชนิดของปัญหา
ด้วยตัวคุณเอง
คำถามใด ๆ เกี่ยวกับ GetString GetInt หรือ?
ใช่?
>> ผู้ชม: ทำไมคุณจะเป็นสองเท่า ความจุของบัฟเฟอร์
แทนที่จะเป็นเพียงที่เพิ่มขึ้น ได้โดยจำนวนเงินที่แน่นอน?
>> DAVID ลัน: เป็นคำถามที่ดี
ทำไมเราจะเป็นคู่ความจุ ของบัฟเฟอร์ตรงข้าม
เพียงแค่เพิ่มขึ้นนั้น โดยบางส่วนค่าคงที่?
มันเป็นการตัดสินใจออกแบบ
เราก็ตัดสินใจว่าเพราะมันมีแนวโน้มที่จะ จะเป็นเพียงเล็กน้อยเวลาที่ชาญฉลาดที่มีราคาแพงที่จะถาม
ระบบปฏิบัติการ สำหรับหน่วยความจำเราไม่ได้
ต้องการที่จะจบลงด้วยการได้รับใน สถานการณ์สำหรับสตริงใหญ่
ที่เราถาม ระบบปฏิบัติการอีกครั้งและอีกครั้ง
และอีกครั้งและอีกครั้งใน อย่างรวดเร็วสำหรับหน่วยความจำ
ดังนั้นเราก็ตัดสินใจที่ค่อนข้าง โดยพลการ แต่เราหวังที่สมเหตุสมผล
ที่คุณรู้ว่าสิ่งที่ขอ พยายามที่จะรับล่วงหน้าของตัวเอง
และเพียงแค่ให้เป็นสองเท่าเพื่อให้ เราลดจำนวนครั้ง
เราจะต้องเรียก malloc หรือ realloc แต่การตัดสินรวม
โทรในกรณีที่ไม่มีการรู้ สิ่งที่ผู้ใช้อาจต้องการที่จะพิมพ์ใน
ทั้งสองวิธีอาจจะพิสูจน์ได้
เนื้อหาที่ดี
>> ดังนั้นลองมาดูที่คู่ ผลข้างเคียงอื่น ๆ ของหน่วยความจำ
สิ่งที่สามารถไปอย่างผิดปกติ และเครื่องมือที่คุณสามารถ
ใช้ในการจับเหล่านี้ชนิดของความผิดพลาด
มันจะเปิดออกทั้งหมดของคุณแม้ว่า check50 ยังไม่ได้บอกว่าคุณเป็นมาก
ได้รับการเขียนรถ รหัสตั้งแต่หนึ่งสัปดาห์
แม้ว่าการทดสอบ check50 ทั้งหมดที่มี ผ่านไปและแม้ว่าคุณและ TF ของคุณ
มีความมั่นใจสุดที่ รหัสของคุณทำงานได้ตามที่ตั้งใจไว้
รหัสของคุณได้รับรถหรือ ข้อบกพร่องในการที่พวกคุณทุกคน
ในการใช้ห้องสมุด CS50, ได้รับการรั่วไหลของหน่วยความจำ
คุณได้รับการขอให้ระบบปฏิบัติการ สำหรับหน่วยความจำในส่วนของโปรแกรม
ที่คุณเขียน แต่คุณได้ ไม่เคยได้รับจริงมันกลับมา
คุณได้เรียกว่า GetString และ GetInt และ GetFloat,
แต่มี GetString คุณได้ ไม่เคยเรียก unGetString หรือให้
String กลับหรือชอบ แต่ที่เราได้เห็น ที่ GetString ไม่จัดสรรหน่วยความจำ
โดยวิธีการนี​​้หรือ malloc realloc ฟังก์ชั่นซึ่งเป็นเพียง
คล้ายกันมากในจิตวิญญาณ และยังเราได้รับ
ขอให้ระบบปฏิบัติการสำหรับ หน่วยความจำและหน่วยความจำอีกครั้งและอีกครั้ง
แต่ไม่เคยให้มันกลับมา
>> ขณะนี้เป็นกันปรากฎว่า เมื่อโปรแกรมจบการทำงานทั้งหมดของหน่วยความจำ
เป็นอิสระโดยอัตโนมัติ
ดังนั้นจึงไม่ได้รับการจัดการที่มีขนาดใหญ่
มันไม่ได้ไปทำลาย IDE หรือสิ่งที่ช้าลง
แต่เมื่อโปรแกรมทำ โดยทั่วไปหน่วยความจำรั่ว
และพวกเขากำลังทำงานเป็นเวลานาน
ถ้าคุณเคยเห็นเล็ก ๆ น้อย ๆ ที่โง่ ลูกบอลชายหาดใน Mac OS หรือนาฬิกาทราย
บน Windows ที่มันเป็นชนิดของ การชะลอตัวลงหรือความคิดหรือความคิด
หรือเพียงแค่เริ่มต้นจริงๆ ที่จะชะลอตัวในการรวบรวมข้อมูล,
มันมากอาจจะเป็น ผลของการรั่วไหลของหน่วยความจำ
โปรแกรมเมอร์ที่เขียน ซอฟแวร์ที่คุณใช้
ขอให้ระบบปฏิบัติการสำหรับหน่วยความจำ ทุกไม่กี่นาทีทุกชั่วโมง
แต่ถ้าคุณใช้ ซอฟแวร์ถึงแม้ว่ามันจะเป็น
ลดลงในเครื่องคอมพิวเตอร์ของคุณ สำหรับชั่วโมงหรือวันที่สิ้นสุด
คุณอาจจะขอเพิ่มเติมและอื่น ๆ หน่วยความจำและไม่เคยใช้มันจริง
และเพื่อให้รหัสของคุณอาจจะมีหรือ โปรแกรมอาจจะมีหน่วยความจำรั่ว
และถ้าคุณเริ่มที่จะรั่วไหลของหน่วยความจำ มีหน่วยความจำน้อยสำหรับโปรแกรมอื่น ๆ
และผลกระทบที่จะ ทุกอย่างช้าลง
>> ตอนนี้คือไกลโดยหนึ่ง โปรแกรมที่เลวร้ายที่สุด
คุณจะมีโอกาส ที่จะทำงานใน CS50 ตราบเท่า
เป็นผลผลิตของตนแม้จะลึกลับมากกว่า เสียงดังกราวหรือทำให้หรือใด ๆ ของคำสั่ง
โปรแกรมบรรทัดที่เราเคยทำงานมาก่อน แต่ โชคดีที่ฝังตัวอยู่ในเอาท์พุท
คือบางส่วนเคล็ดลับที่เป็นประโยชน์สุดที่ จะเป็นประโยชน์ทั้งสำหรับ PSet สี่
หรืออย่างแน่นอน PSet ห้า
valgrind ดังนั้นเป็นเครื่องมือ ที่สามารถนำมาใช้ในการมอง
การรั่วไหลของหน่วยความจำในโปรแกรมของคุณ
มันค่อนข้างง่ายที่จะทำงาน
คุณเรียกใช้ valgrind แล้วแม้ แม้ว่ามันจะเป็นความละเอียดเล็ก ๆ น้อย ๆ
รีบตรวจสอบการรั่วไหลของประ เท่ากับเต็มแล้วจุด
เฉือนและชื่อของโปรแกรมของคุณ
ดังนั้น valgrind จะเรียกใช้โปรแกรมของคุณ และในท้ายสุดของโปรแกรมของคุณ
ทำงานก่อนที่จะจบการทำงานและ จะช่วยให้คุณพร้อมรับคำอื่น
มันจะวิเคราะห์ของคุณ โปรแกรมในขณะที่มันถูกใช้
และบอกคุณคุณไม่รั่วไหล หน่วยความจำใด ๆ และยังดีกว่า
คุณไม่ได้สัมผัสหน่วยความจำที่ ไม่ได้อยู่กับคุณหรือไม่
มันไม่สามารถจับทุกอย่าง แต่ก็ สวยดีที่จับสิ่งที่มากที่สุด
>> ดังนั้นนี่คือตัวอย่างของการทำงานที่มีของฉัน โปรแกรมนี้มีการทำงาน valgrind,
ในโปรแกรมที่เรียกว่า หน่วยความจำและฉันจะ
เพื่อเน้นเส้นที่มี ในที่สุดความสนใจของเรา
เพื่อให้มีการรบกวนมากยิ่งขึ้น ที่ฉันได้ลบออกจากสไลด์
แต่ขอเพียงแค่เห็นสิ่งนี้ โปรแกรมมีความสามารถในการบอกเรา
มันเป็นความสามารถในการบอกเล่าสิ่งที่ เช่นการเขียนที่ไม่ถูกต้องขนาด 4
ในคำอื่น ๆ ถ้าคุณสัมผัสหน่วยความจำ โดยเฉพาะ 4 ไบต์หน่วยความจำ
ที่คุณไม่ควรจะมี valgrind สามารถบอกคุณได้ว่า
เขียนไม่ถูกต้องขนาด 4
คุณสัมผัสสี่ไบต์ ที่คุณไม่ควรจะมี
ในกรณีที่คุณไม่ทำเช่นนั้น?
นี่คือความงาม
หน่วยความจำจุดเส้นค 21 เป็นที่ที่คุณ เมาขึ้นและที่ว่าทำไมมันเป็นประโยชน์
เหมือน GDB ก็สามารถช่วยให้ ชี้ให้คุณที่เกิดขึ้นจริงข้อผิดพลาด
>> ตอนนี้คนนี้เป็นน้อยมาก อย่างละเอียดหากไม่ได้ทำให้เกิดความสับสน
40 ไบต์ใน 1 บล็อกเป็นมั่นเหมาะ หายไปในบันทึกการสูญเสีย 1 จากทั้งหมด 1
นั่นหมายความว่าอย่างไร?
ดีมันก็หมายความว่าคุณถามหา 40 ไบต์และคุณไม่เคยให้มันกลับมา
คุณเรียก malloc หรือที่เรียกว่า GetString และระบบปฏิบัติการ
ให้คุณ 40 ไบต์ แต่คุณไม่เคย หรือได้รับการปล่อยตัวเป็นอิสระที่หน่วยความจำ
และเพื่อความเป็นธรรมที่เราไม่เคยแสดง วิธีการที่จะให้กลับไปหน่วยความจำ
เปิดออกมีซุปเปอร์ ฟังก์ชั่นที่เรียบง่ายที่เรียกว่าฟรี
ใช้เวลาหนึ่งอาร์กิวเมนต์สิ่ง คุณต้องการที่จะเป็นอิสระหรือให้กลับ
แต่ 40 ไบต์เห็นได้ชัด ในโปรแกรมนี้
ได้รับการสูญเสียที่เส้น 20 ของหน่วยความจำจุดค
>> ดังนั้นเรามาดูโปรแกรมนี้
มันไม่มีประโยชน์สุด
มันแสดงให้เห็นถึง ข้อผิดพลาดนี้โดยเฉพาะอย่างยิ่ง
ดังนั้นลองมาดู
นี่คือหลักและหลักแจ้งให้ทราบล่วงหน้าโทร ฟังก์ชั่นที่เรียกว่าฉแล้วผลตอบแทน
ดังนั้นไม่ได้ทั้งหมดที่น่าสนใจ
ฉไม่ทำอะไร?
แจ้งให้ทราบผมไม่ได้รำคาญกับต้นแบบ
ผมอยากจะให้รหัส เป็นน้อยที่สุดเท่าที่จะทำได้
ดังนั้นผมจึงใส่ฉข้างต้นหลักและ ที่ดีอย่างแน่นอน
สำหรับโปรแกรมสั้น ๆ เช่นนี้
ดังนั้นฉไม่กลับอะไรและไม่ ได้ใช้อะไร แต่มันก็ไม่ทำเช่นนี้
มันบอกเหมือน ในตัวอย่างบิงกี้
ตัวชี้ที่เรียกว่า x ที่จะ ในการจัดเก็บที่อยู่ของ int ที่
ดังนั้นที่ด้านซ้ายมือ
ในภาษาอังกฤษสิ่งที่เป็น ด้านขวามือทำ?
ใคร?
นี้จะทำอะไรสำหรับเรา?
ใช่?
>> ผู้ชม: [ไม่ได้ยิน] เท่าของ int ที่
ซึ่งเป็นครั้งที่ 10 [ไม่ได้ยิน]
DAVID ลัน: ดีและแจ้งให้เราสรุป
ดังนั้นการจัดสรรพื้นที่มากพอสำหรับ 10 จำนวนเต็ม หรือ 10 สิ่งที่ขนาดของ int ที่,
มันเป็นสี่ไบต์ดังนั้น 10 ครั้งที่ 4 40 เพื่อให้ด้านขวามือที่ฉันได้
ไฮไลต์คือการให้ฉัน 40 ไบต์และ เก็บที่อยู่ของไบต์แรก
เข้า x
และตอนสุดท้ายและนี่คือที่ โปรแกรมนี้เป็นรถอะไร
ผิดกับสาย 21 บนพื้นฐานของตรรกะที่?
มีอะไรผิดปกติกับสาย 21?
ใช่?
ผู้ชม: คุณไม่สามารถ ดัชนีลงใน x [ไม่ได้ยิน]
DAVID ลัน: ใช่
ฉันไม่ควรดัชนีลงใน x เช่นนั้น
ดังนั้น syntactically ที่ตกลง
มีอะไรที่ดีคือเหมือนคุณ สามารถรักษาชื่อของอาร์เรย์
ราวกับว่ามันเป็นตัวชี้ในทำนองเดียวกัน คุณสามารถรักษาตัวชี้ราวกับว่ามันเป็น
อาร์เรย์และดังนั้นผมจึงสามารถ syntactically พูดอะไรบางอย่าง x วงเล็บวงเล็บ x i,
แต่เป็นปัญหาที่ 10
ทำไม?
>> ผู้ชม: เพ​​ราะมันไม่ได้อยู่ใน
>> DAVID ลัน: มันไม่ได้ ภายในก้อนของหน่วยความจำที่
มีอะไรค่าที่ใหญ่ที่สุดที่ฉันควรจะ จะใส่ในวงเล็บเหลี่ยมเหล่านั้นหรือไม่
9 0 ถึง 9
เพราะเป็นศูนย์การจัดทำดัชนี
ดังนั้น 0 ถึง 9 จะปรับ
Bracket 10 ไม่ดีและ แต่จำได้ว่าทุกครั้งที่
ฉันดูเหมือนจะพยายามที่จะทำให้ CS50 IDE ความผิดพลาดโดยการพิมพ์ค่าปลอม
ไม่เคยให้ความร่วมมือ และแน่นอนคุณมักจะ
ได้รับโชคดีเพียงเพราะ ระบบปฏิบัติการที่ไม่ได้
สังเกตเห็นว่าคุณเคยดังนั้นเล็กน้อย ผ่านก้อนบางส่วนของหน่วยความจำ
เพราะคุณอยู่ภายในในทางเทคนิค ส่วนของคุณ แต่เพิ่มเติมว่า
ในชั้นเรียนระบบปฏิบัติการ และอื่น ๆ บางอย่างเช่นนี้
ได้อย่างง่ายดายมากสามารถไปตรวจไม่พบ
โปรแกรมของคุณไม่เคยไปผิดพลาด อย่างต่อเนื่อง แต่อาจจะครั้งในชั่วขณะหนึ่ง
>> ดังนั้นลอง valgrind เกี่ยวกับเรื่องนี้และนี่คือ
ที่เราจะได้รับจม โดยการส่งออกไปชั่วขณะ
เพื่อให้ตรวจสอบการรั่วไหลของหน่วยความจำ valgrind เท่ากับจุดเต็มหน่วยความจำเฉือน
และนี่คือเหตุผลที่ผมสัญญาว่า นี้จะครอบงำ
นี่คือสิ่งที่ valgrind นี่คือสิ่งที่ โปรแกรมเมอร์หลายปี ago-
ตัดสินใจว่ามันจะเป็นความคิดที่ดี สำหรับการส่งออกให้มีลักษณะเหมือน
ดังนั้นขอให้ความรู้สึกนี้
ดังนั้นทุกทางด้านซ้ายมือ ด้านไม่มีเหตุผลที่ดี
เป็นกระบวนการ ID ของโปรแกรม เราเพียงแค่เรียกใช้ตัวบ่งชี้เฉพาะ
สำหรับโปรแกรมที่เราเพิ่งวิ่ง
เราลบจาก สไลด์ แต่มี
เป็นข้อมูลที่เป็นประโยชน์ในที่นี่
>> ขอเลื่อนขึ้นไปด้านบนสุด
นี่คือสิ่งที่เราเริ่ม
ดังนั้นจึงไม่ได้ทั้งหมดที่ส่งออกมาก
นี่เป็นเรื่องที่ไม่ถูกต้องในการเขียน ขนาด 4 ในบรรทัดที่ 21
ดีสิ่งที่เป็นสาย 21?
สาย 21 ตรง นี้และมันทำให้รู้สึก
ที่ผมอยู่ในการสั่งจ่ายยา เขียน 4 ไบต์เพราะฉัน
พยายามที่จะนำจำนวนเต็มนี้ ซึ่งอาจจะเป็นอะไร
มันก็จะเกิดขึ้น ศูนย์ แต่ฉันพยายาม
ที่จะนำมันที่สถานที่ ที่ไม่ได้อยู่กับผม
นอกจากนี้ที่นี่ 40 ไบต์ในหนึ่ง บล็อกจะหายไปแน่นอนใน 1 รายการ
นั่นเป็นเพราะเมื่อผมเรียก malloc ที่นี่ผมไม่เคยเป็นอิสระของหน่วยความจำ
>> ดังนั้นวิธีที่เราสามารถแก้ไขปัญหานี้?
ให้ฉันไปข้างหน้าและจะมีความปลอดภัยน้อย และจะมี 9 และแจ้งให้เราที่นี่ฟรี x
นี้เป็นฟังก์ชั่นใหม่สำหรับวันนี้
ถ้าตอนนี้ผมเรียกให้หน่วยความจำเฉือนจุด ขอเรียก valgrind กับมันอีกครั้ง
เพิ่มหน้าต่างของฉันและกด Enter
ตอนนี้มันเป็นสิ่งที่ดี
พวกเขาฝังข่าวดี ในทุกการแสดงผลนี้
บล็อกกองทุกคนฟรี
เราจะกลับมากับสิ่งที่กอง แต่ไม่มีการรั่วไหลที่เป็นไปได้
ดังนั้นนี่เป็นเพียงอีกหนึ่ง เครื่องมือสำหรับชุดเครื่องมือของคุณ
ที่คุณสามารถเริ่มต้นที่จะ หาข้อผิดพลาดในขณะนี้เช่นเดียวกับที่
>> แต่ขอดูสิ่งที่ อื่น ๆ อีกมากมายสามารถไปผิดที่นี่
การเปลี่ยนแปลงตอนนี้ขอไป จริงการแก้ปัญหา
เช่นกันว่าจะบรรเทา นิด ๆ หน่อย ๆ ของความสับสนหรือความตึงเครียด
นี้คือตอนนี้ตลก
ใช่
นั่นเป็นสิ่งที่ดีงาม
เพราะเป็นตัวชี้ ที่อยู่และที่อยู่
โดยทั่วไปมักจะโดยการประชุม เขียนด้วยเลขฐานสิบหก
ฮ่านี้เป็นเรื่องตลกในขณะนี้
ทั้งนี้เพื่อให้ในขณะนี้ จริงแก้ปัญหา
นี้ได้รับสุด ซุปเปอร์ระดับต่ำป่านนี้
และเราสามารถทำได้จริงมีประโยชน์ สิ่งที่มีรายละเอียดเหล่านี้ในระดับต่ำ
>> ดังนั้นเราจึงแนะนำเพียงไม่กี่สัปดาห์ ที่ผ่านมาความคิดของอาร์เรย์
อาร์เรย์เป็นดีเพราะ มันยากที่จะทำความสะอาดรหัสของเรา
เพราะถ้าเราต้องการที่จะเขียน โปรแกรมที่มีนักเรียนหลาย
หรือหลายชื่อและที่บ้าน หอพักและวิทยาลัยและทั้งหมดที่
เราจะเก็บทุกอย่างมากขึ้น เรียบร้อยภายในอาร์เรย์
แต่ข้อเสียเสนอหนึ่ง ของอาร์เรย์ป่านนี้
แม้ว่าคุณจะได้รับความเดือดร้อนไม่ได้ด้วยตัวคุณเอง ในโปรแกรมเพียงสัญชาตญาณ
สิ่งที่เป็นสิ่งที่ไม่ดี เกี่ยวกับอาร์เรย์บางที?
ฉันได้ยินเสียงพึมพำบางอย่าง
ผู้ชม: มันยาก การเปลี่ยนขนาด
DAVID ลัน: มันเป็นเรื่องยาก การเปลี่ยนขนาด
คุณไม่สามารถเปลี่ยนขนาด ของอาร์เรย์ในความเป็นจริงต่อ
ใน C. คุณสามารถจัดสรรอาร์เรย์อื่น ย้ายทุกอย่างจากคนเก่า
เข้าไปใหม่และตอนนี้ มีพื้นที่พิเศษ
แต่ก็ไม่ชอบ ภาษาเช่น Java หรืองูหลาม
หรือจำนวนอื่น ๆ ภาษาที่บางส่วนของคุณ
อาจจะคุ้นเคยที่คุณ ก็สามารถเก็บเพิ่มสิ่ง
nauseam โฆษณาไปยังจุดสิ้นสุดของอาร์เรย์
เมื่อคุณมีอาร์เรย์ของ ขนาด 6 ซึ่งก็คือขนาดของมัน
และอื่น ๆ อีกเช่นความคิดที่ก่อนหน้านี้ มีบัฟเฟอร์ที่มีขนาดบางอย่าง
คุณมีที่จะคาดเดาออกจากประตู สิ่งที่ขนาดที่คุณอยากให้มันเป็นอย่างไร
ถ้าคุณคิดว่าใหญ่เกินไป คุณกำลังสูญเสียพื้นที่
ถ้าคุณคิดว่าเล็กเกินไปคุณ ไม่สามารถเก็บข้อมูลได้ว่าอย่างน้อย
โดยไม่ต้องทำงานมากขึ้น
>> ดังนั้นวันนี้ต้องขอบคุณคำแนะนำเราสามารถ เริ่มต้นที่กำหนดเองเย็บเข้าด้วยกันของเราเอง
โครงสร้างข้อมูลและใน ความเป็นจริงนี่คือสิ่งที่
ที่มีลักษณะเล็ก ๆ น้อย ๆ ความลับได้อย่างรวดเร็วก่อน
แต่นี่คือสิ่งที่เราจะเรียกการเชื่อมโยง รายการและชื่อชนิดของการสรุป
มัน
มันเป็นรายการของตัวเลขหรือใน กรณีนี้รายการของตัวเลข
แต่มันอาจจะเป็นรายการอะไร แต่ มันเชื่อมโยงกันโดยวิธีการของลูกศร
และใช้เวลาเพียงแค่คาดเดา ด้วยเทคนิคสิ่งที่
เราจะสามารถ เพื่อตะเข็บด้วยกัน
ประเภทเช่นข้าวโพดคั่วกับด้าย สี่เหลี่ยมรายการที่เชื่อมโยงที่นี่?
ตัวเลขของตนหรือไม่
คุณลักษณะภาษาพื้นฐานคืออะไร?
>> ผู้ชม: ตัวชี้
>> DAVID ลัน: ตัวชี้
ดังนั้นแต่ละลูกศรเหล่านี้แสดงให้เห็นถึงที่นี่ ตัวชี้หรือเพียงแค่ที่อยู่
ดังนั้นในคำอื่น ๆ ถ้าฉันต้องการ ในการจัดเก็บรายชื่อของตัวเลข
ผมก็ไม่สามารถเก็บไว้ถ้าผมต้องการ ความสามารถในการเติบโตและหดตัว
โครงสร้างข้อมูลของฉันในอาร์เรย์
ดังนั้นผมจึงจำเป็นต้องมีเล็ก ๆ น้อย ๆ ความซับซ้อนมากขึ้น
แต่แจ้งให้ทราบว่า ภาพที่แสดงให้เห็นชนิดของ
ว่าถ้าคุณได้เพียงแค่หัวข้อเล็ก ๆ น้อย ๆ เชื่อมต่อทุกอย่างเข้าด้วยกัน
อาจจะไม่ยากที่จะทำให้พื้นที่ ในระหว่างสองสี่เหลี่ยมเหล่านั้น
หรือสองของโหนดเหล่านั้นที่เราจะเริ่มต้น เรียกพวกเขาใส่ในโหนดใหม่
แล้วกับบางหัวข้อใหม่เพียง คลองสามโหนดด้วยกัน
คนแรกคนสุดท้ายและคน ที่คุณเพิ่งแทรกเข้าไปตรงกลาง
>> และแน่นอนรายการเชื่อมโยง ซึ่งแตกต่างจากอาร์เรย์เป็นแบบไดนามิก
มันสามารถเติบโตและสามารถ หดตัวและคุณทำไม่ได้
ต้องรู้หรือการดูแลล่วงหน้าว่า ข้อมูลที่คุณกำลังจะได้รับการจัดเก็บ
แต่ปรากฎว่าเราจะต้องมีเล็ก ๆ น้อย ๆ โปรดใช้ความระมัดระวังเกี่ยวกับวิธีการดำเนินการนี​​้
ดังนั้นก่อนให้พิจารณาวิธีการที่เราใช้ หนึ่งในรูปสี่เหลี่ยมเล็ก ๆ น้อย ๆ เหล่านี้
มันเป็นเรื่องง่ายที่จะใช้เป็น int
คุณเพียงแค่บอกว่า int n แล้​​ว คุณจะได้รับ 4 ไบต์สำหรับ int ที่
แต่วิธีการที่ฉันจะได้รับ int ที่เรียกว่า n, แล้วชี้ขอเรียกมันต่อไป
เราสามารถเรียกเหล่านี้ สิ่งที่เราต้องการอะไร
แต่ผมจำเป็นต้องมีโครงสร้างข้อมูลที่กำหนดเอง
ใช่?
>> ผู้ชม: สัญลักษณ์ [ไม่ได้ยิน]
>> DAVID ลัน: ดังนั้นเครื่องหมายที่เราจะใช้ในการ ได้รับที่อยู่ของโหนดที่อาจเกิดขึ้น
แต่เราจำเป็นอีก คุณลักษณะของ C ในการสั่งซื้อ
จะให้ฉันสามารถในการสร้าง สี่เหลี่ยมผืนผ้าที่กำหนดเองนี้นี้เอง
ตัวแปรถ้าคุณจะในความทรงจำ
ผู้ชม: struct
DAVID ลัน: struct
จำจากสัปดาห์ที่แล้วเราได้แนะนำ struct นี้คำหลักที่ค่อนข้างง่าย
ที่ช่วยให้เราทำสิ่งนี้
C ไม่ได้มาพร้อมกับข้อมูลที่ โครงสร้างที่เรียกว่านักเรียน
มันมาพร้อมกับ int และลอยและถ่านและ ดังกล่าว แต่ก็ไม่ได้มาพร้อมกับนักเรียน
แต่เราสามารถสร้างชนิดข้อมูลนักเรียน โครงสร้างของนักเรียนที่มีรูปแบบนี้
ที่นี่
และคุณจะเห็นนี้อีกครั้งและอีกครั้ง
จึงไม่ต้องกังวลเกี่ยวกับ จำคำหลัก
แต่คำหลักที่สำคัญคือ เพียงแค่ความจริงที่ว่าเรากล่าวว่าที่ struct
และจากนั้นเราเรียกมันว่านักเรียนและภายใน ของนักเรียนเป็นชื่อและที่บ้าน
หรือหอพักหรือชอบ
>> และตอนนี้ดังนั้นวันนี้ขอนำเสนอนี้
ฉันได้เพิ่มคำไม่กี่คำ แต่ถ้าฉันต้องการ ที่จะใช้รูปสี่เหลี่ยมผืนผ้านี้ที่
มีทั้ง int และ ตัวชี้คุณรู้ว่าสิ่งที่ฉัน
จะประกาศโครงสร้างที่เรียกว่าโหนด
ฉันยังภายในของมันจะบอกว่า ที่โหนดสี่เหลี่ยมนี้มีอยู่ int
และเราจะเรียกมันว่า n และ มีตัวชี้ต่อไป
และนี่เป็นเพียงเล็กน้อยอย่างละเอียด, แต่ถ้าคุณคิดเกี่ยวกับมัน
ลูกศรที่อยู่ในภาพ ช่วงเวลาที่ผ่านมาเป็นสิ่งที่ประเภทข้อมูล?
ที่แต่ละของลูกศรชี้เหล่านั้น เพื่อสิ่งที่ประเภทของโครงสร้างข้อมูล?
มันไม่ได้เป็นเพียงแค่ชี้ไป int ต่อ
มันชี้ไปที่ ทั้งสิ่งที่เป็นรูปสี่เหลี่ยมผืนผ้า
และสิ่งที่เป็นรูปสี่เหลี่ยมผืนผ้า เรากล่าวว่าจะเรียกว่าโหนด
และเพื่อให้เราชนิดของต้อง ซ้ำกำหนดเช่นนี้
โหนดที่เราจะพูดว่า จะมี int เรียกว่า n
และตัวชี้ที่เรียกว่าต่อไปและ ชนิดของโครงสร้างข้อมูลที่
ชี้จุดที่เห็นได้ชัดคือ จะเป็นโหนด struct
>> ดังนั้นนี่คือ verbose annoyingly และก็จะอวดความรู้
เหตุผลที่ว่าทำไมเราไม่สามารถ เพียงแค่พูดว่านี้ซึ่งตรงไปตรงมา
ดูมากอ่านได้มากขึ้น เป็นเพราะการเรียกคืนที่ C อ่าน
สิ่งบนลงล่างซ้ายไปขวา
มันไม่ได้จนกว่าเราจะได้รับอัฒภาค ที่โหนดคำที่มีอยู่จริง
ดังนั้นหากเราต้องการที่จะมีการจัดเรียงของนี้ อ้างอิงวัฏจักรภายในของข้อมูล
โครงสร้างเราจะต้องทำเช่นนี้ที่ เราบอกว่าโหนด struct ที่ด้านบนที่
ทำให้เรามีวิธีการอธิบายอีกต่อไปนี้ สิ่งที่แล้วเราบอกว่าภายในโหนด struct,
แล้วที่บรรทัดสุดท้าย เราพูดสิ่งที่ถูกต้อง, C, โดยวิธีการที่
เพียงโทรนี้แช่งทั้ง สิ่งโหนดและหยุด
โดยใช้โครงสร้างคำหลักทั้งหมด
ดังนั้นนี้เป็นเพียงการเรียงลำดับของประโยค เคล็ดลับที่ว่าในท้ายที่สุดจะช่วยให้เราสร้าง
บางสิ่งบางอย่างที่มีลักษณะเช่นนี้ว่า
>> ดังนั้นถ้าเราคิดที่เราสามารถทำได้ในขณะนี้ ใช้สิ่งนี้ในซี
ทำอย่างไรเราจริง เริ่มต้นภายในนี้หรือไม่?
ดีในความเป็นจริงทั้งหมดที่เราต้องทำคือ ย้ำจากซ้ายไปขวาและเพียงแค่
ชนิดของการแทรกโหนดหรือลบโหนด หรือค้นหาสิ่งใดก็ตามที่เราต้องการ
แต่การทำเช่นนี้ให้เป็นไปข้างหน้าและทำให้ สิ่งเล็ก ๆ น้อย ๆ จริงมากขึ้นเพราะ
ได้รับซุปเปอร์ระดับต่ำป่านนี้
ทุกคนจะชอบอย่างแท้จริงเป็นครั้งแรก?
ตกลง.
มาขึ้น
คุณชื่ออะไร?
>> เดวิด: เดวิด
DAVID ลัน: เดวิด
ยินดีที่ได้พบคุณ.
ฉันด้วย.
ทั้งหมดขวา
และเราต้องมีหมายเลข 9
ไม่ดีเท่าครั้งแรกอาจจะ
ตกลงจำนวน 9
จำนวน 17 โปรด
ผมขอกลับไปไกลออกไปเล็กน้อย
จำนวน 22 โปรดและ วิธีการเกี่ยวกับไกลออกไปกลับ
ถ้าฉันสามารถดูมือใด ๆ กับแสงหรือไม่มีเลย
ใครบางคนที่ถูกอาสาสมัครที่นั่น
คุณต้องการที่จะเกิดขึ้น?
แขนของคุณจะถูกบังคับให้ไปขึ้น
ตกลง 17
22
26 ลงมา
คนอื่นต้องการที่จะ forcefully-- มาขึ้น
อาสาสมัครที่เกิดขึ้นจริง
>> ดังนั้นอย่างรวดเร็วถ้า พวกคุณสามารถจัด
เช่นเดียวกับตัวเอง โหนดบนหน้าจอ
ขอขอบคุณ.
และคุณจะได้ 26
สิ่งที่ถูกต้องและการแนะนำอย่างรวดเร็ว
ดังนั้นฉันเดวิดและคุณยัง?
เดวิด: เดวิด
DAVID ลัน: และคุณคืออะไร?
JAKE: เจค
ซู: บางซื่อ
อเล็กซ์: อเล็กซ์
ราฟาเอล: ราฟาเอล
TAYLOR: เทย์เลอร์
DAVID ลัน: เทย์เลอร์
ที่ดีเยี่ยม
ดังนั้นเหล่านี้เป็นอาสาสมัครของเรา สำหรับวันนี้และไปข้างหน้า
และเปลี่ยนเล็ก ๆ น้อย ๆ วิธีการที่ และเพียงแค่ไปข้างหน้าและให้
ถือหมายเลขของคุณในขณะที่คุณอยู่หรือ สัญญาณแรกและการใช้มือซ้ายของคุณ
ไปข้างหน้าและใช้เพียง ลูกศรเหล่านี้เพียง
เพื่อให้มือซ้ายของคุณเป็นตัวอักษร ชี้ไปที่สิ่งที่คุณควรจะชี้
ที่และให้ตัวเองเพื่อให้ห้องพักบางส่วน เราสายตาสามารถมองเห็นแขนของคุณจริง
ชี้และคุณก็สามารถชี้ การจัดเรียงของที่พื้นจะปรับ
>> ดังนั้นที่นี่เรามีรายการที่เชื่อมโยงหนึ่ง สองสามสี่ห้าโหนดแรก
และแจ้งให้ทราบว่าเรามีพิเศษนี้ ชี้ที่จุดเริ่มต้นที่เป็น
ที่สำคัญเพราะเรามีการติดตาม ของรายการตลอดความยาวอย่างใด
พวกเหล่านี้ถึงแม้ว่าพวกเขาจะเหลือ ไปขวากลับไปกลับในหน่วยความจำ
พวกเขาเป็นจริงได้ทุกที่ ในหน่วยความจำของคอมพิวเตอร์
ดังนั้นคนเหล่านี้อาจจะเป็น ยืนอยู่ที่ใดก็ได้บนเวที
และที่ดีตราบใดที่พวกเขากำลัง จริงชี้ไปที่อีกคนหนึ่ง
แต่เพื่อให้สิ่งที่ สะอาดและเรียบง่ายเราจะ
พวกเขาเพียงแค่วาดจากซ้ายไปขวาเช่น นี้ แต่อาจจะมีช่องว่างขนาดใหญ่
ในระหว่างโหนดเหล่านั้น
>> ตอนนี้ถ้าผมต้องการที่จะใส่จริงบางอย่าง ค่าใหม่ให้เป็นไปข้างหน้าและทำเช่นนี้
เรามีโอกาสที่ในขณะนี้ การเลือกโหนดอื่น
กล่าวว่าขอเริ่มต้นด้วย mallocing 55
คนจะคิดเป็น malloc?
ตกลงมาขึ้น
คุณชื่ออะไร?
RAINBOW: สายรุ้ง
DAVID ลัน: เรนโบว์?
ทั้งหมดขวา
malloc สายรุ้ง
มาขึ้น
ดังนั้นตอนนี้เราต้องถามตัวเอง อัลกอริทึมที่เราสามารถใส่ 55
ดังนั้นพวกเราทุกคนรู้ว่า เห็นได้ชัดว่าที่เธออาจ
ถ้าเป็นของที่เรากำลังพยายาม เพื่อให้นี้แยก
และถ้าพวกคุณอาจจะใช้อย่างใดอย่างหนึ่ง ย้อนกลับไปเพื่อให้เราไม่ตกออก
เวทีว่าจะดี
ดังนั้นจริงสายรุ้ง เริ่มต้นที่นี่กับฉัน
เพราะเราเป็นคอมพิวเตอร์ในขณะนี้สามารถ เห็นเพียงตัวแปรหนึ่งที่เวลา
ดังนั้นถ้าเป็นโหนดแรก
ขอให้สังเกตว่าเขาไม่โหนด เขาเป็นเพียงตัวชี้
และที่ว่าทำไมเขาดึงไปเป็น เพียง แต่ขนาดของตัวชี้ไม่
หนึ่งในผู้ที่เต็มรูปสี่เหลี่ยม
ดังนั้นเราจะไปตรวจสอบในแต่ละ ย้ำ 55 น้อยกว่า 9?
เลขที่
55 น้อยกว่า 17
เลขที่
น้อยกว่า 22?
น้อยกว่า 26?
น้อยกว่า 34?
และดังนั้นตอนนี้เห็นได้ชัด รุ้งเป็นที่สิ้นสุด
ดังนั้นเพื่อให้มีความชัดเจนและสิ่งที่ เป็นชื่อของเทย์เลอร์?
>> TAYLOR: เทย์เลอร์
DAVID ลัน: ดังนั้นในหมู่เทย์เลอร์ มือซ้ายและมือของสายรุ้งที่นี่
ที่มีความต้องการที่จะใช้มือชี้ไปที่สิ่งที่อยู่ใน สั่งซื้อที่จะแทรกเข้าไปใน 55 รายการนี​​้
เราต้องทำอย่างไร?
ใช่?
>> ผู้ชม: เทย์เลอร์มือ ความต้องการที่จะชี้ซ้าย
>> DAVID ลัน: แน่นอน
ดังนั้นการแทรกโหนด เป็นจุดสิ้นสุดของรายการ
สวยเรียบง่ายเพราะเพียงแค่เทย์เลอร์ มีการจุดแทนการที่พื้น
หรือเราจะเรียกมันว่าเป็นโมฆะ null เป็นประเภทของการขาด
ของตัวชี้หรือพิเศษ ศูนย์ชี้คุณ
ไปชี้ซ้ายของคุณ มือที่เรนโบว์แล้วสายรุ้ง
ที่ควรซ้ายของคุณ มืออาจชี้?
ลงมา
มันไม่ดีถ้ามือของเธอคือการจัดเรียง ชี้ลงที่นี่หรือประเภทใด ๆ
ทางไหน.
ที่จะได้รับการพิจารณา ค่าขยะ
แต่ถ้าเธอชี้ไปที่ บางค่าที่รู้จักกันเราจะ
เรียกว่าเป็นศูนย์หรือ null ที่ตกลง เพราะเรามีในระยะนี้
และเรารู้ว่ารายการเสร็จสมบูรณ์แล้ว
>> ดังนั้นสิ่งที่เป็นอีก กรณีที่ค่อนข้างง่าย?
เราสามารถ malloc 5?
มาขึ้น
คุณชื่ออะไร?
TIFFANY: ทิฟฟานี่
DAVID ลัน: ฉันขอโทษ?
TIFFANY: ทิฟฟานี่
DAVID ลัน: ทิฟฟานี่
ทั้งหมดขวา
ทิฟฟานี่ได้รับการ malloced ที่มีมูลค่า 5
มาขึ้น
หนึ่งนี้ค่อนข้างง่ายเกินไป แต่ ขอพิจารณาเพื่อการดำเนินงานในขณะนี้ของ
มันเป็นเรื่องง่ายสวย กับเทย์เลอร์ในตอนท้าย
หมายเลข 5 เป็นหลักสูตรที่น้อยกว่า 9 และเพื่อให้เรามีเดวิดเรามีทิฟฟานี่
และสิ่งที่เป็นชื่อของคุณ?
>> JAKE: เจค
>> DAVID ลัน: เจค
ทิฟฟานี่, เจคและเดวิด
มือควรจะปรับปรุงครั้งแรก?
อะไรที่คุณต้องการจะทำที่นี่?
มีวิธีที่เป็นไปคู่ของ แต่ นอกจากนี้ยังมีหนึ่งหรือมากกว่าหนึ่งวิธีที่ไม่ถูกต้อง
>> ผู้ชม: เริ่มต้นด้วยซ้าย
>> DAVID ลัน: เริ่มต้นด้วยซ้ายสุด
ใครเป็นซ้ายที่นี่แล้ว?
ผู้ชม: ครั้งแรก
>> DAVID ลัน: OK
ดังนั้นเริ่มต้นด้วยการเป็นครั้งแรกและที่คุณทำ ต้องการปรับปรุงมือของดาวิดจะเป็น?
ผู้ชม: ต่อ 5
DAVID ลัน: OK
ดาวิดจุดที่ห้า หรือทิฟฟานี่ที่นี่และตอนนี้หรือไม่
>> ผู้ชม: ทิฟฟานี่ชี้ไปที่ 9
DAVID ลัน: เหมาะยกเว้นของบิงกี้ หัวเพียงแค่ชนิดของหล่นลงไปใช่มั้ย?
เพราะสิ่งที่ผิดปกติกับ ภาพที่แท้จริงนี้หรือไม่?
ผู้ชม: ไม่มีอะไรจะชี้
DAVID ลัน: ไม่มีอะไร ชี้ไปที่เจคนี้
เราได้กำพร้าอักษร 9 และ 17 และเราได้อย่างแท้จริง
การรั่วไหลของหน่วยความจำทั้งหมดนี้เพราะโดย ปรับปรุงมือเดวิดเป็นครั้งแรกที่
ปรับตราบเท่าที่มันถูกต้อง ชี้ไปที่ทิฟฟานี่ตอนนี้
แต่ถ้าไม่มีใครมี มองการณ์ไกลที่จะชี้ไปที่เจค
แล้วเราได้หายไป ครบถ้วนของรายการว่า
ดังนั้นขอยกเลิก
เพื่อให้เป็นสิ่งที่ดีที่ การเดินทางมากกว่า แต่ขอแก้ไขในขณะนี้
สิ่งที่เราควรทำก่อนแทน?
ใช่?
>> ผู้ชม: ทิฟฟานี่ควรจะชี้ที่ 9
DAVID ลัน: ฉันไม่สามารถ ได้รับที่ใกล้ชิดกับคุณ
ใครควรจะชี้ที่ 9
>> ผู้ชม: ทิฟฟานี่
>> DAVID ลัน: สิทธิทั้งหมด
ทิฟฟานี่ดังนั้นควรจุดแรกที่ 9
ดังนั้นควรใช้ทิฟฟานี่ ในค่าเหมือนกัน
ดาวิดซึ่งดูเหมือนว่า ซ้ำซ้อนสักครู่
แต่ที่ดีเพราะตอนที่สอง ขั้นตอนที่เราสามารถปรับปรุงมือของดาวิด
ที่จะชี้ไปที่ทิฟฟานี่และจากนั้นถ้า เราเพียงแค่ชนิดของสิ่งที่ทำความสะอาด
ราวกับว่านี้เป็นชนิดของฤดูใบไม้ผลิเหมือน ตอนนี้ที่แทรกที่ถูกต้อง
ดังนั้นที่ดีเยี่ยม
ดังนั้นตอนนี้เราเกือบจะมี
ลองใส่ครั้งสุดท้าย ค่าเช่นค่า 20
ถ้าเราสามารถ malloc หนึ่งในอาสาสมัครสุดท้าย?
มาขึ้น
ดังนั้นนี้เป็นเพียงเล็กน้อยยุ่งยากมากขึ้น
แต่จริงๆรหัสเรา เขียนแม้จะด้วยวาจา
เป็นเพียงเหมือนมีพวง ถ้าเงื่อนไขตอนนี้ใช่มั้ย?
เรามีเงื่อนไข ตรวจสอบว่ามันเป็น
ในตอนท้ายอาจจะเริ่มต้น
เราจำเป็นต้องมีชนิดของวงไปบางส่วน หาจุดที่อยู่ตรงกลาง
ดังนั้นขอให้ทำอย่างนั้นกับสิ่งที่เป็นชื่อของคุณ?
>> ERIC: เอริค
>> DAVID ลัน: เอริค?
เอริค
ยินดีที่ได้พบคุณ.
ดังนั้นเราจึงมี 20
น้อยกว่าห้า?
เลขที่
น้อยกว่าเก้า?
เลขที่
น้อยกว่า 17
เลขที่
ตกลง.
เขาเป็นคนที่นี่และ ชื่อของคุณอีกครั้งหรือไม่
ซู: บางซื่อ
DAVID ลัน: บางซื่อ
อเล็กซ์: อเล็กซ์
DAVID ลัน: ซูอเล็กซ์และ?
ERIC: เอริค
DAVID ลัน: เอริค
มือต้องได้รับการปรับปรุงครั้งแรก?
>> ผู้ชม: เอริค
ตกลง.
ดังนั้นเอริคที่ควรจะชี้ที่ไหน
วันที่ 22
ดี
และตอนนี้ทำอะไรต่อไป
ซูก็จะสามารถชี้ไปที่เอริค และตอนนี้ถ้าพวกคุณเพียง
ทำให้ห้องพักบางส่วนซึ่งเป็นเรื่องปกติ สายตาตอนนี้เราได้ทำแทรก
ดังนั้นตอนนี้ขอพิจารณาคำถาม แต่ ขอบคุณมากสำหรับอาสาสมัครของเรา
ทำได้ดีมาก
คุณสามารถเก็บเหล่านั้นหากคุณต้องการ
และเรามีของที่ระลึกน่ารักถ้าพรากจากกัน คุณต้องการแต่ละต้องการที่จะใช้ลูกความเครียด
ผมขอเพียงแค่ผ่านการลงนี้
ดังนั้นสิ่งที่เป็นประเด็นของเรื่องนี้?
นี้น่าจะเป็นที่น่าตื่นตาตื่นใจ ตราบเท่าที่เรามีตอนนี้
แนะนำทางเลือกไปยัง อาเรย์ที่ไม่ได้ จำกัด อยู่ดังนั้น
ไปยังอาร์เรย์ของขนาดคงที่บาง
พวกเขาสามารถเติบโตแบบไดนามิก
>> แต่เหมือนเราได้เห็นในสัปดาห์ที่ผ่านมา ที่ผ่านมาเราไม่เคยได้รับอะไรฟรี
เหมือนก็มีการออกนี่
ดังนั้นมี upside ที่เชื่อมโยง รายการเป็นพลวัตนี้หรือไม่?
ความสามารถในการเติบโตและตรงไปตรงมา เราจะได้ทำลบ
และเราอาจจะหดตัวตามความจำเป็น
อะไรราคาที่เราจ่ายเงิน?
ครั้งที่สองเป็นพื้นที่มากครั้งแรกของทั้งหมด
ถ้าคุณดูที่ภาพไม่ได้ ฉันเก็บรายชื่อของจำนวนเต็ม
ฉันเก็บรายชื่อของ จำนวนเต็มบวกชี้
ดังนั้นฉันเป็นสองเท่าของจำนวนเงินที่ของพื้นที่
ตอนนี้บางทีที่ไม่ได้เช่น เป็นเรื่องใหญ่ 4 ไบต์, 8 ไบต​​์
แต่แน่นอนสามารถเพิ่ม สำหรับชุดข้อมูลขนาดใหญ่
ข้อเสียมีอะไรอื่นได้หรือไม่
ใช่?
>> ผู้ชม: เราต้อง สำรวจพวกเขาหนึ่งโดยหนึ่ง
DAVID ลัน: ใช่
เรามีการสำรวจพวกเขาหนึ่งโดยหนึ่ง
คุณจะรู้ว่าสิ่งที่เราให้ขึ้นสุด คุณลักษณะที่สะดวกในวงเล็บเหลี่ยม
สัญกรณ์มากขึ้นอย่างถูกต้อง ที่รู้จักกันในการเข้าถึงแบบสุ่ม
ซึ่งเราก็สามารถกระโดด จะเป็นองค์ประกอบของแต่ละบุคคล
แต่ตอนนี้ถ้าผมยังคงมี อาสาสมัครของฉันที่นี่
ถ้าผมต้องการที่จะหา จำนวน 22 ฉันไม่สามารถเพียงแค่
ข้ามไปยังยึดบางสิ่งบางอย่างบางสิ่งบางอย่าง
ผมต้องมองผ่านรายการมาก ตัวอย่างเช่นการค้นหาของเราเป็นเส้นตรง
เพื่อหาจำนวน 22
ดังนั้นเราจึงดูเหมือนจะมีการจ่ายราคามี
แต่กระนั้นเราสามารถทำได้ แก้ปัญหาอื่น ๆ
>> ในความเป็นจริงให้ฉันแนะนำ เพียงไม่กี่ภาพ
ดังนั้นถ้าคุณได้รับการลงไป ท้องของฮอลล์เมื่อเร็ว ๆ นี้การรับประทานอาหาร
คุณจะจำได้ว่าพวกเขา สแต็คของถาดเช่นนี้
เรายืมมาจาก Annenberg ก่อนที่ชั้น
ดังนั้นสแต็คของถาดนี้แม้ว่า เป็นตัวแทนจริง
โครงสร้างข้อมูลของวิทยาการคอมพิวเตอร์
มีโครงสร้างข้อมูลเป็น วิทยาการคอมพิวเตอร์
ที่รู้จักกันเป็นกองที่อย่างมาก ยืมตัวเองไปว่าภาพนี้
ดังนั้นถ้าแต่ละถาดเหล่านี้ไม่ได้เป็น ถาด แต่ชอบเป็นจำนวนมากและฉันต้องการ
ในการจัดเก็บตัวเลขฉัน สามารถใส่อย่างใดอย่างหนึ่งลงที่นี่
และฉันสามารถใส่อีกลงที่นี่ และยังคงตัวเลขซ้อน
ด้านบนของอีกคนหนึ่งและสิ่งที่ ที่อาจเกิดขึ้นที่เป็นประโยชน์เกี่ยวกับเรื่องนี้
นั่นคือสิ่งที่หมาย ของโครงสร้างข้อมูลนี้หรือไม่?
ซึ่งจำนวนที่ฉันสามารถดึงออก สะดวกที่สุดครั้งแรก?
ล่าสุดหนึ่งสวมมี
>> ดังนั้นนี่คือสิ่งที่เราจะเรียก วิทยาการคอมพิวเตอร์ LIFO โครงสร้างข้อมูล
สุดท้ายในครั้งแรกออกมา
และเราจะเห็นว่าทำไมก่อนที่จะยาว ที่อาจจะมีประโยชน์ แต่สำหรับตอนนี้
เพียงแค่พิจารณาทรัพย์สิน
และมันเป็นชนิดของโง่ถ้าคุณคิด เกี่ยวกับวิธีการโรงอาหารไม่ได้
ทุกครั้งที่พวกเขาถาดที่สะอาดและ ใส่คนที่สดใหม่อยู่ด้านบน
คุณอาจจะมีการทำความสะอาดก่อนหน้านี้ แต่ในที่สุดก็มากสกปรกและเต็มไปด้วยฝุ่น
ถาดที่ด้านล่างสุด ถ้าคุณไม่จริง
ได้ที่ด้านล่างว่า กองเพราะคุณเพียงแค่
ให้วางใหม่และ คนทำความสะอาดด้านบนของมัน
สิ่งเดียวที่อาจจะเกิดขึ้น ในซูเปอร์มาร์เก็ตเกินไป
หากคุณมีกรณีการแสดงผล ของนมและ CVS ทุกเวลา
หรือใครก็ตามที่ได้รับนมมากขึ้น คุณเพียงแค่ซุกนม
คุณมีอยู่แล้วที่จะกลับมาและ คุณใส่ใหม่ขึ้นด้านหน้า
คุณกำลังจะมีบางอย่างที่น่ารังเกียจสวย นมในตอนท้ายของโครงสร้างข้อมูลที่
เพราะมันเป็นเสมอที่ด้านล่างหรือ เท่ามันเสมอที่ด้านหลัง
>> แต่มีวิธีการที่จะคิดเกี่ยวกับการอื่น แถวข้อมูลและเช่นนี้
หากคุณเป็นหนึ่งในคนเหล่านั้นที่ชอบ เข้าแถวด้านนอกของร้านค้าแอปเปิ้ล
เมื่อผลิตภัณฑ์ใหม่มา ออกคุณอาจ
ไม่ได้ใช้ข้อมูลที่กอง โครงสร้างเพราะคุณ
จะกลายเป็นคนอื่นที่เป็น แถวที่จะซื้อของเล่นใหม่บางส่วน
แต่คุณอาจใช้ สิ่งที่ชนิดของโครงสร้างข้อมูล
หรือสิ่งที่ชนิดของระบบ ในโลกจริงหรือไม่
หวังว่ามันเป็นเส้นหรือมากกว่า ถูกต้องหรือมากกว่าอังกฤษเหมือนคิว
และปรากฎคิวนอกจากนี้ยังเป็น โครงสร้างข้อมูลในวิทยาการคอมพิวเตอร์
แต่คิวมีมาก สถานที่ให้บริการที่แตกต่างกัน
มันไม่ได้ LIFO
สุดท้ายในครั้งแรกออกมา
พระเจ้าห้าม
มันแทน FIFO
ครั้งแรกในครั้งแรกออกมา
และนั่นเป็นสิ่งที่ดี เพื่อความเป็นธรรม 'ประโยชน์
แน่นอนเมื่อคุณกำลังเข้าแถว ขึ้นต้นสุดในตอนเช้า
ถ้าคุณได้รับมีครั้งแรกคุณ ต้องการที่จะได้รับออกมาเป็นครั้งแรกเช่นกัน
>> และเพื่อให้ข้อมูลทั้งหมดของเหล่านี้ โครงสร้างคิวและสแต็ค
และอัดแน่นของคนอื่น ๆ ที่คุณจะเปิดออก สามารถคิดว่านี้เป็นเพียงอาร์เรย์
นี่คืออาร์เรย์อาจจะ ขนาดคงที่ 4 แต่มันต้องการ
เป็นชนิดของดีถ้าเราเพียงแค่กอง ถาดสูงเกือบอนันต์ถ้าเรา
ที่มีหลายถาดหรือตัวเลข
ดังนั้นบางทีเราต้องการที่จะ ใช้รายการที่เชื่อมโยงที่นี่
แต่การปิดเป็นไปได้ ที่อาจเกิดขึ้นที่เราต้องการหน่วยความจำมากขึ้น
ใช้เวลาน้อยมาก แต่เรา ไม่ จำกัด ความสูงของสแต็ค,
เหมือนกรณีแสดงท้องของ อาจ จำกัด ขนาดของกอง
และอื่น ๆ เหล่านี้จะตัดสินใจในการออกแบบหรือ ตัวเลือกที่มีให้กับเราในที่สุด
ดังนั้นด้วยข้อมูลเหล่านี้ โครงสร้างที่เราได้เริ่มต้น
เห็นขอบเขตบนใหม่ที่อาจเกิดขึ้น ในสิ่งที่ก่อนหน้านี้เป็นที่เร็วสุด
และที่เราจะออกจาก ปิดในวันนี้และที่
เราจะหวังว่าจะได้รับ คือในวันพุธที่เราจะ
เริ่มที่จะดูข้อมูลที่ โครงสร้างที่ช่วยให้เราค้นหา
ผ่านข้อมูลในเวลาสิ้นสุดการเข้าสู่ระบบอีกครั้ง
และเราเห็นว่าจำในสัปดาห์ที่ศูนย์ และเป็นหนึ่งเดียวกับการค้นหาแบบไบนารีหรือแบ่ง
และพิชิต
มันกลับมาและยังดีกว่า จอกศักดิ์สิทธิ์วันพุธนี้
จะเกิดขึ้นกับ โครงสร้างข้อมูลที่ทำงานอย่างแท้จริง
หรือในทางทฤษฎี เวลาคงด้วยเหตุนี้
มันไม่สำคัญว่าหลาย ล้านหรือพันล้านสิ่ง
เรามีอยู่ในโครงสร้างข้อมูลก็จะ พาเราเวลาคงอาจจะขั้นตอนเดียว
หรือสองขั้นตอนหรือ 10 ขั้นตอน แต่ตัวเลขคงที่ของขั้นตอน
การค้นหาผ่านโครงสร้างข้อมูลว่า
นั่นก็จะเป็นจอกศักดิ์สิทธิ์ แต่เพิ่มเติมว่าในวันพุธที่
ดูยาแล้ว
>> [เล่นเพลง]