>> [เล่นเพลง]
>> เดวิดเจลัน: ทั้งหมดสิทธินี้คือ CS50 และนี่คือจุดเริ่มต้นของสัปดาห์ที่ห้า
ดังนั้นวันนี้ภายใต้เบาะที่นั่งของคุณ, คุณจะไม่พบอะไร
แต่ข้างต้นคุณควรหาเหล​​่านี้ token เล็ก ๆ น้อย ๆ จากการแข็งค่าของเรา
ทั้งหมดของการทำงานที่คุณใส่ เป็นเกมจากสิบห้า
เพียงลบวงกลมเล็ก ๆ น้อย ๆ ด้านล่างเพื่อเริ่มต้นการเล่นให้กับ
ส่วนที่เหลือของชั้นเรียน
>> ดังนั้นจำได้ว่าหรือรู้ว่าปัญหาการตั้งค่าที่ สี่ซึ่งออกไปวันหยุดสุดสัปดาห์นี้
เกี่ยวกับการเขียนเกมอื่น
แต่เวลานี้มันเกี่ยวข้องกับการใช้ ส่วนติดต่อผู้ใช้แบบกราฟิกที่เกิดขึ้นจริงไม่ได้
อินเตอร์เฟซเหมือนต้นฉบับ เกมจากสิบห้าคือ
และเกมที่อยู่ข้างหน้าของคุณ, ถ้าคุณยังไม่เห็นต่อไปนี้
มีลักษณะบางสิ่งบางอย่างเล็ก ๆ น้อย ๆ เช่นนี้
ฉันจะไปลงสถานีของฉัน หน้าต่างที่นี่ใน GDB
และฉันจะไปข้างหน้าและเรียกใช้ การแก้ปัญหาพนักงานซึ่งคุณสามารถเข้าถึง
หลังจากใช้การปรับปรุง 50 ตามปกติ
>> แต่ฉันจะใส่มันลงไปเล็ก ๆ น้อย ๆ โหมดความลับเล็ก ๆ น้อย ๆ ไข่อีสเตอร์,
ที่เรียกว่าโหมดพระเจ้าโดย วางพระเจ้าใน argv1
และฉันต้องปฏิบัติตามคำสั่งของตัวเอง ใช้มันในตัวเอง
ไดเรกทอรีชุดปัญหา
ดังนั้นตอนนี้คุณเห็นรุ่นที่สมบูรณ์ ของเกมจากการฝ่าวงล้อม
ในความเป็นจริงนี้เป็นโหมดที่ไม่มีมือ
ดังนั้นจึงเป็นจริง -
wowed แม้ว่าคุณอาจจะมี -
สวยน่ารำคาญที่จะใช้โหมดพระเจ้า แหกคุกเหมือนเกมจากสิบห้า,
ซึ่งบางท่านอาจจะมีความท้าทาย ฉบับที่แฮ็กเกอร์
>> ในการฝ่าวงล้อมมันพอเพียงในพระเจ้า โหมดที่จะเพียงแค่ทำในสิ่งที่,
สังหรณ์ใจกับพาย?
เพียงแค่ทำให้มันเท่ากันกับสิ่งที่ ตำแหน่งในแนวนอนเป็นของลูก
และตราบเท่าที่คุณทำเช่นนี้ใน lockstep กับลูกบอลย้ายเกมนี้จะ
ไม่เคยเคยเคยคิดถึงลูก และคุณจะชนะทุกครั้ง
>> แต่ในฉบับที่แฮ็กเกอร์ในสัปดาห์นี้ มีมากกว่าเพียงแค่โหมดของพระเจ้า
มีจำนวนของคุณสมบัติอื่น ๆ ของ
ในหมู่พวกเขาเลเซอร์
ดังนั้นถ้าหากคุณจริงๆได้รับใจร้อนคุณ สามารถเริ่มต้นการยิงอิฐ
และบางคนอื่น ๆ
และสำหรับบรรดาของคุณที่ต้องการ สอบเทียบมาตรฐานกับแฮกเกอร์
รุ่นที่ผมจะเห็นว่าในสัปดาห์นี้ ฉบับที่แฮกเกอร์จงใจคือ
เล็ก ๆ น้อย ๆ doable พูดกว่าพระเจ้า โหมดอยู่กับเกมของสิบห้า
>> ดังนั้นหากคุณกำลังมองหาการยืดและ คุณกำลังมองหาเพื่อความสนุกสนานเพิ่มเติมบางอย่าง
ที่ทำคุณสมบัติในการดำน้ำถ้าสนใจ
ตอนนี้มากขึ้นในทางปฏิบัติให้ฉันชี้ ออกสิ่งหนึ่งเช่นกัน
GDB ซึ่งบางส่วนของคุณอาจไม่ได้ยัง สัมผัสเองซึ่งเป็นเรื่องปกติ
แต่ตอนนี้เป็นจริงเวลาที่จะได้รับใช้ นี้และความสะดวกสบายด้วยเครื่องมือนี้
เพราะมันจะทำให้ชีวิตของคุณ มากขึ้นอย่างแท้จริง
>> ต่อการบรรยายของ Rob เมื่อ GDB คู่ ของสัปดาห์ที่ผ่านมาจำ
ที่ GDB เป็นดีบัก
มันเป็นเครื่องมือที่ช่วยให้คุณทำงานของคุณ โปรแกรม แต่ทำงานได้ทีละขั้นตอนสาย
โดยสายเพื่อให้คุณสามารถกระตุ้นรอบ, เพื่อที่คุณจะเห็นสิ่งที่เกิดขึ้นดังนั้น
ที่คุณสามารถพิมพ์ออกมา ค่าของตัวแปร
ในระยะสั้นจะช่วยให้คุณมากขึ้น พลังงานกว่า printDef ไม่
>> ตอนนี้เป็นที่ยอมรับของอินเตอร์เฟซ เป็นความลับสวย
อินเตอร์เฟซเป็นข้อความสีดำและสีขาว สำหรับส่วนใหญ่
คำสั่งที่ค่อนข้างจะยาก ที่ต้องจำไว้ในตอนแรก
แต่ถึงแม้ว่ามันอาจนำคุณไปครึ่งหนึ่ง ชั่วโมงชั่วโมงที่จะนำล่วงหน้าว่า
การลงทุนของเวลาเป็นมันไว้วางใจผม
แน่นอนว่าภายในสิ้นภาคการศึกษาที่จะบันทึก คุณลำดับความสำคัญมากขึ้น
เวลาไปกว่านั้น
>> ดังนั้นในช่วงต้นสัปดาห์ดำน้ำค่ะ
และในแง่ของการฝ่าวงล้อมรู้ว่าคุณ สามารถทำเช่นนี้ตราบใดที่คุณมี
รหัสการกระจายหรือรหัสของคุณเอง ในความคืบหน้าในไดเรกทอรี Pst4 ของคุณ
รู้ว่าคุณสามารถเรียกใช้ gdb. / แหกคุก
>> นี้จะเปิดขึ้น หน้าต่างเช่นนี้
ผมขอให้ตัวเองมากขึ้น จากหน้าต่าง terminal
และแล้วสิ่งที่ฉันจะไปข้างหน้า และก็ไม่ได้เป็นเพียงเรียกใช้มัน
ฉันจะเป็นครั้งแรกตั้งจุดพัก การเรียกคืนซึ่งช่วยให้คุณสามารถหยุดการทำงานชั่วคราว
ดำเนินการในสถานที่หนึ่ง
>> เพียงเพื่อให้สิ่งที่ง่ายฉันจะ ที่จะทำลายที่หนึ่งบรรทัดเพียงแค่พิมพ์
หมายเลขหนึ่ง
ให้ฉันจริงเปิดหน้าต่างนี้ เพราะได้รับการ
เล็ก ๆ น้อย ๆ
ดังนั้นสิ่งที่ฉันตอนนี้จะทำนี่คือ ถ้าผมเปิดหน้าต่าง terminal ของฉัน
มาที่มีเราไป
>> ดังนั้นตอนนี้ถ้าผมกลับไปที่ dropbox, Pst4 และเรียกใช้ gdb. / ฝ่าวงล้อมเข้าไปแจ้งให้ทราบล่วงหน้า
ฉันจะทำลายหนึ่งในการตั้งค่า จุดพักที่หนึ่งบรรทัด
และตอนนี้ฉันจะไป ข้างหน้าและการทำงานประเภท
และเมื่อฉันทำอะไรแจ้งให้ทราบล่วงหน้า ดูเหมือนว่าจะเกิดขึ้น
>> มีป๊อปอัพไม่ได้
มีกราฟิกไม่ได้ ส่วนติดต่อผู้ใช้ยัง
แต่ที่เข้าใจได้เพราะฉัน อย่างแท้จริงที่หนึ่งบรรทัดในโปรแกรมของฉัน
และสังเกตเห็นว่าผมเคยส่งต่ออย่างรวดเร็ว โดยเฉพาะในขณะนี้ถึง 62 เพราะ
สิ่งที่ด้านบนของไฟล์นี้คือ สิ่งที่ต้องการความเห็นและค่าคงที่และ
สิ่งที่น่าทึ่งสำหรับตอนนี้
>> ดังนั้นตอนนี้ฉันภายในของหลัก ดูเหมือนว่าที่ 62 เส้น
และนี้เป็นเพียงการกระจาย รหัสการเรียกคืน
ถ้าผมเปิดขึ้นโดยไปในทำนองเดียวกัน ลงในไดเรกทอรีกล่องของฉันแวะไปที่ Pst4,
เป็น breakout.c
และถ้าฉันเลื่อนลงมาและลงและลง และแจ้งให้เราไปข้างหน้าและเปิด
หมายเลขบรรทัดของฉัน
>> สิ่งที่ฉันจะเห็นถ้าผมเลื่อนลงไป 62 เส้นตรงเส้นที่
เราได้หยุดชั่วคราวเมื่อ
ดังนั้นสายนี้ที่นี่, 62, คือ ที่เรากำลังจะ
ดังนั้นตอนนี้ใน GDB ถ้าฉันไปข้างหน้าและพิมพ์ ตอนนี้ต่อไปให้ใส่มันจะ
ดำเนินการบรรทัดที่
และ voila เรามี ที่เรียกว่าหน้าต่างกรัม
ถ้าไม่คุ้นเคยกับสิ่งที่ GWindow คือว่าไม่ต้องกังวล
สเป็คจะแนะนำคุณให้มันเป็น รวมทั้งจำนวนของวิดีโอเกมส์
ที่ฝังอยู่ในสเป็ค
>> แต่ตอนนี้ขอให้นี้ เล็ก ๆ น้อย ๆ ที่น่าสนใจมาก
ผมขอย้ายหน้าต่างมากกว่านี้ ไปด้านข้างเล็กน้อย
ผมขอให้หน้าต่างเล็ก ๆ น้อย ๆ ที่ใหญ่กว่าดังนั้นฉันสามารถดูรายละเอียดเพิ่มเติม
>> และตอนนี้ให้ฉันไปข้างหน้า และทำต่อไปอีกครั้ง
และมีอิฐของฉัน
ถ้าผมพิมพ์ต่อไปอีกครั้ง ตอนนี้ฉันดูลูก
และถ้าฉันพิมพ์ต่อไปอีกครั้ง ตอนนี้ผมเห็นพาย
>> และโชคดีที่ Gedit นี้ไม่ได้ จริงๆความร่วมมือโดยแสดงให้ฉัน
ทุกอย่างที่ฉันต้องการ
แต่ตอนนี้ถ้าผมทำอะไรต่อไปอีกครั้ง ต่อไปอีกครั้งฉันก็เป็นเพียง
ประกาศตัวแปรบางอย่าง
และฉันสามารถพิมพ์ใดคนหนึ่ง ของคนเหล่านี้ออก
อิฐพิมพ์ลายนิ้วมือชีวิต
>> และตอนนี้ถ้าฉันยังคงทำ ต่อมาสังเกตเห็นว่าฉันจะ
ด้านในของห่วงว่า
แต่รหัสที่เป็นไปที่จะดำเนินการ ตรงตามที่ผมคาดว่า
ดังนั้นเมื่อผมกดปุ่มฟังก์ชั่นนี้รอ สำหรับการคลิกที่มันจะทำ
มันอย่างแท้จริงว่า
ดังนั้นผมจึงดูเหมือนจะสูญเสียการควบคุม ผ่านโปรแกรม
>> GDB จะไม่ให้ฉันแจ้งให้อีก
แต่ไม่ต้องกังวล
ไปที่เกมของฉันให้คลิกที่ใดที่หนึ่ง
>> และ voila ตอนนี้ก็ดำเนินการกับสาย 86
ดังนั้นอีกครั้งมันล้ำค่าในที่สุด สำหรับปัญหาการแก้จุดบกพร่อง
เพราะคุณอักษรสามารถก้าวผ่าน รหัสของคุณสิ่งที่พิมพ์ออกมาและมาก,
มากขึ้น
แต่ตอนนี้เครื่องมือเหล่านั้นเพียงอย่างเดียว ควรจะได้รับคุณสวยไกล
>> ดังนั้นเราจึงไม่แน่นอนการดู กราฟิกที่ตอนนี้ทั้งหมดในทันที
และตอนนี้โลกของเราได้รับน้อย น่าสนใจมากขึ้น
และคุณรู้ว่าบางทีจากบางส่วนของ วิดีโอออนไลน์ที่เรามีเหล่านี้
กางเกงขาสั้นที่คุณได้รับชม เป็นส่วนหนึ่งของชุดปัญหา
>> และพวกเขาได้ถูกยิงจงใจ กับฉากหลังสีขาว
และบางส่วนของพวกเขามีการเรียนการสอน Fellows วาดข้อความบางอย่างเกี่ยวกับ
หน้าจอที่หนักหน่วง ที่ด้านข้างของพวกเขา
แต่หลักสูตรนี้ไม่ได้ทั้งหมดว่า ที่น่าสนใจในโลกแห่งความจริง
นี่เป็นเพียงหอประชุมด้วย หน้าจอสีขาวขนาดใหญ่และฉากหลัง
และการผลิตเรียงลำดับทีมที่น่าตื่นตาตื่นใจของเรา ของทำให้ทุกอย่างดูสวยงาม
หลังจากที่ความเป็นจริงโดยการปลูกพืชออก หรือซ้อนทับสิ่งใด
ที่เราทำหรือไม่ต้องการ
>> ตอนนี้เพียงแค่การกระตุ้นสัปดาห์นี้และ จริงๆที่คุณสามารถไปในที่สุด
กับวิทยาศาสตร์คอมพิวเตอร์
ไม่ได้เป็นเพียงปัญหาหลังจากตั้งสี่
แต่หลังจากจบหลักสูตรอื่นหรือทั้งหมด หลักสูตรมันน่าพิศวงสิ่งที่คุณสามารถ
ทำวันนี้ในแง่ของการ กราฟิกโดยเฉพาะอย่างยิ่ง
>> บางส่วนของคุณอาจได้เห็นนี้ ไหลรอบออนไลน์
แต่ฉันคิดว่าฉันต้องการแสดงให้คุณเพียง ไม่กี่นาทีเหลือบของสิ่งที่
เทคโนโลยีคอมพิวเตอร์และสิ่งที่ CGI, คอมพิวเตอร์กราฟิกสามารถทำวันนี้
กับเพลงที่คุ้นเคย และบางทีอาจจะเป็นภาพยนตร์
>> เพลง [- LANA DEL RAY, "YOUNG และสวยงาม]
>> ลำโพง 1: มันก็แค่นิด ๆ หน่อย ๆ ที่น่าตื่นตาตื่นใจบางทีแค่ไหน
ขับไล่ -
>> [APPLAUSE]
>> ลำโพง 1: ผมเพิ่งดาวน์โหลดมัน
แต่มันเป็นที่น่าตื่นตาตื่นใจจริงๆผมคิดว่าเพียงแค่ วิธีการที่ซอฟต์แวร์อยู่ทั่วไปทุกหนทุกแห่งและรหัสและ
เครื่องมือเช่นนี้จริงๆ
เพื่อให้รสชาติของทิศทางของ ในที่ที่คุณสามารถไป
โอ้ Appliance ไม่มีอะไรมากวันนี้
ดีที่ช่วงเวลาที่น่าเศร้าจริง กำหนดจุดที่ฉันเพียงแค่พยายามที่จะทำให้
>> ทั้งหมดขวาจึงขอเปิดตัว ฟิวชั่นอีกครั้ง
เตือนฉันภายหลัง
ทั้งหมดถูกต้องและคุณควรจะได้มี อีเมล์เป็นกันถ้าคุณได้รับ
สังเกตเห็นว่า
ทั้งหมดที่ถูกต้องเพื่อให้จำได้ว่าสัปดาห์ที่ผ่านมา เราเริ่มที่จะปอกเปลือกกลับนี้
ภายหลังเป็นที่รู้จักสตริง
>> สตริงจำได้ว่าชนิดข้อมูลที่ ประกาศใน CS50 ห้องสมุด
และมันก็เป็นส่วนหนึ่งของการฝึกอบรมล้อ ว่าตอนนี้จะเริ่มต้นที่จะปิด
มันเป็นแนวความคิดที่เป็นประโยชน์ในช่วงต้น
แต่ตอนนี้มันกำลังจะได้รับเพิ่มเติม ที่น่าสนใจและมีประสิทธิภาพมากขึ้นเพื่อ
จริงเห็นว่าภายใต้ประทุน, สตริงเป็นเพียงสิ่งที่เราไม่กล่าวว่า?
>> ผมจึงเรียกว่า char *
และมี * หมายถึงว่ามี บางชนิดของที่อยู่ที่เกี่ยวข้อง
ดังนั้นเมื่อคุณพูด ​​char * คุณเพียงแค่หมายถึง ตัวแปรที่มีข้อมูลประเภทคือ
ชี้ขณะนี้
เป็นจริงที่มีดาวมี ก็หมายความว่าคุณได้รับการประกาศ
ตัวชี้ที่เรียกว่า
และตัวชี้ที่จะเห็นได้ชัดว่า เก็บที่อยู่ของของ
แน่นอนถ่าน
>> ตอนนี้ไม่ทำให้รู้สึกว่าทำไม?
ดีเป็นสตริงอะไร ภายใต้ฝากระโปรง?
ดีบางครั้งที่เราได้รับการบอกว่า สตริงดังกล่าวจะอยู่ภายใต้ฝากระโปรงเป็น
เพียงแค่ H-e-l-L-o ตัวอย่างเช่น
>> แต่เราได้พูดคุยเกี่ยวกับเรื่องนี้ในขณะที่ ถูกหลักอาร์เรย์
และแถวนั้นก็จะดูเล็ก ๆ น้อย ๆ มากขึ้นเช่นนี้กับแต่ละเหล่านี้
การขึ้นกัด
แล้วเราได้กล่าวว่ามี บางสิ่งที่พิเศษกลับมาที่นี่,
เครื่องหมายทับขวา 0 หรือ null terminator
>> ดังนั้นเวลานี้ที่นี่ ได้รับสตริง
แต่จริงๆสตริงคือ จริงที่อยู่
และที่อยู่ที่เราจะเห็นมักจะ นำหน้าด้วย 0x โดยการประชุม
สิ่งที่ไม่ 0x แสดง?
ไม่มีใครรู้?
>> ดังนั้นมันก็หมายความว่าเลขฐานสิบหก
ดังนั้นคุณอาจจำจริงจาก PST 1 ผมเชื่อว่าหนึ่งในการอุ่นเครื่อง
คำถามจริงถามเกี่ยวกับ เลขฐานสิบหกที่นอกเหนือไปจาก
ไบนารีและทศนิยม
และแรงจูงใจที่นี่คือ กับเลขฐานสิบหกคุณมี 16
หลักในการกำจัดของคุณ
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, ตาม โดย A, B, C, D, E, F
>> และถ้าคุณนับทั้งหมดขึ้นเหล่านั้น คุณจะได้รับรวมเป็น 16
ดังนั้นนี้เป็นในทางตรงกันข้ามกับ ทศนิยมที่เรามี 10
ตัวเลข 0 ถึงเก้า
มันเป็นในทางตรงกันข้ามกับไบนารี ที่เรามีเพียง 0 และ 1
>> แต่ในตอนท้ายของวันที่คุณสามารถเพียงแค่ แทนตัวเลขเดียวกัน แต่
ค่อนข้างแตกต่างกัน
และเลขฐานสิบหกเป็นเรื่องธรรมดาเพราะเป็น มันจะเปิดออก - และเราจะเห็นสิ่งนี้
ต่อมาในหลักสูตร - แม้เมื่อเราได้รับ การเขียนโปรแกรมเว็บในบริบทของ
HTML และรหัสสี, เลขฐานสิบหกเป็นสิ่งที่ดี
เพราะแต่ละหลัก, จะเปิดออก แสดงให้เห็นถึงสี่บิตอย่างสมบูรณ์แบบ
ดังนั้นจึงเป็นเพียงแค่ชนิดของสายขึ้นอย่าง ในขณะที่เราจะเห็นในที่สุด
ดังนั้นนี้อาจจะมีบางสิ่งบางอย่างหรือ Ox123 เช่นเดียวกับที่ 123 ที่อยู่, denoting
ที่ไหนสักแห่งภายในของฉัน หน่วยความจำของคอมพิวเตอร์
>> แต่แน่นอนปัญหาบางอย่างเกิดขึ้น เพราะพื้นฐานนี้
การดำเนินงาน
และจำได้ว่าผมเอาที่แทง ฟังก์ชั่นการดำเนินการเช่นนี้ -
เปรียบเทียบรีบ 0 จุด C สัปดาห์ที่ผ่านมาว่า แม้ว่ามันจะดูเหมือนว่ามันเป็น
ขวามันก็ไม่ได้เปรียบเทียบ สองสายได้อย่างถูกต้อง
>> ฉันโยนทิ้งไปหลักและฉันได้โยน ออกความเห็นเพียงเพื่อมุ่งเน้นใน
รหัสที่มีความสนใจที่นี่
และมันก็เป็นสีแดงเพราะมันเป็นรถม้าชนิดเล็ก
สำหรับสิ่งที่เหตุผล?
>> ดีที่ด้านบนมีเมื่อฉันประกาศ สตริงสิ่งที่จริงที่เกิดขึ้น
ภายใต้ฝากระโปรง?
ดีให้ฉันข้ามไป หน้าจอที่นี่และวาดว่า
ดังนั้นผมจึงมีการประกาศอีกครั้ง GetString สตริง s
>> ดังนั้นฉันจะไปข้างหน้าในขณะนี้และ วาด s สำหรับสิ่งที่มันคือเรื่องจริง
มันจะเป็นตารางที่นี่
และฉันจะเรียกร้อง ว่าที่ 32 บิต
อย่างน้อยก็มักจะเป็น อย่างน้อยใน CS50
เครื่องใช้ในจำนวนมากของเครื่องคอมพิวเตอร์
ฉันจะเรียกมันว่า s
>> แต่ตอนนี้จำได้ว่าเรา เรียกว่า GetString
ผลตอบแทนที่ GetString ดังนั้น ของหลักสูตรสตริง
ถ้าผู้ใช้ใน H-e-l-L-O ใส่ สตริงสวัสดีได้รับกลับมา
และสตริงที่ในขณะที่เราเพียงแค่บอกว่าจบ ขึ้นที่ไหนสักแห่งในหน่วยความจำของคอมพิวเตอร์ของคุณ
กับ 0 เครื่องหมายทับขวาที่สิ้นสุด
ผมจะวาดนี้เช่นอาร์เรย์ - หรือ บล็อกติดกันของตัวละคร -
ที่มันเป็นจริง
>> และตอนนี้สิ่งที่เป็น getString จริงกลับไปที่ไหน?
สิ่งที่ได้รับกลับมา getString ทั้งหมดในเวลานี้?
ดีที่เราบอกว่าในสัปดาห์ก่อน, ก็จะส่งกลับสตริง
แต่ในทางเทคนิคสิ่งที่ไม่ getString ผลตอบแทนที่เห็นได้ชัด?
>> ผู้ชม: ที่อยู่
>> ลำโพง 1: ที่อยู่
โดยเฉพาะที่จะส่งกลับที่อยู่ของ กัดแรกสิ่งที่เป็น
ผมให้ใช้เพียงหนึ่งสองสาม เพราะมันสะดวก
>> ก็จะส่งกลับที่อยู่ของแรก ตัวอักษรในสตริง
และเรากล่าวว่าสัปดาห์สุดท้ายที่ ที่เพียงพอ
เพราะเรามักจะสามารถคิดออกว่า ในตอนท้ายของสตริงเพียงแค่
iterating กว่ามันอาจจะมีสำหรับ ห่วงหรือในขณะที่ห่วงหรือสิ่งที่ต้องการ
ที่เพียงแค่มองหา "เครื่องหมาย 0" ตัวละครแมวมองพิเศษ
>> แล้วเรารู้ว่าสตริง ที่จะเกิดขึ้นของความยาว -
ในกรณีนี้ -
ห้า
ดังนั้นในทางเทคนิคสิ่ง GetString ไม่ มันคือผลตอบแทนที่ Ox123 ในกรณีนี้
และในทางเทคนิคแล้วสิ่งที่เกิดขึ้นคือ ที่เราจัดเก็บภายในของ s, Ox123
ในตอนท้ายของวันที่แม้ว่านี้ เป็นแนวคิดใหม่ชี้ว่าพวกเขากำลัง
ตัวแปรเพียง
แต่พวกเขาเกิดขึ้นในการจัดเก็บบิตที่ รวมแสดงที่อยู่
ดังนั้นในทางเทคนิคทั้งหมดที่พวกเขาได้รับ เก็บไว้ในเป็น Ox123
>> แต่เราเป็นมนุษย์ -
รวมทั้งวันนี้เป็นต้นไป -
จริงๆไม่ได้ไปดูแลปกติ ที่อยู่ที่เกิดขึ้นจริงคือสิ่งที่
ของหน่วยความจำอันบาง
มันเป็นเพียงในระดับต่ำของรายละเอียดเพื่อ จะน่าสนใจทางสติปัญญา
ดังนั้นฉันจะยกเลิกการนี​​้
แทนระดับสูงมากขึ้นเพียงแค่พูดว่า ที่ว่าเมื่อเรากำลังพูดถึงเกี่ยวกับตัวชี้
ฉันจะเพียงแค่วาดขึ้น ลูกศรใช้งานง่ายที่บ่งบอกถึง
ความคิดเดียวกันและบทคัดย่อไป รายการของสิ่งที่เกิดขึ้นจริง
ที่อยู่พื้นฐานคือ
>> ตอนนี้ถ้าเรากลับไปที่รหัสสิ่งที่ ที่เกิดขึ้นสัปดาห์ที่ผ่านมาถ้าเรามีสาย T
เท่ากับ getString?
ดีถ้าผมอีกครั้งประเภทในสวัสดี เวลาที่ฉันจะได้รับนี้
หน่วยความจำอันอื่น
H-e-l-l-o-0 เครื่องหมายทับขวา
>> แต่เพราะฉันเรียกว่า getString เป็นครั้งที่สอง -
และฉันรู้ว่านี้กำลังมองหาที่ รหัสแหล่งที่มาสำหรับ GetString - แม้
แม้ว่ามันจะบังเอิญว่าสวัสดีเป็น พิมพ์ในสองครั้ง GetString ไม่ได้เป็น
จะพยายามที่จะเพิ่มประสิทธิภาพ และจะฉลาด
มันก็จะได้รับก้อนของผู้อื่น หน่วยความจำจากคอมพิวเตอร์ซึ่งเป็น
จะเป็นที่อยู่ที่อื่น
ขอเพียงแค่พูดว่าพล 456
>> และแล้วมันก็คือสิ่งที่เกิดขึ้นที่จะกลับมา?
มันจะกลับมา 456 และเก็บไว้ในที
ดังนั้นสิ่งที่เป็นจริงที่เกิดขึ้นเมื่อ ด้านซ้ายมือเป็นฉันมีก้อนอื่น
ของหน่วยความจำ 32 บิตโดยทั่วไปแล้ว
และในนั้นเป็นไป Ox456
แต่อีกครั้งฉันไม่สนใจในเหล่านี้ โดยเฉพาะอย่างยิ่งตัวเลขอีกต่อไป
ฉันแค่จะไปเป็นนามธรรม วาดลูกศร
>> ดังนั้นนี่คือตอนนี้คำอธิบายใหม่
แต่มันเป็นความคิดที่แน่นอนเดียวกันที่ รับสิ่งที่เกิดขึ้นทั้งหมดในครั้งนี้
และเพื่อเหตุผลแล้วว่านี่เป็นครั้งแรก รุ่นของรถเปรียบเทียบคือ
สัปดาห์ที่ผ่านมาทำไม
เมื่อคุณทำเช่นถ้า s เท่ากับเท่ากับ ทีสิ่งที่เป็นคุณอย่างแท้จริง
ภายใต้ฝากระโปรงเปรียบเทียบ?
>> คุณกำลังเปรียบเทียบอยู่
และเพียงแค่สังหรณ์ใจอย่างเห็นได้ชัด, Ox123 จะไม่เท่ากับ Ox456
ตัวเลขเหล่านั้นบรรดาบิต จะแตกต่างกันเพียงแค่
>> และอื่น ๆ อย่างต่อเนื่องสัปดาห์ที่ผ่านมาก็กล่าวว่า คุณพิมพ์สิ่งที่แตกต่างแม้ว่า
เป็นคำต่อคำคำเดียวกัน
ดังนั้นเราจึงแก้ไขปัญหานี้
ในแง่คนธรรมดาสิ่งที่แก้ไขคือ?
>> ผู้ชม: ใช้ฟังก์ชัน
>> 1 SPEAKER: ใช้ฟังก์ชั่น
หรือดาวที่มีส่วนเกี่ยวข้องแน่นอน แต่ใช้ฟังก์ชั่นที่จะทำอะไร
>> ผู้ชม: เพ​​ื่อเปรียบเทียบสตริง
>> 1 SPEAKER: เพื่อเปรียบเทียบสตริง
ดังนั้นปัญหาพื้นฐานที่นี่คือ ว่าฉันเป็นเพียงการพิจารณา
คุณภาพของสายที่จะถูกกำหนดโดย การเปรียบเทียบของที่อยู่ของพวกเขา
และเห็นได้ชัดว่าเป็นใบ้เพียงครั้งเดียวในขณะนี้ คุณเข้าใจสิ่งที่เกิดขึ้น
ภายใต้ฝากระโปรง
อย่างแท้จริงเปรียบเทียบสตริงเพื่อดูว่า พวกเขาจะเท่าเทียมกันในวิธีการที่มนุษย์
จะพิจารณาสองสายจะเท่ากับ เราต้องเปรียบเทียบพวกเขาสำหรับตัวละคร
ตัวอักษรสำหรับอักขระ
>> ตอนนี้ฉันจะได้ทำ นี้อย่างน่าเอือมระอา
แต่กันเองเราไม่ ใช้สำหรับวง
และเพียงแค่เปรียบเทียบวงเล็บ s ผมกับทียึดผม
s วงเล็บผมบวก 1 กับ T วงเล็บ ผมบวก 1, และอื่น ๆ ภายใน
ชนิดของห่วงบาง
และถ้าจุดใดที่ตัวละครทั้งสอง แตกต่างกันหรือถ้าฉันตระหนักดีว่าโอคือ
สั้นกว่า T หรือนานกว่า T ฉันทันทีสามารถพูดเท็จ
พวกเขาไม่ได้เหมือนกัน
>> แต่ถ้าฉันได้รับผ่านและ T และพูดว่า เดียวกันเดียวกันเดียวกันเดียวกันสิ้นสุดเดียวกันของ
สตริงทั้งฉันสามารถพูดได้ ความจริงพวกเขามีค่าเท่ากัน
ดีโชคดีปีที่ผ่านมาใครบางคน เขียนรหัสว่าสำหรับเรา
>> และพวกเขาเรียกมันว่า StrComp สำหรับสตริงเปรียบเทียบ
และถึงแม้จะเป็นเคาน์เตอร์เล็ก ๆ น้อย ๆ ใช้งานง่าย StrComp กลับ 0 ถ้าคนเหล่านั้น
สองสตริง, S และ T จะเหมือนกัน
แต่ก็จะส่งกลับค่าลบถ้า s ควรจะมาก่อน T ตามลำดับตัวอักษรหรือ
ค่าบวกถ้ามันจะมา หลังจากที่ T ตามลำดับตัวอักษร
>> ดังนั้นหากคุณเคยต้องการที่จะเรียงลำดับบางสิ่งบางอย่าง ปรากฎว่า StrComp เป็นประโยชน์
เพราะไม่เพียงแค่พูดว่า ใช่หรือไม่เท่ากันหรือไม่
มันจะให้ความรู้สึกของการสั่งซื้อ เช่นพจนานุกรมอาจ
ดังนั้น StrComp, s จุลภาค T เท่ากับ เท่ากับ 0 หมายความว่า
สตริงมีความเสมอภาคอย่างแท้จริง
เพราะใครก็ตามที่เขียนฟังก์ชันนี้ ปีที่ผ่านมาน่าจะนำมาใช้สำหรับวง
หรือในขณะที่ห่วงหรือสิ่งที่ต้องการที่ เพื่อบูรณาการตัวละครอีกครั้ง
และอีกครั้งและอีกครั้ง
>> แต่สองปัญหาที่เกิดขึ้นที่นี่
นี่เป็น copy0.c
และทั้งสองคนในชุดสีแดงเป็น เพราะมันเป็นข้อบกพร่อง
และสิ่งที่พวกเราทำที่นี่?
ดีแรกที่ผมเรียกว่า getString
และฉันเก็บค่าตอบแทนใน s
ดังนั้นที่สวยมากเช่นเดียวกับ นี้ส่วนบนของภาพ
>> แต่เกิดขึ้นหลังจากที่อะไร
ดีให้ฉันไปข้างหน้าและได้รับการกำจัด ของทั้งกลุ่มนี้
เราจะย้อนกลับในเวลาที่จะที่เราเพียงแค่ มี s ซึ่งขณะนี้สอดคล้องกับ
หนึ่งบรรทัดขึ้น
>> ผมตรวจสอบ
ถ้า s เท่ากับเท่ากับ 0
ตอนนี้ทราบด้านข้างอย่างรวดเร็วเมื่อ GetString อาจกลับ 0?
มีหน่วยความจำไม่พอ
ใช่ไหม?
>> มันหายากว่าเรื่องนี้จะเกิดขึ้น, แน่นอนบนคอมพิวเตอร์ที่เป็น
หลายร้อย megs หรือ แม้แต่กิ๊กของ RAM
แต่มันอาจจะในทางทฤษฎีกลับ 0 โดยเฉพาะอย่างยิ่งถ้า
ผู้ใช้ไม่ให้ความร่วมมือ
มีวิธีที่จะแกล้งทำเป็นเหมือนคุณมีไม่ได้อะไร อะไรที่ป้อนและเคล็ดลับ
getString เข้ากลับมา 0 ได้อย่างมีประสิทธิภาพ
>> ดังนั้นมันจะตรวจสอบว่า
เพราะถ้าใด ๆ ของคุณได้เริ่มต้น ได้รับแล้วความผิดพลาดของการแบ่งส่วน -
ที่ได้รับอาจจะเป็นแหล่งที่มา ของบางแห้ว -
เหล่านั้นก็มักจะเป็นผลที่ตามมา ข้อผิดพลาดของหน่วยความจำที่เกี่ยวข้องกับ
อย่างไรก็ตามคุณ messed up ในเรื่องเกี่ยวกับ ตัวชี้แม้ว่าคุณจะไม่ได้ตระหนักถึง
มีตัวชี้เป็น
ดังนั้นคุณอาจจะมีการเหนี่ยวนำให้เกิดการแบ่งส่วน ความผิดพลาดที่เร็วที่สุดเท่าที่ใช้เวลาหนึ่งสัปดาห์
สิ่งที่ต้องการสำหรับวงหรือในขณะที่ ห่วงและอาร์เรย์โดยจะไกลเกินไป
อดีตขอบเขตของอาร์เรย์บางอย่างที่ คุณประกาศในสัปดาห์ที่สองใน
โดยเฉพาะ
>> คุณอาจจะได้ทำมันแม้จะอยู่ในปัญหา ตั้งสี่กับการฝ่าวงล้อม
แม้ว่าคุณอาจจะไม่ได้เห็น ดาวใด ๆ ในรหัสการจัดจำหน่ายสำหรับ
ฝ่าวงล้อมก็จะเปิดออกว่า GRect เหล่านั้น และ GOval และสิ่งอื่น ๆ เช่น
เหล่านั้นเป็นจริงชี้ ภายใต้ฝากระโปรง
>> แต่ Stanford เหมือนเราเรียงลำดับของหนัง ที่รายละเอียดอย่างน้อยสำหรับห้องสมุด
วัตถุประสงค์เหมือนที่เราทำ สำหรับสตริงและ char *
แต่ GRect และ GOval และทุกคน สิ่งที่พวกคุณหรือจะใช้
ในสัปดาห์นี้เป็นที่สุด อยู่หน่วยความจำ
คุณเพียงแค่ไม่ทราบว่ามัน
>> ดังนั้นจึงไม่น่าแปลกใจแล้วบางที ที่คุณอาจจะเดินทางไปบางส่วน
ความผิดพลาดของการแบ่งส่วน
แต่สิ่งที่น่าสนใจที่นี่ตอนนี้ ถ้าหลังจากที่เราตรวจสอบ 0 ที่เราทำ
สตริงทีได้รับ s
ดีให้ฉันบอกที
ฉันจะวาดมันเป็นสี่เหลี่ยม 32 บิตเรียกว่า T
แล้วฉันจะทำจะได้รับ s
>> ดีที่หมายความว่าอย่างไร
ดีก็เป็นเพียงเล็กน้อยยากที่จะคิดว่า เกี่ยวกับเรื่องภาพที่ชาญฉลาด
แต่ขอให้คิดเกี่ยวกับ อยู่ภายในของ x อะไร
แท้จริงสิ่งที่อยู่ภายในตัวแปรนี้?
Ox123 ค่า
>> ดังนั้นเมื่อผมพูดสตริงทีได้รับของที่เพิ่ง หมายถึงตัวอักษรใช้เวลาหลาย
ในซึ่งเป็น Ox123 และวางไว้ Ox123
หรือ pictorially ถ้าผมชนิดของนามธรรม ออกไปจากรายละเอียดที่มี
ผลกระทบของการทำอย่างแท้จริง นี้เป็นอย่างดี
>> ดังนั้นตอนนี้คิดว่ากลับไปเมื่อสัปดาห์ที่ผ่านมา เราดำเนินการต่อไปทุนนิยม ต. ผม
ไม่ T วงเล็บ 0
ดี T วงเล็บ 0 แม้ว่ามันจะเป็น ตัวชี้ที่คุณสามารถรักษามันราวกับว่า
มันเป็นอาร์เรย์ที่มีตาราง สัญกรณ์วงเล็บ
>> เพื่อที่ T วงเล็บคือ 0?
ดีก็ต่อชั่วโมง
ดังนั้นเมื่อเราใช้บรรทัดของรหัสที่ สองชั้นบนซึ่งอยู่ในที่ค type.h
ไฟล์ส่วนหัวที่ที่ มันประกาศ
คุณกำลังพะวงเอชนี้ แต่ แน่นอนว่าชั่วโมงที่แน่นอนเดียวกันที่
ด้านในของ s เพื่อที่จะพูด
และดังนั้นตอนนี้คุณมีการเปลี่ยนแปลงหรือ ทุนทั้งที่เป็นต้นฉบับและ
ที่เรียกว่าสำเนา
เพราะคุณไม่ได้ทำสำเนาใน วิธีการที่มนุษย์จะต้องการให้เป็น
>> ดังนั้นสิ่งที่แก้ไขที่นี่คือ ในสัปดาห์สุดท้าย copy1.c?
ฟังก์ชั่นเพื่อให้เราได้จริง คัดลอกสตริง
และพื้นฐานที่เราทำในสิ่งที่จำเป็นต้อง ทำเพื่อที่จะคัดลอกสตริง?
>> ทั้งในรุ่นสีเขียวนี้ที่นี่ฉัน จะทำมันในระดับที่ค่อนข้างต่ำ
มีจริงฟังก์ชั่น พวกเขาสามารถช่วยนี้
แต่หนึ่งในพื้นฐานที่สุดและมากที่สุด หนึ่งที่คุ้นเคยอย่างน้อยเร็ว ๆ นี้จะ
คุ้นเคยกับเราต่อไปนี้คือ -
ดังนั้นหนึ่งในบรรทัดแรก ของรหัสในสีเขียวในขณะนี้
>> ผมแค่เขียนในฐานะที่เป็น char *
มีการทำงานไม่ได้ คือความแตกต่าง
ผมก็โยนไปห้องสมุดและ CS50 ผมเรียกมันว่ามันคืออะไร char *
>> ตอนนี้จุดจุดจุดเพราะมี การตรวจสอบข้อผิดพลาดบางอย่างที่ไม่
น่าสนใจที่จะพูดคุยเกี่ยวกับอีกครั้ง
ดังนั้นตอนนี้ทีมีการประกาศ
มันก็เป็น char *
ดังนั้นผมจึงดึงตารางเล็ก ๆ น้อย ๆ หน้าจอเหมือนก่อน
>> แต่ในทางด้านขวามือ, malloc, เรากล่าวว่าเป็นหน่วยความจำที่จัดสรร
ดังนั้นการจัดสรรหน่วยความจำอันบาง
และมีกี่ไบต์ที่เราทำจริง ต้องการที่จะจัดสรรมันไม่ดูเหมือน?
>> ดีความยาวสตริงของ s
ดังนั้นถ้ามันสวัสดีที่ จะเป็นห้า
เราจะบอกว่า H-e-l-L-o
ดังนั้นห้าไบต์
>> แต่แล้วบวก 1, 1 ทำไม?
0 ตัวอักษร
ถ้าเราไม่ได้ออกจากห้องพักสำหรับผู้ชายคนนี้ที่เรา ตั้งใจจะสร้างสถานการณ์
ที่สตริงคือ H-e-l-L-o
แล้ว GetString เวลาต่อไปคือ และเรียกฉันพิมพ์ในตัวอย่างเช่น
เดวิด, D--V-I-d, คอมพิวเตอร์ที่เป็นไป ที่จะคิดว่าเป็นจริง
H-e-l-l-o-D--V-I-d เพราะมี หยุดพักในระหว่างคำเหล่านั้น
>> ดังนั้นเราจึงจำเป็นต้องหยุดพักที่
ดังนั้นเราจึงไม่ต้องการห้า
เราต้องการที่หกไบต์
>> และไบต์ที่ผมพูด
แต่จริงๆขนาดเวลาของถ่าน
เทคนิคถ่านเกือบจะเป็น เสมอ byte เดียว
>> แต่เพียงเพื่อให้รหัสของเราแบบพกพา, เพื่อที่จะพูดเพื่อที่จะทำงานบน
เครื่องคอมพิวเตอร์ที่แตกต่างกันถึงแม้ว่าพวกเขาอาจจะ จะค่อนข้างแตกต่างกันภายใต้
เครื่องดูดควันฉันจะเป็นยาชื่อสามัญ ขนาดพูดของถ่านเพื่อให้
รหัสของฉันเสมอไป
และฉันไม่ต้อง recompile มันก็แค่ เพราะผมอัพเกรดคอมพิวเตอร์ของฉันหรือใช้
บางแพลตฟอร์มที่แตกต่างกัน
>> ดังนั้นผมจึงได้มี 6 ครั้งขนาดของ ถ่านที่เกิดขึ้นเป็น 1
ดังนั้น malloc หมายความว่าจะทำได้ ให้ฉันหกไบต์
ที่จริงทำอะไร?
ดีให้ฉันย้อนกลับไปในช่วงเวลาที่นี่ ไปยังที่ที่เราอยู่ในเรื่อง
>> ดังนั้นถ้าฉันไปกลับมาที่นี่ผมได้ประกาศ char * เรียกว่า T
ผมเคยเรียกว่าตอนนี้เป็นเวลาหก malloc ไบต์
และตอนนี้ฉันกำลังจะไปวาดรูปที่หก ไบต์เช่นเดียวกับอาร์เรย์ก่อนหน้านี้
แต่ที่จริงผมไม่ทราบว่ามีอะไร ภายในอาร์เรย์นี้
>> หากคุณจัดสรรหน่วยความจำมันกลับกลายเป็นว่า คุณจะไม่สามารถเชื่อถือได้ว่ามีบางอย่าง
ค่าที่รู้จักกันมี
มันอาจจะถูกใช้โดยบางสิ่งบางอย่าง อื่นบางฟังก์ชั่นอื่น ๆ อื่น ๆ บาง
บรรทัดของรหัสที่คุณเขียน
ดังนั้นเราจึงมักจะเรียกขยะเหล่านี้ ค่านิยมและวาดพวกเขาอาจจะเป็น
เครื่องหมายคำถามเพียงแค่แสดงให้เห็นว่าเรา ไม่ทราบว่ามีจริง
และที่ว่าไม่มีเรื่องใหญ่ตราบใดที่เรา ฉลาดพอที่จะเขียนทับ
ค่าขยะด้วยตัวเลขหรือ ตัวอักษรที่เราดูแลเกี่ยวกับ
>> ดังนั้นในกรณีนี้สิ่งที่ฉันจะทำอย่างไร
ดีบรรทัดของฉันของรหัส ต่อไปฉันมีสี่
int ฉันได้รับ 0, n ได้รับ ความยาวสตริงของ s
ดังนั้นคุ้นเคยสำหรับวง
ผมมีค่าน้อยกว่าหรือเท่ากับ n, ซึ่งมักจะอยู่เหนือ
>> แต่ครั้งนี้มันโดยเจตนา
ผม + + และแล้วผมก็ทำ T วงเล็บผมได้รับของ
เพราะภาพของฉันมีลักษณะเช่นนี้ที่ ขณะนี้ถูกเก็บไว้ใน T คือ
ที่อยู่ของก้อนสุ่มที่ของหน่วยความจำ ค่าที่ไม่เป็นที่รู้จัก
แต่ทันทีที่ฉันทำทีวงเล็บ 0 ที่ทำให้ฉันที่นี่
>> และสิ่งที่จบลงด้วยการวาดมี?
เราจบลงด้วยการวางชั่วโมง
เพราะนั่นคือสิ่งที่อยู่ในวงเล็บ s 0
และแล้วสิ่งเดียวกันสำหรับ e และลิตรและลิตรและ o
>> n ผมทำไมขึ้นไปผ่าน เท่ากับ n?
เพราะตัวละคร 0
ดังนั้นเพียงแค่ต้องมีความชัดเจนแล้วถ้าผมจริง ลบสิ่งที่ขยะเหล่านี้
มีค่าแล้วจริงวาดใน สิ่งที่ผมคาดหวังนี้เป็น s วงเล็บ 1, 2,
3, 4, บวกที่ต่อท้าย ตัวละครใหม่
>> และดังนั้นตอนนี้ถ้าเรายังคงผ่านมาจุด, จุดจุดในรุ่นที่ถูกต้องนี้
และวงเล็บ T ทุน 0 ฉันจะของ แน่นอนจะพะวงอยู่เพียงแค่นี้
คนที่แต่งตัวประหลาดที่นี่ซึ่งแนวคิด ท้ายที่สุดก็คือเป้าหมาย
เพื่อให้ทุกตัวชี้เป็น
>> และคุณได้รับใช้พวกเขาเป็นเวลาหลายสัปดาห์ ขณะนี้ในบริบทของสตริง
แต่อยู่ภายใต้ฝากระโปรงที่พวกเขากำลัง เล็ก ๆ น้อย ๆ ที่ซับซ้อนมากขึ้น
แต่ถ้าคุณคิดว่าเกี่ยวกับพวกเขาในเรื่องนี้ รูปแบบภาพที่ผมเสนอว่าพวกเขากำลัง
อาจจะไม่ใช่สิ่งที่น่ากลัวขณะที่พวกเขา ครั้งแรกอาจจะดูเหมือนได้อย่างรวดเร็วก่อน
โดยเฉพาะอย่างยิ่งกับไวยากรณ์ใหม่ ๆ เช่น
คำถามใด ๆ เกี่ยวกับตัวชี้ สตริงหรือตัวอักษร?
อ้าง?
>> ผู้ชม: คุณสามารถกลับไป ไป [ได้ยิน]
>> 1 SPEAKER: Sure
>> ผู้ชม: ดังนั้นวิธีการมาในครั้งล่าสุดของคุณมาก สายคุณไม่ได้มีสาย T *
และ * ในเส้น?
คุณไม่ได้มีการอ้างอิงถึง -
>> ลำโพง 1: อ่า, คำถามที่ดีจริงๆ
ทำไมฉันจึงไม่ได้ * t และ * s หรือไม่?
เพราะชั่วครู่สัปดาห์ที่ผ่านมาเช่นเดียวกับในของเรา สลับการทำงานของผมไม่บอกว่าเมื่อ
คุณได้มีตัวชี้หมายถึงการ ซึ่งคุณจะไปที่นั่นในฐานะที่เราทำ
ร่างกายบนเวทีเป็นจริง ใช้ตัวดำเนินการดาว
>> แต่กลับกลายเป็นว่านี้ยึดตาราง สัญกรณ์เป็นสิ่งที่เราจะเรียกประโยค
น้ำตาลซึ่งเป็นเพียงวิธีที่เซ็กซี่ของ บอกว่าสัญกรณ์ชวเลขมันสำหรับ
สิ่งที่คุณอธิบาย
แต่มันก็เป็นเพียงเล็กน้อยง่ายขึ้น
และที่มีความเสี่ยงของการทำนี้ดูเหมือน ซับซ้อนกว่าที่จะต้องมี,
สิ่งที่จริงที่เกิดขึ้นที่นี่ เป็นดังต่อไปนี้ -
ถ้าผมพูด * t นั่นหมายความว่าไป ที่อยู่ที่เก็บไว้ในที
>> ดังนั้นตัวอักษรถ้า T เป็นการจัดเก็บ ที่อยู่ของชั่วโมงที่
ในขั้นต้น * หมายถึง t go ที่นี่
ตอนนี้ทีวงเล็บ 0 หมายความว่าอย่างไร
สิ่งที่แน่นอนเดียวกัน
มันเป็นเพียงผู้ใช้น้อยมาก เป็นมิตรกับผู้เขียน
>> แต่ฉันยังไม่ได้ทำ
ฉันไม่สามารถเพียงแค่พูด t * s * ได้รับ
เพราะผมจะต้องทำอะไรแล้ว
ฉันจะวางเอชเอชเอชเอชเอช ตลอดทั้งสิ่ง
ใช่ไหม?
>> เพราะ t * คือไปอยู่ในที
แต่เราก็ด้านในของวง
และฉันว่าค่าการเพิ่ม, แน่นอนแต่ละย้ำ?
ผม
>> แต่มีโอกาสที่ว่า ที่นี่ใช่มั้ย?
แม้ว่านี้รู้สึกเหมือนมันเริ่ม เล็ก ๆ น้อย ๆ ที่ซับซ้อนมากขึ้น
กว่าตารางสัญกรณ์วงเล็บ เราได้ใช้สำหรับบางเวลา -
ให้ฉันยกเลิกการเปลี่ยนแปลงชั่วโมงของฉันมี -
แม้ว่านี่คือตอนนี้ได้รับเพียงเล็กน้อย นักเล่นแนวคิดพื้นฐานถ้า t *
หมายถึงที่นี่และ t * เป็นเพียง ไปที่ที่อยู่ในที
>> แต่สิ่งที่เป็นอยู่ใน T?
จำนวนที่เราให้ใช้?
เช่น Ox456 ให้เอามันกลับไป เพียงเพื่อประโยชน์ของการสนทนา
ดีถ้าฉันต้องการที่จะได้รับ e ใน T สตริงผมเพียงต้องการที่จะไป,
เป็นหลัก 456
>> หรือมากกว่า 457
ผมเพียงแค่ต้องเพิ่มอีกหนึ่ง
แต่ฉันจะทำอย่างนั้นใช่มั้ย?
เพราะทีแม้ว่าฉันให้วาด ตอนนี้ลูกศรก็เพียง
จำนวน Ox456
และถ้าฉันจะเพิ่มหนึ่งนั้นหรือมากกว่า โดยทั่วไปถ้าฉันจะเพิ่ม I เพื่อที่ฉันสามารถ
จริงได้รับสิ่งที่ฉันต้องการ
ดังนั้นหากที่จริงผมทำเช่นนี้ -
และนี่คือสิ่งที่เรียกว่าตอนนี้ คำนวณตัวชี้ -
ฉันจะลบบรรทัดนี้
ซึ่งก็คือตรงไปตรงมาผมคิดว่าชัดเจนและ ผู้ใช้น้อยมากที่เป็นมิตรที่จะอ่าน
แต่เรื่องนี้ไม่น้อยที่ถูกต้อง
>> บรรทัดของรหัสนี้ในขณะนี้คือการใช้ คำนวณตัวชี้
มันบอกว่าให้ไปที่ ที่อยู่ดังต่อไปนี้ -
สิ่งที่เริ่มต้นของ T คือที่ คือ T บวกผมซึ่งในขั้นต้น
0 ซึ่งเป็นที่ดีคือ
เพราะนั่นหมายความว่าจุดเริ่มต้นของ T บวก 1 บวก 2 บวก 3 และอื่น ๆ
และการจัดการที่เหมือนกันกับ s
>> ประโยคน้ำตาลดังนั้นสำหรับนี้
แต่ความเข้าใจของสิ่งที่เกิดขึ้นจริง ภายใต้ฝากระโปรงหน้าผมจะเถียง
เป็นจริงมีประโยชน์ในตัวของมันเอง
เพราะมันหมายความว่าตอนนี้มีไม่ได้ มายากลอื่น ๆ อีกมากมายที่เกิดขึ้น
ภายใต้ฝากระโปรง
มีจะไม่ได้อื่น ๆ อีกมากมาย ชั้นที่เราปอกเปลือกสามารถสำรองสำหรับคุณ
นี้เป็นค
และนี่คือการเขียนโปรแกรม
คำถามที่ดีจริงๆ
>> ขวาทั้งหมดดังนั้นนี้เป็นรถที่ โปรแกรมที่ผมกำลังพูดถึงก่อนหน้านี้
swap มีข้อบกพร่อง
ถ้าไม่ดูเหมือนจะทำงาน
จำได้ว่าเพียงแค่เช่นเดียวกับนมและ น้ำส้ม - ที่ฉันเริ่ม
สาธิตการดื่มของวันนี้
ดังนั้นเช่นเดียวกับน้ำส้มและ นมเราไม่ต้องใช้
ตัวแปรชั่วคราว, tmp, ที่จะถือ ชั่วคราวเพื่อให้เราสามารถแล้ว
เปลี่ยนค่าของมันแล้วปรับปรุงข
>> แต่ฟังก์ชั่นนี้เรากล่าวว่านี้หรือ โปรแกรมที่ฟังก์ชั่นนี้คือ
เขียนเป็นความผิดพลาดและข้อบกพร่องทำไม?
ใช่?
>> ผู้ชม: [ได้ยิน]
>> 1 SPEAKER: ว่าเมื่อ คุณโทร swap -
หรือมากกว่าปกติเมื่อคุณ เรียกฟังก์ชั่นมากที่สุดใด ๆ -
ถ้าขัดแย้งในการทำงานที่มี ints เพื่อที่จะพูด, ดั้งเดิมและตัวอักษร
และคู่ผสมและลอยสิ่งโดยไม่ ดาวคุณจะผ่านในสำเนาของ
อาร์กิวเมนต์
ดังนั้นถ้า x เป็น 1 และ y เป็น 2 จะ เป็น 1 และ b เป็นไปได้ 2
แต่พวกเขากำลังจะได้รับชิ้นที่แตกต่างกัน ของบิตชิ้นที่แตกต่างกันของ
หน่วยความจำที่เกิดขึ้นที่จะจัดเก็บ ค่าเหมือน
>> ดังนั้นรหัสนี้เป็นซุปเปอร์ที่สมบูรณ์แบบ ที่แลกเปลี่ยน a และ b
มันไม่ดีที่การแลกเปลี่ยน -
ในตัวอย่างสัปดาห์สุดท้ายของ -
x และ y
เพราะอีกครั้งที่พวกเขากำลัง อยู่ในขอบเขตที่ไม่ถูกต้อง
>> ตอนนี้เราก็จะไปเกี่ยวกับการแก้ไขนี้
เราต้องทำให้ฟังก์ชั่น ดูไม่สวยงามเท่าน้อย
แต่อีกครั้งพิจารณาสิ่งที่ นี้ก็หมายความว่า
>> และที่จริงให้ฉัน, เพื่อความมั่นคง, เปลี่ยนสิ่งหนึ่งดังนั้นมันจึงเหมือนกับ
สิ่งที่เราก็ไม่ได้
ที่ผมกล่าวถึงสัปดาห์ที่ผ่านมามันไม่ได้ เรื่องที่จะไป
ในความเป็นจริงมักจะคุณจะใส่ ดาวที่อยู่ถัดจากชื่อตัวแปร
แต่ฉันคิดว่ามันจะง่ายขึ้นเล็กน้อย ที่จะต้องพิจารณา * ที่อยู่ถัดจาก
ชนิดของข้อมูลที่เป็นความหมายมันเป็นตัวชี้ เพื่อ int ในกรณีนี้
>> ฉันดังนั้นสิ่งที่ทำอะไรที่นี่?
ที่ฉันพูดไม่ให้ฉัน int ตามด้วย int อีก
เรียกพวกเขา A และ B
ให้ฉันที่อยู่ของ int
ให้ฉันที่อยู่ของ int อีก
โทรที่อยู่เหล่านั้น A และ B
>> แล้วใช้สัญกรณ์ * ลง ด้านล่างไปแต่ละที่อยู่เหล่านั้น
เท่าที่จำเป็นที่จะได้รับ หรือตั้งค่าของมัน
แต่มีข้อยกเว้นอยู่ที่นี่
ทำไมฉันจึงไม่ได้มี * ถัด tmp?
ทำไมไม่ทำเช่นนี้ตัวอย่างเช่น?
มันให้ความรู้สึกเหมือนฉันก็ควรไปทั้งหมด ออกและแก้ไขสิ่งที่ทั้ง
อ้าง?
>> ผู้ชม: [ได้ยิน]
>> 1 SPEAKER: ฉันยังไม่ได้ประกาศ tmp เป็นสตริง
ดังนั้นนี้จะประกาศในกรณีนี้, tmp ไปจะเป็นที่อยู่ของ int
แต่ที่ไม่มากสิ่งที่ฉันต้องการ สำหรับคู่ของเหตุผล
>> ผู้ชม: คุณไม่ต้องการที่จะแลกเปลี่ยนพวกเขา
>> 1 ลำโพงตรงฉันไม่ต้องการที่จะแลกเปลี่ยน อะไรกับ tmp tmp เป็นเพียง
สิ่งหนึ่งสัปดาห์-
ทั้งหมดที่ฉันต้องการเป็นตัวแปร ในการจัดเก็บบางหมายเลข
ฉันไม่ได้ดูแลเกี่ยวกับที่อยู่ ตอนนี้
>> ฉันต้อง 32 บิตหรือ เพื่อที่จะเก็บ int
และฉันต้องการที่จะใส่ในที่ 32 บิต อะไรก็ตามที่ไม่ได้อยู่ในเพื่อที่จะพูด แต่
อยู่ที่อะไรเพียงเพื่อจะแม่นยำมากขึ้น
เพราะถ้าเป็นที่อยู่, * หมายถึง ไปที่นั่นและได้รับมูลค่า 1
ยกตัวอย่างเช่นในตัวอย่างสัปดาห์สุดท้ายของ หรือในกรณีของ b, รับค่าของ 2
>> ดังนั้นสิ่งที่เกิดขึ้นจริง?
ให้ฉันวาดภาพที่นี่ที่จะ เพียงหยอกล้อกันเป็นส่วนหนึ่งของวันนี้
แต่นี้จะยังคงปรากฏ สำหรับค่อนข้างบางเวลา
>> นี้ผมเรียกร้องคือสิ่งที่คอมพิวเตอร์ของคุณ หน่วยความจำดูเหมือนว่าเมื่อคุณเรียกใช้
โปรแกรมโปรแกรมใด ๆ
เมื่อคุณเรียกใช้โปรแกรมที่ด้านบนมาก ของ RAM ของคอมพิวเตอร์ของคุณ - ดังนั้นคิดว่า
รูปสี่เหลี่ยมผืนผ้านี้อย่างแท้จริงเป็นของคุณ แรมของคอมพิวเตอร์หรือหน่วยความจำทั้งหมด 101
พันล้านไบต์ของมันทั้งหมดสองพันล้าน ไบต์ทั้งหมดสองกิกะไบต์ของมัน
สิ่งที่ปริมาณที่คุณมีคือ ให้วาดเป็นรูปสี่เหลี่ยมผืนผ้า
และผมก็เรียกร้องว่าเมื่อคุณเรียกใช้โปรแกรม เช่น Microsoft Word หรือ Chrome
หรือสิ่งที่ต้องการที่บิตที่ ไมโครซอฟท์หรือ Google ที่เขียน -
ในกรณีของโปรแกรมเหล่านั้น -
จะโหลดลงในหน่วยความจำของคอมพิวเตอร์ของคุณ ที่พวกเขาสามารถดำเนินการได้มากขึ้น
ได้อย่างรวดเร็วและป้อนเข้า CPU ซึ่ง เป็นสมองของคอมพิวเตอร์
>> และใน TAM ที่พวกเขากำลังเก็บไว้ที่มาก ด้านบนของโปรแกรมของคุณเพื่อที่จะพูด
ในคำอื่น ๆ ถ้าเป็นก้อน หน่วยความจำเมื่อคุณดับเบิลคลิกที่
โปรแกรม Microsoft Word, บิตมา ปิดฮาร์ดไดรฟ์
พวกเขาได้รับการโหลดเข้าสู่ RAM
และเราจะผลักพวกเขาขึ้นที่ด้านบนมาก ของสี่เหลี่ยมผืนผ้าแนวคิดนี้
>> ดีส่วนที่เหลือของหน่วยความจำของคุณคือ ใช้สำหรับสิ่งที่แตกต่างกัน
ที่ด้านบนมากที่คุณเห็นในการเริ่มต้น ข้อมูลได้และยกเลิกข้อมูล
นี้จะทำอย่างไรสำหรับส่วนใหญ่ที่มี ค่าคงที่หรือตัวแปรทั่วโลก
ที่มีค่า
แต่เพิ่มเติมเกี่ยวกับการเหล่านั้นอีกครั้ง
>> แล้วคุณมีกองซึ่ง เราจะกลับมา
แต่ที่ด้านล่างเป็นส่วนหนึ่งที่ โดยเฉพาะอย่างยิ่งซึ่งเกี่ยวดองกันอย่างใกล้ชิดในขณะนี้
มันเป็นสแต็คที่เรียกว่า
ดังนั้นเช่นเดียวกับในที่สุดห้องโถง D ใด ๆ ที่นี่ วิทยาเขตคุณมีถาดที่
เพียงกองอยู่ด้านบนของแต่ละอื่น ๆ ที่ คุณสามารถใส่อาหารและ whatnot
สแต็คในระบบคอมพิวเตอร์ จะคล้ายกันมาก
ยกเว้นในขณะที่ถาดในขณะที่เราใช้ในการ ห้องอาหารของหลักสูตรที่มีความหมาย
ที่จะดำเนินการสิ่งที่ถาด หรือเฟรม -
ในขณะที่เราจะเรียกพวกเขา - ในเครื่องคอมพิวเตอร์ หน่วยความจำที่ใช้ในการถือ
ตัวแปรและค่านิยม
>> ดังนั้นจริงๆสิ่งที่ไปใน ภายใต้ฝากระโปรง?
ดีให้ฉันพลิก ไปยังหน้าจอที่นี่
และขอเน้นเพียง ส่วนล่างสักครู่
ถ้าเป็นส่วนที่ด้านล่างของฉัน หน่วยความจำของคอมพิวเตอร์ก็จะเปิดออกเมื่อฉัน
เรียกใช้ฟังก์ชันหลัก - ที่เกิดขึ้นตรงไปตรงมา
โดยอัตโนมัติสำหรับฉัน -
ฉันได้รับรู้ของหน่วยความจำที่ ด้านล่างของแรมของฉันเพื่อที่จะพูด
และนี่คือที่หลักของ ตัวแปรท้องถิ่นไป
มันเป็นเรื่องที่ argc และ argv บางที ไปและตัวแปรที่ฉัน
ประกาศภายในของหลัก
พวกเขาจบลงที่ด้านล่าง ของ RAM คอมพิวเตอร์ของฉัน
>> สมมติว่าขณะนี้สายหลักที่ฟังก์ชั่น เช่นการแลกเปลี่ยนเช่นเดียวกับที่มันทำสัปดาห์สุดท้าย?
ดีเราเป็นหลักใส่ถาดใหม่ กรอบใหม่ลงบนก้อนของฉันของหน่วยความจำ
และฉันจะอธิบายเรื่องนี้ในขณะที่ เป็นฟังก์ชั่นการแลกเปลี่ยน
>> ตอนนี้ภายในของการแลกเปลี่ยนคืออะไร
ดีขึ้นอยู่กับโปรแกรมสัปดาห์สุดท้ายของและ หนึ่งที่เราเพิ่งเห็นข้อความที่ตัดตอนมาจาก,
ภายในกรอบของการแลกเปลี่ยนหรือแลกของ ถาดตัวแปรสิ่งที่เป็น?
ดี a และ b
เพราะผู้ที่มีข้อโต้แย้งในประเทศของตน บวก tmp สาม
ดังนั้นจริงๆที่ฉันสามารถวาดนี้ เล็ก ๆ น้อย ๆ อย่างหมดจด
ให้ฉันไปข้างหน้าและยกเลิกการติดฉลาก
และแจ้งให้เราอ้างว่าคุณรู้ว่าสิ่งที่?
>> อาจจะจบลงที่นี่
B จะไปจบลงที่นี่
และ tmp จะไปจบลงที่นี่
ตอนนี้อาจจะสั่งซื้อ จะเป็นเพียงเล็กน้อยที่แตกต่างกัน
แต่แนวคิดนี้ก็คือค​​วามคิด
>> และเพียงแค่เรียกรวมกันว่านี่คือสิ่งที่ เราจะเรียกกรอบการแลกของหรือ
ถาดอาหารห้องโถง
และการจัดการที่เหมือนกันกับหลัก
แต่ฉันจะไม่วาดว่า
แต่ที่ที่ argc และ argv และใด ๆ ของตัวแปรท้องถิ่นเช่น x และ y
อาจจะมีเช่นกัน
>> ดังนั้นตอนนี้พิจารณาสิ่งที่เกิดขึ้นจริง เมื่อคุณโทร swap
เมื่อคุณโทร swap, รหัสการดำเนินการเช่น นี้คุณผ่านในใน
รุ่นรถ, A และ B เป็นสำเนาของ x และ y
ดังนั้นถ้าฉันทำตอนนี้วาดนี้ บนหน้าจอ -
จะได้รับดีกว่าที่นี้ -
ดังนั้นเรื่องที่ผมบอกกับตัวเอง เป็นรถในรุ่นนี้เมื่อเรา
เรียกสลับผ่านในตัวอักษร A และ B เป็นจำนวนเต็มสิ่งที่เกิดขึ้นจริง?
>> ดีสิ่งที่เกิดขึ้นจริงนี้
ให้ฉันไปข้างหน้าและยกเลิกเพียง เพื่อล้างพื้นที่นี่คือบางส่วน
ดังนั้นนี่คือหน่วยความจำคอมพิวเตอร์ของฉัน
>> ดังนั้นถ้าฉันมีตัวอย่างเช่น -
ที่จริงเราทำมันด้วยวิธีนี้ -
ถ้าผมเรียกร้องว่านี่คือ x, จัดเก็บ มูลค่า 1 เช่นเดียวกับสัปดาห์ที่ผ่านมา
และนี่คือ y จัดเก็บค่า 2 เช่นเดียวกับสัปดาห์ที่ผ่านมา
และนี่คือหลักเมื่อฉันโทร swap, จึงให้ตัวเองเข้าถึงและ
b และ tmp, ฉั​​นจะอ้างว่า นี้และนี่คือ 1
>> นี่คือข
นี่คือ 2
นี้เรียกว่า tmp
>> และต้นมันมีค่าขยะบาง จนกว่าฉันจะเก็บจริงในนั้น
ซึ่งเป็น 1
แล้วฉันไปข้างหน้าและการเปลี่ยนแปลง จะเป็นสิ่งที่?
มูลค่าของ B
>> และดังนั้นตอนนี้ฉันมีสองที่นี่
แล้วเรากล่าวว่า b ได้รับ tmp
อีกครั้งเช่นเดียวกับที่ตรวจสอบสติที่สาม บรรทัดของรหัสที่นี่เป็นเพียงนี้
หนึ่ง b ได้รับ tmp
>> และสุดท้ายสิ่งที่ฉันจะทำอะไร?
ฉันไปข้างหน้าและเปลี่ยน b เป็นสิ่งที่ ค่าของ tmp เป็นซึ่งเป็น 1
ผมไม่ได้สัมผัส tmp อีกครั้ง
>> แต่ตอนนี้ปัญหาคือเร็วที่สุดเท่าที่ swap ผลตอบแทนที่ได้เพราะมันไม่ได้ส่ง
กลับค่าบางอย่างมีผลตอบแทนไม่ได้ คำสั่งอย่างชัดเจนในนั้น
สิ่งที่เกิดขึ้นจริง?
ดีเป็นหลักหน่วยความจำทั้งหมดนี้ -
ตกลงเห็นได้ชัดว่ายางลบชอบ เพียงหนึ่งนิ้วในเวลา -
เพียงแค่หายไป
>> ตอนนี้ในความเป็นจริงมันไม่ใช่ ไปทุกที่
แต่คุณสามารถคิดว่ามัน ขณะนี้เป็นเครื่องหมายคำถาม
เพราะมันไม่มีอีกต่อไป จริงในการใช้งาน
และไม่มีอะไรที่จะทำกับค่าเหล่านั้น
>> ดังนั้นในกรณีของรุ่นสีเขียวของ รหัสนี้สิ่งที่จะถูกแทน
ผ่านเข้าไปใน swap?
ดังนั้นที่อยู่
ดังนั้นที่อยู่ของ x และ ที่อยู่ของ y
ดังนั้นถ้าเรากลับบอกเรื่องนี้ล่าสุด เวลาและที่จริงผมวาด swap อีกครั้ง
แต่กับตัวชี้นี่เป็นนี้ เป็น b, tmp นี้เป็นสิ่งที่เป็น
ถูกจัดเก็บจริงในสีเขียวนี้ รุ่นของรหัสของฉันที่ฉันผ่าน
ในที่อยู่?
>> มันจะเป็นตัวชี้ไปยัง x
ดังนั้นผมจึงสามารถวาดลูกศร
แต่ขอใช้กันโดยพลการ ตัวอย่างเช่นที่ผ่านมา
ขอบอกว่านี้คือ สิ่งที่ต้องการ Ox123
และสิ่งนี้เป็นไปได้เพราะ Ox127 มันเป็นไบต์ที่สี่ออกไปเพราะมัน
int ดังนั้น Ox127
>> และอีกครั้งที่ผมสละเสรีภาพบางส่วน กับตัวเลข
พวกเขากำลังมีขนาดเล็กกว่าที่พวกเขาจะ ความเป็นจริงและในการสั่งซื้อที่แตกต่างกัน
แต่ที่วิธีการที่ภาพ คือตอนนี้ที่แตกต่างกัน
>> แต่เมื่อฉันใช้รหัสนี้สีเขียว และ tmp int ฉันจะได้รับ *
* วิธีทำต่อไปนี้จะต้องมีการ ที่อยู่ที่อยู่ในและไปกับมัน
ซึ่งเป็น 1
และนั่นคือสิ่งที่ฉันแล้วใส่ใน tmp
ในขณะเดียวกันในบรรทัดถัดไปของรหัส ที่นี่ได้รับ * b, ว่าหมายความว่าอย่างไร
>> ดี * เพื่อไปที่นี่ได้รับ * b, ซึ่งหมายถึงไปที่นั่น
และนั่นหมายความว่าใส่ค่าที่จะมี
สุดท้ายบรรทัดสุดท้ายของรหัส เพียงกล่าวว่า b * ได้รับ tmp
>> ดังนั้น B พูดว่าไปที่นั่นและเขียนทับด้วย tmp ซึ่งในกรณีนี้เป็นไป
ที่จะเป็นอีกครั้ง 1
และนี่คือเหตุผลที่รุ่นสีเขียว งานรหัสของเราในขณะที่สีแดง
รุ่นที่ไม่เคยทำ
ซึ่งทั้งหมดจะเดือดลงไปเพียงแค่วิธีการที่ หน่วยความจำที่มีการจัดการและที่มัน
จริงวางในของคุณ ของคอมพิวเตอร์ RAM
และสำหรับตอนนี้ที่เป็นหนึ่งในสิ่ง สแต็คที่จะถูกใช้สำหรับ
>> คำถามในรูปแบบ?
เมื่อชี้?
หรือบน swap?
>> สิทธิทั้งหมด malloc เพื่อให้การเรียกคืน, ทำอะไรบางอย่างเช่นนี้
นี้เป็นตัวอย่างง่ายสุด
และนี่ก็เป็นหนึ่งที่บิงกี้ แนะนำให้เราแม้จะค่อนข้าง
ได้อย่างรวดเร็วในตอนท้ายของชั้นเรียน
โธ่เว้ยมีเราไปอีกครั้ง
>> ดังนั้นจำได้ว่าเรื่องนี้เป็นตัวอย่างที่ บิงกี้นำเราไปแม้ว่า
ค่อนข้างได้อย่างรวดเร็วในตอนท้ายของชั้นเรียน
และที่นี่เราใช้ malloc จริงๆ เป็นครั้งที่สอง
เพราะครั้งแรกที่เราใช้มันเพื่อ สร้าง RAM เพียงพอจัดสรร RAM เพียงพอ
เพื่อเก็บสตริง
>> บิงกี้คราวนี้เก็บไว้มันง่าย
ดังนั้นจึงเป็นเพียงการจัดเก็บ int เห็นได้ชัดว่า
และที่ดีโดยสิ้นเชิง
มันเป็นเรื่องที่แปลกเล็กน้อยตรงไปตรงมาเพื่อ ใช้ malloc ในการจัดสรรหนึ่ง int
แต่จุด claymation ของ Nick คือ จริงๆเพียงแค่บอกเล่าเรื่องราวของสิ่งที่
เกิดขึ้นหรือไม่เกิดขึ้นเมื่อ คุณข่มเหงหน่วยความจำ
>> ดังนั้นในกรณีนี้โปรแกรมนี้ ทำบางสิ่ง
ในกรณีแรกที่นี่ก็บอกว่า ตัวชี้ที่เรียกว่า x เพื่อ int
จากนั้นก็ประกาศตัวชี้ ที่เรียกว่า Y เพื่อ int
จากนั้นจะจัดเก็บใน x, อะไร
คนอื่นในขณะนี้
สิ่งที่ได้รับการจัดเก็บไว้ใน x ตาม บรรทัดที่สามของโปรแกรมนี้?
>> ผู้ชม: [ได้ยิน]
>> 1 SPEAKER กันไม่มาก ไบต์ต่อว่า
จะแม่นยำมากขึ้นในขณะนี้
สิ่งที่ได้รับการจัดเก็บไว้ใน X?
ที่อยู่ฉันคิดว่าฉันได้ยินมัน
>> ดังนั้น malloc สิ่งที่ไม่กลับมา?
malloc behaviorally จัดสรร หน่วยความจำอัน
แต่มันเป็นวิธีการที่ไม่ทำให้คุณสามารถใช้มันได้หรือ
มันกลับอะไร
ที่อยู่ของไบต์แรก ในหน่วยความจำอัน
>> ตอนนี้ง่ายสุด
มันเป็นเพียงหนึ่งไบต์ซึ่งหมายความว่า ที่เราได้รับกลับเป็น
ที่อยู่ของสิ่งที่ทั้ง
เก็บไว้ดังนั้นใน x ก็คือที่อยู่ ของหน่วยความจำอันว่า
ในขณะเดียวกันสิ่งที่เกิดขึ้นต่อไปคืออะไร?
ดังนั้นจริงให้ไปข้างหน้าและ วาดอย่างรวดเร็วนี้จริงออก
>> ดังนั้นถ้าเราไปกว่าไปยังหน้าจอที่นี่และ เราเล่นออกนี้ int * int x และ y *
จะไปทำในสิ่งที่สำหรับฉันหรือไม่
ผมอ้างว่ามันเป็นเพียงแค่จะทำ บางอย่างเช่นนี้และเรียกว่า x และ
นี้และเรียกว่า y
ขณะที่บรรทัดที่สามของรหัสคือ ไปจัดสรรขนาดของ int,
ที่เกิดขึ้นจะ - ขออภัยหากผมบอกว่า หนึ่งก่อนที่ผมจะหมายถึงหนึ่ง int -
สี่ไบต์บนเครื่องคอมพิวเตอร์ทั่วไป
อย่างน้อยกับ CS50 เครื่องใช้
>> ดังนั้นนี้เป็นไปจัดสรร มันใครจะรู้?
ที่ไหนสักแห่งออกจากที่นี่
และนี่คือบางส่วนเก็บไว้ที่ วัวที่อยู่ใครจะรู้?
แต่สิ่งที่จะได้รับกลับมา เป็นที่อยู่ที่
แต่เราจะวาดนี้ pictorially เป็นเพียงเช่นเดียวกับที่ลูกศร
>> ตอนนี้ในบรรทัดถัดไปจะได้รับ * x 42
สิ่งที่ไม่ x * หมายถึงในแง่ของคนธรรมดา?
เพียงแค่ไปที่นั่น
ไปที่ที่อยู่ที่
หรือในคำอื่น ๆ ทำตาม ศรและใส่ 42 มี
แต่แล้วสิ่งที่ไม่ดีเกิดขึ้น ไปบิงกี้ใช่มั้ย?
>> จำเส้นที่ห้านี่, y * ได้รับ 13 จริงจำนวนโชคร้าย
ทำในสิ่งที่เรา?
ดี * y หมายถึงไปที่นั่น
อย่างนี้ยังไม่ได้รับ มูลค่ายังขวา?
รหัสไม่ได้เป็น y เริ่มต้นกับสิ่งใด
เราได้ x ถูกเริ่มต้น ไปยังที่อยู่
แต่ y ถูกประกาศขึ้นด้านบน
แต่แล้วอัฒภาคไม่มีค่า ถูกจริงใส่ในนั้น
ดังนั้นมันยุติธรรมที่จะเรียกสิ่งนี้ว่า ค่าขยะ
รู้ว่าสิ่งที่อยู่ที่นั่นใคร?
มันเป็นเศษเล็กเศษน้อยของบิตที่ถูกนำมาใช้ โดยบรรทัดก่อนหน้าบางส่วนของรหัสใน
โปรแกรมของฉัน
>> ดังนั้นถ้าฉันบอกว่าไปที่นั่นเช่นนี้, ผมมีความคิดที่ลูกศรนี้จะไม่มี
จะจบลง
และที่ว่าเมื่อคุณมักจะ ได้รับความผิดส่วน
หากคุณ dereference ตั้งใจเพื่อที่จะ พูดหรือไปยังที่อยู่ที่ไม่
จริงที่อยู่ถูกต้องตามกฎหมาย สิ่งเลวร้ายที่เกิดขึ้น
>> และนั่นคือสิ่งที่เกิดขึ้น ที่จะคิดว่าบิงกี้
ดังนั้นจำได้ว่าเรื่องที่นิคคือ บอกที่นี่เป็นความคิดเดียวกันกับสิ่งที่
ผมเคยวาดด้วยภาพลวงตาของ ชอล์กบนกระดานมี
x และ y มีการประกาศ
>> แล้วเราจัดสรรขนาดของ int และเก็บไว้ใน x
แล้วบรรทัดถัดไปที่เราทำ x *
นี่เป็นไม้กายสิทธิ์ของ Nick จาก dereferencing
ที่วาง 42 ในหน่วยความจำ แหลมออกโดย x
>> แต่นี่คือสิ่งที่ ไปอย่างน่ากลัวผิด
ใช่ไหม?
เราพยายามที่จะ y dereference
แต่ y มีค่าบางอย่างที่ปลอมใช่มั้ย?
>> ลูกศรในด้านล่างซ้ายมือว่า มุมไม่ได้
จริงชี้ไปที่ใด
เป็นชนิดของการทำสิ่งที่ฉัน ได้ที่นี่บนกระดาน
ดังนั้นสิ่งที่ไม่ดีเกิดขึ้นการแบ่งส่วน, ความผิดความผิดหรือบิงกี้ในกรณีนี้
>> แต่ถ้าเราแก้ไขแล้วว่าการดำเนินการ x y วิธีการที่ไม่ได้รับการเปลี่ยนแปลงเรื่อง?
ดีถ้าฉันได้รับ x y ที่ ได้อย่างมีประสิทธิภาพเช่นเดียวกับการพูด
สิ่งนี้คือวัวบางสิ่งบางอย่าง เป็นไปได้เหมือนกันที่นี่
วัวบางสิ่งบางอย่าง
หรือ pictorially เราจะวาดล​​ูกศร
>> ดังนั้นที่นี่บนกระดานกับบิงกี้, ด้วยบรรทัดถัดไปของ
รหัส * y หมายถึงไปที่นั่น
ที่มี?
มันหมายความว่ากว่าที่นี่
>> และเมื่อเราปรับปรุงนั้นให้อยู่เป็น 13 มันก็เกี่ยวข้องกับการคงอยู่และ
เขียน 13 ที่นี่ตอนนี้
ดังนั้นอาจจะไม่สมบูรณ์ ตรงไปตรงมาอย่างรวดเร็วก่อน
แต่การที่จะปะยางรถและการใช้ศัพท์แสงเดียวกัน ที่บิงกี้ก็ใช้ที่นี่ดังนั้น
สองคนแรกที่จัดสรรตัวชี้, x และ y แต่ไม่ pointees
และ pointees ไม่ได้เป็น คำที่ใช้โดยทั่วไป
แต่ตัวชี้อย่างแน่นอนคือ
แต่มันเป็นสิ่งที่ถูกชี้ ที่ในบิงกี้ของศัพท์
>> บรรทัดนี้ต่อไปแน่นอน จัดสรร pointee int
ดังนั้นก้อนของหน่วยความจำ - เป็นฉันวาดไปบน ด้านขวามือมี - และชุด
x เท่ากับชี้ไปที่มัน
นี้ x dereferences ในการจัดเก็บที่ 42 ใน หน่วยความจำที่มันชี้ไปที่
และแล้วนี้แน่นอน เป็นสิ่งที่ไม่ดี
เพราะ y ไม่ได้ชี้ ที่อะไรเลย
นี้จะแก้ไขมัน
ดังนั้นนี่คือโปรแกรมยังรถม้าชนิดเล็ก
เพียงเพราะเรากำลังพัดผ่าน รหัสสายเส้นและพูดว่าโอ้ดี
ปล่อยให้มันผิดพลาดมี
นั่นเป็นสิ่งที่ไม่ดี
ราคาต่อรองเป็นโปรแกรมเพียงแค่ไป ยกเลิกทั้งหมดที่บรรทัดที่
แต่ถ้าคุณจะเอาชน แถวและแทนที่ด้วยสองคนสุดท้าย
สายมีคุณกำหนด -
โดยใช้ตัวชี้ที่ได้รับมอบหมาย - y ให้ชี้ไปที่ x เป็นจุดที
แล้ว dereference คุณ y วิธีการที่ปลอดภัยมาก
>> ดังนั้นนี้ไม่ที่ปล่อยให้เรา?
ดีปรากฎว่าอยู่ภายใต้ฝากระโปรง ในห้องสมุด CS50 ตัวชี้เป็น
ใช้ตลอด
และเราจริงจะเริ่มต้นในการปอกเปลือก กลับชั้นก่อนที่จะมานานแล้วว่า
แต่ปรากฎเกินไปนิพจน์ที่ บางส่วนของคุณอาจจะคุ้นเคยกับ
โดยเฉพาะผู้ที่สะดวกสบายมากขึ้น เป็นจริงที่เป็นที่นิยมมาก
เว็บไซต์หรือกองล้น, วันนี้
>> แต่เรื่องนี้จริงมีมาก ความหมายทางเทคนิค
ตอนนี้เรารู้ว่าสิ่งที่สแต็คเป็น
มันเหมือนสแต็คของถาด ภายในห้องโถง
>> หรือด้านในของเครื่องคอมพิวเตอร์ของคุณ หน่วยความจำของเฟรมเหล่านั้น
ที่ใช้โดยฟังก์ชั่น
ดีก็ปรากฎว่าเนื่องจากการที่ การดำเนินงานที่ง่ายมาก
หน่วยความจำและกรอบบนที่เรียกว่า สแต็คที่คุณจริงสามารถที่จะควบคุม
ของระบบคอมพิวเตอร์ได้ค่อนข้างง่าย
คุณสามารถตัดเข้าสู่ระบบถ้าคน เหมือนเรายังไม่ได้เขียนรหัสของเรา
โดยเฉพาะอย่างยิ่ง
>> ถ้าคนชอบเราใช้ชิ้น ของอาร์เรย์หน่วยความจำหรือการใช้งาน -
มากยิ่งขึ้นโดยทั่วไป -
แต่บางครั้งลืมที่จะตรวจสอบ ขอบเขตของอาร์เรย์ของเราในขณะที่คุณอาจจะ
ตัวเองมีบางครั้งและซ้ำ วิธีการที่ผ่านมาปลายแถว
ในกรณีที่ดีที่สุดโปรแกรมของคุณ เพียงแค่อาจผิดพลาด
ความผิดส่วนชนิด, อาย
ไม่ดี แต่มันก็ไม่จำเป็นต้อง สิ่งที่ไม่ดีอย่างมหาศาล
>> แต่ถ้าโปรแกรมของคุณเป็นจริงจริง คอมพิวเตอร์ของผู้ใช้ถ้ามันทำงาน
บนเว็บไซต์ที่คนสุ่มที่เกิดขึ้นจริง บนอินเทอร์เน็ตจะตีให้
คนก่อให้เกิดสิ่งที่ไม่ดีเกี่ยวกับรหัสของคุณ โดยทั่วไปไม่ได้เป็นสิ่งที่ดีเพราะ
มันหมายถึงโอกาสที่จะ การควบคุมของเครื่องคอมพิวเตอร์
และสิ่งนี้จะไปดู เล็ก ๆ น้อย ๆ เป็นความลับ
แต่ฉันคิดว่าฉันทำให้คุณกลัวด้วย ตัวอย่างสุดท้ายนี้ที่นี่
>> นี่คือตัวอย่างของรหัสของ
และมีดีวิกิพีเดีย บทความที่เดินผ่าน
นี้ในรายละเอียดมากขึ้น
ผมมีหลักในการโทรด้านล่าง foo ผ่านใน argv จาก 1
และนี่เป็นเพียงเพื่อให้คุณสามารถ รันโปรแกรมและผ่าน
การป้อนข้อมูลโดยพลการ
>> แล้ว foo มีการประกาศขึ้นด้านบน เป็นที่ยอมรับสตริงหรือมากกว่า
แม่นยำ char *
จากนั้นจะประกาศอาร์เรย์ของตัวอักษร
เรียกว่าบัฟเฟอร์มากกว่าโดยทั่วไป จากขนาด 12
ดังนั้น 12 ตัวอักษรสามารถพอดีภายใน ของอาร์เรย์เรียกว่า C ที่
>> และจากนั้นจะใช้ฟังก์ชันนี้ใหม่ ซึ่งเป็นของใหม่ แต่ไม่ยากที่จะ
เข้าใจสำเนาหน่วยความจำ
เป็นชุดหน่วยความจำจากแถบซึ่งเป็น n ที่ผ่านมาตัวแปรอะไรก็ตาม
ผู้ใช้พิมพ์ลงใน argv 1 เป็น C
กี่ไบต์?
ความยาวสตริงของแถบ
>> ดังนั้นในคำอื่น ๆ ถ้าผู้ใช้ใน H-e-l-L-O ใส่, ความยาวสตริง
ของสวัสดีคือห้า
ดังนั้นห้าของไบต์ที่เป็นไปได้ คัดลอกลงในอาร์เรย์เรียกว่า C ซึ่ง
เป็นขนาด 12
แต่สิ่งที่ผู้ใช้ชนิดในอีกไม่นาน คำที่ 13 อักขระหรือ 14
อักขระหรือ 100 ตัวอักษรหรือมากกว่า?
>> พวกเขาจะไปที่ไหน?
ดีกรอบที่ถาดว่า ในกอง Dining Hall,
พวกเขากำลังจะไปที่นั่น
และเป็นเพียงจะเริ่มต้นการเขียนทับ สิ่งอื่น ๆ ที่มีอยู่แล้ว
บนสแต็คที่ล้น สแต็คเพื่อที่จะพูด
>> ดังนั้น pictorially คิดว่าวิธีนี้
นี่เป็นเพียงรุ่นที่มีสีสันของ ภาพที่เราได้วาดภาพ
ที่ด้านล่างสมมติว่าเป็นหลัก
และด้านบนสิ่งที่คุณเห็นในขณะนี้ เป็นกรอบสีที่เขียนตอนนี้สำหรับ
ฟังก์ชันที่เรียกว่า foo
แต่สิ่งที่น่าสนใจเกี่ยวกับที่นี่ foo คือว่าที่นี่เป็นกรอบ
จึงดึงออกมาเช่นเดียวกับผม แต่ไม่ได้อยู่ในแสงไฟสีฟ้า
และตอนนี้เป็นที่ที่ ควงเล็บ 0 ไป
และนี่คือที่ c วงเล็บ 11 จะจบลง
>> ในคำอื่น ๆ มันเกิดขึ้นกับ จะแสดงเป็นตาราง
แต่ถ้าคุณเพียงแค่ให้ plopping ไบต์ ลง - หรือตัวอักษร - พวกเขากำลังจะสิ้นสุด
ขึ้นที่สถานที่ตั้ง 0 ตลอดทางขึ้น ถึง 11 เพราะมันเป็น 0 การจัดทำดัชนี
>> แต่ที่ตัวละครที่ 13 คือ จะจบลง?
ที่ 14 หรือไม่
ในกรณีที่ตัวละคร 50 คน จะจบลง?
>> มันจะให้ไปลง
เพราะแม้ว่าเราจะวาด รูปภาพที่มีสแต็คเติบโตขึ้น
ที่อยู่ก็จะเปิดออกไปจาก ที่อยู่เล็ก ๆ
ชี้ไปยังที่อยู่ขนาดใหญ่
ดังนั้นมันก็ช่วยให้ขึ้นไปและขึ้น
>> ดังนั้นหากผู้ใช้ประเภทใน สวัสดีที่ดี
ข้อผิดพลาดไม่มีไม่มีปัญหาทุกคนปลอดภัย
แต่ถ้าผู้ใช้ในสิ่งที่เราจะ เรียกรหัสขัดแย้งแทน
โดยทั่วไปในขณะที่การโจมตีการโจมตี, โจมตีการโจมตีสิ่งที่สามารถเกิดขึ้นได้อย่างไร
>> ดีถ้าทั้งหมดของท่านที่ผู้ใช้ พิมพ์ในไม่ได้เป็นเพียงบางส่วนที่เป็นมิตร
หรือสตริงที่น่ารังเกียจของตัวอักษร
เป็นจริงลำดับของตัวอักษร ว่าถ้าคุณเรียบเรียง,
มันเป็นจริงรหัส
อาจจะเป็นรหัสที่ลบทั้งหมด ไฟล์บนฮาร์ดไดรฟ์ของคุณหรือส่งสแปม
หรือสิ่งที่ต้องการที่
ขอให้สังเกตว่าสิ่งที่สำคัญที่นี่คือ ถ้าคนเลวโชคดีพอที่จะ
เขียนทับก้อนสีแดงของหน่วยความจำ -
ซึ่งผมไม่ได้วาดภาพของฉัน แต่ นี้ภาพที่วิกิพีเดียที่นี่มี -
ที่อยู่ผู้ส่งของที่เรียกว่า
>> เมื่อผลตอบแทนอาหารเมื่อผลตอบแทนที่ได้แลกเปลี่ยน คอมพิวเตอร์ไม่ทราบว่าจะไปจากวิธี
ขึ้นที่นี่เพื่อลงที่นี่?
หรือในส่วนของเทคโนโลยีขึ้นข้างต้นว่า ก็รู้ว่าจะไปจากการแลกเปลี่ยน
รหัส - 0 และ 1 ที่ประกอบด้วยการแลกเปลี่ยน -
กลับไปที่หน้าหลัก?
มีที่อยู่ผู้ส่งที่เรียกว่าคน เก็บไว้ในกองกรอบที่เดียวกันบน
ถาดโรงอาหารเดียวกัน
>> ดังนั้นถ้าคนเลวเป็นคนฉลาดพอที่จะ ใส่รหัสโจมตี, รหัสโจมตีการโจมตี,
รหัสและได้รับโชคดีพอ -
มักจะผ่านการทดลองและข้อผิดพลาด - เพื่อ เขียนทับที่อยู่ผู้ส่งที่สีแดง,
มีที่อยู่และแจ้งให้ทราบล่วงหน้า ด้านบนมาก
สังเกต 0835C080
มันเขียนย้อนกลับขึ้นด้านบนสำหรับ เหตุผลที่เราอาจจะทบทวน
นี้เป็นตัวเลขที่
>> ดังนั้นถ้าคนเลวได้รับโชคดีพอหรือ ฉลาดพอที่จะเขียนทับสีแดง
เปลื้องผ้าของหน่วยความจำที่มีอยู่ของ รหัสที่เขาหรือเธอมีอย่างใด
ฉีดเข้าไปในเครื่องคอมพิวเตอร์ของคุณซึ่งเดา รหัสจะถูกส่งกลับไปยัง
เร็วที่สุดเท่าที่จะทำ foo ทํางาน
>> รหัสของคนเลว
ดังนั้นรหัสการโจมตีนี้ AAA อีกครั้งอาจจะ ส่งสแปมอาจลบไฟล์ทั้งหมด
ในฮาร์ดดิสก์ของคุณ
แต่นั่นคือสิ่งที่แท้จริงแตกล้น เป็นหรือลักษณะ buffer overrun หรือ
การโจมตีหน่วยความจำล้น
>> และมันก็เป็นอย่างไม่น่าเชื่อเหมือนกันอย่างไม่น่าเชื่อ จนถึงวันที่มีโปรแกรมที่เขียนในนี้
C, C + + และแม้กระทั่งบางภาษาอื่น ๆ
ในบันทึกที่น่ากลัวว่าเราจะ จบลงด้วยเรื่องตลก
>> [เสียงหัวเราะ]
>> ดูคุณในวันพุธที่
ที่ต่อไป CS50 -
ดังนั้นฉันออกจากโคมไฟดิสก์ทั้งหมดในวันนี้ แต่ รอไขมันฟรีนมครึ่งโทรศัพท์
หนังสือน้ำส้ม ที่ฉันดื่มวันนี้
สาย USB, ประแจ
>> [เล่นเพลง]