[เล่นเพลง]
>> เดวิดเจลัน: ทั้งหมดขวา
นี้เป็น CS50
และนี่คือจุดเริ่มต้นของสัปดาห์ที่ 5
และในขณะที่คุณอาจจะสังเกตเห็น บางส่วนของวัสดุ
จะได้รับน้อยมาก ซับซ้อนหนาแน่นน้อย
>> และมันเป็นเรื่องง่ายมากโดยเฉพาะถ้า คุณได้รับในนิสัยบางครั้ง
จะต้องพยายามที่จะเขียนลวกลงมากที่สุด อะไรที่เราทำเรากำลังพูดในชั้นเรียน
แต่ตระหนักว่าไม่อาจจะ วิธีการสอนที่เหมาะ
เพื่อการเรียนรู้ชนิดของวัสดุนี้ และวัสดุอื่น ๆ โดยทั่วไป
และเพื่อให้เรามีความยินดีที่จะ ประกาศ CS50 ที่ตัวเอง Gheng
กงได้เริ่มขึ้นเพื่อเตรียมความพร้อม ชุดที่ยอมรับของบันทึก
สำหรับหลักสูตรที่ความหวังของ ซึ่งเป็นที่หนึ่งเหล่านี้
ไม่เพียง แต่ทำหน้าที่เป็น การอ้างอิงและทรัพยากร
สำหรับการตรวจสอบวัสดุและจะ กลับผ่านวัสดุที่อาจมี
หนีคุณครั้งแรกรอบ แต่ นอกจากนี้ยังเพื่อให้หัวของคุณได้มากขึ้น
ขึ้นลงกว่าเมื่อมัน ถึงเวลาที่จะบรรยาย
เพื่อที่คุณอาจจะมีส่วนร่วม มากขึ้นคิดเป็น
ตรงข้ามกับการเพิ่มเติม scribbly
>> กับที่กล่าวว่าสิ่งที่คุณจะพบใน เว็บไซต์ที่เป็นเอกสารดังกล่าวเช่นนี้
และแจ้งให้ทราบที่ด้านบนซ้ายมี ไม่เพียง แต่ตารางของเนื้อหาที่
แต่ยังรหัสเวลานั้น ทันทีที่คุณจะกระโดด
ไปยังส่วนที่เหมาะสม ในวิดีโอออนไลน์
และสิ่งที่ช้างที่นี่ได้ทำ คือเป็นหลักเอกสาร
สิ่งที่เกิดขึ้นในครั้งนี้ การบรรยายโดยเฉพาะอย่างยิ่ง
และอีกหลายแห่งที่มีการบรรยาย ออนไลน์แล้วตอนนี้มี URL นี้
และเราจะยังคงโพสต์ที่เหลือ ของผู้ที่อยู่ในช่วงปลายสัปดาห์นี้
จึงใช้ประโยชน์จากทรัพยากรที่
>> โดยไม่ต้องกังวลใจต่อไป เราเริ่มที่จะปอกเปลือกกลับ
ชั้นที่ได้รับ สตริงบางครั้ง
และเราไม่พูดสิ่งที่สตริง เป็นจริงเมื่อสัปดาห์ที่แล้ว?
ดาวดังนั้นถ่าน
และถ่านดาว, ดี, สิ่งที่ ไม่ว่าจริงๆหมายถึงอะไร
ดีทุกเวลานี้ถ้าเราได้ รับการเรียกฟังก์ชัน
เช่น getString และการจัดเก็บ ที่เรียกว่าผลตอบแทน
ค่าของ getString ใน variable-- ก็เรียกว่า
S ประเภท string-- เราได้รับการเขียน บรรทัดของรหัสที่มีขึ้นดังกล่าวข้างต้น
และเป็นเพียงเมื่อฉันเห็นของฉัน เขียนด้วยลายมือขยายที่นี่
ฉันจะตระหนักถึงเพียงวิธีเลวร้ายนี้
>> แต่สมมติว่า อยู่ทางด้านขวามือ
เป็นกระนั้นเหมาะสม ภาพของสิ่งที่
ได้เกิดขึ้นทั้งหมดนี้ เวลากับ getString
getString ของหลักสูตรได้รับสาย
แต่สิ่งที่ไม่ว่าจริงๆหมายถึงอะไร
มันหมายความว่าจะได้รับก้อน หน่วยความจำจากระบบปฏิบัติการ
โดยการเรียกฟังก์ชั่นที่เรียกว่า malloc
แต่เพิ่มเติมว่าภายหลัง
และจากนั้นก็ populates ก้อนของหน่วยความจำที่
ด้วยตัวอักษรที่ผู้ใช้มี พิมพ์ในตามด้วยแน่นอน
อักขระ null หรือเครื่องหมาย ศูนย์ที่ท้ายสุด
>> ในขณะเดียวกันในด้านซ้ายมือ ในเรื่องนี้ตลอดเวลานี้
เราได้รับการประกาศตัวแปรเช่น S
และตัวแปรที่เป็นสิ่งที่ตอนนี้ จะเริ่มเรียกตัวชี้
มันไม่ใช่กล่องภายในที่ เราใส่สตริง Daven ต่อ se
แต่เราใส่ในตารางที่ กล่องทางด้านซ้ายสิ่งที่ว่าหรือไม่
ใช่?
>> ผู้ชม: ที่อยู่ของ ที่เป็นอยู่ในหน่วยความจำ
>> เดวิดเจลัน: แน่นอน
ที่อยู่ของที่ Daven ตั้งอยู่ในหน่วยความจำ
และไม่ที่ทุก Daven ตั้งอยู่ ต่อ แต่เฉพาะที่อยู่
ของอะไร
ใช่?
>> ผู้ชม: ตัวอักษรแรก
>> เดวิดเจลัน: ตัวอักษรตัวแรก ใน Daven ซึ่งในกรณีนี้
ผมเสนอให้เป็นพล และบวก 1 OX1,
ซึ่งก็หมายความว่า เลขฐานสิบหกของ 1
แต่มันอาจจะ จะเป็นตัวเลขที่มีขนาดใหญ่มาก
ที่เราอาจจะวาด ด้วย 0x เป็นคำนำหน้า,
ที่เป็นตัวแทนของตัวละครที่เลขฐานสิบหก
และเนื่องจากเราไม่จำเป็นต้องทราบว่า ส่วนที่เหลือของตัวละครของ Daven
เป็นเพราะสิ่งที่ออกแบบที่เรียบง่าย การตัดสินใจที่ถูกสร้างขึ้นมาเป็นเวลาหลายปีที่ผ่านมา?
ใช่?
>> ผู้ชม: 0 ทับขวา
เดวิดเจลัน: ใช่ว่า
เครื่องหมาย 0 ช่วยให้คุณแม้ว่าใน เส้นเวลาการสำรวจสตริง
เดินจากซ้ายไปขวา กับการห่วงหรือในขณะที่
ห่วงหรือสิ่งที่ต้องการ ที่และกำหนดโอ้นี่
เป็นจุดสิ้นสุดของสตริงนี้โดยเฉพาะ
ดังนั้นมีเพียงที่อยู่ที่ จุดเริ่มต้นของสตริง,
เราสามารถเข้าถึงความสมบูรณ์ของ เพราะทั้งหมดในขณะนี้
สตริงได้รับเพียงดาวถ่าน
>> ดังนั้นจึงเป็นที่แน่นอนที่ดีที่จะดำเนินการโดยใช้ ห้องสมุด CS50 และสิ่งที่เป็นนามธรรมนี้
จึงจะพูด แต่เราจะ เริ่มเห็นว่า
สิ่งที่ได้เกิดขึ้น ภายใต้เวลานี้ทั้ง
ดังนั้นคุณอาจจำตัวอย่างนี้ เกินไปจากครั้งล่าสุดเปรียบเทียบ 0,
ซึ่งไม่จริงเปรียบเทียบ
แต่เราเริ่มที่จะแก้ปัญหานี้
>> แต่บางทีอาจจะทบทวน, ฉันอาจจะสนใจใครสักคน
ในช้างสีชมพูในวันนี้ นอกจากนี้ยังทำโดยช้าง?
วิธีการเกี่ยวกับคุณในหน้า? [ไม่ได้ยิน]
มาขึ้น
>> และในขณะเดียวกัน ในขณะที่คุณมาให้
พิจารณาเพียงแค่ช่วงเวลาที่สิ่งที่ รหัสนี้เป็นจริงการทำ
ก็ประกาศตัวแปรสองขึ้น ด้านบนวินาที, และเสื้อและเรียก getString
นี้ไม่ได้เป็นโปรแกรมที่ใช้งานง่ายมาก เพราะมันไม่ได้บอกคุณว่าจะทำอย่างไร
แต่ขอเพียงสมมติเรา โดยมุ่งเน้นในส่วนของฉ่ำ
แล้วเราก็ทำถ้า S เท่ากับ เท่ากับเสื้อก็ควรจะพูดว่า printf,
คุณพิมพ์ในสิ่งเดียวกัน
สวัสดี
คุณชื่ออะไร?
>> JANELLE: แน็ล
เดวิดเจลัน: แน็, มีความสุขที่ได้พบคุณ
ดังนั้นความท้าทายของคุณใน มือสำหรับช้างนี้
แรกคือการวาดภาพของเราว่ามีอะไร เป็นตัวแทนในการที่สองคนแรก
สาย
ดังนั้นเสื้อและอาจจะมี แสดงวิธีการบนหน้าจอ?
และคุณก็สามารถวาดมันด้วย นิ้วของคุณบนหน้าจอขนาดใหญ่นี้
>> ดังนั้นจึงมีสองส่วนที่จะ ด้านข้างของสมการที่แต่ละ
จึงมีบนด้านซ้ายและ แล้ว GetString ด้านขวา
แล้วมีเสื้อด้านซ้าย แล้ว GetString ด้านขวา
ดังนั้นวิธีที่เราอาจเริ่มต้น การวาดภาพที่
แสดงให้เห็นถึงสิ่งที่เกิดขึ้น ที่นี่ในหน่วยความจำที่คุณจะพูด?
และแจ้งให้เราช่วยให้คุณสามารถอธิบาย สิ่งที่คุณทำตามที่คุณไป
>> JANELLE: OK
อย่างแรกก็จะขอให้ คุณจะได้รับสายเข้า
และมันจะ store-- โอ้ขอโทษ
เดวิดเจลัน: OK
ที่ดี
และนี้เรียกว่าอะไร
โอ้ตกลง
เก็บไป
ฉันไม่ได้ตั้งใจที่จะขัดขวาง
JANELLE: ขออภัย
ดังนั้นมันจะใส่มันลงไปใน อยู่เเล้ไม่แน่ใจว่า
ฉันไม่สามารถว่าจำเลขที่ แต่ผมเชื่อว่ามันก็เริ่มต้นด้วย 0
>> เดวิดเจลัน: นั่นเป็นสิทธิทั้งหมด เพราะผมทำตัวเลขขึ้น
จึงไม่มีคำตอบที่ถูก
>> JANELLE: เริ่มต้นด้วย 0 โค้ง
>> เดวิดเจลัน: OK ดังนั้นองค์ประกอบ 0
แน่นอนว่า
>> JANELLE: แล้วถ้าเป็น เช่นเดียวสอง letter---
>> เดวิดเจลัน: ตกลงกลับมาให้คุณ
>> JANELLE: ดังนั้นองค์ประกอบ 0 และ แล้วองค์ประกอบ 1 หรือ 2 องค์ประกอบ
เดวิดเจลัน: และที่ชิ้นส่วนของ ภาพที่คุณวาดตอนนี้?
โทรไป getString?
หรือการประกาศของ S?
>> JANELLE: ประกาศ ของผมเชื่อ
โอ้ getString เพราะมันจะ ได้รับการป้อนเข้าไปในแต่ละ [? พื้นที่ ?]
>> เดวิดเจลัน: ดี
ว่า
แม้ว่านี้ได้อย่างมีประสิทธิภาพ กลับอาร์เรย์เรียกคืน,
เมื่อเราได้รับกลับสตริงที่เราสามารถทำได้ ดัชนีเป็นสตริงใช้ 01 และ 2 ว่า
เทคนิคเหล่านี้อาจจะเป็น แสดงโดยที่อยู่แต่ละ
แต่ที่ดี
>> ดังนั้นคิดว่าถ้าผมสามารถได้อย่างรวดเร็วเพียงแค่ ส่งต่อไปยังที่เราซ้ายปิด
ครั้งสุดท้ายถ้าหนึ่งใน สตริงเป็นกรัมขอี
เครื่องหมาย 0 จึงเป็นตัวแทนของเกบ ป้อนข้อมูลวิธีที่เราอาจเป็นตัวแทนของตอนนี้หรือไม่
หากเป็นหน่วยความจำที่ ถูกส่งกลับโดย getString?
>> JANELLE: มันจะเป็น แสดงโดยอาร์?
>> เดวิดเจลัน: โดยอาร์?
ดีไม่มี
ขอเพียงบอกว่า pictorially, ให้ฉันเพียงไปข้างหน้า
และเสนอว่าถ้าเป็นวินาที, นี้ เป็นค่าตอบแทนของ getString
และคุณได้วาดนี้เป็น 0, 1, 2 ซึ่ง มีความสมเหตุสมผลอย่างสมบูรณ์แบบเพราะเรา
สามารถจัดทำดัชนีเป็นสตริงเป็นเช่นนี้
แต่เพียงเพื่อให้สอดคล้องกับ ครั้งสุดท้ายให้ฉันไปข้างหน้า
และพลเสนอว่านี้ 1 คือที่อยู่นี้เป็นที่อยู่ที่ 2
นี้คือที่อยู่ที่ 3, และอื่น ๆ
และอื่น ๆ เพียงเพื่อเป็นซุปเปอร์ ชัดเจนสิ่งที่เกิดขึ้น
ที่จะไปในฐานะที่เป็นผลจากการที่ บรรทัดแรกของรหัสที่คุณจะพูด?
>> JANELLE: ที่อยู่ 1?
>> เดวิดเจลัน: แน่นอน
ดังนั้น 0x1 อยู่
และในขณะเดียวกันให้ฉันไปข้างหน้าและ ที่ซ้ำกันมากของสิ่งที่คุณทำ
และเพิ่มเสื้อของตัวเองที่นี่
ถ้าฉันจะพิมพ์ในเกบ อีกครั้งเป็นครั้งที่สอง
เมื่อได้รับข้อความที่มี getString ที่ไหน แน่นอนจะเกบจะไป?
ดี presumably--
>> JANELLE: ชอบที่นี่?
เดวิดเจลัน: ใช่
JANELLE: หรือก็ยังอยู่ในกล่องเดียวกันได้หรือไม่
เดวิดเจลัน: ผมขอเสนอใช่ ว่าดังนั้นในกล่องเหล่านี้เพิ่มเติม
แต่สิ่งที่สำคัญตอนนี้คือแม้ แต่ผมได้วาดเหล่านี้สวยใกล้
together-- 0x1 นี้ เป็น 0x2-- ในความเป็นจริง
ตอนนี้อาจจะเป็นที่อยู่ 0x10, เช่นและ 0x11 และ 0x12,
และอื่น ๆ
ดังนั้นถ้าเป็นกรณีที่ สิ่งที่เกิดขึ้นจะจบลงที่นี่ใน T?
>> JANELLE: 0x10?
เดวิดเจลัน: แน่นอน
ดังนั้น 0x10
และอื่น ๆ ตอนนี้คำถามสุดท้าย
คุณได้โดยไกลต้องทำงาน ที่ยากที่สุดสำหรับช้างป่านนี้
โดยตอนนี้ถ้าผมดึงรหัส อีกครั้งเมื่อฉันทำในสายที่สาม
ถ้า S เท่ากับเท่ากับตันสิ่งที่ฉันจริง เปรียบเทียบว่าเราได้มาที่นี่?
>> JANELLE: สองที่อยู่?
เดวิดเจลัน: แน่นอน
ดังนั้นฉันพูดคือ s เท่ากับเท่ากับ t?
ในคำอื่น ๆ 1 เท่ากับเท่ากับ 10?
และแน่นอน คำตอบที่ชัดเจนตอนนี้คือไม่มี
และอื่น ๆ โปรแกรมนี้เป็นที่สุด จะพิมพ์สิ่งที่คุณจะพูด?
>> JANELLE: มันจะเป็นไปได้ คุณพิมพ์สิ่งเดียวกัน
>> เดวิดเจลัน: ดังนั้นหาก คือ 1 และเสื้อคือ 10?
>> JANELLE: คุณพิมพ์สิ่งที่แตกต่าง
>> เดวิดเจลัน: แน่นอน
คุณพิมพ์สิ่งที่แตกต่าง
ขวาทั้งหมด
ดังนั้นรอบของเสียงปรบมือที่ ถ้าเราทำได้ที่นี่
[APPLAUSE]
ที่เป็นความเจ็บปวด
ฉันรู้ว่า
ทำอย่าง
ดังนั้นตอนนี้เราจะมาดูว่าเราทำไม่ได้ แซวกันสิ่งที่แก้ไขได้
และแน่นอนเมื่อเราคงที่เจ้านี่ ซึ่งตอนนี้ผมจะเป็นตัวแทนทับด้วยสีเขียว
เราทำคู่ของการปรับปรุงที่นี่
ครั้งแรกเช่นเดียวกับที่มีสุขภาพจิตดี ตรวจสอบผมตรวจสอบครั้งแรก
ถ้า S เท่ากับโมฆะและเสื้อเท่ากับโมฆะ
และเพียงแค่ต้องมีความชัดเจนเมื่ออาจจะ หรือเสื้อเป็นโมฆะในรหัสเช่นนี้?
เมื่อเสื้อหรืออาจเป็นโมฆะ
ใช่?
>> ผู้ชม: [ไม่ได้ยิน]
>> เดวิดเจลัน: แน่นอน
ถ้าสตริงที่ผู้ใช้ พิมพ์เป็นวิธีที่ยาวเกินไป
เพื่อให้เหมาะสมกับในหน่วยความจำหรือบาง กรณีมุมแปลกเช่นนั้น
GetString ที่เราจะเห็นตัวอักษร วันนี้ในเอกสารประกอบของ
กล่าวว่ามันจะกลับมาเป็นโมฆะ ค่าแมวมองพิเศษ
หรือเพียงแค่การเรียงลำดับของสัญลักษณ์พิเศษ นั่นหมายความว่าสิ่งที่ผิดพลาด
ดังนั้นเราจึงต้องการที่จะตรวจสอบ ว่าเพราะมันจะเปิดออก
null ที่เป็นค่าที่อันตรายมาก
>> บ่อยครั้งที่ถ้าคุณพยายามที่จะทำอะไรกับ null ที่เกี่ยวข้องกับฟังก์ชันผ่านมัน
เป็น input สำหรับ instance-- ฟังก์ชันที่ อาจจะผิดพลาดมากและด้วยความมัน
จะลงโปรแกรมทั้งหมดของคุณ
ดังนั้นบรรทัดที่สามในตอนนี้เป็นเพียงสติ ตรวจสอบการตรวจสอบข้อผิดพลาดถ้าคุณจะ
นั่นเป็นนิสัยที่ดีในตอนนี้สำหรับ ที่เราจะได้รับในเวลาที่เรา
พยายามที่จะใช้ค่าที่ อาจจะอาจเป็นโมฆะ
>> ขณะนี้ในบรรทัดที่สี่นี่ "ถ้า strcmp (S, T)," อย่างดี
สิ่งที่หมายถึง?
ดีที่เรากล่าวว่าเรื่องนี้เป็นอย่างมากรัดกุม ฟังก์ชั่นการตั้งชื่อตามการเปรียบเทียบสตริง
และวัตถุประสงค์ในชีวิตคือการเปรียบเทียบ อาร์กิวเมนต์แรกกับมันที่สอง
แต่ไม่ใช่ในแง่ของการที่อยู่ของพวกเขา ในขณะที่เราไม่ได้ตั้งใจสักครู่
ที่ผ่านมากับรหัสสีแดง แต่ ค่อนข้างที่จะเปรียบเทียบทั้งสอง
สตริงในการใช้งานง่ายอย่างมนุษย์ปุถุชน วิธีนี้โดยการเปรียบเทียบกับนี้
ต่อนี้กับเรื่องนี้และ แล้วหยุดถ้าและเมื่อหนึ่ง
หรือทั้งสองมือของฉัน ฮิตเครื่องหมาย 0
strcmp ปีดังนั้นคนที่ผ่านมาดำเนินการ ที่จะใช้ฟังก์ชั่นสำหรับเรา
ที่เราหวังว่าเราจะได้รับ โดยเพียงแค่การเปรียบเทียบสองค่าง่าย
>> ตอนนี้ตรงไปตรงมาผมเก็บภาพวาด ทั้งหมดของตัวเลขต่างๆเหล่านี้
แต่ความเป็นจริงคือผมได้รับ ทำให้เหล่านี้ขึ้นตลอดเวลา
และเพื่อให้ฉันเพียงไปข้างหน้า และเขียนลวก ๆ เหล่านี้ออก
เพื่อให้จุดที่ในตอนท้าย ของวันและก้าวไปข้างหน้า
เราไม่ได้จริงๆจะไปเกี่ยวกับการดูแล สิ่งที่อยู่ในสิ่งที่เป็นจริง
ในความทรงจำ
ดังนั้นผมจะไม่วาดเหล่านี้ ชนิดของตัวเลขมากอีกต่อไป
ฉันก็เป็นเพียงนามธรรมนี้ไป เล็ก ๆ น้อย ๆ ที่เป็นมิตรมีเพียงลูกศร
>> ในคำอื่น ๆ ถ้าคือตัวชี้ ดีขอเพียงแค่วาดตัวอักษร
เป็นตัวชี้ลูกศรชี้ จากตัวเองไปอย่างอื่น
และไม่ต้องกังวลมากเกินไปเกี่ยวกับ minutia ที่อยู่เหล่านี้
ซึ่งอีกครั้งที่ผมทำขึ้นมาแล้ว
แต่เราจะเห็นอยู่นั้น บางครั้งเมื่อรหัสการแก้จุดบกพร่อง
>> ตอนนี้ขณะที่โปรแกรมนี้ ที่นี่แก้ไขแน่นอน
ปัญหาโดยการเปรียบเทียบว่า ทั้งสองสาย
แต่เราวิ่งเข้าไปในปัญหาอื่น
นี้จากการคัดลอก โปรแกรมครั้งสุดท้าย
ซึ่งผมพยายามที่จะใช้ประโยชน์ เพียงแค่ตัวอักษรตัวแรกในสตริง
แต่สิ่งที่เป็นอาการ เราเห็นครั้งสุดท้ายเมื่อ
ผู้ใช้พิมพ์ลงในมูลค่าเช่น เกบในตัวพิมพ์เล็กสำหรับวินาที,
แล้วเราได้รับมอบหมายให้เข้าเป็นตัน ในบรรทัดที่สามมี
แล้วฉันพยายามที่จะ ประโยชน์ทีวงเล็บ 0?
สิ่งที่เป็นผลกระทบจากการ เปลี่ยนเสื้อวงเล็บ 0 นี่?
>> ผู้ชม: มันเปลี่ยนของ
>> เดวิดเจลัน: ใช่ ผมเปลี่ยนวินาที, เช่นเดียวกับ
เพราะสิ่งที่เป็นจริงที่เกิดขึ้น?
ดีให้ฉันดูว่าฉันสามารถทำความสะอาด ขึ้นภาพนี้ดังต่อไปนี้
>> หากคืออีกครั้งกรัมคำว่า A, B, E, เครื่องหมาย, 0, และ S
เราจะยังคงวาดภาพเป็นกล่อง ที่นี่ แต่ที่อยู่ไม่มาก
ขอหยุดการทำสิ่งที่ขึ้น
ขอเพียงวาดภาพ เพื่อลดความซับซ้อนของโลก
>> เมื่อผมประกาศทีกับสตริงตัน ที่สร้างก้อนของหน่วยความจำที่
สแควร์ที่จะเกิดขึ้น 32 บิตในคอมพิวเตอร์มากที่สุด
ในความเป็นจริงถ้าคุณเคยได้ยินของ คอมพิวเตอร์ที่มีสถาปัตยกรรมแบบ 32 บิต
จริงๆแฟนซีพูดว่าเพียงแค่ หมายความว่าจะใช้ที่อยู่ 32 บิต
และในขณะที่ทางเทคนิคกัน ถ้าคุณเคยสงสัย
ทำไมคอมพิวเตอร์เก่าถ้าคุณจริง พยายามที่จะซุปพวกเขามีจำนวนมากของ RAM
สามารถมีได้สูงสุดเพียง สี่กิกะไบต์แรม
ดีว่าเป็นเพราะตัวอักษร คอมพิวเตอร์เก่าของคุณอาจจะเพียง
นับเป็นสูงที่สุดเท่าที่ 4 พัน 4 พันล้านไบต์
เพราะมันถูกใช้ 32 บิต หมายเลขที่อยู่
>> แต่ในกรณีใด ๆ ในเรื่องนี้ ตัวอย่างเช่นเรื่องที่ง่ายมาก
เสื้อเป็นเพียงตัวชี้อื่นหรือ จริงๆดาวถ่านสตริงอาคา
และวิธีการที่ฉันต้องการที่จะปรับปรุงภาพนี้ ตอนนี้มีบรรทัดที่สองของรหัส
หลังจากจุด, จุด, จุด?
เมื่อฉันทำสตริงทีเท่ากับ S อัฒภาค วิธีการที่ไม่ภาพนี้เปลี่ยน?
ใช่?
>> ผู้ชม: [ไม่ได้ยิน]
>> เดวิดเจลัน: ใช่
ว่า
ฉันเพียงแค่ใส่ลูกศรจาก กล่องทีไปยังที่อยู่เดียวกัน
ตัวอักษรตัวแรกเหมือนกันในให้
หรือเทคนิคที่ว่านี้ ผู้ชายที่ยังคงอยู่ที่ 0x1,
มันเหมือนกับว่าผมมี 0x1 และ 0x1 ที่นี่ที่นี่
แต่อีกครั้งที่ใส่ใจ เกี่ยวกับที่อยู่?
มันเป็นเพียงแค่ความคิดที่ว่าตอนนี้เรื่อง
ดังนั้นนี่คือสิ่งที่เกิดขึ้นที่นี่
ดังนั้นแน่นอนถ้าคุณทำทีวงเล็บ 0 ซึ่งเป็นสัญกรณ์อาร์เรย์
ของ course-- และตรงไปตรงมามันก็ดู เช่นมีอาร์เรย์กว่าที่นี่
แต่ตอนนี้มีสิ่งที่แปลกนี้
รู้ว่าการเขียนโปรแกรมภาษาที่ C ให้คุณคุณลักษณะนี้
โดยแม้ว่าเสื้อเป็น ตัวชี้หรือคือตัวชี้
คุณยังสามารถใช้คุ้นเคยว่า ตารางที่ยึดความสะดวกสบาย
สัญกรณ์ไปที่องค์ประกอบแรก หรือองค์ประกอบที่สองหรือองค์ประกอบใด ๆ
ตัวชี้ที่จะชี้ เพราะสมมุติมัน
เป็นเช่นเดียวกับในกรณีนี้ ชี้ไปที่อาร์เรย์บาง
>> ดังนั้นเราจะแก้ไขปัญหานี้
ตรงไปตรงนี้เป็นที่ที่มันได้ ครอบงำเล็ก ๆ น้อย ๆ ได้อย่างรวดเร็วก่อน
แต่ที่นี่เป็นรุ่นใหม่และปรับปรุง
>> ดังนั้นครั้งแรกที่ฉันได้รับ การกำจัดของห้องสมุด CS50,
เพียงเพื่อแสดงว่า s แน่นอน ดาวถ่านเพียงคำพ้องความหมาย
และเสื้อยังเป็นดาวถ่าน
แต่สิ่งที่เกิดขึ้นเมื่อวันที่ ด้านขวามือของบรรทัดที่
โดย t เป็นกำหนดค่าหรือไม่
>> malloc คืออะไร?
สิ่งที่มัน strlen?
sizeof (ถ่าน) คืออะไร?
ทำไม heck ไม่นี้ เส้นลักษณะที่ซับซ้อนเพื่อ?
สิ่งที่จะทำในระดับสูงหรือไม่
มันเป็นสิ่งที่จัดเก็บใน T?
ใช่?
ผู้ชม: มันจัดสรร จำนวนหนึ่งของพื้นที่หน่วยความจำ
มันจะเก็บผมว่า ตัวอักษร [ไม่ได้ยิน]
>> เดวิดเจลัน: ที่สมบูรณ์แบบ
ที่สมบูรณ์แบบ
มันเป็นบางอย่างที่จัดสรร จำนวนของพื้นที่หน่วยความจำ
ในการจัดเก็บสมมุติตัวอักษรในอนาคต
และโดยเฉพาะอย่างยิ่ง malloc จึงจะกลับมาอย่างไร
>> ผู้ชม: กลับมา [ไม่ได้ยิน]
เดวิดเจลัน: แน่นอน
กลับมาที่อยู่ของหน่วยความจำนั้น ซึ่งเป็นวิธีที่จินตนาการของบอกว่า
ผลตอบแทนที่อยู่ของ ไบต์แรกของหน่วยความจำที่
ความรับผิดชอบอยู่ที่ผมจำได้ หน่วยความจำเท่าใดฉันจริง
จัดสรรหรือถาม malloc สำหรับ
>> ตอนนี้เท่าไหร่คือ?
ดีแม้ว่าจะมีเป็น จำนวนมากที่มีวงเล็บที่นี่
malloc ใช้เวลาเพียงอาร์กิวเมนต์เดียว
และฉันระบุ strlen ของวินาที, เพื่อให้ ฉันไบต์มากที่สุดเท่าที่มีอยู่ในวินาที,
แต่เพิ่มหนึ่ง
ทำไม?
ใช่?
>> ผู้ชม: 0 ทับขวา
เดวิดเจลัน: แน่นอน
เราได้มีการทำเช่นการดูแลน้อย
ดังนั้นเพราะมีเครื่องหมาย 0 เราควรที่จะจำไว้ว่า
มิฉะนั้นเราจะ เพื่อสร้างสตริงที่
ไม่ได้มีที่ต่อท้ายพิเศษ
>> ในขณะเดียวกันก็จะสุด ทางทวารหนั​​กฉันมี sizeof (ถ่าน)
เพียง แต่ในกรณีที่คนทำงานของฉัน รหัสไม่ได้อยู่บนเครื่อง CS50,
แต่อาจจะแตกต่างกันคอมพิวเตอร์ ทั้งหมดที่ตัวอักษร
เป็นหนึ่งไบต์โดยการประชุม แต่ทั้งสอง ไบต์หรือสิ่งที่ใหญ่กว่านั้น
มันเป็นเพียงที่จะเป็นซูเปอร์ ซุปเปอร์รังเกียจที่จะเกิดข้อผิดพลาด
แม้ว่าในความเป็นจริงมันเป็น ส่วนใหญ่จะเป็น 1
>> ตอนนี้ในขณะที่ผมไปข้างหน้าและคัดลอก สตริง, เสื้อตัวฉันเท่ากับเสื้อวงเล็บ S
และพ่อท่านคล้อยสัปดาห์สุดท้ายของ รหัสแหล่งที่มาเพื่อดูสิ่งที่เกิดขึ้น
แต่ Takeaway ที่สำคัญและ เหตุผลที่ฉันใส่รหัสตอนนี้อยู่ในสีเขียว
เป็นเพราะบรรทัดสุดท้ายมากที่ เสื้อวงเล็บ 0 เท่ากับ ToUpper,
มีผลกระทบของ พะวงซึ่งสตริง?
เสื้อและ / หรือหรือไม่
ที่บรรทัดสุดท้ายของรหัส
>> t เพียงเพราะสิ่งที่เป็น ที่เกิดขึ้นเวลานี้
ถ้าผมเล็กน้อยยกเลิกขั้นตอนสุดท้ายว่า สิ่งที่เกิดขึ้นคือเมื่อผมเรียก malloc,
ฉันเป็นหลักได้รับก้อนของหน่วยความจำ ที่มีขนาดเดียวกับต้นฉบับ
เพราะนั่นคือการคำนวณที่ผมทำ
ฉันเก็บในทีที่อยู่ ของก้อนหน่วยความจำที่
แม้จะดูดี และสวยดีและที่ว่างเปล่า
ความเป็นจริงจะมีสิ่งที่เราจะ ให้โทรค่าขยะในที่นี่
ก้อนของหน่วยความจำที่อาจจะมาก อย่างดีมีการใช้มาก่อน
ไม่กี่วินาทีไม่กี่นาทีที่ผ่านมา
ดังนั้นจึงมีอย่างแน่นอนอาจจะเป็นหมายเลข หรือตัวอักษรที่นั่นเพียงแค่อุบัติเหตุ
แต่พวกเขาไม่ได้ถูกต้องจนกว่าฉัน ตัวเองเติมก้อนของหน่วยความจำนี้
ที่มีตัวอักษรที่เกิดขึ้นจริงที่ผม ทำในสิ่งที่ห่วงมี
ทั้งหมดใช่มั้ย?
>> ดังนั้นตอนนี้จุดสำคัญของ เหล่านี้สามตัวอย่าง
ที่ถูกหักดูเหมือนว่าเวลาที่ผ่านมา ตัวอย่างเช่น Swap นี้ฟังก์ชั่นนี้
ทำงานอยู่ในความรู้สึก ว่ามันเปลี่ยนและข
แต่มันไม่ได้ทำงานในสิ่งที่ความรู้สึกอื่น ๆ
ใช่?
>> ผู้ชม: [ไม่ได้ยิน]
>> เดวิดเจลัน: แน่นอน
ถ้าฉันจะเรียกใช้ฟังก์ชันนี้ จาก another-- เช่น
จากการทำงานเช่นเดียวกับหลักที่ ฉันมีตัวแปร x, และ y เป็นฉัน
เมื่อสัปดาห์ที่แล้วได้รหัสเดียวกัน และฉันผ่านใน x และ y
ที่จะสลับแล้วโทร Swap-- นี้ แน่นอนเป็นรุ่นที่ถูกต้อง
คือสิ่งที่เรากำลังจะ ดูหน่อยมันไม่ได้ทำงาน
ดังนั้นสิ่งที่แก้ไขหรือไม่
>> ดีดังนั้นเพียงเพื่อให้ ที่ชัดเจนให้ฉันไปข้างหน้า
and-- ให้ฉันคนที่สองที่นี่และดู ถ้าฉันสามารถแสดงให้คุณคนสุดท้ายซึ่ง
จะ in-- เรามาดูว่าฉันสามารถหา นี้ตกลง fast-- จริง [ไม่ได้ยิน]
ตกลงมีเป็น
ดังนั้นไม่สนใจคำสั่งฉันแค่พิมพ์
ฉันต้องการที่จะดึงที่ นาทีสุดท้ายตัวอย่างเช่น
จากครั้งล่าสุดที่ เรียกว่าตอนนี้ไม่ Swap
>> จึงไม่มี Swap คือที่ เราซ้ายปิดครั้งสุดท้าย
โดยผมเริ่มต้นได้ x 1 และ y 2
จากนั้นผมก็เรียก Swap ผ่านใน 1 และ 2
แล้วฟังก์ชั่นนี้ ทำงานอยู่ในความรู้สึกบางอย่าง
แต่มันก็ไม่ได้ถาวร ผลกระทบต่อ x และ y
ดังนั้นคำถามที่อยู่ในมือคือวิธีที่ตอนนี้ เราทำจริงแก้ไขปัญหานี้หรือไม่
อะไรคือสิ่งที่การแก้ปัญหาที่อยู่ในมือหรือไม่
>> ทั้งใน swap.c ซึ่งเป็นของใหม่ในวันนี้ สังเกตเห็นคู่ของความแตกต่าง
x และ y ที่เหมือนกัน
แต่สิ่งที่เห็นได้อย่างชัดเจน ที่แตกต่างกันเกี่ยวกับสาย 25?
มีอะไรใหม่มีถ้าคุณจำได้ สิ่งที่มันดูเหมือนที่สองที่ผ่านมา?
>> ผู้ชม: [ไม่ได้ยิน]
>> เดวิดเจลัน: ใช่
ดังนั้นเครื่องหมายเป็นชิ้นใหม่ ของไวยากรณ์ไม่เพียง แต่ในโปรแกรมนี้
แต่ยังมากขึ้นโดยทั่วไปใน CS50
จนถึงวันนี้ผมไม่คิดว่า เราได้เห็นตัวอย่างใด ๆ
หรือจริงๆพูดคุยเกี่ยวกับพวกเขาในที่ใด ๆ รายละเอียดอื่น ๆ กว่าบางที preemptively
ในส่วนเครื่องหมายเช่นนี้
ดีก็จะเปิดออกเครื่องหมายเป็นหนึ่ง ในชิ้นสุดท้ายของไวยากรณ์ใหม่
เราจะเรียนรู้
ทั้งหมดก็หมายถึงคือ ที่อยู่ของตัวแปรบาง
สิ่งที่อยู่ x ไม่อยู่?
แต่สิ่งที่ไม่อยู่ปีอยู่?
เพราะถ้า ปัญหาพื้นฐานก่อน
คือ x และ y ที่ถูกส่งผ่านไป เป็นสำเนาสิ่งที่เราอยากจะทำ
จะให้สลับด้วยเหมือนขุมทรัพย์ แผนที่ที่นำไปสู่​​ที่ x และ y จริง
อยู่ในหน่วยความจำเพื่อให้ Swap สามารถทำตามแผนที่ที่
และไปที่ใดก็ตามที่ x หรือ Y เครื่องหมายจุด และการเปลี่ยนแปลงที่เกิดขึ้นจริงค่าที่ 1 และ 2
มี
>> ดังนั้น Swap ต้องเปลี่ยนเล็กน้อยเกินไป
และได้อย่างรวดเร็วก่อนอาจนี้ ดูเหมือนคล้ายกันเล็ก ๆ น้อย ๆ ที่จะถ่านดาว
และแน่นอนมันเป็น
เพื่อเป็นตัวชี้ไปยังสิ่งที่ประเภทของข้อมูล ขึ้นอยู่กับส่วนไฮไลท์นี้
ดังนั้นจึงเป็น int
>> ดังนั้นไม่ int, มันเป็นที่อยู่ของ int
และในทำนองเดียวกันขอยู่ในขณะนี้ไป ให้เป็นที่อยู่ของ int
ดังนั้นเมื่อผมตอนนี้เรียก Swap จากหลัก ฉันจะไม่ให้สลับที่ 1 และ 2
ฉันจะให้มันเหมือน วัวบางสิ่งบางอย่างและบางสิ่งบางอย่างวัว,
สองที่อยู่ที่จะนำไปสู่ สลับไปยังสถานที่จริงของพวกเขา
ในหน่วยความจำของคอมพิวเตอร์ของฉัน
>> ดังนั้นขณะนี้การดำเนินงานที่เหลืออยู่ของฉัน ต้องเปลี่ยนตาด
มีอะไรที่แตกต่างกันอย่างเห็นได้ชัดในขณะนี้ ในทั้งสามบรรทัดของรหัส?
เหล่านี้มีดาวแช่งทั้งหมดเป็น ทั่วสถานที่ขวาทั้งหมดหรือไม่
ดังนั้นสิ่งที่เกิดขึ้นที่นี่?
ใช่?
>> ผู้ชม: มันเห็นได้ชัด [ไม่ได้ยิน]
>> เดวิดเจลัน: แน่นอน
ดังนั้นใน context-- นี้และนี้ไม่ได้ การตัดสินใจการออกแบบที่ดีที่สุดที่ยอมรับ
ปีที่ผ่านมา
ในบริบทนี้ที่ คุณเพียงแค่ต้องดาว
และคุณไม่ได้มีชนิดข้อมูล เช่น int ทันทีไปทางซ้าย
แทนคุณมีเครื่องหมายเท่ากับชัดเจน ในบริบทนี้เมื่อคุณบอกว่าดารา,
นั่นหมายความว่าไปที่ ที่อยู่ที่อยู่ใน
ตามแผนที่สมบัติจึงจะพูด
>> และในขณะเดียวกันในสาย 37, มันจะหมายถึงสิ่งเดียวกัน
ไปที่ที่อยู่และใส่สิ่งที่มี?
ไม่ว่าอยู่ที่ สถานที่ตั้งที่ระบุข
ในคำอื่น ๆ ให้ไปที่ข
ได้รับค่าที่
ไปและต่อเท่ากับ ลงชื่อผู้ประกอบการกำหนด
ใส่ค่าที่มี
>> ในทำนองเดียวกันอุณหภูมิ int เป็นเพียง int
ไม่มีอะไรที่ต้องเปลี่ยนเกี่ยวกับอุณหภูมิ
มันเป็นเพียงแก้วว่างจาก Annenberg สำหรับนมหรือน้ำผลไม้สีส้ม
แต่ฉันไม่ต้องการที่จะบอกว่าให้ไปที่ข
ไปยังปลายทางที่และ ใส่ค่าในอุณหภูมิที่นั่น
ดังนั้นสิ่งที่เกิดขึ้นนั้นจะเป็นอย่างไร
เมื่อที่จริงผมเรียกสลับเวลานี้ถ้า ถาดแรกที่นี่เป็นหลัก
ถาดที่สองนี้แสดงให้เห็นถึงการแลกเปลี่ยนเมื่อ ฉันผ่านเครื่องหมาย x และเครื่องหมายปี
จากหลักเพื่อแลกเพียงเพื่อจะชัดเจน นี่คือกรอบที่ได้รับการสแต็ค?
ใช่?
>> ผู้ชม: [ไม่ได้ยิน]
เดวิดเจลัน: แน่นอน
ที่อยู่ของ x และที่อยู่ของ y
และคุณสามารถคิดเหล่านี้ เช่นที่อยู่ทางไปรษณีย์
33 Oxford Street 35 Oxford Street และคุณ
ต้องการที่จะย้ายอาคารสอง ที่อยู่ในสถานที่เหล่านั้น
>> มันเรียงลำดับของความคิดที่ไร้สาระ แต่นั่นคือทั้งหมดที่เราหมายถึงที่อยู่
ที่ไหนในโลกที่สามารถ คุณจะพบว่าทั้งสอง ints?
ที่ไหนในโลกที่คุณสามารถ พบว่าทั้งสองอาคาร?
ดังนั้นหากในที่สุดหลังจากที่ทุกเวลานี้ฉัน ไปลงในรหัสแหล่งที่มาของวันนี้และรวบรวม
swap และเรียก ./swap ที่สุดสำหรับ ครั้งแรกที่เราเห็นว่าจริง
ค่าของฉันมีแน่นอน ประสบความสำเร็จในการเปลี่ยน
และตอนนี้เรายังสามารถใช้เวลา บันทึกนี้ในการพูด, gdb
>> เพื่อให้ฉันไปเป็นไฟล์เดียวกัน
ให้ฉันไปข้างหน้าและเรียกใช้ gdb ของ ./swap
และขณะนี้ในการแลกเปลี่ยนฉันจะไป ข้างหน้าและกำหนดจุดหยุดพักในหลัก
และตอนนี้ฉันจะไป ข้างหน้าและเรียกใช้โปรแกรม
และตอนนี้เราจะเห็นรหัสของฉัน หยุดที่บรรทัดที่
>> ถ้าฉันไปข้างหน้าและการพิมพ์ x สิ่งที่ฉันควรจะเห็นที่นี่?
มันเป็นคำถามที่
พูดอีกครั้งหรือไม่
>> ผู้ชม: [ไม่ได้ยิน]
>> เดวิดเจลันดังนั้น ตัวเลขสุ่มอาจจะ
บางทีฉันอาจจะได้รับโชคดีและก็ ที่ดีและง่ายเช่น 0
แต่อาจจะเป็นบางส่วนจำนวนสุ่ม
ในกรณีนี้ผมโชคดี
มันก็เกิดขึ้นเป็น 0
แต่มันเป็นความจริงโชค เพราะไม่ได้จนกว่าฉัน
พิมพ์ต่อไปและจากนั้นพิมพ์ x มีที่ บรรทัดของรหัสสาย 19, ถูกประหารชีวิต
>> ขณะเดียวกันถ้าฉันพิมพ์ต่อไปอีกครั้งและ ตอนนี้พิมพ์ออกมาปีนี้ผมกำลังจะไปดู 2
ตอนนี้ถ้าฉันพิมพ์ต่อไปมันจะ ได้รับความสับสนเล็กน้อยเพราะตอนนี้
printf จะปรากฏบน หน้าจอขณะที่มันทำ x 1
>> ลองทำเช่นนี้อีกครั้ง
และตอนนี้ที่นี่เป็นที่ที่ สิ่งที่ได้รับที่น่าสนใจ
ก่อนที่ผมจะเรียก Swap หรือแม้กระทั่งขั้นตอนที่ เป็นมันลองมาแอบมองเล็ก ๆ น้อย ๆ
x คืออีก 1
Y เป็นของหลักสูตรที่มีสุขภาพจิตดีอย่างรวดเร็ว ตรวจสอบ 2 จึงไม่ยากที่จะมี
แต่สิ่งที่เป็นเครื่องหมาย x อะไร
คำตอบมันเป็นชนิดของขี้ขลาดมอง
แต่ดาว int ในวงเล็บเป็นเพียง วิธีที่จีดีพีของคำพูดนี้คือที่อยู่
มันไม่ได้ int มันเป็นตัวชี้ไปยัง int หรือที่เรียกว่าอยู่
>> คืออะไร? นี้สิ่งที่บ้า
เราไม่เคยเห็นอะไรบางอย่าง ค่อนข้างเช่นนั้นก่อน
ดังนั้นนี่คือที่อยู่ในคอมพิวเตอร์ของฉัน ความทรงจำของที่ x ที่เกิดขึ้นกับชีวิต
มันเป็นวัวบางสิ่งบางอย่าง
และนี่คือตรงไปตรงมาว่าทำไม ผมได้เริ่มต้นการวาดลูกศร
แทนตัวเลข เพราะคนที่ใส่ใจจริงๆ
ที่ int ของคุณอยู่ที่ใด อยู่ที่ว่าใหญ่
แต่ bffff0c4 เ​​หล่านี้ทั้งหมด แน่นอนตัวเลขฐานสิบหก
ซึ่งเป็น 0 ถึงฉ
>> ดังนั้นเราจึงไม่ได้ไปอาศัยอยู่ด้วย ยาวในสิ่งเหล่านั้น
แต่ถ้าผมพิมพ์ออกมาปี, แน่นอนฉันดู 2
แต่เครื่องหมายปีผมเห็นอยู่นี้
และแจ้งให้ทราบล่วงหน้าอยากรู้อยากเห็น วิธีห่างไกลกัน x และ y คืออะไร?
คุณสามารถละเว้นส่วนใหญ่ของที่อยู่
สี่ไบต์
และที่สอดคล้องกับของเรา ก่อนหน้านี้อ้างว่าวิธีการใหญ่เป็น int?
สี่ไบต์
เพื่อให้ดูเหมือนว่าซับทุกอย่างขึ้น อย่างที่คุณอาจจะหวังในความทรงจำ
>> ดังนั้นตอนนี้ขอเพียงแค่ไปข้างหน้าอย่างรวดเร็ว ถึงตอนจบของเรื่องนี้
ให้เป็นไปข้างหน้าและพิมพ์ขั้นตอน การดำน้ำในการทำงานแลกเปลี่ยน
ตอนนี้สังเกตเห็นว่าฉันพิมพ์มัน เหมือนกันไปยังที่อยู่ของ x
ถ้าผมชนิด b ก็เหมือนกัน ไปยังที่อยู่ของ y
ดังนั้นสิ่งที่ฉันควรจะดูว่าฉัน บอกว่าให้ไปที่ที่อยู่ได้หรือไม่
ดังนั้นดาวพิมพ์
ดังนั้นดาวหมายถึงไปที่นั่นในบริบทนี้
เครื่องหมายหมายถึงสิ่งที่เป็นที่อยู่ของ
ดังนั้นวิธีการดาว 1
และดาวพิมพ์ขให้ฉัน 2
>> และแจ้งให้เราถือว่าในขณะนั้น ว่าอย่างน้อยรหัสที่
วิธีการที่จะดำเนินการขณะนี้สามารถ ให้เหตุผลผ่านทางในทางที่
แต่เราจะทบทวนความคิดนี้ไม่นาน
ดังนั้นรุ่นของ Swap นี้ คือตอนที่ถูกต้องและช่วยให้
เราจะแลกเปลี่ยนข้อมูลชนิดนี้โดยเฉพาะ
>> ดังนั้นคำถามใด ๆ แล้วใน Swap?
บนดาว?
เกี่ยวกับที่อยู่ของ?
และคุณจะเห็นด้วย ปัญหาชุด 4, การจัดเรียงของ
แต่ปัญหาตั้ง 5 แน่นอนวิธีการเหล่านี้ สิ่งที่มีประโยชน์และได้รับมากขึ้น
สะดวกสบายกับพวกเขาเป็นผล
อะไรที่ทั้งหมดหรือไม่
ขวาทั้งหมด
ดังนั้น malloc คืออีกฟังก์ชั่นนี้ ที่เพิ่งจัดสรรหน่วยความจำหน่วยความจำ
การจัดสรร
และเหตุผลนี้เป็นประโยชน์หรือไม่
ดีทุกเวลานี้ คุณได้ใช้ malloc
หากคุณพิจารณาตอนนี้วิธี GetString งานสมมุติมัน
รับการขอให้คนสำหรับก้อน หน่วยความจำที่ทุกเวลาผู้ใช้ประเภทสตริง
ในเพราะเราอย่างแน่นอน ไม่ทราบว่าเป็นพนักงาน CS50,
วิธีการใหญ่สายที่มนุษย์ จะพิมพ์อาจจะมี
>> จึงขอเป็นครั้งแรกที่เริ่มต้นที่จะ เปลือกกลับวิธีการทำงานของห้องสมุด CS50,
โดยวิธีการที่คู่ของตัวอย่าง ที่จะนำเราไปที่นั่น
ดังนั้นถ้าผมเปิดขึ้น Gedit และเปิด scanf 0,
เรากำลังจะไปดูรหัสต่อไปนี้
scanf 0, มีอยู่ในเว็บไซต์สำหรับ ในวันนี้มีเพียงไม่กี่บรรทัดของรหัส
ที่นี่ 14 ผ่าน 20
และขอดูสิ่งที่มันทำ
มันประกาศ int เรียกว่า x
มันบอกว่าสิ่งที่ต้องการจำนวนโปรด
และตอนนี้ก็กล่าวว่า scanf% i & x
จึงมีพวงของสิ่งใหม่ ๆ มี
>> แต่ scanf คุณชนิดของสามารถคิด ในฐานะที่เป็นตรงข้ามของ printf
printf แน่นอนพิมพ์ไปที่หน้าจอ
จัดเรียง scanf การสแกนจากผู้ใช้ สิ่งที่แป้นพิมพ์เขาหรือเธอได้พิมพ์
>> % ผมก็เหมือนกับ printf
ซึ่งหมายความว่า ผู้ใช้สามารถพิมพ์ int
และตอนนี้ทำไมคุณคิดว่าฉัน อาจจะมีการผ่าน scanf และ x?
หากจุดประสงค์ในชีวิตของ scanf คือการได้รับบางสิ่งบางอย่างจากผู้ใช้
สิ่งที่เป็นความหมายของ ผ่านมันและ x, ตอนนี้หรือไม่
ใช่?
>> ผู้ชม: [ไม่ได้ยิน]
เดวิดเจลัน: แน่นอน
สิ่งที่ฉัน, มนุษย์, พิมพ์ในการป้อนข้อมูลของฉัน จะถูกบันทึกไว้ที่ตำแหน่งที่
มันไม่เพียงพอจำได้เพียงแค่ ผ่านใน x เพราะเราได้เห็นแล้ว
เวลาที่คุณผ่านเพียงตัวแปรดิบ เช่น int, บางฟังก์ชั่นอื่น ๆ
แน่ใจว่ามันสามารถเปลี่ยนที่ ตัวแปร แต่ไม่ถาวร
มันไม่สามารถมีผลกระทบต่อหลัก
มันสามารถเปลี่ยนเฉพาะสำเนาของตัวเอง
แต่ถ้าแทนคุณทำไม่ได้ ให้ฉัน int จริง
แต่คุณให้ฉันเส้นทางไป int ที่ตอนนี้ผมเป็น scanf,
แน่นอนผมสามารถทำตามที่ ที่อยู่และใส่หมายเลขที่นั่น
เพื่อให้คุณสามารถเข้าถึงได้เช่นกัน
>> ดังนั้นเมื่อผมรันโปรแกรมนี้เรามาดู
ทำให้ scanf 0 จุดเฉือน, scanf 0
และถ้าตอนนี้ผมพิมพ์หมายเลข เช่น 50 ขอบคุณ 50
ถ้าตอนนี้ผมพิมพ์หมายเลขเช่น ลบ 1 สำหรับลบ 1
ตอนนี้ผมพิมพ์ตัวเลขเช่น 1.5 แฮะ
ทำไมโปรแกรมของฉันไม่สนใจฉัน?
ดีเพราะเพียงแค่ผมบอก มันจะคาดหวัง int เท่านั้น
ขวาทั้งหมด
เพื่อให้เป็นรูปแบบหนึ่งของเรื่องนี้
ลองใช้สิ่งที่ขึ้นรอยและ เสนอว่านี้ไม่ดี
และในที่นี้อยู่เป็นตัวอย่างที่ง่ายมาก ของวิธีการที่เราสามารถเริ่มต้นการเขียนโค้ด
ว่าคนอื่น ๆ สามารถใช้ประโยชน์หรือ ประนีประนอมด้วยการทำสิ่งที่ไม่ดี
ดังนั้นสาย 16 ที่คล้ายกันมาก ในจิตวิญญาณที่จะมาก่อน
แต่ผมไม่ได้ประกาศว่า int เวลานี้
ผมประกาศว่าดาวถ่านอาคาสตริง
>> แต่สิ่งที่ไม่ว่าจริงๆหมายถึงอะไร
ดังนั้นถ้าฉันไม่ได้ระบุ address-- และ ผมเรียกมันว่าพลบัฟเฟอร์
แต่ผมจะเรียกมันจะ simple-- และแล้วฉันทำเช่นนี้อธิบายให้ฉัน
ถ้าคุณสามารถขึ้นอยู่กับก่อนหน้านี้ ตรรกะสิ่งที่ scanf ทำในสาย 18
ถ้า% s ผ่านและบัฟเฟอร์ ซึ่งเป็นที่อยู่?
อะไรคือสิ่งที่ scanf ถ้าคุณใช้ ตรรกะเดียวกันแน่นอนเป็นรุ่น 0,
จะพยายามที่จะทำที่นี่เมื่อ สิ่งที่ผู้ใช้มีอะไรบ้าง?
ใช่?
>> ผู้ชม: [ไม่ได้ยิน]
>> เดวิดเจลัน: แน่นอน
scanf โดยตรรกะก่อนหน้านี้ จะใช้สตริง
ที่พิมพ์ของมนุษย์ in-- ก็ตอนนี้สตริง
มันไม่ได้เป็นตัวเลขสมมุติ ถ้าเขาหรือเธอ cooperates--
และก็จะพยายามที่จะใส่ที่ สตริงในหน่วยความจำที่อยู่ที่ใด
ระบุบัฟเฟอร์
และนี่คือที่ดีเพราะบัฟเฟอร์ มีความหมายแน่นอนจะเป็นที่อยู่
>> แต่ผมเรียกร้องโปรแกรมนี้เป็นรถใน วิธีการที่รุนแรงมากเพราะสิ่งที่มีค่าเป็น
buffer โดยปริยายหรือไม่?
สิ่งที่ฉันได้เริ่มต้นเป็น?
สิ่งที่รับรู้ของหน่วยความจำ?
ฉันไม่ได้ใช่มั้ย?
>> ดังนั้นแม้ว่าฉันได้รับการจัดสรร ดาวถ่านที่ไม่ได้เรียกว่าวินาที,
ก็เรียกว่าแทน buffer-- ดังนั้น ให้วาดชื่อของตัวแปร
ขณะนี้เป็น buffer-- ถ้าฉันไม่ได้ เรียกว่า getString หรือ malloc ที่นี่
ที่มีประสิทธิภาพหมายถึงการที่ บัฟเฟอร์เป็นเพียงบางค่าขยะ
>> ตอนนี้สิ่งที่หมายความว่า?
มันหมายความว่าฉันได้บอก scanf ที่คาดหวังสตริงจากผู้ใช้
และคุณรู้อะไรไหม
ไม่ว่าสิ่งนี้จะชี้ ยา่และฉันวาดเครื่องหมายคำถาม
แต่ในความเป็นจริงมันเป็นไปได้ สิ่งที่ต้องการ OX1, 2, 3, ขวา?
มันเป็นบางค่าปลอมที่เพียงแค่ ที่จะเกิดขึ้นก่อนที่จะมีจาก
ดังนั้นใส่อีกวิธีหนึ่งก็ ราวกับว่ากันชนเป็นเพียง
ชี้ไปที่สิ่งที่อยู่ในหน่วยความจำ
ผมมีความคิดว่า
>> ดังนั้นถ้าผมพิมพ์ในเกบตอนนี้มันจะ เพื่อพยายามที่จะนำ G--b-e / 0 มี
แต่ใครจะรู้ว่ามันคืออะไร?
และในอดีตที่ผ่านมาใด ๆ เวลาที่เราได้พยายามที่จะสัมผัส
หน่วยความจำที่ไม่ได้อยู่ ให้เราสิ่งที่ได้เกิดขึ้น?
หรือเกือบทุกครั้ง
ความผิดส่วนใช่มั้ย?
>> ลูกศรนี้ผมไม่มีความคิดที่จะเป็น ชี้ มันเป็นเพียงแค่บางส่วนค่าสุ่ม
และแน่นอนถ้าคุณตีความ ค่าสุ่มที่อยู่,
คุณกำลังจะไปที่ บางสถานที่สุ่ม
ดังนั้นเกบอาจจะผิดพลาดแน่นอน โปรแกรมในกรณีนี้ที่นี่ของฉัน
>> ดังนั้นสิ่งที่เราสามารถทำสิ่งที่เกือบจะเป็นไม่ดี?
พิจารณาที่สามนี้และ ตัวอย่างสุดท้ายของ scanf
รุ่นนี้จะดีกว่าในความรู้สึกอะไร
ถ้าคุณมีความสะดวกสบายด้วย ปัญหาก่อนหน้านี้จะดีกว่า
ทำไม?
>> ผู้ชม: [ไม่ได้ยิน]
เดวิดเจลัน: ดี
ดังนั้นกรณีของสาย 16 นี้ จะดีกว่าในแง่ที่
ว่าเราอย่างชัดเจน จัดสรรหน่วยความจำบางส่วน
เราไม่ได้ใช้ malloc, เรากำลังใช้สัปดาห์ที่ 2
วิธีการเพียงการประกาศอาร์เรย์
และเราได้กล่าวก่อนที่สตริง เป็นเพียงอาร์เรย์ของตัวอักษร,
ดังนั้นนี่คือถูกต้องตามกฎหมายทั้งหมด
แต่ก็แน่นอนว่า คุณทราบขนาดคงที่ 16
>> ดังนั้นโปรแกรมนี้ ทั้งหมดปลอดภัยถ้าฉันพิมพ์
ในสตริงตัวละครตัวหนึ่งในสองตัวละคร สตริงสตริง 15 ตัวอักษร
แต่ทันทีที่ผมเริ่มพิมพ์ 16 17, 18, 1,000 สตริงตัวอักษร
ที่มีการสตริงที่จะจบได้อย่างไร
มันจะจบลงด้วยการเป็นส่วนหนึ่งที่นี่
แต่แล้วผู้ที่รู้สิ่งอื่น อยู่นอกเหนือขอบเขต
ของอาร์เรย์นี้โดยเฉพาะ?
>> มันเหมือนกับว่าฉันได้ ประกาศ 16 กล่องที่นี่
ดังนั้นแทนที่จะวาดออกทั้งหมด 16 เราจะ เพียงแค่แกล้งทำเป็นว่าผมได้วาด 16
แต่ถ้าฉันก็พยายามที่จะอ่านสตริง ที่มากอีกต่อไปเช่น 50 ตัวอักษร
ฉันจะเริ่มวาง A, B, C, D, x, y, z
และนี่คือสันนิษฐาน บางส่วนหน่วยความจำอื่น ๆ
ที่อีกครั้งอาจทำให้เกิด โปรแกรมของฉันที่จะผิดพลาด
เพราะฉันไม่ได้ถาม อะไรที่มากกว่าเพียงแค่ 16 ไบต์
>> ดังนั้นผู้ที่ใส่ใจ?
ดีที่นี่เป็นห้องสมุด CS50
และส่วนใหญ่ของนี้เป็นเพียง เช่นคำแนะนำขึ้นด้านบน
ห้องสมุด CS50 ทุกเวลานี้ มีสายในสาย 52 นี้
เราได้เห็น typedef หรือ คุณจะเห็น typedef
ใน pset 4 ที่เพิ่งสร้าง คำพ้องความหมายโดยถ่านดาวได้มากขึ้น
ก็เรียกว่าเป็นสตริง
ดังนั้นนี้เป็นหนึ่งใน ล้อการฝึกอบรมไม่กี่
เราเคยใช้แอบอยู่ใต้กระโปรงหน้ารถ
>> ในขณะเดียวกันนี่คือฟังก์ชัน getchar
ตอนนี้เห็นได้ชัดว่ามีร่างกายไม่มัน
และในความเป็นจริงถ้าผมเก็บ เลื่อนฉันไม่จริง
เห็นการใช้งานใด ๆ ฟังก์ชั่นเหล่านี้
การตรวจสอบสุขภาพจิตดีทำไมจึงเป็นเช่นนั้น
>> ผู้ชม: [ไม่ได้ยิน]
เดวิดเจลัน: ใช่
ดังนั้นนี่คือส่วนหัวของแฟ้ม
และไฟล์ส่วนหัวมีต้นแบบ บวกบางสิ่งอื่น ๆ ดูเหมือนว่า
เช่น typedefs
แต่ใน CS50.c ซึ่งเราได้ ไม่เคยได้รับคุณทันที
แต่ได้รับในเครื่อง CS50 ทั้งหมด เวลานี้ลึก ๆ ข้างในโฟลเดอร์ของ
สังเกตเห็นว่ามีทั้ง พวงของการทำงานที่นี่
>> ในความเป็นจริงให้เลื่อนลง
ลองไม่สนใจส่วนใหญ่ของพวกเขาในขณะนี้
แต่เลื่อนลงไป GetInt และดูงานวิธี GetInt
ดังนั้นนี่คือ GetInt
และถ้าคุณเคยดูแลจริงๆว่าได้รับ int ทำงานที่นี่เป็นเอกสารประกอบ
และเหนือสิ่ง มันบอกว่ามันจะบอกคุณ
สิ่งที่ช่วงของค่าที่จะสามารถกลับ
มันเป็นเชิงลบเป็นหลัก 2 พันล้าน บวก 2 พันล้านหรือจะให้
>> และมันจะเปิดออกทั้งหมดนี้ เวลาแม้ว่าเราไม่เคย
ได้ที่คุณตรวจสอบมัน ถ้าอะไรผิดพลาด
ปรากฎว่าทั้งหมด เวลานี้มี GetInt
รับกลับมาเป็นพิเศษ คงไม่เป็นโมฆะ
แต่ INT_MAX ซึ่งเป็น เพียงแค่การประชุมของโปรแกรมเมอร์
มันหมายความว่านี่เป็นค่าพิเศษ
ตรวจสอบให้แน่ใจในการตรวจสอบนี้เพียงแค่ ในกรณีที่มีอะไรผิดพลาด
แต่เราไม่เคยใส่ใจ กับที่ในวันที่
เพราะครั้งนี้ จะหมายถึงการลดความซับซ้อนของ
>> แต่วิธีการที่ไม่ได้รับการดำเนินการ GetInt?
ดีหนึ่งก็จะใช้เวลาไม่มีข้อโต้แย้ง
เรารู้ว่า
มันกลับ int
เรารู้ว่า
ดังนั้นวิธีที่จะทำงานภายใต้เครื่องดูดควันหรือไม่
>> จึงมีเห็นได้ชัดไม่มีที่สิ้นสุด ห่วงอย่างน้อยการปรากฏตัวของหนึ่ง
ขอให้สังเกตว่าเรากำลังใช้ getString
เพื่อให้เป็นที่น่าสนใจ GetInt เรียกฟังก์ชันของเราเอง getString
และตอนนี้ทำไมนี้อาจจะมีกรณีหรือไม่
ทำไมฉันถึงการป้องกัน ที่นี่ในสาย 165?
สิ่งที่อาจเกิดขึ้นในสาย 164 เพียงเพื่อจะชัดเจน?
เป็นคำตอบที่เหมือนก่อน
ก็อาจจะออกมาจากหน่วยความจำ
อะไรผิดพลาดกับ getString, เราได้มีการจะสามารถจัดการที่
และเหตุผลที่ฉันไม่กลับเป็นโมฆะ ว่าในทางเทคนิค null เป็นตัวชี้
GetInt มีที่จะกลับ int
ดังนั้นผมจึงได้พล ตัดสินใจเป็นหลัก
ที่ 2 พันล้านหรือจะให้เป็นไป จะเป็นค่าพิเศษที่ผมไม่สามารถ
ได้รับจริงจากผู้ใช้
มันเป็นเพียงค่าเดียวที่ฉันจะ เสียเพื่อเป็นตัวแทนของรหัสข้อผิดพลาด
>> ดังนั้นตอนนี้สิ่งที่ได้รับแฟนซีเล็ก
และมันก็ไม่มากฟังก์ชั่นเดียวกัน เหมือนก่อน แต่ก็คล้ายกันมาก
เพื่อให้สังเกตเห็นฉันประกาศที่นี่ในสาย 172 ทั้ง n int และถ่านค
และแล้วฉันจะใช้เส้นขี้ขลาดนี้ sscanf ซึ่งมันจะเปิดออก
ไม่สแกนสตริงจากแป้นพิมพ์
มันยืนสตริงที่มีอยู่ที่ ผู้ใช้มีการพิมพ์แล้วใน
ดังนั้นฉันแล้วเรียกว่า getString ซึ่ง หมายถึงฉันมีสตริงในหน่วยความจำ
sscanf เป็นสิ่งที่คุณต้องการ การเรียกใช้ฟังก์ชันการแยก
มันมีลักษณะที่สตริงฉัน พิมพ์ตัวอักษรโดยตัวอักษร
และไม่สิ่งที่มีประโยชน์
สตริงที่ถูกเก็บไว้ในสาย
และฉันรู้ว่ามีเพียงโดยไป กลับขึ้นที่นี่และพูดว่าโอ้ตกลง
ผมเรียกมันไม่ได้เวลานี้ แต่สาย
>> และตอนนี้มีความแตกต่างเล็ก ๆ น้อย ๆ
แต่ตอนนี้มีประสิทธิภาพหมายถึงเหตุผล เราค่อนข้างจะโบกมือของเราในวันนี้
ว่าเรามีการตรวจสอบเพื่อ ดูว่าผู้ใช้พิมพ์ลงใน
และ int และอาจจะเป็นตัวละครอื่น
หากผู้ใช้พิมพ์ลงใน int ก็ จะถูกเก็บไว้ใน n เพราะฉัน
การผ่านนี้ตามที่อยู่ที่ เคล็ดลับใหม่ที่เราได้เห็นในวันนี้
หากผู้ใช้ยังพิมพ์ ในเช่น 123x, x ที่
กำลังจะจบลง จดหมายในลักษณะค
>> ตอนนี้มันจะเปิดออก sscanf ที่ จะบอกฉันอย่างชาญฉลาด,
วิธีการหลายตัวแปรที่ถูก sscanf ประสบความสำเร็จสามารถที่จะเติมเต็ม
ดังนั้นโดยตรรกะนี้ถ้าฟังก์ชัน ผมดำเนินการเป็น GetInt,
แต่ฉันกำลังตรวจสอบ ที่อาจเกิดขึ้นสำหรับผู้ใช้
จะมีการพิมพ์ใน int ตามมาด้วยสิ่งอื่น
สิ่งที่ฉันต้องการของ sscanf ค่าตอบแทนอย่างแท้จริงจะเป็นอย่างไร
หากมีวัตถุประสงค์ที่จะได้รับ เพียง int จากผู้ใช้?
>> ดังนั้นหากผลตอบแทน sscanf 2 สิ่งที่หมายความว่า?
ผู้ใช้พิมพ์ลงใน สิ่งที่ต้องการอย่างแท้จริง
123x ซึ่งเป็นเพียงเรื่องไร้สาระ
มันเป็นเงื่อนไขข้อผิดพลาดและ ผมต้องการที่จะตรวจสอบว่า
>> ดังนั้นหากผู้ใช้ประเภทนี้โดย ตรรกะนี้สิ่งที่ไม่ sscanf กลับ
คุณจะพูดว่า?
ดังนั้นมันจะกลับ 2 เนื่องจาก 123 จะไปในที่นี่
และ x เป็นไปจบลงที่นี่
แต่ฉันไม่ต้องการ x จะได้รับการเติมเต็ม
ผมต้องการที่จะ sscanf เพียงประสบความสำเร็จใน เติมครั้งแรกของตัวแปร
และอื่น ๆ ที่ว่าทำไมฉัน ต้องการที่จะกลับ sscanf 1
>> และถ้าเป็นบิตเหนือหัว สำหรับช่วงเวลาที่ดีโดยสิ้นเชิง
ตระหนักถึงแม้ว่าที่หนึ่ง ค่านิยมของ GetInt และ getString
คือว่าเรากำลังทำ heck ของ จำนวนมากของข้อผิดพลาดการตรวจสอบเช่นนี้เพื่อให้
ว่าวันที่คุณสามารถสวยมาก พิมพ์สิ่งที่แป้นพิมพ์ของคุณ
และเราจะจับมัน
และเราอย่างแน่นอน พนักงานจะไม่แน่นอน
เป็นแหล่งที่มาของข้อผิดพลาดในส่วนของคุณ โปรแกรมเพราะเรา defensively
การตรวจสอบสำหรับทุกโง่ สิ่งที่ผู้ใช้อาจจะทำ
เช่นการพิมพ์สตริงเมื่อ คุณต้องการ int จริงๆ
ดังนั้นสำหรับ now-- เราจะมา กลับไปก่อนหน้านี้ long--
แต่ทั้งหมดเวลานี้ getString และ GetInt มี
รับภายใต้กระโปรงหน้ารถใช้นี้ แนวคิดพื้นฐานที่อยู่ของหน่วยความจำ
>> ดังนั้นตอนนี้ขอทำในสิ่งที่ ใช้งานง่ายเพียงเล็กน้อย
ในขณะที่คุณอาจจำจากบิงกี้ล่าสุด time-- ถ้าเมาส์ของฉันจะ cooperate-- ดังนั้น
เรามีรหัสนี้ซึ่ง ตรงไปตรงมาเป็นไร้สาระอย่างเป็นธรรม
รหัสนี้ประสบความสำเร็จอะไร ที่มีประโยชน์ แต่ก็เป็นตัวอย่าง
อาจารย์ Parlante ที่ ที่ใช้ในการสั่งซื้อเพื่อเป็นตัวแทนของ
สิ่งที่เกิดขึ้นใน โปรแกรมที่เกี่ยวข้องกับหน่วยความจำ
>> จึงขอเปิดเผยความลับนี้ เรื่องราวสุดในเวลาสั้น ๆ
ทั้งสองสายแรกใน อังกฤษทำในสิ่งที่คุณจะพูด?
เพียงแค่ในเหตุผลของมนุษย์ แต่ เล็กน้อยด้านเทคนิคใช้แทง
ผู้ชม: [ไม่ได้ยิน]
>> เดวิดเจลัน: ตกลงคุณกำลังสร้าง ที่อยู่สำหรับ x และตัวแปร Y ของคุณ
ไม่มากเพราะ x และ y ไม่ได้ ตัวแปรในความหมายดั้งเดิม
x และ y มีอยู่ หรือจะเก็บที่อยู่
ดังนั้นเรามาลองนี้อีกครั้ง
ไม่ได้เริ่มต้นที่ไม่ดี แต่
ใช่?
>> ผู้ชม: [ไม่ได้ยิน]
เดวิดเจลัน: ดี
ผมคิดว่าการทำความสะอาดเพียงเล็กน้อย
ประกาศสองตัวชี้จำนวนเต็มสองจำนวน
และเรากำลังเรียกพวกเขา x และ y
หรือถ้าเราจะวาด นี้เป็นภาพอีกครั้ง
จำค่อนข้างง่ายว่า ที่เรากำลังทำกับสายแรกที่
เป็นรูปวาดกล่องเช่นนี้ ที่มีค่าขยะบางอย่างในนั้น
และเรียกมันว่า x แล้ว กล่องอื่นเช่นนี้
ที่มีค่าขยะบาง ในนั้นเรียกมันว่าปี
เราได้ประกาศสอง ชี้ว่าในท้ายที่สุด
จะเก็บที่อยู่ของ int
นั่นคือทั้งหมดที่มี
>> ดังนั้นเมื่อบิงกี้ทำอย่างนี้ ดินเพียงแค่มองเช่นนี้
และนิคเพียงชนิดของ ห่อลูกศร
ราวกับว่าพวกเขาไม่ได้ชี้ไปที่ใดก็ได้ โดยเฉพาะอย่างยิ่งเพราะพวกเขากำลังเพียง
ค่าขยะ
พวกเขาไม่ได้เริ่มต้นได้อย่างชัดเจน ทุกที่โดยเฉพาะอย่างยิ่ง
>> ตอนนี้บรรทัดถัดไปของ รหัสการเรียกคืนเป็นแบบนี้
ดังนั้นในการใช้งานง่ายพอสมควร แต่ภาษาอังกฤษค่อนข้างเทคนิค
สิ่งที่เป็นบรรทัดของรหัสการทำเช่นนี้?
ใช่?
>> ผู้ชม: [ไม่ได้ยิน]
>> เดวิดเจลัน: ที่สมบูรณ์แบบ
มันจัดสรรก้อน หน่วยความจำที่เป็นขนาดของ int
และนั่นคือคำตอบครึ่งหนึ่ง
คุณตอบที่ถูกต้อง ครึ่งหนึ่งของการแสดงออก
สิ่งที่เกิดขึ้นเมื่อวันที่ ด้านซ้ายมือของเครื่องหมายเท่ากับหรือไม่
ใช่?
ผู้ชม: และกำหนด ให้ตัวแปร x?
>> เดวิดเจลัน: และกำหนด ให้ตัวแปร x
ดังนั้นเพื่อปะยางรถขวามือด้านจัดสรร หน่วยความจำพอที่จะเก็บ int
แต่ malloc เฉพาะ ผลตอบแทนที่ได้อยู่
ของก้อนที่ของหน่วยความจำซึ่งคุณได้ เสนอเพียงแค่ได้รับการจัดเก็บไว้ใน x
>> ดังนั้นสิ่งที่นิคได้เป็นครั้งสุดท้ายกับบิงกี้เป็น เขาลากตัวชี้ให้เห็นว่าดินที่
ชี้ตอนนี้ที่เป็นก้อนสีขาวของหน่วยความจำ ที่เท่ากับขนาดของ int
และแน่นอนว่าหมายถึง เพื่อเป็นตัวแทนของสี่ไบต์
>> ตอนนี้บรรทัดถัดไปของรหัส ทำอย่างนี้ได้รับดาว x 42
ดังนั้น 42 ตรงไปตรงมาเกี่ยวกับ ด้านขวามือ, ความหมายของชีวิต
ด้านซ้ายมือดาว x หมายถึงอะไร
ที่มากเกินไปอาจมี gone-- ที่ตกลง
ตกลง
>> ผู้ชม: โดยทั่วไป ไปที่ [ไม่ได้ยิน]
เดวิดเจลัน: ดี
ผู้ชม: [ไม่ได้ยิน]
เดวิดเจลัน: แน่นอน
ด้านซ้ายมือหมายถึงการไปที่ x
x คือที่อยู่
มันก็เหมือนกับ 33 Oxford Street หรือ OX1
และดาว x หมายถึงการไปที่ ที่อยู่และนำสิ่งที่มี?
42
>> ดังนั้นจริงที่ว่าสิ่งที่นิคได้
เขาเริ่มต้นด้วยโดย เป็นหลักใจ
ชี้นิ้วที่ x ตามลูกศร
กล่องสีขาวที่อยู่ทางขวามือ ด้านข้างและใส่หมายเลข 42 มี
แต่แล้วสิ่งที่ได้รับ อันตรายเล็ก ๆ น้อย ๆ ใช่มั้ย?
บิงกี้จะสูญเสียหัวของเขา
>> ดาวปีเท่ากับ 13 โชคไม่ดีหมายถึงอะไร
ดังนั้นวิธี Y ดาวไปที่ที่อยู่ในปี
แต่สิ่งที่เป็นอยู่ในปี?
ขวาทั้งหมดก็ค่าขยะใช่มั้ย?
ฉันวาดเป็นเครื่องหมายคำถาม
นิคเข้ามาเป็นลูกศรขด
และเร็วที่สุดเท่าที่คุณพยายามที่จะ ทำ Y ดาวบอกว่าไปที่นั่น
แต่ที่มีอยู่ไม่ถูกต้องตามกฎหมาย อยู่มันเป็นสถานที่ปลอมบางส่วน
โปรแกรมจะผิดพลาด
และหัวบิงกี้เป็นไป ที่จะบินออกจากที่นี่เท่าที่จะทำได้
>> ดังนั้นในที่สุดโปรแกรมนี้ เป็นข้อบกพร่องออกแบนเพียง
มันเป็นโปรแกรมรถ
และมันจะต้องได้รับการแก้ไข
และวิธีเดียวจริงๆที่จะแก้ไขได้ จะเป็นเช่นบรรทัดนี้
ซึ่งเราไม่ได้รับการเพราะ โปรแกรมตกเร็วเกินไป
แต่ถ้าเราจะแก้ไขปัญหานี้สิ่งที่ ผลกระทบไม่ทำ Y x เท่ากับมี?
ดีก็เป็นหลักชี้ปีที่ สิ่งที่ค่า x จะชี้ไปที่
>> ดังนั้นในเรื่องของนิค หรือเรื่องราวของบิงกี้ทั้ง
x และ y ถูกชี้ไปที่ ก้อนสีขาวของหน่วยความจำ
เพื่อที่ว่าในที่สุดเมื่อคุณ ไม่ดาวปีเท่ากับ 13 อีกครั้ง
คุณท้ายวาง 13 สถานที่ตั้งที่เหมาะสม
ดังนั้นทั้งหมดของเส้นเหล่านี้อย่างสมบูรณ์แบบ ถูกต้องตามกฎหมายยกเว้นสำหรับคนนี้
เมื่อมันเกิดขึ้นก่อนที่คุณจะ ที่ได้รับมอบหมายจริง Y ค่าบางอย่าง
>> ตอนนี้โชคดีที่คุณทำไม่ได้ มีการให้เหตุผลผ่านทั้งหมด
เหล่านี้ชนิดของปัญหาด้วยตัวคุณเอง
ให้ฉันไปข้างหน้าและเปิด ขึ้นหน้าต่าง terminal ที่นี่
และเปิดขึ้นเพียงชั่วครู่หนึ่ง โปรแกรมซุปเปอร์สั้น ๆ ว่า
นอกจากนี้ยังมีการจัดเรียงของจุดหมาย
มันน่าเกลียด
มันไม่ประสบความสำเร็จในสิ่งที่มีประโยชน์
แต่มันก็ไม่แสดงให้เห็นถึงปัญหา ของหน่วยความจำเพื่อให้มาดู
>> หลักง่ายสุด
มันเห็นได้ชัดเรียกฟังก์ชัน ฉแล้วกลับ 0
เป็นชนิดของยากที่จะระเบียบนี้ขึ้น
ดังนั้นหลักคือที่ดีงามเพื่อให้ห่างไกล
>> ดังนั้นฉเป็นปัญหา
และก็ไม่ได้ใส่มาก ความพยายามในการตั้งชื่อมันว่า
ที่นี่เพื่อให้มุ่งเน้นในรหัส
ฉมีสองสาย
และขอดูสิ่งที่เกิดขึ้นตอนนี้
ดังนั้นในมือข้างหนึ่ง ตรงนี้และแจ้งให้เราทำให้
นี้สอดคล้องกับก่อนหน้านี้ ยกตัวอย่างในมือข้างหนึ่ง
ด้านซ้ายมือเป็น ทำในสิ่งที่ในภาษาอังกฤษได้ไหม
มันค่าเท่าใด
ผู้ชม: การสร้างตัวชี้
เดวิดเจลัน: การสร้างตัวชี้ เป็น int และเรียกมันว่า x
จึงสร้างหนึ่งของกล่องเหล่านั้น ฉันให้วาดภาพบนหน้าจอสัมผัส
และตอนนี้ทางด้านขวามือ ด้าน malloc แน่นอน
จะจัดสรรก้อนของหน่วยความจำ
และเพียงแค่ต้องมีความชัดเจนว่า หน่วยความจำมากมันเห็นได้ชัด
การจัดสรรถ้าคุณเพียง ชนิดของทำคณิตศาสตร์ที่นี่?
>> ดังนั้นจึงเป็น 40 ไบต์
และฉันรู้ว่าเพียงเพราะฉันรู้ว่า int ในเครื่อง CS50 อย่างน้อย
สี่ไบต์
ดังนั้น 10 ครั้ง 4 คือ 40
ดังนั้นนี้จะถูกจัดเก็บ x อยู่ ของออกก่อน 40 ints ที่
ได้รับการจัดสรรพื้นที่กลับ การสำรองข้อมูล, การสำรอง, การสำรองข้อมูล
>> และนั่นคือสิ่งที่สำคัญเกี่ยวกับ malloc
จะไม่ใช้หน่วยความจำน้อย ที่นี่เล็ก ๆ น้อย ๆ ที่นี่เล็ก ๆ น้อย ๆ ที่นี่
มันจะช่วยให้คุณหนึ่งก้อนของหน่วยความจำ ติดกันจากการดำเนินงาน
ระบบ
>> ตอนนี้สิ่งที่เกี่ยวกับเรื่องนี้ x 10 วงเล็บเท่ากับ 0?
เส้นโดยพลการของรหัส
มันไม่ประสบความสำเร็จในสิ่งที่มีประโยชน์
แต่ก็เป็นที่น่าสนใจ เพราะ x วงเล็บ 10--?
ใช่?
>> ผู้ชม: [ไม่ได้ยิน]
>> เดวิดเจลัน: x วงเล็บ 10 ไม่จำเป็นต้องเป็นโมฆะ
null รายละเอียดเพียงเข้ามาในเล่น กับสตริงในตอนท้ายของสตริง
แต่เป็นความคิดที่ดี
>> วิธีการใหญ่เป็นแถวนี้แม้ แต่ฉันได้รับการจัดสรร 40 ไบต์?
มัน 0 ถึงเก้าใช่มั้ย?
มันเป็น 10 ints รวม
40 ไบต์ แต่ 10 ints, การจัดทำดัชนี 0 ถึง 0
>> ดังนั้นสิ่งที่เป็นที่วงเล็บ x 10?
มันเป็นความจริงบางส่วน ค่าขยะที่ไม่รู้จัก
มันเป็นความทรงจำที่ไม่ได้อยู่กับผม
ฉันไม่ควรจะได้รับการสัมผัสที่ หมายเลข 41, 42, 43, 44 ไบต์
ฉันจะเล็กน้อยมากเกินไป
>> และแน่นอนถ้าฉันทำงานนี้ โปรแกรมก็อาจเป็นอย่างดีผิดพลาด
แต่บางครั้งเราจะได้รับโชคดี
และอื่น ๆ เพียงเพื่อแสดงให้เห็นถึง เจ้านี่และตรงไปตรงมา
ที่คุณไม่เคยรู้ว่าก่อนที่คุณจะ พูดไปไม่ให้ทำงานนี้
มันไม่ได้ผิดพลาดจริง
>> แต่ถ้าผมเปลี่ยนนี้สำหรับ เช่นจะเป็นเหมือน 1,000
จะทำให้เรื่องนี้จริงๆ เจตนาเรามาดู
ถ้าเราสามารถทำให้การผิดพลาดในครั้งนี้
ตกลงมันไม่ได้ผิดพลาด
วิธีการเกี่ยวกับ 100,000?
ลองรีเมคมันและตอนนี้มันวิ่ง
ตกลง
ว้า
ขวาทั้งหมด
ดังนั้นเห็นได้ชัดอีกครั้งเหล่านี้ ส่วนของหน่วยความจำเพื่อที่จะพูด
มีขนาดใหญ่พอสมควรเพื่อให้เราสามารถ ได้รับโชคดีอีกครั้งและอีกครั้ง
แต่ในที่สุดเมื่อคุณได้รับไร้สาระ และจริงๆไปไกลออกไปบนหน้าจอ
ที่คุณสัมผัสหน่วยความจำที่จริงๆ จริงๆไม่ได้เป็นของคุณ
>> แต่ตรงไปตรงมาเหล่านี้ ชนิดของข้อผิดพลาดที่จะไป
ที่จะเป็นหนักและยาก ที่จะคิดออกด้วยตัวคุณเอง
แต่โชคดีที่เป็นโปรแกรมเมอร์ที่เรามี เครื่องมือที่ช่วยให้เราสามารถทำเช่นนี้สำหรับเรา
ดังนั้นนี่คือบางทีหนึ่ง ของโปรแกรมที่น่าเกลียดที่สุดใน
แม้ไม่สวยงามเท่ากว่าการส่งออก gdb ของ
แต่มันมักจะมีเส้นหรือ สองที่มีประโยชน์สุด
>> valgrind เป็นโปรแกรมที่จะช่วยให้ คุณไม่ได้แก้ปัญหาโปรแกรมต่อ se
แต่พบว่าหน่วยความจำที่เกี่ยวข้อง ปัญหาเฉพาะ
มันจะเรียกใช้รหัสของคุณโดยอัตโนมัติ คุณและมองหาอย่างน้อยสองสิ่ง
หนึ่งคุณไม่ได้ทำอะไรบางอย่าง อุบัติเหตุเช่นหน่วยความจำสัมผัส
ที่ไม่ได้อยู่กับคุณหรือไม่
มันจะช่วยให้คุณพบกรณีที่
>> และทั้งสองก็จะช่วยให้ คุณพบสิ่งที่เรียกว่า
การรั่วไหลของหน่วยความจำที่เรามี สมบูรณ์ละเลยอย่างไร้เดียงสา,
บางครั้งและสุขสันต์
แต่มันจะเปิดออกทั้งหมด เวลานี้เมื่อใดก็ตามที่
ที่คุณได้เรียกว่า getString ใน ดังนั้นหลายโปรแกรมของเรา
คุณกำลังขอให้การดำเนินงานของ ระบบหน่วยความจำ
แต่คุณมีความทรงจำใด ๆ จากที่เคยให้มัน
กลับทำ unalloc หรือ ฟรีเป็นมันเรียกว่า
ไม่มีเพราะเราไม่เคย ถามคุณจะทำเช่นนั้น
>> แต่ทั้งหมดเวลานี้โปรแกรม คุณได้รับการเขียนใน C
ได้รับการรั่วไหลของหน่วยความจำ ขอให้การดำเนินงานของ
ระบบมากขึ้นและมากขึ้น หน่วยความจำสำหรับสตริงและ whatnot,
แต่ไม่เคยส่งกลับ
และตอนนี้เป็นบิต ของเปลือก,
แต่ถ้าคุณเคยใช้ Mac ของคุณหรือ เครื่องคอมพิวเตอร์ของคุณสำหรับค่อนข้างบางเวลาเปิด
จำนวนมากของโปรแกรม อาจจะปิดโปรแกรม
และแม้ว่าคุณ คอมพิวเตอร์ยังไม่ได้ตรวจค้น
ก็เริ่มช้าลงมาก ราวกับว่ามันเป็นจริง
โดยใช้หน่วยความจำมากหรือ ทรัพยากรแม้ว่า
ถ้าคุณไม่ได้ สัมผัสแป้นพิมพ์
ที่อาจ be-- แต่ไม่สามารถ always-- เป็นไปได้ว่าโปรแกรมที่คุณกำลังใช้งาน
มีการรั่วไหลของหน่วยความจำตัวเอง
และพวกเขาให้ถาม OS สำหรับข้อมูลเพิ่มเติมและ หน่วยความจำมากขึ้น แต่ลืมเกี่ยวกับมัน
ไม่จริงโดยใช้มัน แต่ ดังนั้นการใช้หน่วยความจำไป
จากโปรแกรมอื่น ๆ ที่อาจต้องการมัน
นั่นคือคำอธิบายที่พบบ่อย
ตอนนี้ที่นี่เป็นที่ที่ Valgrind ของ การส่งออกจะสมบูรณ์
เลวร้ายกับผู้น้อย และสะดวกสบายมากขึ้นเหมือนกัน
แต่ที่น่าสนใจ สิ่งที่ถูกต้องที่นี่
มันจะบอกฉันเขียนที่ไม่ถูกต้องของ ขนาดสี่เกิดขึ้นในโปรแกรมนี้
โดยเฉพาะอย่างยิ่งที่เส้น 21 จาก memory.c
>> ถ้าผมไปที่สาย 21, HM มีแน่นอน คือการเขียนที่ไม่ถูกต้องของขนาดสี่
ทำไมขนาดสี่
ดี number-- นี้และมัน อาจจะ anything-- เป็น int
ดังนั้นจึงเป็นสี่ไบต์
ดังนั้นฉันวางสี่ไบต์ ที่พวกเขาไม่ได้เป็น
นั่นคือสิ่งที่ Valgrind เป็นจริงบอกฉัน
นอกจากนี้ก็จะยัง บอกฉันที่เราจะเห็น
ในขณะที่คุณทำงานนี้ใน pset ในอนาคตถ้า เมื่อคุณได้รั่วไหลออกมาหน่วยความจำซึ่งแน่นอน
ฉันมีเพราะผมเคยเรียกว่า malloc แต่ฉันไม่ได้จริง
เรียกว่าในกรณีนี้ฟรี ซึ่งในที่สุดเราก็จะเห็น
เป็นตรงข้ามของ malloc
>> ดังนั้นตอนนี้ผมคิดว่าเป็นตัวอย่างที่สุดท้าย
ดังนั้นหนึ่งนี้เป็นข้อมูลเพิ่มเติมเล็กน้อย ความลับ แต่ก็อาจจะเป็น
เหตุผลที่ดีที่สุดที่จะ ระมัดระวังกับหน่วยความจำ
และเหตุผลที่ว่าหลายโปรแกรม และ / หรือเว็บเซิร์ฟเวอร์แม้จนถึงทุกวันนี้
จะถูกนำตัวไปจากคนเลวอยู่ที่ไหนสักแห่ง บนอินเทอร์เน็ตที่มีอย่างใด
การส่งแพ็คเก็ตปลอมยังเซิร์ฟเวอร์ของคุณ พยายามที่จะประนีประนอมบัญชีของคุณ
หรือใช้ข้อมูลของคุณหรือเพียงแค่ โดยทั่วไปใช้เวลามากกว่าเครื่อง
บัฟเฟอร์ล้นเป็น ชื่อแนะนำวิธีการ
ไม่ล้น int แต่บัฟเฟอร์
และกันชนเป็นเพียงวิธีแฟนซี ที่บอกว่ามันเป็นพวงของหน่วยความจำ
>> และแน่นอนฉันเรียกว่าสตริง ก่อนที่จะบัฟเฟอร์แทนที่จะ S
เพราะถ้ามันเป็นกันชน เหมือนในความรู้สึก YouTube,
หรือเวลาที่คุณกำลังดูวิดีโอใด ๆ คุณอาจจะได้เห็นการกำหนดบัฟเฟอร์คำว่า
จุดจุดจุด
มันน่ารำคาญอย่างไม่น่าเชื่อ
และนั่นก็หมายความว่า ที่ผู้เล่นวิดีโอของคุณ
พยายามที่จะดาวน์โหลดจำนวนมาก ไบต์จำนวนมากของไบต์
จากวิดีโอจากอินเทอร์เน็ต
แต่ช้าจึงพยายาม ดาวน์โหลดพวงของพวกเขา
เพื่อเติมบัฟเฟอร์ภาชนะเพื่อให้ คุณมีไบต์พอที่จะสามารถแล้ว
แสดงวิดีโอ โดยไม่ต้องหยุดอย่างต่อเนื่อง
แต่มันกลับกลายเป็นคุณสามารถ มีบัฟเฟอร์ใหญ่นี้
แต่พยายามที่จะนำข้อมูลมากนี้ มันและมากสิ่งที่ไม่ดีสามารถเกิดขึ้นได้
ดังนั้นสำหรับตัวอย่างเช่นให้ดูที่ ทีเซอร์นี้สุดท้ายของตัวอย่างเช่น
นี้เป็นโปรแกรมอื่น ว่าได้อย่างรวดเร็วก่อน
ไม่ได้ทำอะไรที่มีประโยชน์สุด
มันมีฟังก์ชั่นหลัก ที่เรียกว่าฟังก์ชั่นฉ
และฟังก์ชั่นที่, F, ขึ้นที่นี่มี อาร์เรย์ถ่านที่เรียกว่าค, ขนาด 12
และแล้วก็ใช้นี้ ฟังก์ชั่นใหม่ที่เรียกว่า strncpy
>> ปรากฎว่ามีง่ายๆ เส้นที่เรียบง่ายของรหัสเพียงสองเส้น
เราได้ทำโปรแกรมทั้งหมดของฉัน และดังนั้นคอมพิวเตอร์ทั้งหมดของฉัน
และบัญชีผู้ใช้ของฉันและยากของฉัน ขับรถที่อาจเสี่ยงกับทุกคน
ที่รู้และเป็นสิ่งที่ดีพอที่จะทำงาน โปรแกรมนี้กับบรรทัดคำสั่งบางอย่าง
อาร์กิวเมนต์
ในคำอื่น ๆ ถ้าคนเลว ทำให้ภายในของ argvargv [1] โดยการพิมพ์
ที่แป้นพิมพ์ที่สร้างขึ้นอย่างมากเป็นพิเศษ สตริงไม่ abc, 123 แต่เป็นหลัก
สัญลักษณ์ที่แสดงถึงฐานปฏิบัติการ รหัสโปรแกรมที่เขาหรือเธอเขียน,
ด้วยโปรแกรมที่ง่ายนี้ซึ่งเป็น เป็นตัวแทนของพันของโปรแกรม
ที่มีความเสี่ยงเช่นเดียวกัน, daresay, เขาหรือเธอในที่สุดสามารถลบทั้งหมด
ไฟล์ในฮาร์ดไดรฟ์ของฉันได้รับ พร้อมกระพริบเพื่อให้เขาหรือเธอสามารถ
พิมพ์คำสั่งของตัวเอง ส่งอีเมล์ไฟล์ทั้งหมดกับตัวเอง
สิ่งที่ฉันสามารถทำอะไรเขา หรือเธอสามารถทำอะไรกับรหัสนี้
>> เราจะไม่แก้ปัญหานี้ยัง
และในความเป็นจริงมันเป็นไป เกี่ยวข้องกับภาพเล็ก ๆ น้อย ๆ
เช่นนี้ซึ่งเราเร็ว ๆ นี้จะมา ที่จะทำความเข้าใจกับสิ่งที่ดีกว่า
แต่สำหรับวันนี้เราจะมาสิ้นสุดใน สิ่งที่หวังว่าเล็กน้อย
เข้าใจ XKCD ตลก จนกว่าเราจะกลับมาทำงานในครั้งต่อไป
ขวาทั้งหมด
เห็นคุณในวันพุธที่
>> [เล่นเพลง]
>> ลำโพง: และตอนนี้ลึก ความคิดโดย Daven อัม
หน่วยความจำก็เหมือนกับการกระโดดลงไปในกอง ใบสีทองบนบ่ายวันอาทิตย์
ลมพัดโยนของคุณ hair-- โอ้ฉันคิดถึงวันที่ when--
>> [หัวเราะ]