>> [เล่นเพลง]
>> เดวิดเจลัน: ทั้งหมดขวา
>> [เสียงหัวเราะ]
>> ยินดีต้อนรับกลับ
นี่คือ CS50
และในตอนท้ายของสัปดาห์ที่ห้า
และจนถึงขณะนี้เราได้สวยมาก รับการได้รับว่ามี
คอมไพเลอร์ที่มีอยู่นี้เสียงดังกราวว่าคุณได้ ถูกอัญเชิญโดยวิธีการนี​​้
เครื่องมืออื่น ๆ ที่เรียกว่าทำอย่างใด อย่างน่าอัศจรรย์แปลงรหัสต้นฉบับของคุณ
เป็นรหัสวัตถุศูนย์และคนที่ ว่าซีพียูของเครื่องคอมพิวเตอร์กลาง
หน่วยประมวลผลจริงเข้าใจ
แต่ปรากฎว่ามีจำนวนที่ ที่เกิดขึ้นภายใต้ประทุนใน
ระหว่าง input และ output
>> และฉันต้องการที่จะเสนอว่าเนื้อเรา ออกไปในรายละเอียดเล็ก ๆ น้อย ๆ ลงไปว่า
สี่ขั้นตอนเหล่านี้มีสิ่งที่เรียกว่า ก่อนการประมวลผลบางอย่าง
ที่เรียกว่ารวบรวมซึ่งเราได้เห็น สิ่งที่เรียกว่าการประกอบและ
สิ่งที่เรียกว่าการเชื่อมโยง
ดังนั้นจนถึงขณะนี้ในบางส่วนของเรา โปรแกรมที่เราได้มีความคมชัดรวมถึง
เมื่อเร็ว ๆ นี้เราได้มีบางคม สำหรับกำหนดค่าคงที่
ดังนั้นมันจึงกลับกลายเป็นว่าสิ่งเหล่านั้น จะมีคำนำหน้าด้วยสัญลักษณ์กัญชาหรือ
สัญลักษณ์ปอนด์ pre-การประมวลผล สั่ง
นั่นเป็นเพียงวิธีแฟนซีของบอกว่ามันเป็นอะไร บรรทัดของรหัสที่เป็นจริง
แปลงเป็นอย่างอื่นก่อน คอมพิวเตอร์แม้พยายามแปลงของคุณ
โปรแกรมเป็นศูนย์และคน
>> ยกตัวอย่างเช่นคมมีมาตรฐาน I / O h., สวยมากแค่หมายความว่าไป
ข้างหน้าคว้าเนื้อหาของไฟล์ stdio.h และวางพวกเขามีสิทธิ
ดังนั้นไม่มีเลขศูนย์และคนที่ ที่จุดที่ยัง
มันจริงๆเพียงแค่ทดแทน
และที่ทำในช่วงที่เรียกว่า ขั้นตอนก่อนการประมวลผลเมื่อคุณ
ทำงานจริงหรือเฉพาะเสียงดังกราว ทำให้ในกรณีส่วนใหญ่
ดังนั้นทั้งหมดนี้ได้รับการเกิดขึ้น แรกโดยอัตโนมัติป่านนี้
>> แล้วขั้นตอนการรวบรวมมา
แต่เราได้รับความสมจริงสมจัง การรวบรวม
รวบรวมโปรแกรมจริงๆหมายถึง ใช้เวลาจากบางสิ่งบางอย่างเช่น C,
รหัสแหล่งที่มาของเราได้รับการเขียนลง เพื่อสิ่งที่เรียกว่าการชุมนุม
ภาษาประกอบเป็นระดับที่ต่ำกว่า ภาษานั้นโชคดีที่เราจะไม่ได้
ได้มากโอกาสที่จะ เขียนภาคการศึกษานี้
แต่มันก็อยู่ในระดับที่ต่ำสุดใน ความรู้สึกที่ว่าคุณอย่างแท้จริงเริ่มต้นการเขียน
เพิ่มและลบและคูณและโหลด จากหน่วยความจำและบันทึกไปยังหน่วยความจำ,
คำแนะนำพื้นฐานมากที่เครื่องคอมพิวเตอร์, ภายใต้ประทุน,
จริงเข้าใจ
>> สุดท้ายการประกอบภาษาที่ใช้ ไปที่ศูนย์และคนที่เราเคย
อธิบายป่านนี้
อย่างแท้จริงและสุดท้ายมีสิ่งที่เรียกว่า การเชื่อมโยงขั้นตอนซึ่งเราจะ
เพียงแค่เห็นในขณะที่ผสมผสาน ศูนย์และคนที่มีศูนย์และของคุณ
คนที่คนอื่น ๆ ก่อน คุณได้สร้างขึ้น
>> ดังนั้นพิจารณาโปรแกรมนี้ง่ายสุด
มันมาจาก 1 สัปดาห์
มันก็บอกว่า Hello World, บนหน้าจอ
เราวิ่งผ่านเสียงดังกราว
หรือเราวิ่งมันผ่านให้ ที่วิ่งเสียงดังกราว
และ outputted ในเวลาที่ ศูนย์บางและคนที่
แต่มันจะเปิดออกมี ขั้นตอนกลาง
ถ้าฉันไปกว่าที่นี่ - โอ๊ะไม่ได้ ต้องการที่จะเห็นเขายัง
ถ้าฉันไปกว่าที่นี่เพื่อเครื่องใช้ของฉัน และฉันเปิด hello.c นี่
ว่าโปรแกรมเดียวกัน
และสิ่งที่ฉันจะทำในขั้วของฉัน ผมเป็นหน้าต่างที่นี่กำลังจะไป
ทำงานเสียงดังกราวแทนที่จะให้ซึ่ง โดยอัตโนมัติทั้งสี่ของ
ขั้นตอนเหล่านั้นสำหรับเรา
และฉันจะทำเสียงดังกราวและ S- แล้ว hello.c จากนั้นใส่
>> และฉันได้รับแจ้งให้กระพริบ อีกครั้งซึ่งเป็นสิ่งที่ดี
และตอนนี้ในหน้าต่างใหญ่กว่าเล็กน้อย, ฉันจะเปิดขึ้น Gedit ที่นี่
และฉันจะเปิดแฟ้มที่, จะเปิดออกจะเรียกว่า hello.s นี้
มีการใช้ภาษาการชุมนุมที่ ผมหมายถึงก่อนหน้านี้
และนี่คือสิ่งที่เรียกว่าการชุมนุม ภาษาในระดับที่ค่อนข้างต่ำ
คำสั่งที่ใช้ซีพียู intel ของคุณ หรือสิ่งที่เป็นที่อยู่ภายใน
เข้าใจ
และ mov เป็นสำหรับการย้าย โทรสำหรับ โทรฟังก์ชั่นในระดับที่ต่ำมาก
ย่อยเป็นลบ
>> ดังนั้นเมื่อคุณมีเฉพาะ CPU ภายใน ของคอมพิวเตอร์ของคุณสิ่งที่ทำให้
ซีพียูที่แตกต่างกันเมื่อเทียบกับคนอื่น ๆ ตลาดเป็นคำแนะนำที่มัน
และมักจะเข้าใจว่ามันมีประสิทธิภาพ เป็นวิธีที่รวดเร็วเป็นที่ดำเนินการบางอย่าง
ของคำสั่งเหล่านั้น
ตอนนี้สำหรับข้อมูลเพิ่มเติมเกี่ยวกับเรื่องนี้คุณสามารถใช้ CS61 ฤดูใบไม้ร่วงต่อไปที่วิทยาลัย
แต่ที่นี่เรามีตัวอย่างเช่นไม่กี่ ระบุว่าอาจมีลักษณะที่คุ้นเคย
hello.c เป็นชื่อของโปรแกรม
>> ข้อความ. -
มีไม่มากที่น่าสนใจมี เพียงแค่ตอนนี้จำได้ว่าข้อความที่
ส่วนขณะที่วันจันทร์เป็นที่ที่ใน หน่วยความจำโปรแกรมของคุณจริงจบลง
เพื่อที่ว่าอย่างน้อยคลุมเครือ คุ้นเคยมี
ที่นี่แน่นอนที่กล่าวถึงคือ ของฟังก์ชั่นหลักของเรา
เลื่อนลงเหล่านี้หมายถึงสิ่งที่ ลงทะเบียนที่เรียกว่าชิ้นเล็กมาก
หน่วยความจำภายในของ CPU ที่แท้จริงของคุณ
และถ้าฉันเลื่อนลงมาแม้ ต่อไปผมเห็นอะไรบางอย่าง
กล่าวถึงทางอ้อมของ ASCII
และมีจริงสตริงนั่นคือ สวัสดีจุลภาคโลก
>> ดังนั้นเรื่องยาวสั้นนี้ได้รับ สิ่งที่เกิดขึ้นสำหรับคุณโดยอัตโนมัติ
ภายใต้ฝากระโปรงทั้งหมดในเวลานี้
และสิ่งที่เกิดขึ้นจริงๆเป็นครั้งเดียว คุณเคยทำงานเสียงดังกราวหรือโดยวิธีการ
ทำให้คุณได้รับเป็นครั้งแรก, จากรหัสที่มา,
จึงเรียกว่าภาษาประกอบ
แล้วเสียงดังกราวแปลงการชุมนุมนี้ ภาษาลงไปที่ศูนย์และคน
และนี้เป็นภาพนิ่งที่เราเริ่มต้น การสนทนาของเราในสัปดาห์ที่ 0 -
และจากนั้น 1 สัปดาห์เมื่อ
และแล้วในที่สุด, ศูนย์เหล่านั้นและคนที่ จะรวมกันด้วยศูนย์และคนที่
จากห้องสมุดที่เราได้รับการ ได้รับมาตรฐานเช่น I / O หรือ
ห้องสมุดสตริงหรือแม้กระทั่ง CS50 ห้องสมุด
>> ดังนั้นในการวาดภาพนี้ขึ้น สายตาเรามี hello.c
และมันแน่นอนใช้ printf ทำงานที่จะพูดว่า Hello World
ขั้นตอนการรวบรวมจะใช้เวลามันลงไป ว่าไฟล์ที่เราเพิ่งเห็น hello.s แม้
แต่ที่มักจะถูกลบ สำหรับคุณโดยอัตโนมัติ
แต่ที่รหัสการชุมนุม ในขั้นตอนกลาง
และจากนั้นเมื่อเราประกอบการชุมนุม ภาษาเพื่อที่จะพูดว่าเมื่อคุณ
ได้รับค่าศูนย์เหล่านั้นและคนที่
ดังนั้นเราจึงซูมได้อย่างมีประสิทธิภาพในวันนี้ สิ่งที่เราได้รับการให้ได้รับ,
หมายถึงรหัสที่มาที่ไป รหัสที่จะคัดค้าน
>> แต่สุดท้ายตอนนี้ว่าภาพเดียวกัน - ให้ผลักมันไป
ทางด้านซ้ายมือ
และทราบว่าในด้านบนมี ที่ผมกล่าวถึง stdio.h
ที่ไฟล์ที่เราได้รวม ในเกือบทั้งหมดของ
โปรแกรมที่เราเขียน
และนั่นก็คือไฟล์ที่มีเนื้อหา ได้รับสำเนาวาง
ได้อย่างมีประสิทธิภาพบนรหัสของคุณ
แต่มันกลับกลายเป็นว่าในคอมพิวเตอร์ ระบบบางแห่งมีการสันนิษฐาน
ไฟล์ stdio.c ว่าคนที่อ้างปี ที่ผ่านมาที่ดำเนินการทั้งหมดของ
ฟังก์ชั่นที่ได้รับการประกาศ ใน stdio.h
>> ตอนนี้ในความเป็นจริงมันอาจจะไม่ได้อยู่ใน Mac หรือเครื่องคอมพิวเตอร์ของคุณหรือแม้กระทั่งใน
CS50 เครื่องใช้คือรหัส C ดิบ
ใครบางคนที่คอมไพล์แล้วมันรวม o. ไฟล์สำหรับรหัสวัตถุหรือ.
ไฟล์ซึ่งหมายถึงห้องสมุดที่ใช้ร่วมกัน ที่ได้รับการติดตั้งและ
ก่อนรวบรวมสำหรับคุณ
แต่คิดว่ามีแน่นอนที่มีอยู่ เมื่อ stdio.c คอมพิวเตอร์ของเราในแบบคู่ขนาน
กับเสียงดังกราว
รหัสของคุณจะถูกรวบรวม และประกอบ
รหัส stdio.c 's จะถูกรวบรวมและ ประกอบเพื่อที่ว่านี้สุดท้าย
ขั้นตอนลงที่นี่เราจะต้องอย่างใด การเชื่อมโยงเพื่อที่จะพูด, ศูนย์และคนของคุณ
ด้วยศูนย์ของเขาหรือเธอและคนที่เป็นหนึ่ง โปรแกรมง่ายๆว่าในท้ายที่สุดคือ
เรียกว่าเพียงแค่สวัสดี
>> ดังนั้นนั่นคือทั้งหมดของมายากลที่ ที่เกิดขึ้นป่านนี้
และจะยังคงที่จะใช้เหล่านี้ กระบวนการให้ได้รับ แต่ตระหนักถึง
มีรายละเอียดจำนวนมากฉ่ำของ ที่เกิดขึ้นภายใต้มี
และนี่คือสิ่งที่ทำให้คุณ เครื่องคอมพิวเตอร์ที่มี Intel Inside
ที่แตกต่างกันโดยเฉพาะอย่างยิ่ง
>> ดังนั้นเมื่อทราบว่าถ้าคุณต้องการที่จะ เข้าร่วมกับเราเพื่อรับประทานอาหารกลางวันศุกร์นี้ทำไป
เพื่อ cs50.net/rsvp สถานที่ปกติ 13:15 ศุกร์นี้
และตอนนี้ประกาศไม่กี่
ดังนั้นเราจึงมีบางข่าวที่ดี
และเรามีบางข่าวที่ไ​​ม่ดี
เริ่มต้นด้วยข่าวที่ดีบางอย่างที่นี่
>> [ส่งเสียงพึมพัม]
>> ทั้งหมดขวา
ดีก็ทางเทคนิควันหยุดดังนั้น มันไม่มากของขวัญจากเรา
แต่แล้วข่าวร้ายแน่นอน
>> [ส่งเสียงพึมพัม]
>> ผมใช้เวลามาก เมื่อภาพเคลื่อนไหวเหล่านี้
>> [เสียงหัวเราะ]
>> จะมีเซสชั่นทาน นี้มาจันทร์
มันจะต้องใช้เวลา 05:30
เราจะเตือนคุณของรายละเอียดทั้งหมดเหล่านี้ ผ่านทางอีเมลของหลักสูตร
เว็บไซต์ในเพียงไม่กี่วันเวลา
มันจะถูกถ่ายทำและทำใช้ได้ หลังจากนั้นไม่นาน
ดังนั้นถ้าคุณไม่สามารถที่จันทร์ สล็อตคืนไม่ต้องกังวล
ส่วนในสัปดาห์นี้มาจะยัง มุ่งเน้นการทบทวนเกี่ยวกับการตอบคำถาม
หากส่วนของคุณเป็นในวันจันทร์ซึ่งเป็น แน่นอนมหาวิทยาลัยวันหยุดเราจะ
ยังคงตอบสนองความต้องการในส่วน
ถ้าคุณก็ไม่สามารถที่ ส่วนเพราะคุณกำลังจะไป
ห่างออกไปที่ดี
เข้าร่วมวันอาทิตย์หรือวันอังคารส่วนหรือ ปรับแต่งในส่วนของ Jason ซึ่งเป็น
พร้อมใช้งานออนไลน์
>> ข่าวดังนั้นที่เลวร้ายมากขึ้น
ดังนั้นตามหลักสูตร, เรามีการบรรยายวันศุกร์ถัดไป
แต่ข่าวดี -
เห็นได้ชัดว่าฉันใช้เวลามากเกินไปเกี่ยวกับเรื่องนี้
>> [เสียงหัวเราะ]
>> เราจะยกเลิกการบรรยายต่อไปวันศุกร์
เพื่อที่จะเป็นของขวัญสำหรับเราเพื่อให้คุณ จริงๆคุณสามารถมีสุขในการพักผ่อน
ระหว่างสัปดาห์นี้และสัปดาห์ที่สองด้วยเหตุนี้
จึงไม่มีการบรรยายสัปดาห์ถัดไปเพียงเล็ก ๆ ตอบคำถามเล็ก ๆ น้อย ๆ ที่คุณควรจะเป็น
ตื่นเต้นมากขึ้น
>> ดังนั้นตอนนี้ขอหันความสนใจของเราที่จะ สิ่งที่เป็นจริงที่มองเห็นได้มากขึ้น
และอื่น ๆ ที่น่าตื่นเต้นและการตั้งเวที สำหรับสิ่งที่เป็นไปได้บนเส้นขอบฟ้า
ในเพียงไม่กี่สัปดาห์ครั้ง
หลังจากการทดสอบครั้งแรกที่เราจะเปิด มุ่งเน้นของชุดปัญหาของเราไปยังอีก
โดเมนปัญหาที่เฉพาะเจาะจงว่า นิติเวชหรือการรักษาความปลอดภัยมากขึ้นโดยทั่วไป
>> ในความเป็นจริงประเพณีกับปัญหานี้ ชุดสำหรับฉันเป็นหนึ่งใน
การเรียนการสอนเพื่อนหรือ CAs เดินข้าม วิทยาเขตถ่ายภาพบางส่วนของ
แต่ไม่สามารถระบุตัวคนที่เห็นได้ชัด สถานที่หรือสิ่งแล้วทุกปีผม
อย่างใดจัดการเพื่อตั้งใจลบ หรือเสียหายบัตรสื่อดิจิตอล
ที่ภายในของกล้องของเรา
แต่ไม่มีเรื่องใหญ่
ผมสามารถไปข้างหน้าและเสียบ ที่ลงในเครื่องคอมพิวเตอร์ของฉัน
ฉันจะทำให้ภาพทางนิติวิทยาศาสตร์ของมันดังนั้น ที่จะพูดโดยการคัดลอกศูนย์และ
คนที่ออกจากการ์ดหน่วยความจำที่ไม่ว่าจะเป็น การ์ด SD หรือการ์ดแฟลชขนาดเล็กหรือ
สิ่งที่คุณคุ้นเคยกับ
แล้วเราสามารถส่งออกว่า
>> และเพื่อความท้าทายข้างหน้าในหมู่อื่น ๆ สิ่งที่คุณจะได้รับการเขียน
รหัส C ที่กู้ทั้งกลุ่ม JPEGs สำหรับผมและเผยให้เห็นจะเป็น
คนเหล่านั้นสถานที่หรือสิ่ง
และเรายังจะพูดคุยในปัญหานี้ ตั้งค่าและในวันที่จะมาเกี่ยวกับ
กราฟิกมากขึ้นโดยทั่วไป
เราได้ใช้พวกเขา, สนาม, สำหรับการแบ่งออก
แต่คุณได้รับการเรียงลำดับของการได้รับ เหล่านี้มีความคิดที่มีอยู่ในระดับสูง
จากรูปสี่เหลี่ยมและวงรี
แต่อยู่ภายใต้ฝากระโปรง มีพิกเซล
และคุณได้มีการเริ่มต้น คิดเกี่ยวกับการเหล่านั้น
หรือคุณจะ p สำหรับชุด-4 ต้องคิด เกี่ยวกับช่องว่างระหว่างก้อนอิฐของคุณอย่างไร
ได้อย่างรวดเร็วลูกกำลังคุณจะย้ายข้าม หน้าจอเพื่อให้แตกออก
จึงมีแนวความคิดนี้ก็คือ จุดบนหน้าจอของคุณที่
เข้ามาเล่นแล้ว
>> ตอนนี้สิ่งที่คุณเห็นว่าเป็นสิ่งที่ คุณจะได้รับบนหน้าจอคอมพิวเตอร์
ถ้าคุณเคยดูบางส่วนที่ดีหรือ ทีวีที่ไม่ดีต่อรองที่พวกเขาสวยมาก
การรักษาผู้ชมเช่น technophobes ที่ทำไม่ได้จริงๆ
รู้มากเกี่ยวกับการคำนวณ
และดังนั้นมันจึงง่ายมากสำหรับตำรวจ นักสืบที่จะบอกว่าคุณสามารถ
ทำความสะอาดสำหรับฉันว่า?
หรือเพิ่มใช่มั้ย?
เพิ่มเป็นเหมือนคำฉวัดเฉวียนใน มาก ๆ สำหรับความผิดทางอาญาที่เกี่ยวข้องกับการแสดง
และในความเป็นจริงถ้าคุณใช้เวลามาก ภาพที่พร่ามัวของผู้ต้องสงสัยทำ
สิ่งที่ไม่ดีคุณจะไม่สามารถ เพียงแค่เพิ่มมัน
คุณไม่สามารถซูมเข้าเพียบ
คุณไม่สามารถมองเห็นในแววของใครบางคน ตาที่มุ่งมั่นว่า
อาชญากรรมโดยเฉพาะอย่างยิ่งแม้จะมี ความชุกของการนี​​้บนหน้าจอโทรทัศน์
>> และเพื่อให้มีที่ให้แรงจูงใจที่ ปัญหาที่จะเกิดขึ้นกับการตั้งค่าการมองแ​​วบเดียวที่
แสดงให้เห็นว่าบางอย่างที่คุณ อาจไม่คุ้นเคย
>> [เล่นภาพวิดีโอ]
>> OK-
ตอนนี้ขอดูดีที่คุณ
>> -ถือมัน
เรียกกลับว่า
>> -รอสักครู่
ไปทางขวา
>> -มี
แช่แข็งที่
>> เต็มหน้าจอ
>> OK-
แช่แข็งที่
>> -กระชับขึ้นครับว่าจะ?
>> เวกเตอร์ในเมื่อผู้ชายคนนั้น โดยล้อหลัง
>> การซูมที่นี่ในจุดนี้
>> ด้วยอุปกรณ์ที่เหมาะสม, การถ่ายภาพ สามารถขยายและรุนแรงขึ้น
>> มีอะไรที่?
>> -มันเป็นโปรแกรมเสริม
>> สามารถที่คุณชัดเจนว่าใด ๆ ?
>> ผมไม่ทราบ
ขอเพิ่มมัน
>> -Enhance ส่วน-6
>> -I ปรับปรุงรายละเอียดและ -
>> ผมคิดว่ามีมากพอที่จะเพิ่ม
ปล่อยมันไปที่หน้าจอของฉัน
>> -Enhance สะท้อนอยู่ในสายตาของเธอ
>> -Let 's ทำงานนี้ผ่าน การเพิ่มประสิทธิภาพวิดีโอ
>> -เอ็ดการ์ที่คุณสามารถเพิ่มนี้
>> -แขวน
>> -I've ได้ทำงานในนี้สะท้อน
>> สะท้อนให้เห็นถึงใครบางคนในระยะเวลา
>> การสะท้อนแสง
>> -มีการสะท้อนของ ของใบหน้าของชายคนนั้น
>> -สะท้อน
>> -มีการสะท้อนของ
>> การซูมบนกระจก
>> คุณสามารถเห็นภาพสะท้อนของ
>> -คุณสามารถเพิ่มภาพจากที่นี่?
>> -คุณสามารถเพิ่มเขาที่นี่?
>> -คุณสามารถเพิ่มหรือไม่
>> เราสามารถเพิ่มนี้
>> -คุณสามารถเพิ่มหรือไม่
>> -Hold on ที่สองฉันจะเพิ่ม
>> การซูมเข้าประตู
>> -x10
>> Zoom-
>> [เสียงหัวเราะ]
>> การขนย้ายค่ะ
>> รอหยุด
>> -Stop
>> -Pause มัน
>> หมุน 75 องศารอบ แนวตั้งโปรด
>> [เสียงหัวเราะ]
>> -Stop และกลับไปส่วนหนึ่ง เกี่ยวกับประตูอีกครั้ง
>> -Got ภาพเพิ่ม ที่สามารถบิตแมป?
>> -บางทีเราสามารถใช้ Pradeep Sen วิธีการที่จะมองเข้าไปในหน้าต่าง
>> นี้ซอฟแวร์เป็นรัฐของศิลปะ
>> -มูลค่าไอคอนปิด
>> ด้วยการรวมกันทางด้านขวา อัลกอริทึม
>> -เขาเอาขั้นตอนวิธีการส่องสว่างไป ระดับถัดไปและฉันสามารถใช้พวกเขาเพื่อ
เพิ่มรูปนี้
>> ล็อคและขยายแกน z-
>> -Enhance
>> -ตรึงและเพิ่ม
>> [เล่นวิดีโอจบ]
>> เดวิดเจลัน: Set ปัญหาดังนั้น 5 คือสิ่งที่อยู่ข้างหน้ามี
ดังนั้นเราเร็ว ๆ นี้จะได้รับความเข้าใจที่ดีขึ้น เมื่อและเหตุผลที่คุณสามารถ
และไม่สามารถเพิ่มของเราในทางที่
แต่ก่อนอื่นขอกลับมาความสนใจของเรา กับบางส่วนของการสร้างบล็อคเราจะ
ต้องสามารถที่จะบอกเล่าเรื่องราวว่า
>> ดังนั้นจำได้ว่าเราดึงภาพบนนี้ วันจันทร์และนิด ๆ หน่อย ๆ สัปดาห์ที่ผ่านมา
และนี้อธิบายถึงรูปแบบของสิ่งที่ ในหน่วยความจำของคอมพิวเตอร์ของคุณเมื่อ
การเรียกใช้โปรแกรมบางอย่าง
ส่วนเทคโนโลยีขึ้นด้านบนเรียกคืนหมาย ไปยังศูนย์ที่เกิดขึ้นจริงและคนที่
ที่ประกอบด้วยโปรแกรมของคุณ
มีด้านล่างที่บางส่วนเริ่มต้นหรือ ข้อมูล uninitialized ซึ่งโดยทั่วไปแล้ว
หมายถึงสิ่งที่ต้องการค่าคงที่หรือ สตริงหรือตัวแปรทั่วโลกที่มี
รับการประกาศล่วงหน้า
มีกอง แต่เราจะมา กลับไปว่าในบิต
>> แล้วมีสแต็คของ
เหมือนสแต็คของในถาด โรงอาหารนี้เป็นที่หน่วยความจำที่ได้รับ
ชั้นและชั้นเมื่อใดก็ตามที่ คุณทำในสิ่งที่ในโปรแกรม?
การใช้สแตกคืออะไร?
>> อ้าง?
>> Call of ฟังก์ชั่น
ทุกครั้งที่คุณเรียกใช้ฟังก์ชันใด ๆ ก็ ให้กับเศษไม้จากหน่วยความจำสำหรับการ
ตัวแปรท้องถิ่นหรือพารามิเตอร์
และ pictorially เราจะเห็นว่าในแต่ละ ฟังก์ชั่นต่อเนื่องที่เรียกว่าเมื่อ
โทรสาย B สาย C D พวกเขา รับชั้นบนสแต็ค
และในแต่ละชิ้นนั้น หน่วยความจำเป็นหลักขอบเขตที่ไม่ซ้ำกัน
สำหรับฟังก์ชั่นนั้นซึ่งแน่นอน เป็นปัญหาถ้าคุณต้องการมือ
จากฟังก์ชั่นหนึ่งไปยังอีกชิ้น จากข้อมูลที่คุณต้องการมัน
กลายพันธุ์หรือเปลี่ยนแปลง
>> ดังนั้นสิ่งที่แก้ปัญหาของเราที่จะทำให้เป็น ฟังก์ชั่นหนึ่งที่แสดงโดยสแต็ค
กรอบที่จะเปลี่ยนหน่วยความจำภายใน ของกองกรอบอื่นได้หรือไม่
วิธีการทำทั้งสองพูดคุยกับคนอื่น?
ดังนั้นโดยวิธีการของตัวชี้หรือที่อยู่ ซึ่งอีกเพียงอธิบายที่อยู่ใน
หน่วยความจำโดยวิธีเฉพาะเจาะจงของ จำนวนกัดโดยเฉพาะอย่างยิ่ง
ค่าที่สามารถพบได้
ดังนั้นจำครั้งสุดท้ายที่เรายังคงเกินไป เรื่องราวและมองไปที่
โปรแกรมรถอย่างเป็นธรรม
และโปรแกรมนี้เป็นรถสำหรับไม่กี่ เหตุผลหนึ่ง แต่ที่น่าเป็นห่วงมากที่สุดคือ
เพราะมันล้มเหลวในการตรวจสอบสิ่งที่?
>> ใช่มันล้มเหลวในการตรวจสอบการป้อนข้อมูล
ขออภัย?
>> ถ้ามันมากกว่า 12 ตัวอักษร
ดังนั้นมากอย่างชาญฉลาด, เมื่อโทร memcopy, ซึ่งเป็นชื่อแนะนำเพียง
สำเนาหน่วยความจำจากอาร์กิวเมนต์ที่สองของ เป็นอาร์กิวเมนต์แรกของ
argument ตัวที่สามมากอย่างชาญฉลาดคือ การตรวจสอบเพื่อให้แน่ใจว่าคุณทำไม่ได้
คัดลอกมากขึ้นกว่าในกรณีนี้ความยาว ของแถบ, จำนวนตัวอักษร,
เป็นปลายทางซึ่งเป็นนี้ อาร์เรย์ C. แต่ปัญหาคือว่าสิ่งที่
c ถ้าตัวเองไม่ได้มีขนาดใหญ่พอ การจัดการที่?
คุณจะคัดลอกจำนวน ไบต์ที่คุณได้รับ
แต่สิ่งที่คุณจะมีมากขึ้น ไบต์กว่าที่คุณมีห้องพักสำหรับ?
>> ดีโปรแกรมนี้เพียงอย่างโง่เขลามาก สุ่มสี่สุ่มห้าดำเนินการที่จะใช้สิ่งที่มันเป็น
ให้สวัสดีเครื่องหมายเป็น 0 ดีถ้าสายสั้น
พอเช่นห้าตัวอักษร
แต่ถ้ามันเป็นจริง 12 ตัวอักษรหรือ 1,200 ตัวอักษรที่เราเห็นครั้งสุดท้าย
ที่คุณเพิ่งจะไปอย่างสมบูรณ์ หน่วยความจำที่เขียนทับ
ไม่ได้เป็นของคุณ
และกรณีที่เลวร้ายที่สุดถ้าคุณเขียนทับว่า ส่วนสีแดงมีที่เราเรียกว่า
กลับที่อยู่ -
นี้เป็นเพียงที่ใช้คอมพิวเตอร์ โดยอัตโนมัติสำหรับคุณอยู่เบื้องหลัง
ฉาก Tucks ห่างมูลค่า 32 บิตที่ จะแจ้งเตือนไปยังสิ่งที่อยู่ที่ควร
กลับมาเมื่อ foo นี้ฟังก์ชั่นอื่น ๆ จะทำดำเนินการ
มันเป็นเศษขนมปังของแปลก เพื่อที่จะส่งกลับ
ถ้าคุณเขียนทับที่อาจเกิดขึ้น, ถ้าคุณเป็นคนเลวสามารถทำได้
อาจใช้เวลามากกว่า คอมพิวเตอร์ของใครบางคน
และคุณจะได้มากที่สุดอย่างแน่นอน ผิดพลาดในกรณีส่วนใหญ่
>> ตอนนี้ปัญหานี้เลวร้ายเพียง ในขณะที่เราเริ่มพูดคุยเกี่ยวกับหน่วยความจำ
การจัดการมากขึ้นโดยทั่วไป
และ malloc สำหรับจัดสรรหน่วยความจำคือ ฟังก์ชั่นที่เราสามารถใช้ในการจัดสรร
หน่วยความจำเมื่อเราไม่ทราบล่วงหน้า ที่เราอาจจะต้องมีการ
ดังนั้นสำหรับตัวอย่างเช่นถ้าผมกลับไป ไปยังเครื่องใช้ที่นี่
และผมก็เปิดขึ้นมาจาก hello2.c ครั้งสุดท้าย เรียกโปรแกรมนี้ที่นี่ซึ่งมอง
บางสิ่งบางอย่างเล็ก ๆ น้อย ๆ เช่นนี้ เพียงแค่สามบรรทัด -
ระบุชื่อชื่อสตริงแล้วของคุณ ด้านซ้ายเท่ากับ GetString
และจากนั้นเราก็พิมพ์ออกมา, ชื่อของผู้ใช้
>> ดังนั้นนี้เป็นโปรแกรมที่ง่ายสุด
ต้องมีความชัดเจนให้ฉันไปข้างหน้า และทำให้สวัสดี-2
ฉันจะทำจุดเฉือนสวัสดี-2
ระบุชื่อของคุณ -
เดวิด
เข้าไป
สวัสดีเดวิด
ดูเหมือนว่าการทำงานตกลง
แต่สิ่งที่จริงที่เกิดขึ้น ภายใต้ประทุนที่นี่?
เปลือกแรกให้กลับชั้นบาง
สตริงเป็นเพียงคำพ้องเราได้ ตระหนักในสิ่งที่?
ดาว Char
ดังนั้นขอให้มันเป็นความลับเล็ก ๆ น้อย ๆ แต่เทคนิคที่ถูกต้องว่านี้
เป็นดาวที่ถ่านซึ่งหมายความว่า ชื่อใช่เป็นตัวแปร
แต่สิ่งที่ร้านค้าชื่อที่อยู่ของ ถ่านซึ่งให้ความรู้สึกเล็ก ๆ น้อย ๆ ที่แปลกประหลาด
เพราะฉันได้รับกลับสตริง
ฉันได้รับกลับหลาย ตัวอักษรไม่ได้ถ่าน
>> แต่แน่นอนคุณจะต้องแรก ที่อยู่ถ่านที่จะจำที่
สตริงทั้งเป็นเพราะเหตุใด?
คุณจะทำอย่างไรคิดออกว่าจุดสิ้นสุดของ สตริงคือการรู้จุดเริ่มต้น?
ศูนย์เครื่องหมายทับขวา
ดังนั้นด้วยทั้งสองเบาะแสให้คุณคิดออก ก่อนที่จะเริ่มต้นและสิ้นสุดของ
สตริงใด ๆ ตราบใดที่พวกเขากำลัง ที่เกิดขึ้นอย่างถูกต้องกับโมฆะว่า
เทอร์มิศูนย์เครื่องหมายทับขวาที่
>> แต่นี้จะเรียก GetString
และมันจะเปิดออก GetString ว่า ตลอดเวลานี้ได้รับชนิดของ
โกงสำหรับเรา
มันถูกทำแรงงานนี้เพื่อให้แน่ใจว่า รับสายจากผู้ใช้
แต่ที่หน่วยความจำที่ รับมาจาก?
ถ้าเราไปกลับไปยังภาพที่นี่และ ใช้คำนิยามจากเพียง
ช่วงเวลาที่ผ่านมาว่าสแต็คเป็นที่ที่ หน่วยความจำไปเมื่อฟังก์ชั่นที่เรียกว่า,
โดยเหตุผลที่ว่าเมื่อคุณโทร GetString, แล้วฉันพิมพ์ใน
D--V-I-D ใส่ที่เป็น D--V-I-D เครื่องหมายทับขวาเป็นศูนย์จัดเก็บอยู่บนพื้นฐานของ
เรื่องราวที่เราได้บอกกับเราว่าไกล?
>> มันจะดูเหมือนจะอยู่ใน สแต็คขวา?
เมื่อคุณโทรรับสายคุณจะได้รับ ชิ้นเล็ก ๆ น้อย ๆ ของหน่วยความจำใน stack
ดังนั้นมันยืนเพื่อเหตุผลที่ D--V-I-D เครื่องหมายทับขวาเป็นศูนย์จะถูกเก็บไว้
มีในสแต็ค
แต่รอสักครู่, getString ผลตอบแทน สตริงที่เพื่อที่จะพูดซึ่งหมายความว่า
มันถาดจากโรงอาหาร ถูกนำตัวออกจากสแต็ค
และเรากล่าวว่าครั้งสุดท้ายที่เร็วที่สุดเท่าที่ กลับมาทำงานและคุณใช้เวลาที่
ถาดเพื่อที่จะพูดออกสแต็คสิ่งที่ คุณสามารถคิดเกี่ยวกับเศษของ
หน่วยความจำที่?
จัดเรียงของฉันวาดรูปพวกเขาเป็นเครื่องหมายคำถาม เพราะพวกเขาได้อย่างมีประสิทธิภาพกลายเป็น
ค่าที่ไม่รู้จัก
พวกเขาสามารถนำมาใช้ใหม่เมื่อบาง ฟังก์ชั่นต่อไปจะเรียกว่า
>> ในคำอื่น ๆ ถ้าเราเกิดขึ้น ที่จะจัดเก็บ -
ผมจะวาดภาพที่รวดเร็ว ที่นี่ของสแต็ค
ถ้าเราเกิดขึ้นที่จะวาดภาพด้านล่าง ของส่วนของหน่วยความจำของฉันและเราจะพูด
ที่นี้เป็นสถานที่ของหน่วยความจำ ครอบครองโดยหลักและอาจจะหาเรื่องคและ
หาเรื่องวีและสิ่งอื่น ๆ ในโปรแกรม, เมื่อ GetString เรียกว่า
สันนิษฐานว่าได้รับ GetString ก้อนของหน่วยความจำที่นี่
แล้ว D--V-I-D อย่างใด จะจบลงในฟังก์ชั่นนี้
และฉันจะ oversimplify
แต่สมมติว่าของ D--V-I-D ศูนย์เครื่องหมายทับขวา
ดังนั้นนี่ไบต์จำนวนมากถูกใช้ใน กรอบสำหรับ GetString
>> แต่ทันทีที่ผลตอบแทน GetString เรา ครั้งสุดท้ายที่กล่าวว่าหน่วยความจำนี้
ที่นี่จะกลายเป็นทั้งหมด - ห่วง -
ทั้งหมดจะกลายเป็นลบได้อย่างมีประสิทธิภาพ
และเราสามารถคิดในตอนนี้เป็นคำถาม เครื่องหมายเพราะใครจะไปรู้
สิ่งที่จะกลายเป็นหน่วยความจำที่
แท้จริงฉันมากมักจะเรียกใช้ฟังก์ชัน นอกเหนือจาก getString
และทันทีที่ผมเรียกอื่น ๆ บาง ฟังก์ชั่นกว่า GetString อาจจะไม่ได้อยู่ใน
นี้โปรแกรมเฉพาะเราเพียงแค่มอง แต่บางที่อื่น ๆ แน่นอนอื่น ๆ บาง
ฟังก์ชั่นอาจท้ายที่จะได้รับ จุดนี้ต่อไปในสแต็ค
>> ดังนั้นจึงไม่สามารถเป็นไปได้ว่าร้านค้า GetString D--V-I-D ในกองเพราะผมจะ
ทันทีจะไม่สามารถเข้าถึงมัน
แต่เรารู้ว่าพวกเขา getString จะส่งกลับเฉพาะอะไร
มันไม่ได้กลับไป ฉันหกอักขระ
มันเป็นสิ่งที่แท้จริงกลับไม่ เราสรุปครั้งสุดท้าย?
ที่อยู่ของแรก
ดังนั้นอย่างใดเมื่อคุณเรียกว่า GetString, จะจัดสรรหน่วยความจำอันสำหรับ
สตริงที่ประเภทของผู้ใช้และ ที่อยู่นั้นกลับของมัน
และปรากฎว่าเมื่อคุณต้องการ ทำงานในการจัดสรรหน่วยความจำในเรื่องนี้
วิธีการและผลตอบแทนให้กับบุคคลที่เรียกว่า ฟังก์ชันที่อยู่ของ
หน่วยความจำอันนั้นคุณอย่างแน่นอน ไม่สามารถวางไว้ในสแต็คที่
ด้านล่างเพราะหน้าที่มันก็แค่ ไปไม่ได้กลายเป็นของคุณมาก
ได้อย่างรวดเร็วดังนั้นคุณอาจจะสามารถคาดเดาที่ เราอาจจะโยนมัน
แทนกองที่เรียกว่า
>> ดังนั้นระหว่างด้านล่างของหน่วยความจำของคุณ รูปแบบและด้านบนของหน่วยความจำของคุณ
รูปแบบมีทั้งกลุ่มของกลุ่ม
หนึ่งในนั้นคือสแต็คและขวา ข้างต้นนั้นเป็นกอง
และกองเป็นเพียงก้อนที่แตกต่างกันของ หน่วยความจำที่ไม่ได้ใช้สำหรับฟังก์ชั่น
เมื่อพวกเขากำลังเรียกว่า
โดยจะใช้งานสำหรับหน่วยความจำระยะยาวเมื่อ คุณต้องการฟังก์ชั่นหนึ่งที่จะคว้าบาง
หน่วยความจำและสามารถที่จะแขวนบนมัน โดยไม่สูญเสียการควบคุมมากกว่านั้น
>> ตอนนี้คุณอาจจะสามารถทำได้ทันที เห็นว่านี้ไม่ได้เป็น
จำเป็นต้องมีการออกแบบที่สมบูรณ์แบบ
ในฐานะที่เป็นโปรแกรมของคุณจัดสรรหน่วยความจำใน สแต็คหรือเป็นคุณโทรมากขึ้นและ
ฟังก์ชั่นมากขึ้นหรือในขณะที่คุณจัดสรร หน่วยความจำในกองกับ malloc ออกเป็น
GetString จะทำสิ่งที่เห็นได้อย่างชัดเจน ดูเหมือนว่าจะเป็นปัญหาที่หลีกเลี่ยงไม่?
>> ขวา
เช่นเดียวกับความจริงที่ว่าลูกศรเหล่านี้ จะชี้ไปที่แต่ละอื่น ๆ
ไม่ได้เป็นลางดี
และแน่นอนเราได้อย่างรวดเร็วอาจผิดพลาด โปรแกรมในจำนวนของรูปแบบใด ๆ
ในความเป็นจริงผมคิดว่าเราอาจจะมี การกระทำเช่นนี้โดยบังเอิญอีกครั้ง
หรือถ้าไม่ได้ลองทำมัน จงใจในขณะนี้
ให้ฉันไปข้างหน้าและเขียนได้อย่างรวดเร็วสุด โปรแกรมที่เรียกว่า dontdothis.c
และตอนนี้ฉันจะไปในที่นี่และ ทำคมรวม stdio.h
ขอประกาศฟังก์ชัน foo ใช้เวลา ไม่มีข้อโต้แย้งซึ่งเป็น
แทนเช่นกันโดยเป็นโมฆะ
>> และสิ่งเดียวที่ foo จะทำคือ โทร foo ซึ่งอาจจะไม่
ความคิดที่ฉลาด แต่ไม่ว่าจะเป็น
Ent เป็นโมฆะหลัก
ตอนนี้สิ่งเดียวที่หลักที่จะ ทำคือการเรียก foo เช่นกัน
และเพียง kicks, ฉันจะไป ไปข้างหน้าและพูดว่าที่นี่ printf "สวัสดีจาก
foo. "
>> ตกลง
ดังนั้นถ้าฉันไม่ได้ทำผิดพลาดใด ๆ ทำให้ dontdothis จุดเฉือน
และให้ทำมันในหน้าต่างที่ใหญ่กว่า -
จุดเฉือน, dontdothis
มาเมื่อ
โอ๊ะ
เห็นได้ชัดว่าคุณสามารถทำเช่นนี้
Damn มัน
ตกลง
รอ
ยืนตาม
ที่เราทำ -
เราได้ใช้มันให้กับ
>> [Sighs]
>> ผมรู้ แต่ผมคิดว่าเรา ลบเพียงว่า
เอ่อใช่
Damn มัน
แก้ร็อบนี้
อะไร?
มันง่ายมาก
ใช่เราหันมาเพิ่มประสิทธิภาพ
ตกลงยืนลาก่อน
ตอนนี้ฉันรู้สึกดีขึ้น
ตกลง
ทั้งหมดขวา
>> ดังนั้นขอ recompile นี้ -
ทำให้คุณ dontdothis
คุณอาจต้องเปลี่ยนชื่อนี้ dothis.c ในเวลาเพียงสักครู่
มีที่เราไป
ขอบคุณ
ตกลง
ดังนั้นความจริงที่ว่าฉันถูกพิมพ์ ออกบางสิ่งบางอย่างเป็นจริงเพียง
ชะลอตัวลงกระบวนการโดยที่เรา จะมีรายได้ถึงจุดนั้น
ตกลง
ว้า!
>> ดังนั้นสิ่งที่เป็นจริงที่เกิดขึ้น?
เหตุผลมีเช่นเดียวกันคือ ทำอะไรในแง่ของการป้อนข้อมูลและ
การส่งออกมีแนวโน้มที่จะชะลอตัวลงเพราะคุณ มีการเขียนตัวอักษร
หน้าจอมันจะต้องมีเลื่อน
ดังนั้นเรื่องยาวสั้นฉันมีจริง ที่เกิดขึ้นใจร้อนเช่นนั้นเราจะมี
เห็นผลลัพธ์ที่ได้นี้เป็นอย่างดี
ตอนนี้ที่ผมได้นั่งอัพพิมพ์, เราจะเห็นได้ทันที
ดังนั้นนี่คือเหตุผลที่เกิดขึ้น
ดีคำอธิบายง่ายๆแน่นอน คือ foo ที่อาจไม่ควร
จะเรียกตัวเอง
>> ขณะนี้อยู่ในข้อตกลงทั่วไป นี้คือการเรียกซ้ำ
และเราคิดว่าสัปดาห์ที่สอง ซ้ำที่ผ่านมาเป็นสิ่งที่ดี
recursion นี้เป็นวิธีขลังของ การแสดงตัวเองซุปเปอร์ชัดถ้อยชัดคำ
และมันก็ทำงานได้
แต่มีคุณลักษณะสำคัญของทั้งหมดคือ โปรแกรมแบบวนซ้ำที่เราได้พูดคุย
เกี่ยวกับและมองไปที่ป่านนี้ซึ่ง คือการที่พวกเขามีอะไร
กรณีฐานซึ่งเป็นบางรหัสยาก กรณีที่กล่าวว่าในบางสถานการณ์
ไม่โทร foo ซึ่งเห็นได้ชัดว่า ไม่ใช่กรณีที่นี่
>> ดังนั้นสิ่งที่เกิดขึ้นจริง ในแง่ของภาพนี้
ดีเมื่อสายหลัก foo มัน ได้รับชิ้นของหน่วยความจำ
เมื่อเรียก foo foo จะได้รับ ชิ้นของหน่วยความจำ
เมื่อเรียก foo foo จะได้รับชิ้น
จะได้รับชิ้น
เพราะ foo จะไม่กลับมา
เราไม่เคยลบหนึ่งในบรรดา ภาพจากกอง
ดังนั้นเราจึงกำลังพัดผ่านกองไม่ พูดถึงผู้ที่รู้สิ่งอื่นและ
เรากำลัง overstepping ขอบเขตของเรา ส่วนที่เรียกว่าหน่วยความจำ
ข้อผิดพลาดไปการแบ่งส่วนเท็จ
>> เพื่อแก้ปัญหาที่มี อย่างเห็นได้ชัดไม่ทำเช่นนี้
แต่ความหมายที่ใหญ่กว่าก็คือใช่ มีขีด จำกัด บางอย่างคือ
แม้จะไม่ได้กำหนดไว้เป็นวิธีการ ฟังก์ชั่นมากมายที่คุณสามารถโทร
โปรแกรมกี่ครั้งที่ฟังก์ชั่น สามารถเรียกตัวเอง
ดังนั้นแม้ว่าเราได้ประกาศเรียกซ้ำ เป็นสิ่งที่วิเศษที่อาจเกิดขึ้นนี้
สองสามสัปดาห์ที่ผ่านมาสำหรับซิก ฟังก์ชั่นและเมื่อเราได้รับข้อมูล
โครงสร้างและ CS50 คุณจะเห็นอื่น ๆ สำหรับการใช้งานมันไม่ได้
จำเป็นต้องเป็นสิ่งที่ดีที่สุด
เพราะถ้าฟังก์ชั่นที่เรียกตัวเอง, เรียกตัวเองแม้ว่าจะมีฐาน
กรณีถ้าคุณไม่ตีกรณีฐานว่า สำหรับโทร 1000 หรือ 10000 โทรตาม
เวลาที่คุณอาจจะวิ่งออกจากห้องพัก ในกองที่เรียกว่าตีของคุณและ
บางส่วนอื่น ๆ ของหน่วยความจำ
ดังนั้นมันก็คือการออกแบบการปิด ระหว่างความสง่างามและระหว่าง
ความทนทานของคุณโดยเฉพาะ การดำเนินงาน
>> ดังนั้นจึงมีข้อเสียหรือของผู้อื่น gotcha กับสิ่งที่เราได้อีก
ได้รับการทำป่านนี้
เมื่อตอนที่ผมเรียกว่า GetString -
ให้ฉันกลับไปสวัสดี-2
ขอให้สังเกตว่าฉันโทร GetString, ซึ่งจะกลับที่อยู่
และเราเรียกร้องในวันนี้ว่าที่อยู่ คือจากกอง
และตอนนี้ผมพิมพ์ออก สตริงที่อยู่ที่ว่า
แต่เราไม่เคยเรียกว่า ตรงข้ามของ getString
เราไม่เคยมีการ calll ฟังก์ชั่นเช่น ungetstring ที่มือคุณกลับมา
หน่วยความจำที่
แต่ตรงไปตรงมาเราอาจ ควรจะได้รับ
เพราะถ้าเราให้ถามคอมพิวเตอร์ สำหรับหน่วยความจำโดยวิธีของคนเช่น
GetString แต่ไม่ให้มันกลับมาแน่นอน ที่เกินไปเป็นผูกพันที่จะนำไปสู่​​การ
ปัญหาซึ่งให้เราทำงานออกจากหน่วยความจำ
>> และในความเป็นจริงเราสามารถมองหาเหล​​่านี้ ปัญหาเกี่ยวกับเครื่องมือใหม่ที่มีการใช้งาน
เป็นเพียงเล็กน้อยคลุมเครือในการพิมพ์
แต่ให้ฉันไปข้างหน้าและสาดมันขึ้นมา บนหน้าจอในเวลาเพียงสักครู่
ฉันจะไปข้างหน้าและเรียกใช้ Valgrind กับพารามิเตอร์ที่มีคำสั่งแรก
เส้นอาร์กิวเมนต์เป็นชื่อ ของโปรแกรมสวัสดี-2 ที่
และโชคไม่ดีที่มันเป็น เอาท์พุทเป็นอย่างทารุณ
ที่ซับซ้อนสำหรับเหตุผลที่ดีไม่
ดังนั้นเราจึงเห็นว่าระเบียบ
เดวิดเป็นรัฐที่ชื่อของฉัน
ดังนั้นว่าโปรแกรมอะไร ทำงานจริง
และตอนนี้เราได้รับผลนี้
>> ดังนั้น Valgrind มีความคล้ายคลึง ในจิตวิญญาณเพื่อ GDB
มันไม่ดีบักต่อ SE
แต่การตรวจสอบหน่วยความจำ
มันเป็นโปรแกรมที่จะทำงานของคุณ โปรแกรมและบอกคุณถ้าคุณถาม
คอมพิวเตอร์สำหรับหน่วยความจำและไม่เคยส่งมัน กลับจึงหมายความว่าคุณมี
หน่วยความจำรั่ว
และการรั่วไหลของหน่วยความจำที่มีแนวโน้มที่จะไม่ดี
และคุณเป็นผู้ใช้คอมพิวเตอร์มี นี้อาจรู้สึกว่าคุณมี
Mac หรือ PC
คุณเคยใช้คอมพิวเตอร์ของคุณสำหรับ ในขณะที่และไม่ได้รับการรีบูตในหลาย
วันหรือที่คุณได้เพียงแค่มีจำนวนมาก โปรแกรมที่ทำงานและสิ่งแช่ง
ช้าหยุดบดหรืออย่างน้อย มันน่ารำคาญสุดที่จะใช้เพราะ
ทุกอย่างเพียงแค่มีซุปเปอร์ช้า
>> ตอนนี้ที่สามารถเป็นหมายเลขใด ๆ ของเหตุผล
มันอาจจะเป็นห่วงอนันต์, ข้อผิดพลาดใน รหัสของใครบางคนหรือมากกว่าเพียงแค่มัน
อาจหมายความว่าคุณกำลังใช้มากขึ้น หน่วยความจำหรือความพยายามที่จะดีกว่าของคุณ
คอมพิวเตอร์จริงมี
และอาจจะมีข้อผิดพลาดในบางโปรแกรมของ ว่าขอให้สำหรับหน่วยความจำ
เบราว์เซอร์สำหรับปีเป็นที่รู้จักสำหรับ นี้ขอให้หน่วยความจำมากขึ้น
แต่ไม่เคยส่งมันกลับมา
แน่นอนถ้าคุณมีเพียง จำกัด ปริมาณของหน่วยความจำคุณไม่สามารถขอ
อย่างมากมายหลายครั้งสำหรับ บางส่วนของหน่วยความจำที่
>> และเพื่อให้สิ่งที่คุณเห็นที่นี่แม้ว่า อีกครั้ง Valgrind เอาท์พุทคือ
โดยไม่จำเป็นที่ซับซ้อนในการเหลือบ แรกนี้เป็นส่วนที่น่าสนใจ
กอง -
ในการใช้งานที่ประตูทางออก
ดังนั้นนี่คือเท่าใดหน่วยความจำคือ ในการใช้งานในกองที่
เวลาออกจากโปรแกรมของฉัน -
เห็นได้ชัดว่าหกไบต์ในหนึ่งช่วงตึก
ดังนั้นฉันจะโบกมือของฉัน สิ่งที่บล็อกคือ
คิดว่ามันเป็นเพียงก้อนมากขึ้น คำทางเทคนิคสำหรับก้อน
แต่หกไบต์ -
สิ่งที่หกไบต์ที่มี ยังคงอยู่ในการใช้งาน?
>> อย่างแน่นอน
D--V-I-D เครื่องหมายศูนย์ห้าตัวอักษร ชื่อบวก null terminator
ดังนั้นโปรแกรมนี้ Valgrind สังเกตเห็นว่าผม ถามหกไบต์เห็นได้ชัดโดย
วิธีการ GetString แต่ไม่เคย ให้พวกเขากลับมา
และในความเป็นจริงนี้อาจจะไม่ได้ดังนั้น ที่เห็นได้ชัดถ้าโปรแกรมของฉันไม่ได้เป็นสาม
เส้น แต่เส้น 300
ดังนั้นเราจริงสามารถให้คำสั่งอื่น อาร์กิวเมนต์บรรทัด Valgrind ไป
ให้มากขึ้น verbose
มันเป็นที่น่ารำคาญเล็ก ๆ น้อย ๆ ที่จะจำ
แต่ถ้าฉันทำ -
เรามาดู
รั่วไหล -
คือมันรั่วไหล -
แม้ผมจำไม่ได้ มันคือสิ่งที่ออกจากมือ
>> - รั่วที่เช็คเท่ากับเต็ม
ครับขอขอบคุณ
- รั่วที่เช็คเท่ากับเต็ม
เข้าไป
โปรแกรมเดียวกันทำงาน
พิมพ์ในเดวิดอีกครั้ง
ตอนนี้ผมดูรายละเอียดเล็ก ๆ น้อย ๆ
แต่ด้านล่างสรุปกองซึ่ง เป็นเหมือนสี่ - ah,
นี้เป็นชนิดของดี
ตอนนี้ Valgrind เป็นจริงที่กำลังมองหา หนักขึ้นเล็กน้อยในรหัสของฉัน
และก็บอกว่าเห็นได้ชัด, malloc ที่บรรทัด -
เราซูมออก
สายที่ -
เราไม่เห็นสิ่งที่มันเป็นเส้น
แต่ malloc เป็นผู้กระทำผิดครั้งแรก
มีบล็อกใน malloc ของ
>> ขวาทั้งหมด?
ตกลงไม่มี
ใช่ไหม?
ฉันเรียกว่า getString
เห็นได้ชัดว่า GetString เรียก malloc
ดังนั้นบรรทัดของรหัสเป็นสิ่งที่เห็นได้ชัดว่า ที่ผิดสำหรับการมี
การจัดสรรหน่วยความจำนี้
สมมติว่าใครก็ตามที่อ้าง malloc ได้รับรอบนานพอที่จะทำให้มัน
ไม่ใช่ความผิดของพวกเขา
ดังนั้นมันอาจเหมือง
getString ใน cs50.c - เพื่อที่ว่า ไฟล์ที่อยู่บนเครื่องคอมพิวเตอร์ -
ในสาย 286 น่าจะเป็นผู้กระทำผิด
ตอนนี้ขอสมมติว่า CS50 ได้รับ รอบสำหรับจำนวนที่เหมาะสมของเวลาดังนั้น
เราก็มีความผิด
และดังนั้นจึงอาจจะไม่ได้อยู่ใน getString ว่าปัญหาอยู่ แต่ใน
สวัสดี 2.C-18 เส้น
>> ดังนั้นลองมาดูที่ สิ่งบรรทัดที่ 18 คือ
แหม
อย่างไรก็ตามบรรทัดนี้ไม่จำเป็นต้องเป็น รถต่อ SE แต่มันคือเหตุผลที่
ที่อยู่เบื้องหลังการรั่วไหลของหน่วยความจำที่
ดังนั้นซุปเปอร์เพียงสิ่งที่จะหยั่งรู้ จะแก้ปัญหาที่นี่?
ถ้าเรากำลังขอให้สำหรับหน่วยความจำไม่เคย ให้มันกลับมาและที่น่าจะเป็น
ปัญหาเพราะเมื่อเวลาผ่านไปคอมพิวเตอร์ของฉัน อาจทำงานออกจากหน่วยความจำอาจชะลอตัว
ลงสิ่งเลวร้ายที่อาจจะเกิดขึ้นดี โซลูชั่นที่ใช้งานง่ายง่ายคืออะไร
เพียงแค่ให้มันกลับ
>> คุณเพิ่มหน่วยความจำวิธีการที่?
ดีโชคดีที่มันค่อนข้างง่าย ที่จะเพียงแค่พูดชื่อฟรี
และเราไม่เคยทำแบบนี้มาก่อน
แต่คุณเป็นหลักสามารถคิด ฟรีเป็นตรงข้ามของ malloc
ฟรีเป็นตรงข้ามของ จัดสรรหน่วยความจำ
ดังนั้นตอนนี้ให้ฉัน recompile นี้
ทำให้สวัสดี-2
ผมขอเรียกใช้อีกครั้ง สวัสดี-2 เดวิด
ดังนั้นจึงดูเหมือนว่าจะทำงานใน ตรงเช่นเดียวกับ
แต่ถ้าฉันกลับไป Valgrind และ re-run ว่าคำสั่งเดียวกันของฉันใหม่
โปรแกรมการพิมพ์รวบรวม ในนามของเราเป็นมาก่อน -
ดี
สรุปกอง -
ในการใช้งานที่ทางออก -
ศูนย์ไบต์ในบล็อกเป็นศูนย์
และนี่คือซุปเปอร์ดีทั้งหมด บล็อกกองเป็นอิสระ
การรั่วไหลไม่มีที่เป็นไปได้
>> ดังนั้นขึ้นมาไม่ได้กับปัญหาชุดที่ 4 แต่มีปัญหาชุด 5, นิติ
และเป็นต้นไปนี้ก็จะกลายเป็น ตัวชี้วัดของความถูกต้องของคุณ
โปรแกรมหรือไม่ว่าคุณมี หรือไม่ต้องมีการรั่วไหลของหน่วยความจำ
แต่โชคดีที่ไม่เพียง แต่คุณสามารถเหตุผล ผ่านพวกเขาสังหรณ์ใจซึ่ง
คือเนื้อหาง่ายสำหรับโปรแกรมขนาดเล็ก แต่ยากสำหรับโปรแกรมที่มีขนาดใหญ่
Valgrind สำหรับโปรแกรมขนาดใหญ่เหล่านั้น สามารถช่วยให้คุณระบุ
ปัญหาเฉพาะ
>> แต่มีหนึ่งปัญหาอื่น ๆ ที่อาจเกิดขึ้น
ผมขอเปิดไฟล์นี้ที่นี่ซึ่งก็คือ อีกครั้งเป็นตัวอย่างที่ค่อนข้างง่าย
แต่ขอเน้นสิ่งที่ โปรแกรมนี้จะ
นี้เรียกว่า memory.c
เราจะโพสต์วันนี้ในภายหลัง ซิปของรหัสที่มาของวันนี้
และสังเกตเห็นว่าฉันมีฟังก์ชันที่เรียกว่า F ที่ใช้เวลาและไม่มีข้อโต้แย้ง
ไม่มีอะไรตอบแทน
ในบรรทัดที่ 20 ผมเห็นได้ชัดว่าการประกาศ ตัวชี้ไปที่ int และเรียกมันว่า x
ผมกำหนดคือการกลับไป ค่าของ malloc
และเพียงแค่ต้องมีความชัดเจนกี่ไบต์ am ฉันอาจจะกลับมาจาก malloc
ในสถานการณ์เช่นนี้?
>> อาจจะ 40
คุณจะได้รับว่ามาจากที่ไหน?
ดีถ้าคุณจำได้ว่า int มักจะเป็น 4 ไบต์อย่างน้อยมันอยู่ใน
เครื่องใช้ไฟฟ้า 10 4 ครั้งจะเห็นได้ชัด 40
ดังนั้น malloc จะกลับที่อยู่ของ ก้อนของหน่วยความจำและการจัดเก็บที่
ที่อยู่ในท้ายที่สุด x
ดังนั้นต้องมีความชัดเจนในสิ่งที่ แล้วที่เกิดขึ้น?
ดีให้ฉันเปลี่ยนกลับ ไปยังภาพของเราที่นี่
ให้ฉันไม่ได้เพียงแค่วาดด้านล่างของฉัน หน่วยความจำของเครื่องคอมพิวเตอร์ให้ฉันไปข้างหน้าและ
วาดรูปสี่เหลี่ยมผืนผ้าทั้งหมดที่ แสดงทั้งหมดของ RAM ของฉัน
>> เราจะบอกว่าสแต็ค เป็นที่ด้านล่าง
และมีส่วนข้อความที่อยู่ใน ข้อมูล uninitialized
แต่ฉันก็จะเป็นนามธรรมเหล่านั้น สิ่งอื่น ๆ ออกไปขณะที่จุด dot dot
ฉันแค่จะไปพูดถึงเรื่องนี้ เป็นกองที่ด้านบน
และจากนั้นที่ด้านล่างของภาพนี้ เพื่อเป็นตัวแทนหลักของฉันจะ
ให้มันเป็นความทรงจำชิ้น บน stack
สำหรับ F, ฉันจะให้มันชิ้น ของหน่วยความจำใน stack
ตอนนี้ผมได้ให้คำปรึกษาของฉัน รหัสแหล่งที่มาอีกครั้ง
อะไรคือตัวแปรท้องถิ่นสำหรับหลักคือ?
เห็นได้ชัดว่าไม่มีอะไรดังนั้นชิ้นที่เป็น ได้อย่างมีประสิทธิภาพว่างเปล่าหรือไม่ได้เป็นใหญ่
เป็นฉันได้วาดมัน
แต่ในฉฉันมีตัวแปรท้องถิ่น, ซึ่งเรียกว่า x
ดังนั้นฉันจะไปข้างหน้าและให้ F ก้อนของหน่วยความจำเรียกมันว่า x
>> และตอนนี้ malloc จาก 10 ครั้ง 4 ดังนั้น malloc 40 ที่ว่ามา
หน่วยความจำที่มาจาก?
เราไม่ได้วาดภาพ เช่นนี้มาก่อน
แต่ขอสมมติว่ามันเป็นไปได้อย่างมีประสิทธิภาพ มาจากที่นี่ดังนั้นหนึ่ง
สองสามสี่ห้า
และตอนนี้ฉันต้อง 40 จากเหล่านี้
ดังนั้นฉันจะทำจุดจุดจุดที่จะแนะนำ ว่ามีหน่วยความจำมากยิ่งขึ้นว่า
กลับมาจากกอง
ที่อยู่ตอนนี้คืออะไร
ให้เลือกของเราโดยพลการ อยู่เช่นเคย -
Ox123 แม้ว่ามันอาจจะ จะเป็นสิ่งที่แตกต่างอย่างสิ้นเชิง
นั่นเป็นที่อยู่ของไบต์แรกใน หน่วยความจำที่ฉันขอ malloc สำหรับ
>> ดังนั้นในระยะสั้นเส้นครั้งเดียว 20 รัน, เป็นอักษรอะไร
ที่เก็บไว้ภายในของ x ที่นี่?
Ox123
และวัวเป็นที่น่าทึ่ง
มันก็หมายความว่านี่คือ จำนวนฐานสิบหก
แต่สิ่งที่สำคัญคือสิ่งที่ฉันได้เก็บ ใน x ซึ่งเป็นตัวแปรท้องถิ่น
แต่ชนิดของข้อมูลของตนอีกครั้ง เป็นที่อยู่ของ int
ดีฉันจะเก็บ Ox123
แต่อีกครั้งหากที่น้อยเกินไป ซับซ้อนเกินความจำเป็นถ้าผมเลื่อน
กลับเราสามารถนามธรรมนี้ไปค่อนข้าง พอสมควรและก็บอกว่า x คือ
ตัวชี้ไปยังหน่วยความจำอันว่า
>> ตกลง
ตอนนี้คำถามที่อยู่ในมือ เป็นดังต่อไปนี้ -
บรรทัดที่ 21 มันจะเปิดออกเป็นรถ
ทำไม?
>> ขออภัย?
แต่ไม่ได้มี -
บอกว่าอีกครั้ง
ดีมันไม่ได้ฟรี
เพื่อให้เป็นที่สอง แต่
เพื่อให้มีคนอื่น ๆ แต่เฉพาะคน ที่บรรทัด 21
>> อย่างแน่นอน
บรรทัดนี้ที่เรียบง่ายของรหัสเป็นเพียง หน่วยความจำล้นในลักษณะ buffer overrun
บัฟเฟอร์เพียงหมายถึงหน่วยความจำอัน
แต่ก้อนหน่วยความจำที่มีขนาด 10, 10 จํานวนเต็มซึ่งหมายความว่าถ้าเรา
ดัชนีลงไปโดยใช้น้ำตาล syntactic สัญกรณ์อาร์เรย์ตาราง
วงเล็บคุณมีการเข้าถึง x วงเล็บ 0 วงเล็บ x 1 x,
วงเล็บจุดจุดจุด
x 9 วงเล็บคือหนึ่งที่ใหญ่ที่สุด
ดังนั้นถ้าฉันทำ x 10 วงเล็บที่ ฉันจริงไปในหน่วยความจำ?
>> ดีถ้าฉันมี 10 int -
ให้วาดจริงทั้งหมด ของเหล่านี้ออกจากที่นี่
เพื่อให้เป็นครั้งแรกที่ห้า
ที่นี่อีกห้า ints ของ
ดังนั้น x วงเล็บ 0 อยู่ที่นี่ x วงเล็บคือ 1 ที่นี่ x วงเล็บ 9 อยู่ที่นี่ วงเล็บ x
10 อยู่ที่นี่ซึ่งหมายความว่าฉันบอก ในสาย 21 เครื่องคอมพิวเตอร์ที่จะนำ
จำนวนที่?
0 จำนวนที่?
ดีก็ 0, ใช่
แต่ความจริงที่ว่าที่ 0 เป็นชนิดของความบังเอิญ
มันอาจจะเป็นจำนวน 50 สำหรับทุกสิ่งที่เราดูแล
แต่เรากำลังพยายามที่จะนำมันที่ x วงเล็บ 10 ซึ่งเป็นที่ที่นี้
เครื่องหมายคำถามจะถูกวาดขึ้นซึ่ง ไม่ได้เป็นสิ่งที่ดี
โปรแกรมนี้อาจจะเป็นอย่างดี ความผิดพลาดเป็นผล
>> ตอนนี้ขอไปข้างหน้าและดูว่านี้ เป็นจริงสิ่งที่เกิดขึ้น
ทำให้หน่วยความจำตั้งแต่ไฟล์ เรียกว่า memory.c
ให้ไปข้างหน้าและเรียกใช้ หน่วยความจำโปรแกรม
ดังนั้นเราโชคดีจริงดูเหมือนว่า
เรามีโชคดี
แต่ให้ดูว่าตอนนี้เราทำงาน V​​algrind
ได้อย่างรวดเร็วก่อนโปรแกรมของฉันอาจจะ ดูเหมือนจะถูกต้องสมบูรณ์
แต่ให้ฉันทำงานกับ Valgrind - รั่วที่เช็คเท่ากับเต็มรูปแบบในหน่วยความจำ
>> และตอนนี้เมื่อฉันทำงานนี้ -
น่าสนใจ
เขียนไม่ถูกต้องจาก 4 ขนาดที่ สาย 21 จาก memory.c
สาย 21 จาก memory.c หนึ่งที่?
โอ้ที่น่าสนใจ
แต่รอ
4 ขนาดคือว่าหมายถึงอะไร
ผมคนหนึ่งไม่เพียง แต่เขียน แต่จาก 4 ขนาด
ทำไมมันจึงเป็น 4?
ก็เพราะมันเป็น int ซึ่ง คืออีกครั้งไบต์ที่สี่
ดังนั้น Valgrind พบข้อบกพร่องที่ฉัน, glancing ที่รหัสของฉันไม่ได้
และอาจ TF ของคุณจะหรือจะไม่
อะไร แต่สำหรับ Valgrind พบว่า เราได้ทำผิดพลาดมีแม้
แม้ว่าเราจะโชคดีและคอมพิวเตอร์ ตัดสินใจมั้ยผมไม่ได้ไปผิดพลาด
เพียงเพราะคุณสัมผัสหนึ่งไบต์, หนึ่ง คุ้มค่า int ของหน่วยความจำที่คุณไม่ได้
ของตัวเองจริง
>> ดีสิ่งอื่นรถอยู่ที่นี่
ที่อยู่ -
นี้เป็นที่อยู่บ้ามองหา ในเลขฐานสิบหก
ที่เพียงแค่หมายความว่าอยู่ที่ไหนสักแห่งในกองคือ ศูนย์ไบต์หลังจากที่บล็อกขนาด 40
จะถูกจัดสรร
ผมขอซูมออกที่นี่และดูว่า นี้เป็นเพียงเล็กน้อยที่มีประโยชน์มากขึ้น
น่าสนใจ
40 ไบต์จะหายไปแน่นอน ในการบันทึกการสูญเสีย 1 จาก 1
อีกครั้งที่คำพูดมากกว่าจะเป็นประโยชน์ที่นี่
แต่ขึ้นอยู่กับสายที่ไฮไลต์, ฉันควรที่จะมุ่งเน้นของฉัน
ความสนใจสำหรับข้อผิดพลาดอื่นได้หรือไม่
ดูเหมือนว่าสาย 20 จาก memory.c
>> ดังนั้นหากเรากลับไปที่ 20 สายที่ หนึ่งที่คุณระบุไว้ก่อนหน้านี้
และมันก็ไม่จำเป็นต้องมีรถม้าชนิดเล็ก
แต่ตอนนี้เราได้ย้อนกลับไปที่ผลกระทบของมัน
ดังนั้นผมจะแก้ไขอย่างน้อยวิธี หนึ่งในความผิดพลาดเหล่านั้นหรือไม่
สิ่งที่ฉันจะทำหลังจากที่สาย 21?
ฉันจะทำฟรี x, ดังนั้น ที่จะให้กลับหน่วยความจำที่
และวิธีการที่ฉันจะแก้ไขปัญหานี้?
แน่นอนผมควรจะไป ไม่ไกลออกไปกว่า 0
เพื่อให้ฉันลองและ re-run นี้
ขออภัยแน่นอนไป ไม่ไกลออกไปกว่า 9
ทำให้หน่วยความจำ
ให้ฉันวิ่ง Valgrind ในหน้าต่างที่ใหญ่กว่า
และตอนนี้ดู
ไนซ์
บล็อคของกองเป็นอิสระ
การรั่วไหลไม่มีที่เป็นไปได้
และขึ้นเหนือที่นี่มีการเอ่ยถึงไม่ได้ เพิ่มเติมใด ๆ จากทางด้านขวาที่ไม่ถูกต้อง
>> เพียงเพื่อให้ได้โลภและขอ ดูว่าการสาธิตอื่น
ไม่ได้ไปตามที่ตั้งใจไว้ -
ผมไม่ได้รับโชคดีสักครู่ที่ผ่านมา
และความจริงที่ว่านี้เป็น 0 อาจจะเป็น ทำให้เข้าใจผิดโดยไม่จำเป็น
ขอเพียงทำ 50, ตามอำเภอใจ จำนวนให้หน่วยความจำหน่วยความจำจุดเฉือน -
ยังคงได้รับโชคดี
ไม่มีอะไร crashing
สมมติว่าฉันเพียงแค่ทำอะไรจริงๆ โง่และฉันทำ 100
ให้ฉัน remake หน่วยความจำ, หน่วยความจำจุดเฉือน -
โชคดีอีกครั้ง
วิธีการเกี่ยวกับ 1,000?
ints เกินหยาบคาย ที่ฉันควรเป็นอย่างไร
ทำให้หน่วยความจำ -
เจ้ากรรมมัน
>> [เสียงหัวเราะ]
>> ตกลง
Let 's ไม่ยุ่งรอบอีกต่อไป
รันใหม่อีกครั้งหน่วยความจำ
มีที่เราไป
ทั้งหมดขวา
ดังนั้นเห็นได้ชัดว่าคุณดัชนี 100,000 ints เกินกว่าที่คุณควรได้รับใน
หน่วยความจำสิ่งที่ไม่ดีเกิดขึ้น
ดังนั้นนี่คือไม่ชัด ยากที่กฎได้อย่างรวดเร็ว
ฉันเป็นชนิดของการใช้การทดลอง และข้อผิดพลาดที่จะได้มี
แต่เป็นเพราะเรื่องยาวสั้น หน่วยความจำของคอมพิวเตอร์ของคุณยังแบ่งออกเป็น
สิ่งเหล่านี้เป็นส่วนที่เรียกว่า
และบางครั้งเครื่องคอมพิวเตอร์จริง ได้ให้คุณความทรงจำเล็ก ๆ น้อย ๆ
กว่าที่คุณถามหา
แต่สำหรับประสิทธิภาพก็แค่ง่ายต่อการ รับหน่วยความจำมากขึ้น แต่เพียงบอกคุณ
ว่าคุณได้รับส่วนหนึ่งของมัน
>> และถ้าคุณได้รับโชคดีบางครั้ง ดังนั้นคุณอาจจะสามารถที่จะสัมผัส
หน่วยความจำที่ไม่ได้เป็นของคุณ
คุณมีไม่มีการรับประกันว่าสิ่งที่มูลค่า ที่คุณใส่ก็จะอยู่ที่นั่นเพราะ
คอมพิวเตอร์ยังคงคิดว่ามันเป็นไม่ได้ ของคุณ แต่ไม่จำเป็นต้องไป
ที่จะตีส่วนของหน่วยความจำอีก คอมพิวเตอร์และก่อให้เกิดความผิดพลาดเช่น
นี้ที่นี่
ทั้งหมดขวา
คำถามใด ๆ แล้วในหน่วยความจำ?
>> ทั้งหมดขวา
ลองมาดูที่นี่แล้วที่ บางสิ่งบางอย่างที่เราได้รับการสำหรับ
ที่ได้รับสำหรับค่อนข้างบางเวลาซึ่ง ที่อยู่ในไฟล์ที่เรียกว่า cs50.h. นี้
ดังนั้นนี่คือไฟล์
เหล่านี้เป็นเพียงทั้งกลุ่ม จากความเห็นขึ้นด้านบน
และคุณอาจจะมองไปที่นี้ถ้า คุณ poked รอบในเครื่องใช้ไฟฟ้า
แต่มันกลับกลายเป็นว่าตลอดเวลา เมื่อเรานำไปใช้เพื่อใช้เป็นสตริง
ไวพจน์, วิธีการที่เราประกาศ ที่เป็นคำพ้องความหมายกับเรื่องนี้
คำหลัก typedef สำหรับนิยามประเภท
และเราเป็นหลักว่าให้ สตริงไวพจน์ดาวถ่าน
ที่หมายถึงการที่สแต็ค สร้างล้อการฝึกอบรมเหล่านี้เป็นที่รู้จักกัน
สตริง
>> ตอนนี้ที่นี่เป็นเพียงต้นแบบ สำหรับ getchar
เราอาจจะได้เห็นมันมาก่อน แต่ที่ แน่นอนสิ่งที่มันไม่ getchar
จะไม่มีข้อโต้แย้งกลับถ่าน
getdouble ใช้อาร์กิวเมนต์ไม่ ผลตอบแทนที่สอง
getfloat ใช้ผลตอบแทนไม่มีข้อโต้แย้ง ลอยและอื่น ๆ
GetInt อยู่ในที่นี่ getlonglong อยู่ในที่นี่
และ GetString อยู่ในที่นี่
และที่มัน
ทางรถไฟสายนี้เป็นสีม่วง preprocessor ​​อื่น สั่งเพราะ
hashtag ที่จุดเริ่มต้นของมัน
>> ทั้งหมดขวา
ดังนั้นตอนนี้ให้ฉันไปเป็น cs50.c.
และเราจะไม่พูดยาวเกินไปเกี่ยวกับเรื่องนี้
แต่การที่จะให้คุณมองแวบเดียวของสิ่งที่ รับไปทั้งหมดนี้
เวลาให้ฉันไป -
ขอทำ getchar
ดังนั้น getchar ส่วนใหญ่จะเป็นความเห็น
แต่มันก็มีลักษณะเช่นนี้
ดังนั้นนี่คือฟังก์ชั่นที่เกิดขึ้นจริง getchar ที่เราเคย
การได้รับอยู่
และถึงแม้เราไม่ได้ใช้นี้ ว่ามักจะหากเคยเป็นอย่างน้อย
ที่ค่อนข้างง่าย
ดังนั้นจึงเป็นมูลค่าการ ดูอย่างรวดเร็วที่นี่
>> ดังนั้น getchar มีห่วงอนันต์, ดังนั้นเห็นได้ชัดว่าจงใจ
จากนั้นก็เรียก - และนี่คือชนิดของ นำมาใช้ใหม่ที่ดีของรหัสตัวเราเองครับ
มันเรียก getString
เพราะสิ่งที่ไม่ได้ หมายถึงการได้รับถ่าน?
ดีคุณอาจรวมทั้งพยายามที่จะได้รับ ทั้งบรรทัดของข้อความจากผู้ใช้และ
แล้วก็มองไปที่หนึ่ง ของตัวละครเหล่านั้น
ในบรรทัดที่ 60, ที่นี่เล็ก ๆ น้อย ๆ บิตของการตรวจสอบสุขภาพจิต
ถ้า GetString กลับโมฆะ ให้ไม่ดำเนินการต่อไป
สิ่งที่ผิดพลาด
>> ตอนนี้เป็นที่น่ารำคาญบ้าง แต่ ในการชุมนุม C. ถ่านสูงสุดอาจ
แสดงให้เห็นถึงสิ่งเพียง ตามชื่อของมัน
มันคงที่
มันเหมือนเป็นค่าตัวเลขของ ที่ใหญ่ที่สุดของถ่านที่คุณสามารถแสดงด้วย
หนึ่งกัดซึ่งอาจเป็นจำนวน 255 ซึ่งเป็นจำนวนที่ใหญ่ที่สุดของคุณ
เป็นตัวแทนของแปดบิต เริ่มต้นจากศูนย์
ดังนั้นฉันใช้ในฟังก์ชั่นนี้เมื่อ การเขียนรหัสนี้เพียงเพราะ
ถ้าอะไรผิดพลาดใน getchar แต่ จุดประสงค์ของมันในชีวิตคือการที่จะกลับมา
ถ่านที่คุณจะต้องอย่างใดจะสามารถ เพื่อส่งสัญญาณไปยังผู้ใช้ว่า
สิ่งที่ผิดพลาด
เราไม่สามารถกลับมาเป็นโมฆะ
แต่กลับกลายเป็นว่าเป็นตัวชี้โมฆะ
และอีกครั้ง, getchar มี เพื่อกลับถ่าน
>> ดังนั้นการประชุมถ้ามีอะไร ผิดคุณเป็นโปรแกรมเมอร์หรือใน
กรณีนี้ผมกับห้องสมุดฉันมี เพียงแค่ตัดสินใจโดยพลการถ้า
บางสิ่งบางอย่างที่ผิดไปฉันจะไป ส่งกลับจำนวน 255 ซึ่งเป็นอย่างแท้จริง
หมายความว่าเราไม่สามารถที่ผู้ใช้ไม่สามารถพิมพ์ ตัวละครที่แสดงโดย
255 จำนวนเพราะเรามีขโมยมัน เป็นค่าแมวมองที่เรียกว่า
เป็นตัวแทนของปัญหา
ตอนนี้มันกลับกลายเป็นว่า 255 ตัวอักษร ไม่ใช่สิ่งที่คุณสามารถพิมพ์บน
แป้นพิมพ์ของคุณดังนั้นมันจึงไม่ใช่เรื่องใหญ่
ผู้ใช้ไม่ได้สังเกตเห็นว่า ผมเคยถูกขโมยตัวละครตัวนี้
แต่ถ้าคุณเคยเห็นในหน้าคนเมื่อ ระบบคอมพิวเตอร์การอ้างอิงถึงบาง
ตัวพิมพ์ใหญ่ทั้งหมดคงที่เช่นนี้ที่บอกว่า ในกรณีของข้อผิดพลาดนี้อาจจะคงที่
จะกลับมานั่นคือทั้งหมดของมนุษย์ได้บาง ปีที่ผ่านมามีการตัดสินใจโดยพลการ
กลับนี้ค่าพิเศษและ เรียกว่าค่าคงที่ในกรณีที่
มีอะไรผิดพลาด
>> ตอนนี้ความมหัศจรรย์ที่เกิดขึ้นลงที่นี่
ครั้งแรกที่ผมประกาศใน 67 เส้น ตัวละครทั้งสอง C1 และ C2
จากนั้นในบรรทัดที่ 68, มีจริง บรรทัดของรหัสที่ชวนให้นึกถึง
เพื่อนของเรา printf ระบุว่ามัน จะมีเปอร์เซ็นต์ Cs ในเครื่องหมายคำพูด
แต่สังเกตเห็นสิ่งที่เกิดขึ้นที่นี่ sscanf หมายถึงการสแกนสตริง -
หมายถึงการจัดรูปแบบการสแกน สตริง sscanf Ergo,
ว่าหมายความว่าอย่างไร
มันหมายความว่าคุณจะส่งผ่านไปยัง sscanf สตริง
และสายเป็นสิ่งที่ ประเภทผู้ใช้ค่ะ
คุณส่งผ่านไปยัง sscanf สตริงรูปแบบเช่น นี้ที่บอก scanf สิ่งที่เป็น
คุณหวังว่าผู้ใช้มีการพิมพ์นิ้ว
จากนั้นคุณผ่านในที่อยู่ของทั้งสอง ชิ้นของหน่วยความจำในกรณีนี้
เพราะผมมีสองตัวยึด
ดังนั้นฉันจะให้มันอยู่ จาก C1 และที่อยู่ของ C2
>> และจำได้ว่าคุณให้ฟังก์ชั่น ที่อยู่ของตัวแปรบางสิ่งที่
ความหมาย?
ฟังก์ชั่นที่สามารถทำอะไรเป็นผล ของการให้ที่อยู่ของมัน
ตัวแปรเมื่อเทียบกับ ตัวแปรตัวเอง?
มันสามารถเปลี่ยนมันใช่มั้ย?
หากคุณมีคนแผนที่ทางกายภาพ ที่อยู่พวกเขาสามารถไปที่นั่นและทำ
สิ่งที่พวกเขาต้องการที่อยู่ที่ว่า
ความคิดเดียวกันที่นี่
ถ้าเราส่งผ่านไปยัง sscanf ที่อยู่ของทั้งสอง ชิ้นของหน่วยความจำแม้เล็ก ๆ เหล่านี้
ชิ้นเล็ก ๆ น้อย ๆ ของหน่วยความจำ, C1 และ C2 แต่ เราบอกว่าที่อยู่ของพวกเขา,
sscanf สามารถเปลี่ยนได้
>> ดังนั้นวัตถุประสงค์ sscanf ในชีวิตถ้าเราอ่าน หน้าคนที่จะอ่านสิ่งที่
ผู้ใช้พิมพ์ลงในความหวังสำหรับผู้ใช้ที่มี พิมพ์ตัวอักษรและบางที
ตัวละครอื่นและสิ่งที่ผู้ใช้ พิมพ์ตัวอักษรตัวแรกไป
ที่นี่อักขระตัวที่สองที่นี่
ขณะนี้เป็นกันนี้และคุณจะ เพียงรู้นี้จากเอกสาร,
ความจริงที่ว่าฉันใส่พื้นที่ว่างมี ก็หมายความว่าฉันไม่สนหรอกว่า
ผู้ใช้พบแถบพื้นที่ไม่กี่ ครั้งก่อนที่เขาหรือเธอจะใช้เวลา
ตัวฉันจะไม่สนใจ ช่องว่างใด ๆ
เพื่อที่ว่าฉันรู้จาก เอกสารประกอบ
>> เป็นจริงที่มี% c ที่สอง ตามด้วยช่องว่างสีขาวเป็นจริง
โดยเจตนา
ผมต้องการที่จะสามารถที่จะตรวจสอบหากผู้ใช้ เมาขึ้นหรือไม่ให้ความร่วมมือ
ดังนั้นฉันหวังว่าผู้ใช้พิมพ์เพียง ในตัวละครตัวหนึ่งดังนั้นฉันหวัง
ที่ sscanf เท่านั้นจะกลับมา 1 มูลค่าเพราะอีกครั้งถ้าผมอ่าน
เอกสารที่มีวัตถุประสงค์ใน sscanf ชีวิตคือการกลับไปยังหมายเลขของ
ตัวแปรที่เต็มไป ที่มีผู้ใช้ป้อน
>> ฉันผ่านในสองตัวแปร ที่อยู่, C1 และ C2
ฉันหวังว่าแม้ว่าเพียงหนึ่งใน พวกเขาได้รับฆ่าเพราะถ้า sscanf
2 จะส่งกลับสิ่งที่สันนิษฐานว่า ความหมายเหตุผล?
ที่ผู้ใช้ไม่ได้เพียงแค่ให้ฉันหนึ่ง ตัวอักษรเหมือนที่ผมบอกเขาหรือเธอ
พวกเขาอาจจะอยู่ที่พิมพ์ อย่างน้อยตัวละครทั้งสอง
ดังนั้นถ้าฉันแทนไม่ได้ที่สอง % c, ฉันเพิ่งมีหนึ่งซึ่ง
ตรงไปตรงมาก็จะง่ายขึ้น วิธีการที่ผมคิดว่าอย่างรวดเร็วก่อน
คุณจะไม่สามารถที่จะตรวจสอบ หากผู้ได้รับการให้คุณมากขึ้น
อินพุตกว่าที่คุณต้องการจริง
ดังนั้นนี่คือรูปแบบโดยปริยาย จากการตรวจสอบข้อผิดพลาด
>> แต่สังเกตเห็นสิ่งที่ฉันทำที่นี่
เมื่อฉันแน่ใจว่าผู้ใช้ให้ฉันหนึ่ง ตัวละครที่ผมฟรีบรรทัดที่ทำ
ตรงข้ามของ GetString ซึ่งในทางกลับกัน ใช้ malloc และจากนั้นเราจะกลับมา
C1, ตัวละครที่ฉันหวังว่า ผู้ที่ให้บริการและให้เฉพาะ
อย่างรวดเร็ว glimpsed เท่านั้น แต่ คำถามใด ๆ เกี่ยวกับ getchar?
เราจะกลับมาบางส่วนของคนอื่น ๆ
>> ดีให้ฉันไปข้างหน้าและทำเช่นนี้ - สมมติว่าขณะนี้เพียงเพื่อกระตุ้นของเรา
การอภิปรายในสัปดาห์บวกเวลานี้ เป็นไฟล์ที่เรียกว่า structs.h
และอีกครั้งนี้เป็นเพียงรสชาติ จากสิ่งที่อยู่ข้างหน้า
แต่แจ้งให้ทราบว่ามาก ของที่นี่คือความเห็น
เพื่อให้ฉันเน้นเพียง ส่วนที่น่าสนใจสำหรับตอนนี้
typedef -
มีที่คำหลักเดียวกันอีกครั้ง
typedef เราใช้ในการประกาศสตริง เป็นชนิดข้อมูลพิเศษ
คุณสามารถใช้ typedef ในการสร้างแบรนด์ใหม่ ชนิดข้อมูลที่ไม่อยู่เมื่อ
C ถูกคิดค้น
ยกตัวอย่างเช่น int มาพร้อมกับ C. ถ่าน มาพร้อมกับ C. คู่มาพร้อมกับซี แต่
มีความคิดของนักเรียนไม่ได้
และยังมันจะสวยมีประโยชน์เพื่อให้ สามารถที่จะเขียนโปรแกรมที่จัดเก็บ
ในตัวแปรหมายเลขของนักเรียน, ชื่อของพวกเขาและบ้านของพวกเขา
ในคำอื่น ๆ สามชิ้น ของข้อมูลเช่น int และ
สตริงและสตริงอื่น
>> ด้วย typedef, มีประสิทธิภาพสวยอะไร เกี่ยวกับเรื่องนี้และ sturct คำหลักสำหรับ
โครงสร้างคุณโปรแกรมเมอร์ในปี 2013, จริงสามารถกำหนดเองของคุณ
ชนิดข้อมูลที่ไม่อยู่ปี ที่ผ่านมา แต่ที่เหมาะสมกับวัตถุประสงค์ของคุณ
และอื่น ๆ ที่นี่ในสาย 13 ผ่าน 19, เรากำลังประกาศชนิดข้อมูลใหม่เช่น
int แต่เรียกมันว่านักเรียน
และภายในของตัวแปรนี้จะไป มีสามสิ่ง - int, สตริง,
และสตริง
เพื่อให้คุณสามารถคิดว่าสิ่งที่เป็นจริง เกิดขึ้นที่นี่ถึงแม้ว่านี้คือ
บิตของความเรียบง่ายสำหรับวันนี้ นักเรียนเป็นหลักไป
ลักษณะเช่นนี้
จะเป็นก้อนของมัน หน่วยความจำที่มีรหัสชื่อ
สนามและสนามบ้าน
และเราจะสามารถที่จะใช้ชิ้นนั้น หน่วยความจำและการเข้าถึงพวกเขาดังต่อไปนี้
>> ถ้าฉันไปเป็น struct0.c นี่คือ ค่อนข้างยาว แต่ต่อไปนี้
รูปแบบของรหัสที่ ใช้เคล็ดลับนี้ใหม่
ดังนั้นครั้งแรกให้ฉันดึงความสนใจของคุณ ไปยังส่วนที่น่าสนใจขึ้นด้านบน
ชาร์ปกำหนด 3 นักเรียนบอก นักเรียนที่เรียกว่าคงที่และกำหนด
มันพลจำนวน 3 เพียง ดังนั้นผมจึงมีสามนักเรียนใช้
โปรแกรมสำหรับตอนนี้
ที่นี่มาที่หน้าหลัก
และแจ้งให้ทราบฉันจะประกาศ อาร์เรย์ของนักเรียน?
ดีฉันเพียงแค่ใช้ไวยากรณ์เดียวกัน
นักเรียนเป็นคำใหม่ที่เห็นได้ชัด
แต่นักเรียนระดับนักเรียนวงเล็บ
>> ดังนั้นน่าเสียดายที่มีจำนวนมากที่สุด จากการนำมาใช้ใหม่ของข้อตกลงที่นี่
นี่เป็นเพียงตัวเลข
ดังนั้นนี่คือเหมือนว่าสาม
ชั้นเป็นเพียงสิ่งที่ฉันต้องการ ที่จะเรียกตัวแปร
ฉันจะเรียกมันว่าเป็นนักเรียน
แต่ชั้นนี้ไม่ได้ในชั้นเรียน วัตถุชนิด Java ที่มุ่งเน้นวิธีการ
มันเป็นเพียงชั้นเรียนของนักเรียน
และชนิดข้อมูลของทุกองค์ประกอบ ในอาร์เรย์ที่นักเรียนเป็น
ดังนั้นนี่เป็นเพียงเล็กน้อยที่แตกต่างกัน และจากการพูดอะไรบางอย่าง
เช่นนี้ก็เพียง -
ที่ฉันพูดให้ฉันสามนักเรียน และเรียกชั้นอาร์เรย์ที่
>> ทั้งหมดขวา
ตอนนี้ที่นี่สี่ห่วง
ของผู้ชายคนนี้ที่คุ้นเคย - ย้ำ จากศูนย์เมื่อถึงสาม
และนี่เป็นชิ้นใหม่ของไวยากรณ์
โปรแกรมจะแจ้งให้ฉัน มนุษย์ที่จะให้มันนักเรียน
ID ซึ่งเป็น int
และนี่คือรูปแบบที่คุณสามารถ เก็บสิ่งที่อยู่ในเขตข้อมูล ID ที่
สถานที่ชั้นวงเล็บ I. ดังนั้น รูปแบบนี้ไม่ใช่เรื่องใหม่
นี้ก็หมายความว่าให้ฉันที่แปด นักเรียนในชั้นเรียน
แต่สัญลักษณ์นี้เป็นของใหม่
จนถึงตอนนี้เราไม่สามารถใช้จุด อย่างน้อยก็ในรหัสเช่นนี้
ซึ่งหมายความว่าไปที่ struct รู้จักกันในชื่อ นักเรียนและนำสิ่งที่มี
ในทำนองเดียวกันในบรรทัดถัดไปนี้, 31, ไป ข้างหน้าและใส่สิ่งที่ผู้ใช้พิมพ์
สำหรับชื่อที่นี่และสิ่งที่พวกเขาทำเพื่อ บ้านสิ่งเดียวกันไปข้างหน้าและ
วางไว้ใน. บ้าน
>> ดังนั้นโปรแกรมนี้ไม่สิ่งที่ ในที่สุดก็ทำอะไร?
คุณสามารถดูทีเซอร์น้อยมี
ให้ฉันไปข้างหน้าและจะทำให้ structs 0 จุดเฉือน struct 0 ID ของนักเรียน 1,
เดวิดบอกว่าท้องประจำตัวนักศึกษา 2
ร็อบเคิร์กแลนด์, นักเรียน ID 3
Leverit ลอเรน -
และสิ่งเดียวที่โปรแกรมนี้ได้ ซึ่งเป็นเพียงการสุ่มอย่างสมบูรณ์คือ
ฉันอยากจะทำอะไรกับข้อมูลนี้ ตอนนี้ที่ผมเคยสอนเราวิธีการ
ใช้ structs เป็นฉันเพิ่งมี วงนี้พิเศษที่นี่
ผมย้ำผ่านแถวของนักเรียน
ผมเคยเป็นเพื่อนที่เราอาจจะคุ้นเคยตอนนี้ สตริงเปรียบเทียบ stircomp ไป
ตรวจสอบเป็นบ้านของนักเรียน 8 เท่ากับท้อง?
และถ้าเป็นเช่นนั้นเพียงแค่พิมพ์บางสิ่งบางอย่าง พลชอบใช่มันคือ
แต่อีกเพียงแค่ให้ฉันโอกาส ในการใช้และนำมาใช้ใหม่และ
สัญกรณ์นำมาใช้จุดนี้ใหม่
>> ดังนั้นใส่ใจที่ขวา?
ขึ้นมาพร้อมกับโปรแกรมนักเรียนคือ ค่อนข้างโดยพลการ แต่ปรากฎออก
ที่เราสามารถทำสิ่งที่เป็นประโยชน์กับ นี้ตัวอย่างเช่นดังต่อไปนี้
นี่คือโครงสร้างที่ซับซ้อนมากขึ้น ใน C. มันมีโหลหรือสาขาที่มากขึ้น
ชื่อค่อนข้างชัดเจน
แต่ถ้าคุณเคยได้ยินของกราฟิก รูปแบบไฟล์ที่เรียกว่าบิตแมป, BMP, มัน
ปรากฎว่ารูปแบบไฟล์บิตแมป สวยมากมีลักษณะเช่นว่านี้
มันเป็นเรื่องที่โง่ใบหน้าที่ยิ้มเล็ก ๆ น้อย ๆ
มันเป็นภาพขนาดเล็กที่ผมซูมใน เมื่อสวยขนาดใหญ่เพื่อที่ฉันจะได้เห็นแต่ละ
แต่ละจุดหรือพิกเซล
ตอนนี้มันกลับกลายเป็นว่าเราสามารถเป็นตัวแทนของ จุดดำกับกล่าวว่าจำนวน 0
และจุดสีขาวที่มีหมายเลข 1
>> ดังนั้นในคำอื่น ๆ ถ้าคุณต้องการวาด ใบหน้าที่ยิ้มและบันทึกภาพในที่
คอมพิวเตอร์ก็พอเพียงที่จะเก็บศูนย์และ คนที่มีลักษณะเช่นนี้ที่ไหน
อีกคนที่เป็นสีขาว และศูนย์เป็นสีดำ
และร่วมกันถ้าคุณได้อย่างมีประสิทธิภาพมี คาดของคนและศูนย์ที่คุณมี
ตารางของพิกเซลและถ้าคุณวาง พวกเขาออกคุณมีน่ารัก
ใบหน้าที่ยิ้มเล็ก ๆ น้อย ๆ
ตอนนี้รูปแบบไฟล์บิตแมป, BMP, คือ ได้อย่างมีประสิทธิภาพที่อยู่ภายใต้ประทุน,
แต่มีพิกเซลมากขี้เมาที่คุณ จริงสามารถแสดงสี
>> แต่เมื่อคุณมีความซับซ้อนมากขึ้น รูปแบบไฟล์เช่น BMP และ JPEG และ GIF
ที่คุณอาจไม่คุ้นเคยเหล่านั้น ไฟล์บนดิสก์มักจะไม่เพียง แต่
มีศูนย์และคนสำหรับพิกเซล แต่ พวกเขามีข้อมูลบางส่วนเช่นกัน -
เมตาดาต้าในแง่ที่ว่าไม่ได้จริงๆ ข้อมูล แต่ก็มีประโยชน์ที่จะมีการ
ดังนั้นเขตข้อมูลเหล่านี้ที่นี่มีนัยว่าและ เราจะเห็นสิ่งนี้ในรายละเอียดใน P-ชุด
5 ว่าก่อนที่เลขศูนย์และคนที่ เป็นตัวแทนของพิกเซลในภาพ,
มีพวงของเมตาดาต้าที่ชอบ ขนาดของภาพและ
ความกว้างของภาพ
และสังเกตเห็นผมถอนขนออกไปบางส่วน สิ่งที่พลที่นี่ -
ความกว้างและความสูง
นับ Bit และบางสิ่งอื่น ๆ
เพื่อให้มีข้อมูลในแฟ้มบาง
>> แต่โดยการทำความเข้าใจวิธีการที่ไฟล์จะถูกวาง ออกมาในวิธีนี้คุณสามารถจริง
แล้วจัดการกับภาพ, กู้ภาพ จากดิสก์, ปรับขนาดภาพ
แต่คุณสามารถไม่จำเป็นต้อง เพิ่มพวกเขา
ผมจำเป็นต้องมีการถ่ายภาพ
ดังนั้นผมจึงเดินกลับไปที่อาร์เจนี่คนที่คุณเห็น บนหน้าจอค่อนข้างบางเวลาที่ผ่านมา
และถ้าฉันเปิดปราศรัยที่นี่นี้เป็น เกิดอะไรขึ้นถ้าคุณพยายามที่จะขยายสิ่งและ
เพิ่ม RJ
เขาไม่ได้รับการใด ๆ ที่ดีกว่าจริงๆ
ตอนนี้ Keynote เป็นชนิดของการทำให้เปรอะเปื้อนมัน นิด ๆ หน่อย ๆ เพียงเพื่อปัดสวะ
ความจริงที่ว่า RJ ไม่ได้รับโดยเฉพาะอย่างยิ่ง ที่เพิ่มขึ้นเมื่อคุณขยาย
และถ้าทำมันด้วยวิธีนี้ ดูสี่เหลี่ยม?
ใช่คุณแน่นอนสามารถมองเห็นได้ สแควร์โปรเจ็ก
>> นั่นคือสิ่งที่คุณได้รับเมื่อคุณเพิ่ม
แต่ในการทำความเข้าใจการ RJ ของเราหรือ ใบหน้าที่ยิ้มมีการใช้งานจะช่วยให้เรา
จริงเขียนรหัสที่ปรุงแต่ง สิ่งเหล่านี้
และฉันคิดว่าฉันสิ้นสุดในบันทึกนี้ด้วย 55 วินาทีของยกที่,
ผมกล้าพูดค่อนข้างทำให้เข้าใจผิด
>> [เล่นภาพวิดีโอ]
>> -เขาโกหก
เกี่ยวกับสิ่งที่ผมไม่ทราบ
>> -So สิ่งที่เรารู้
>> ที่เรย์ที่ 09:15 Santoya ที่ตู้เอทีเอ็ม
>> -ดังนั้นคำถามคือสิ่งที่ เขาทำถูกที่ 9:16?
>> ถ่ายภาพเก้ามิลลิเมตร ที่บางสิ่งบางอย่าง
บางทีเขาอาจจะเห็นมือปืน
>> หรือเป็นคนที่ทำงานกับเขา
>> รอ
กลับไปหนึ่ง
>> อะไรที่คุณไม่เห็น
>> -นำใบหน้าของเขาขึ้นเต็มหน้าจอ
>> แว่นตาของเขา
>> -มีการสะท้อนของ
>> -นั่นคือทีมเบสบอล Neuvitas
ที่โลโก้ของพวกเขา
>> -และเขาพูดอะไรกับใครก็ได้ สวมเสื้อแจ็คเก็ตที่
>> [เล่นวิดีโอจบ]
>> เดวิดเจลัน: นี้จะ จะตั้งปัญหา 5
เราจะเห็นคุณในสัปดาห์หน้า
>> SPEAKER Re: ตอนต่อไป CS50
>> [จิ้งหรีดร้อง]
>> [เล่นเพลง]