>> ลำโพง 1: สวัสดีทุกคน
พวกเราจะไปเริ่มต้น
ผมคิดว่าคนจะยังคง จะต้องมีการกรองใน
แต่ในความสนใจของเวลาเพื่อให้เราสามารถ ได้รับพวกคุณออกจากที่นี่ในเวลา
เรากำลังจะเริ่มต้น
เพื่อต้อนรับ CS50 คำถาม 0 ความคิดเห็นที่
สำหรับบรรดาของคุณที่ไม่ได้ตระหนักถึง แต่คุณมีคำถามในวันพุธที่
วูฮู
>> ถ้าคุณยังไม่ได้เริ่มเรียนหรือยัง ยังไม่ได้ตระหนักว่านี้มีอยู่ยัง
แบบทดสอบที่ผ่านมาและข้อมูลทั้งหมดที่เกี่ยวกับ การตอบคำถามของคุณอยู่ใน cs50.net/quizzes
มีบางสิ่งที่ดีงามอยู่ในที่นั่น แบบทดสอบที่ผ่านมาจากช่วง 10
ปีเช่นเดียวกับข้อมูล เกี่ยวกับการตอบคำถามนี้และหัวข้อ
ที่จะได้รับการคุ้มครอง
ดังนั้นขอเริ่มต้น
>> ดังนั้นพวกคุณอาจจะจำได้ว่าครั้งแรก วันของการเรียนดาวิดมีผู้ที่อยู่ในโคมไฟ
เพื่อเป็นหลักทุกอย่างที่จะไป ขึ้นภายใต้ประทุนของคอมพิวเตอร์เป็น
ทำในไบนารี
Binary หมายความว่าสิ่งที่มันเสียง เช่น 0 และ 1
มันมีอยู่สองค่าที่ สามารถแสดง
>> ดังนั้นเช่นเดียวกับในวันแรกของส่วน เมื่อเดวิดเปิดแสง
หลอดไฟที่จะเป็นตัวแทนในหรือ 1, เครื่องคอมพิวเตอร์ของเรา เข้าใจไบนารีที่เป็น 0 และ
1, หรือปิด
พื้นฐานของไบนารี
สถานที่ที่ทุกคนจะเป็นตัวแทนของ ในสองฐาน
เพื่อให้คุณเพิ่ม 2 0 เพื่อ 1 ถึง 2 ตลอดทางขึ้น
>> ในการคำนวณสิ่งที่คู่ของคุณคือการ ทศนิยมคุณเพียงทำตามสมการนี​​้
ประเภทสิ่ง
หากคุณมี 1 ในใด ๆ ของสถ​​านที่เหล่านั้น คุณคูณโดยสิ่งที่
ฐานมันอยู่ในเพิ่มขึ้นและ คุณจะได้รับทศนิยม
ดังนั้นนี่คือวิธีการที่คุณนับ ถึง 5 ในไบนารี
เช่นเดียวกับสิ่งที่เรากำลังทำใน สไลด์ที่ผ่านมานี้เป็นวิธีที่คุณจะ
แสดง 1 ถึง 5
>> ในทำนองเดียวกันเช่นเดียวกับคุณสามารถเพิ่มและ ลบในทศนิยมหรือฐาน 10 หรือ
จริงๆฐานใด ๆ ที่สามารถเพิ่ม และลบในไบนารี
สิ่งที่คุณจะคาดหวังเมื่อคุณ เพิ่มขึ้นสองถ้ามันมากขึ้นเท่ากับ
กว่า 1, คุณพก 1, ทำให้มันเป็น 0, และทำนอกจากนี้วิธีการที่เพียงแค่
เช่นคุณจะคาดหวังกับปกติ ทศนิยมหรือฐานอื่น ๆ
เย็น
>> ดังนั้นเหมือนที่ผมกล่าวว่าก่อนที่จะทุกอย่างที่ ไปในภายใต้ประทุนของคอมพิวเตอร์ของเรา
จะทำใน 0 และ 1 หรือเลขฐานสอง
ดังนั้นวิธีที่เราจะแสดงตัวอย่างเช่น ตัวอักษรหรือตัวเลขหรือตัวอักษรที่?
และคำตอบที่เป็น ASCII
>> ASCII คือการทำแผนที่ระหว่างตัวละคร ที่เรามักจะเห็นใน
ภาษาอังกฤษเหมือนของบี, ของ C, เน้น, ขีดกลางและ
อะไรอย่างนั้น
และแผนที่ที่ค่า ASCII
ค่า ASCII เป็นเพียงตัวเลขว่า สามารถเข้าใจได้โดยคอมพิวเตอร์ของคุณ
และเช่นเดียวกับที่คุณสามารถทำได้และนอกจากนี้ ลบกับตัวเลขที่คุณสามารถทำได้
พวกเขาด้วยค่า ASCII
>> ดังนั้นในตัวอย่างนี้สิ่งที่ นี้จะพิมพ์ออกมา?
ใช่เพียงแค่พื้นที่ B พื้นที่ C พื้นที่ D. ที่ไหนเมาส์ของฉันไป?
สังเกตเห็นว่าคุณสามารถกำหนด int ที่ 65
และเมื่อคุณพิมพ์ที่ออกมาใช้ ร้อยละ C ก็จะตีความว่าเป็น
ตัวอักษรและจะพิมพ์ออก A.
>> ในทำนองเดียวกันคุณสามารถประกาศ เป็นถ่าน
และเมื่อคุณพิมพ์ออกมาใช้ร้อยละ C ก็จะตีความว่าเป็น
ร้อยละดีและเช่นเดียวกับที่คุณสามารถเพิ่ม หมายเลขคุณสามารถเพิ่มตัวอักษร
ค่า ASCII ในกรณีนี้
>> ดังนั้นตัวชี้เล็ก ๆ น้อย ๆ สำหรับทุกคน
5 เป็นสตริงไม่ จริงเท่ากับ 5
ดังนั้นวิธีที่เราจะแปลง 5 ถึงสตริงจำนวนเต็ม 5?
ความคิดใด?
ใช่
>> ดังนั้นถ้าเรามี 5 เป็นสตริง เราสามารถลบ 0
และที่จะให้เรา 5
และในทำนองเดียวกันถ้าเรามี 5 เป็น จำนวนเต็มเพิ่มว่าสตริง 0
และที่ทำให้เราสตริง 5
เย็น
>> ตอนนี้จำกลับไปบรรยายที่หนึ่ง เราได้พูดคุยเกี่ยวกับอัลกอริทึม
ดังนั้นทำอย่างไรเราจริงต้องการให้คอมพิวเตอร์ ที่จะทำสิ่งที่น่าสนใจ?
คุณรู้ว่าเพียงแค่การเพิ่มและการลบ ตัวเลขและการพิมพ์สิ่งที่ออกไม่ได้
ที่น่าตื่นเต้นที่
ปกติเราต้องการให้คอมพิวเตอร์ของเราที่จะ ดำเนินการชนิดของขั้นตอนวิธีบางอย่าง
บางสิ่งบางอย่างที่ซับซ้อนมากขึ้นเล็กน้อย กว่าคณิตศาสตร์ง่ายๆเพียง
>> อัลกอริทึมเป็นเพียงขั้นตอนโดยขั้นตอนที่กำหนด ของคำแนะนำสำหรับวิธีการดำเนินการ
task-- บาง
เช่นเดียวกับสูตร
คุณอาจจะจำได้ว่าวันแรกของ ชั้นที่เดวิดได้เรานับห้องพัก
ของผู้คนและมีกี่คน อยู่ในห้อง
คุณอาจจะใช้ในการนับ หนึ่งโดยหนึ่ง
1, 2, 3, 4
ในกรณีที่อัลกอริทึมเวลาเชิงเส้น
>> แต่ดาวิดนำอัลกอริทึมสำหรับ คุณจะนับคนที่อยู่ในห้องพัก
ที่ทุกคนลุกขึ้นยืนคุณพูดของคุณ จำนวนให้กับบุคคลอื่นเพิ่มที่
จำนวนขึ้นและมีคนคนหนึ่งนั่งลง
และคุณย้ำว่า
นั่นเป็นประเภทหนึ่งของอัลกอริทึม
เราสามารถวิเคราะห์วิธีการที่มีประสิทธิภาพ อัลกอริทึมจะขึ้นอยู่กับว่าจะใช้เวลา
แต่เราจะพูดคุยนิด ๆ หน่อย ๆ เพิ่มเติมเกี่ยวกับที่มา
>> ดังนั้นทุกขั้นตอนวิธีนี้ยังสามารถ จะเขียนใน pseudocode
pseudocode เป็นเพียงภาษาอังกฤษเช่น ไวยากรณ์ที่ใช้ในการแสดง
การเขียนโปรแกรมภาษา
ตัวอย่างเช่นถ้าเราต้องการที่จะขอให้ผู้ใช้ การคาดเดาหมายเลขที่ชื่นชอบเรา
อาจมี pseudocode เช่น
>> ได้รับผู้ใช้เดา
ถ้าเดาถูกต้องบอกพวกเขา พวกเขากำลังถูกต้องอื่นบอกพวกเขา
พวกเขาไม่ได้ถูกต้อง
และ pseudocode เป็นวิธีการได้อย่างง่ายดาย ที่เป็นตัวแทนของความคิดหรืออัลกอริทึม
ดังนั้นตอนนี้เราอาจจะต้องการที่จะเขียนจริง ในภาษาที่คอมพิวเตอร์เครื่องนี้
อาจจะเข้าใจ
ดังนั้นเราสามารถเขียน pseudocode ของเราและ ตีความว่าเป็นรหัสแหล่งที่มา
>> เพื่อให้ห่างไกลโค้ดต้นฉบับจะต้องปฏิบัติตาม เพื่อไวยากรณ์บางอย่างของ
การเขียนโปรแกรมภาษา
และจนถึงขณะนี้ใน CS50 เราได้ ได้ใช้ส่วนใหญ่ค
ดังนั้นนี้อาจจะมีซอร์สโค้ดของค
ต่อมาในหลักสูตรที่คุณมาคืน ในการติดต่อกับโปรแกรมอื่น ๆ
ภาษาเช่น PHP
หรือถ้าคุณยังใช้เวลาเรียนอื่น ๆ คุณ อาจจะทำ Java, งูใหญ่หรือแม้แต่ OCML
แต่ในภาษาโปรแกรมคของเรานี้เป็น วิธีการที่เราอาจเขียนรหัสที่มาสำหรับ
อัลกอริทึม pseudocode ที่ ผมแค่อธิบายไว้ก่อนหน้า
>> ดังนั้นวิธีการของเครื่องคอมพิวเตอร์ของคุณจริง เข้าใจว่า?
เช่นฉันกล่าวว่าก่อนที่จะเท่านั้นจริงๆ ความเข้าใจในศูนย์และคน
ดังนั้นวิธีที่จะได้รับจากแหล่งที่มา รหัสเพื่อสิ่งที่สามารถ
เข้าใจ?
ดีเรามีบางสิ่งบางอย่าง ที่เรียกว่าคอมไพเลอร์
>> ถ้าคุณจำกลับมาในส่วนของคุณ psets คุณมีชนิดของโปรแกรมบางอย่าง
เขียนในคไฟล์จุด
แล้วคุณจะพิมพ์ให้
ดังนั้นสิ่งที่จะทำให้ทำอะไร
>> คุณสามารถพิมพ์ทำให้การรวบรวมของคุณ โปรแกรมเพราะ someone--
ใครก็ตามที่เขียนพีชุดของคุณ อาจ David--
สร้างไฟล์ให้
และที่บอกให้รู้ว่าการทำงานของคุณ คอมไพเลอร์ที่เรียกว่าเสียงดังกราว, จะว่า
แล้วรวบรวมรหัสต้นฉบับของคุณในการคัดค้าน รหัสซึ่งเป็นศูนย์และคน
ว่าคอมพิวเตอร์ของคุณเข้าใจ
แต่เล็ก ๆ น้อย ๆ ต่อมาในวันที่เราจะไป เพิ่มเติมในเชิงลึกเกี่ยวกับคอมไพเลอร์
>> ดังนั้นจำ pset 0, where-- ใช่ คุณมีคำถาม?
>> ผู้ชม: [ไม่ได้ยิน]
>> ลำโพง 1: ใช่
ผมคิดว่าพวกเขาเป็นจริง ควรจะออนไลน์
ใช่
>> ผู้ชม: มันเหมือน [ไม่ได้ยิน]
>> ลำโพง 1: มันไม่ได้เป็น
อยู่ใน cs50.net/quizzes
>> ผู้ชม: Slash แบบทดสอบการเฉือน 2013, เฉือน 0, และเพียงแค่คลิกผ่าน
แบบทดสอบ 2013 และตอบคำถาม 0, สไลด์ส่วนการตรวจสอบ
>> ลำโพง 1: ใช่ดังนั้นหากพวกคุณต้องการ ดึงมันขึ้นมาและมองไปที่มันด้วยตัวคุณ
คอมพิวเตอร์ของตัวเองที่ดีเกินไป
บอกว่าอีกครั้ง
>> ผู้ชม: [ไม่ได้ยิน]
>> ลำโพง 1: ใช่ [ไม่ได้ยิน] เป็นตัวแปรดัมมี่
โอ้ใช่?
>> ผู้ชม: [ไม่ได้ยิน]
>> ลำโพง 1: ไม่มีการนัดหยุดงาน ไม่ได้ในการสอบ
ขออภัยคำถามของเธอก็คือเป็น การนัดหยุดงานในการสอบ
และมันไม่ได้
ดังนั้น pset 0, พวกคุณควรจะมีทั้งหมด ดำเนินการบางอย่างโดยใช้รอยขีดข่วน
และเราได้เรียนรู้บางการเขียนโปรแกรมขั้นพื้นฐาน การสร้างบล็อกโดยใช้รอยขีดข่วน
>> ดังนั้นลองมาดูที่บางส่วน ของการก่อสร้างตึกเหล่านี้
ที่ทำขึ้นโปรแกรม
แรกคือนิพจน์บูลีน
สำนวนที่บูลีนเป็นคนและ 0 หรืออะไรที่มี
สองค่าที่เป็นไปได้
ในกรณีนี้จริงหรือเท็จ หรือปิดและใช่หรือไม่
ตัวอย่างของการที่ง่ายและง่ายมาก, โปรแกรมที่ใช้บูลีน
การแสดงออกที่นี่
>> ดังนั้นเพื่อให้การแสดงออกบูลีนไป เป็นประโยชน์เรามีผู้ประกอบการบูลีน
เหล่านี้เป็นผู้ประกอบการที่สามารถใช้ เพื่อเปรียบเทียบค่าบางอย่าง
เพื่อให้เรามีหรือไม่เท่ากับน้อย มากกว่าหรือเท่ากับ, มากกว่าหรือ
เท่ากับและน้อยกว่า หรือมากกว่า
แต่ผู้ประกอบการเหล่านี้ไม่ได้มีประโยชน์มาก หากเราไม่สามารถรวมพวกเขาเป็น
เงื่อนไข
>> ดังนั้นพวกคุณอาจจะจำได้ว่าตั้งแต่เริ่มต้น และจากพีของคุณกำหนดว่าเรา
มีเงื่อนไข
พวกเขาจะเป็นหลักเช่นเดียวกับส้อมใน ตรรกะของโปรแกรมของคุณที่
ดำเนินการขึ้นอยู่กับว่า สภาพจะพบ
ดังนั้นหนึ่งในเงื่อนไขที่เรามี ใช้หลายครั้งในหลักสูตรนี้เป็น
ถ้าอื่นหากการและเงื่อนไขอื่น
>> นี่คือตัวอย่างของวิธีการที่เป็น คุณอาจใช้ที่
ไม่มีใครทราบความแตกต่างระหว่าง เพียงแค่ใช้ถ้างบทั้งหมด
ทางลงกลอนถ้าอื่นที่ ถ้าและอื่น ๆ รวมกัน?
ใช่?
>> ผู้ชม: [ไม่ได้ยิน]
>> ลำโพง 1: แน่นอน
ดังนั้นถ้าผมมีถ้าทุกทางลงนี้ วิธีที่แม้ว่าสภาพนี้ผลตอบแทน
จริงก็จะยังคงดำเนินการต่อไป การทดสอบอีกสอง
ในขณะที่มีคนอื่นถ้าอื่น คำสั่งหากผลตอบแทนจริง
คนอื่น ๆ จะไม่ได้รับการทดสอบ
คำถามใด ๆ เกี่ยวกับที่?
เย็น
>> เพื่อให้คุณใช้ถ้า-อื่นของอื่น คำสั่งถ้าคุณรู้ว่ามันสามารถเฉพาะ
เป็นหนึ่งในกรณีเหล่านี้
ดังนั้นเรารู้ว่าถ้า x น้อยกว่า 0 มันเป็น แน่นอนไม่ได้ไปเป็น
มากกว่า 0
>> ถัดไปบล็อกอาคารอื่น ที่เราได้เรียนรู้เป็นลูป
เรามีสามประเภทของลูป
สำหรับลูปในขณะที่ลูป และทำในขณะที่ลูป
และโดยทั่วไปเมื่อคุณนั่งลง เขียนสิ่งที่คุณต้องตัดสินใจ
ที่สามที่คุณต้องการใช้
ดังนั้นเราจะตัดสินใจที่หนึ่ง?
>> โดยทั่วไปเราใช้สำหรับห่วงถ้าเรารู้ กี่ครั้งที่เราต้องการที่จะย้ำ
ผ่านสิ่งที่หรือวิธีการหลายครั้ง เราต้องการที่จะดำเนินงาน
ที่เราใช้ในขณะที่ลูปถ้าเราต้องการบางอย่าง เงื่อนไขที่จะเป็นจริงเพื่อให้ทำงาน
และเราใช้ทำในขณะที่คล้ายกับ ในขณะที่ แต่เราต้องการรหัสของเราที่จะทำงานที่
อย่างน้อยหนึ่งครั้ง
>> เพื่อทำในขณะที่สิ่งที่อยู่ในสิ่งที่ต้องทำจะ มักจะใช้เวลาอย่างน้อยหนึ่ง
ในขณะที่มีในขณะนั้น อาจไม่ทำงานเลยถ้า
สภาพไม่พอใจ
คำถามใด ๆ กับที่?
>> ดังนั้นโครงสร้างของห่วง
พวกคุณทุกคนได้เห็นนี้
คุณเริ่มต้นมัน
คุณมีชนิดของเงื่อนไขบางอย่าง
ดังนั้นสำหรับตัวอย่างเช่นเราอาจจะเริ่มต้น สำหรับผมเท่ากับ 0
i คือน้อยกว่า 10
และ i ++
หนึ่งที่ง่ายมากที่เราเคยทำมา
>> สำหรับวงในขณะที่เหมือนกันคุณมี จะมีชนิดของการเริ่มต้นบางอย่าง
บางชนิดของสภาพและ ชนิดของการปรับปรุงบางส่วน
เพื่อให้เราสามารถดำเนินการของเรายังห่วง เป็นห่วงในขณะที่การใช้นี้
และเช่นเดียวกันกับสิ่งที่ต้องทำในขณะที่ห่วง เราอาจจะมีการเริ่มต้นบางอย่าง
สิ่งที่ดำเนินการปรับปรุงมันและ จากนั้นตรวจสอบสภาพ
>> ฟังก์ชั่นดังนั้นตอนนี้
เราใส่ทุกอย่างเข้าด้วยกัน
เราอาจต้องการที่จะเขียนบาง ชนิดของฟังก์ชั่น
ฟังก์ชั่นทั่วไปที่คุณอาจจะ ได้เห็นแล้วเป็นหลัก
ที่สำคัญคือฟังก์ชั่น
แต่ก็มีประเภทกลับ int
มันมีชื่อฟังก์ชันหลัก
และมีข้อโต้แย้ง argc และ argv
ดังนั้นหลักเป็นเพียงฟังก์ชั่น
>> ฟังก์ชั่นอื่น ๆ ที่คุณอาจจะมีการใช้ printf printf-- เป็นฟังก์ชัน
GetInt, ToUpper
แต่สิ่งเหล่านี้เกิดขึ้นจะได้รับการ นำมาใช้สำหรับเรา
ชนิดของห้องสมุดบางส่วน
ถ้าพวกคุณจำรวมทั้ง นี้ห้องสมุด CS50.h หรือ
มาตรฐาน I / O ห้องสมุด
ใช่คำถาม?
>> ผู้ชม: เป็นหลักเพียงแค่อยู่ในค?
ไม่ได้เพียงชนิดของ [ไม่ได้ยิน]
>> ลำโพง 1: คำถามคือ ถ้าหลักมีอยู่ในค
และใช่การทำงานทั้งหมด มีหน้าที่หลัก
เป็นชนิดของสิ่งที่จำเป็นสำหรับคอมพิวเตอร์ ที่จะทราบว่าจะเริ่มต้น
ใช้รหัส
>> ผู้ชม: ดังนั้นคุณจะไม่ [ไม่ได้ยิน]
>> ลำโพง 1: เลขที่
หากมีปัญหาอื่น ๆ
เย็น
เช่นดังนั้นเพียงแค่คุณสามารถใช้ฟังก์ชัน ที่เขียนขึ้นสำหรับคุณคุณยังสามารถ
เขียนฟังก์ชันของคุณเอง
นี่คือหน้าที่ที่ใครบางคนอาจจะ ได้เขียนในการคำนวณปริมาณ
คิวยกตัวอย่างเช่น
มีประเภทกลับเป็นที่นี่ในกรณีนี้ int, คิวชื่อฟังก์ชันของเราและของเรา
รายการของพารามิเตอร์
>> และทราบว่าคุณมีการเขียนข้อมูล ประเภทของพารามิเตอร์ที่คุณต้องการ
ใช้หรืออื่น ๆ ฟังก์ชั่นไม่ได้ ทราบชนิดของ
พารามิเตอร์ที่ฉันควรจะยอมรับ
ดังนั้นในกรณีนี้เราต้องการ จำนวนเต็มเป็นอินพุทของเรา
ดังนั้นทำไมเราอาจต้องการที่จะใช้ฟังก์ชั่น?
>> แรกของทั้งหมดที่ดีสำหรับองค์กร
พวกเขาช่วยทำลายรหัสของคุณลง ระเบียบมากขึ้นและทำให้ชิ้น
มันง่ายต่อการอ่าน
ความเรียบง่าย
นี้เป็นสิ่งที่ดีสำหรับการออกแบบ
เมื่อคุณกำลังอ่านชิ้นส่วนของรหัส และฟังก์ชั่นหลักคือจริงๆ
นานจริงๆมันอาจจะยากที่จะ เหตุผลเกี่ยวกับสิ่งที่เกิดขึ้น
ดังนั้นหากคุณทำลายมันลงไปในฟังก์ชั่น มันอาจจะง่ายต่อการอ่าน
และนำมาใช้ความสามารถ
หากคุณมีก้อนของรหัสที่เป็น เรียกว่าหรือเรียกใช้หลายครั้ง
แทนการเขียนใหม่รหัสที่ 10 ครั้ง ในการทำงานหลักของคุณคุณอาจจะ
ต้องการที่จะนำมาใช้ใหม่
แล้วทุกครั้งที่คุณจำเป็นต้องใช้ว่า ชิ้นส่วนของรหัสเรียกใช้ฟังก์ชัน
>> ดังนั้นตอนนี้ถ้าเราจำได้ว่ากลับไปเริ่มต้น เรายังพูดคุยเกี่ยวกับแนวความคิดไม่กี่
ซึ่งหนึ่งในนั้นเป็นเกลียว
ด้ายเป็นแนวคิดของหลาย ลำดับของรหัส
การดำเนินงานในเวลาเดียวกัน
ดังนั้นคิดว่ากลับไปวันหนึ่งที่ดาวิดมี พวกคุณออกนับจำนวน
คนในห้อง
>> โดยพื้นฐานแล้วสิ่งที่เกิดขึ้น ที่มีทั้งหมดของพวกคุณอยู่
ใช้หัวข้อที่แยกต่างหาก
และหัวข้อที่ได้มาร่วมกัน ที่จะได้รับชนิดของคำตอบบางอย่าง
ในทำนองเดียวกันใน Scratch เมื่อคุณมี สไปรท์หลายท่านอาจจะ
มีแมวและสุนัข
และพวกเขาจะพร้อมกัน การเรียกใช้สคริปต์ของตัวเอง
นั่นคือตัวอย่างของเกลียว
>> และแนวความคิดอื่น ๆ ที่เป็น นำมาใช้ในเหตุการณ์ที่เกิดขึ้นเป็นรอยขีดข่วน
และเหตุการณ์ที่เกิดขึ้นเมื่อหลายส่วนของ รหัสของคุณสื่อสารกับแต่ละอื่น ๆ
ใน Scratch นี้ก็คือตอนที่คุณใช้ การควบคุมการออกอากาศและเมื่อฉัน
ได้รับบล็อก
>> และยังอยู่ในปัญหาชุดที่ 4 เราเห็น นิด ๆ หน่อย ๆ ของเหตุการณ์ที่เกิดขึ้นได้เป็นอย่างดี
พวกคุณอาจจะได้ใช้ ห้องสมุด Gevent
และมีฟังก์ชั่น waitForClick ที่คุณกำลังรอ
สำหรับผู้ใช้ที่คลิก
และคลิกของคุณในกรณีนี้จะเป็น เหตุการณ์และรอการคลิกของคุณเป็น
จัดการเหตุการณ์
>> และยังทำงานอยู่ตลอด psets ของคุณ และการทำงานใน psets ของคุณคุณ
อาจจะได้เข้ามาติดต่อกับ บางส่วนของคำสั่งเหล่านี้
นี่คือสิ่งที่คุณพิมพ์ลงในของคุณ หน้าต่าง terminal หรืออะไรก็ตามที่หน้าต่าง
ที่ปรากฏขึ้นบนกรัมแก้ไขของคุณไป เป็นหลักนำทางคอมพิวเตอร์ของคุณ
>> ดังนั้นสำหรับตัวอย่างเช่น LS แสดง เนื้อหาของไดเรกทอรี
ไดเรกทอรีให้สร้างโฟลเดอร์ใหม่
ซีดีเปลี่ยนไดเรกทอรี
RM ลบลบไฟล์ หรือไดเรกทอรีบาง
แล้วลบไดเรกทอรี เอาไดเรกทอรี
>> ผู้ชม: [ไม่ได้ยิน]
>> ลำโพง 1: ใช่แน่ใจว่า
ขออภัยคำถามคือถ้าคุณ ขอแนะนำให้วางนี้
ในแผ่นโกง
มันอาจช่วยให้
หากคุณมีห้องพักคุณสามารถวางมันลงบน
นอกจากนี้ยังเป็นโดยทั่วไปเพียงแค่ดีพอ ที่จะจำได้เพราะเมื่อคุณใช้มัน
คุณอาจต้องการเพียงแค่ มีมันจำ
ที่จะทำให้ชีวิตของคุณง่ายขึ้นมาก
ฉันไม่ตอบคำถามของคุณ?
>> ดังนั้นตอนนี้เราได้พูดคุยนิด ๆ หน่อย ๆ สั้น ๆ เกี่ยวกับห้องสมุด
แต่ทั้งสองคนหลักที่เราได้รับ ใช้เพื่อให้ห่างไกลในหลักสูตรที่มี
มาตรฐาน I / O และ CS50
ชนิดของสิ่งที่จะถูกรวม ใน I / O ห้องสมุดมาตรฐาน?
>> ใช่จนถึงขณะนี้เราได้ใช้ printf
ใน CS50 เราเคยใช้ GetInt และ GetString
และสตริงชนิดข้อมูลยังเกิดขึ้น ที่จะได้รับการประกาศในห้องสมุด CS50 นี้
เราจะพูดน้อยมากในเชิงลึกเกี่ยวกับ วิธีห้องสมุดทำงานและวิธีที่พวกเขา
มีปฏิสัมพันธ์กับส่วนที่เหลือของรหัสของคุณ
แต่ผู้ที่มีสองคนหลักที่เรา ได้เข้ามาติดต่อกับเพื่อให้ห่างไกลใน
แน่นอน
>> ประเภท
เหล่านี้เป็นสิ่งที่ดีที่จะจำได้ว่า แต่ละประเภทเป็นตัวแทนจากหรือวิธี
ไบต์แต่ละชนิดหลาย requires--
int 4 ไบต์; ถ่าน, 1 ไบต์
Float คือ 4 ไบต์
อะไรคือสิ่งที่สองหรือไม่
>> ผู้ชม: [ไม่ได้ยิน]
>> ลำโพง 1: ใช่ดังนั้นลอย แต่เป็นสองเท่าของขนาด
สิ่งที่เกี่ยวกับความยาว?
>> ผู้ชม: [ไม่ได้ยิน]
>> ลำโพง 1: ตกลง
อะไรคือสิ่งที่นาน?
>> ผู้ชม: [ไม่ได้ยิน]
>> ลำโพง 1: ใช่สอง int
ใช่
>> ผู้ชม: [ไม่ได้ยิน]
>> ลำโพง 1: [ไม่ได้ยิน]
แล้วนานเป็นสองเท่า
>> ผู้ชม: ไม่ไม่
ยาวเป็นเพียง int
มันขึ้นอยู่กับสถาปัตยกรรม ก่อน [ไม่ได้ยิน]
และ int มีขนาดเดียวกัน
[ไม่ได้ยิน]
>> ลำโพง 1: ดังนั้นยาวและ int เหมือนกัน
แล้วนาน เป็นสองเท่า int
เย็น
และแล้วสิ่งที่เป็นประเภทสุดท้าย?
>> ผู้ชม: ตัวชี้
>> ลำโพง 1: ใช่เพื่อให้เราได้เรียนรู้ นิด ๆ หน่อย ๆ เกี่ยวกับตัวชี้
และคำนึงถึงสิ่งที่ชี้เป็น ชี้ยา่มันอาจจะเป็นดาวถ่าน
หรือ int star--
มันเสมอ 4 ไบต์สำหรับตัวชี้
คำถามเกี่ยวกับที่?
ใช่?
>> ผู้ชม: [ไม่ได้ยิน]
>> ลำโพง 1: ดังนั้นยาวและ int เป็น เดียวกันในเครื่อง CS50 นี้
>> ผู้ชม: เครื่องจะสมบูรณ์ ใช้แทนกันได้
>> ลำโพง 1: ใช่
ดังนั้นแล้วนานเป็นสองเท่า int
>> ผู้ชม: นี่คือ 32 bit?
>> ลำโพง 1: 32 บิตใช่
>> ผู้ชม: ดังนั้น [ไม่ได้ยิน]
>> ลำโพง 1: ใช่ถ้ามันไม่ได้ อย่างชัดเจนว่าคุณ
ต้องถือว่า 32 บิต
>> ผู้ชม: มันจะพูดอะไรบางอย่าง เช่นสมมติว่า
สถาปัตยกรรมเช่นเครื่องใช้ไฟฟ้า
64 บิตสิ่งเดียวที่ การเปลี่ยนแปลงมีความปรารถนาและตัวชี้
พวกเขาทั้งสอง [ไม่ได้ยิน]
>> ลำโพง 1: ใช่?
>> ผู้ชม: คำถาม
ดังนั้นในหนึ่งของการปฏิบัติแบบทดสอบ, จะถามเกี่ยวกับ int ลงนาม
ดังนั้นวิธีการที่จะได้รับการพิจารณาว่า จาก int [ไม่ได้ยิน]?
>> ลำโพง 1: ลงนาม ในนี้ยังมี 4 ไบต์
แต่สิ่งที่แตกต่างกันเกี่ยวกับการลงนามใน int และ int ลงนาม?
>> ผู้ชม: [ไม่ได้ยิน]
>> ลำโพง 1: ขวา
หนึ่งสามารถเป็นตัวแทนของค่าลบ
แต่วิธีการที่ไม่ได้ทำที่?
>> ผู้ชม: [ไม่ได้ยิน]
>> ลำโพง 1: ใช่มันช่วยประหยัด 1 บิตที่จะเป็นตัวแทนเข้าสู่ระบบ
ลงนามมีหนึ่งบิตที่ แสดงให้เห็นถึงสัญญาณที่
และลงนามเพียงแค่เป็นบวกทั้งหมด
>> ผู้ชม: OK
เพื่อให้คุณบอกว่าสองเป็น สองเท่าของขนาดของลอย?
>> ลำโพง 1: ดับเบิ้ลเป็นสองเท่า ขนาดของลอยใช่
>> ผู้ชม: วิธีการที่ไม่ชี้ ไปนาน [ไม่ได้ยิน]
>> ลำโพง 1: ดังนั้นคำถามคือวิธีการที่ไม่ ตัวชี้ไปยัง long-- ยาว
วิธีการที่ว่ามีเพียงสี่ไบต์เมื่อ นาน 8 ไบต​​์ของ
ดังนั้นอย่าลืมสิ่งที่เป็นตัวชี้ เป็นหลักมูลค่าพื้นฐานมาก
>> ผู้ชม: [ไม่ได้ยิน]
>> ลำโพง 1: ใช่ดังนั้นตัวชี้ เป็นเพียงสถานที่ตั้งหน่วยความจำ
ดังนั้นมันไม่สำคัญว่าพื้นที่เท่าใด ตัวชี้ที่ชี้ไปที่
เพียงต้องการไบต์ที่ 4 เพื่อติดตาม สถานที่ตั้งของหน่วยความจำที่
หากมีปัญหาอื่น ๆ
เย็น
>> ดังนั้นสิ่งสุดท้ายที่ฉันมี เป็นออกมาตรฐาน
คุณควรจะใช้พวกเขาบ่อย พอที่จะทำให้คุณสามารถจำได้
แต่นี้คือเมื่อเราใช้ printf ตัวอย่างเช่น
และเรามีตัวยึดตำแหน่งเหล่านี้ที่ ถูกเรียกว่าโค้ดรูปแบบ
>> ดังนั้นร้อยละคถ่านร้อยละฉันสำหรับ int, และเรายังสามารถใช้ร้อยละง
มันเป็นสิ่งเดียวกัน
แต่โดยทั่วไปใน CS50 เรา พยายามที่จะใช้ฉันเป็นร้อยละ
ร้อยละฉสำหรับลอย
LD ร้อยละนานยาวและ ร้อยละสำหรับการสตริง
>> ในทำนองเดียวกันเราได้ใช้ไม่กี่ ของลำดับหนีเหล่านี้
ตัวอย่างเช่น n เครื่องหมายสำหรับบรรทัดใหม่
นี้เป็นเพียงสำหรับเมื่อคุณกำลังจัดรูปแบบ รหัสของคุณสำหรับการพิมพ์ฉ
ใช่?
>> ผู้ชม: อะไรคือร้อยละงใช่หรือไม่
>> ลำโพง 1: ดังนั้นคำถาม จะเป็นสิ่งที่ดีสำหรับร้อยละ?
ร้อยละงสำหรับ ints
ร้อยละงและร้อยละฉันเหมือนกัน
>> ผู้ชม: อะไรคือความแตกต่างระหว่าง n เครื่องหมายและเครื่องหมาย R?
>> ลำโพง 1: ดังนั้นคำถามคือสิ่งที่ ความแตกต่างระหว่าง n ฟันเฟืองและ
ฟันเฟือง R?
ผมคิดว่าเครื่องหมาย R ค่าเท่าใด
>> ผู้ชม: ดังนั้นเครื่องหมายอาร์เพียงหมายถึง กลับไปที่จุดเริ่มต้นของบรรทัด
โดยไม่ต้องจริงจะขึ้นบรรทัดใหม่
ดังนั้นถ้าคุณพิมพ์เครื่องหมาย R และคุณ กลับไปที่จุดเริ่มต้นของบรรทัด
แล้วคุณพิมพ์สิ่งที่มากขึ้นคุณเขียนทับ สิ่งที่มีอยู่แล้วใน
[ไม่ได้ยิน]
ในขณะที่ n จริงไปที่ใหม่ สายและไป [ไม่ได้ยิน]
>> ลำโพง 1: ดีคำถามอื่น ๆ ?
ขวาทั้งหมด
ฉันจะส่งมันออกไป และที่จะดำเนินต่อไป
>> [APPLAUSE]
>> DAN: righty ทั้งหมด
ดังนั้นฉันจะพูดคุยเกี่ยวกับความกว้างอีก ช่วงของความคิดจากชั้นเรียนที่มี
ๆ ตัวแทนของสัปดาห์ที่สองและ จุดเริ่มต้นของสัปดาห์ที่สามเริ่มจาก
กับการคัดเลือกนักแสดงซึ่งเป็นเพียงวิธีการ การรักษาค่าของบางประเภทเป็น
ค่าของชนิดที่แตกต่างกัน
เพื่อให้เราสามารถทำเช่นนี้กับตัวอักษรที่จะ ints ลอยไป ints และ
ปรารถนายาวเป็นสองเท่า
>> ทุกสิ่งเหล่านี้สามารถใช้เป็นวิธี ของการรักษาบางค่าที่เป็นตัวเลข
ถ่านลบอื่น ๆ บาง ค่าตัวเลข
ดังนั้นจึงมีปัญหาบางอย่างกับเรื่องนี้ของ แน่นอนที่มาเมื่อคุณโยน
สิ่งที่ต้องการลอยไป ints
ดังนั้นนี่คือแปลกเล็กน้อย
เรามีลอยที่ 1.31
เราคูณด้วย 10,000
แล้วเราพิมพ์เป็น int
ไม่ออกนี้คืออะไร?
10,000 ครั้ง 1.31
ดังนั้น 13,000 เป็นที่คาดเดาหรือไม่
>> ผู้ชม: ฉันคิดว่ามันเป็น 10,000
>> DAN: ดังนั้นฉันคูณ 10,000 ก่อนที่ฉันหล่อมัน
>> ผู้ชม: โอ้
จะไม่ได้มีเป็นหนึ่งใน 9 และบาง 0 หมายเลข?
>> DAN: คุณอาจมีบางตัวเลขแปลก
ดังนั้นตอนนี้มันเป็น 1.3 เท่า 10,000
เพื่อให้เป็น 13,000
และนี่ weird-- พิเศษ
>> ผู้ชม: 13,100
>> DAN: 13,100
ขอบคุณร็อบ
และนี่ weirdness-- พิเศษ
นี้ 9,9--
เป็นเพียงเพราะหล่อนี้ จบลงด้วยการปัดเศษลงที่
มันไม่ควรมี
ใช่
>> ผู้ชม: หล่อที่เกิดขึ้น หลังจากที่อะไรอีกหรือไม่
>> DAN: ดังนั้นเพราะฉันมีนี้ในการพิมพ์มัน ไม่คูณนี้ก่อนที่จะ
ไม่หล่อนี้
>> ผู้ชม: [ไม่ได้ยิน]
>> DAN: ผมคิดว่ามันจะโยนครั้งแรก ใช่ซึ่งจะเป็น 10,000
อะไรอีกหรือไม่
เย็น
ดังนั้นนี่คือ 13,099
ทำไมนี้เกิดขึ้นได้อย่างไร
ไม่แน่ชัด
>> ลอยจะไม่สมบูรณ์แบบ
พวกเขาสามารถที่จะแสดงตัวเลข จำนวนหนึ่งของตัวเลขที่มีนัยสำคัญ
ดังนั้นหากเราพิมพ์ออกมา 8 มะเดื่อ sig ที่ ลอยนี้เราได้รับชนิดของ
น่าเกลียดมองตัวเลข
และที่เพราะ 1.31 ไม่สามารถถูกต้อง จะแสดงโดยง่าย
อำนาจของสองในเครื่อง
ดังนั้นมันจะจบลงด้วยการที่อยู่ใกล้ที่สุด เดาซึ่งสิ้นสุด
เป็นเพียงเล็กน้อยต่ำ
ทำให้รู้สึก?
ตกลง
>> ตอนนี้เปลี่ยนเป็นวิธีที่แตกต่างกันของ ทำงบเงื่อนไขที่ทุก
เราดูแลเกี่ยวกับการเป็นตัวแปรเดียว
ดังนั้นในตัวอย่างนี้โดยเฉพาะเราไม่ รับจำนวนเต็มจากผู้ใช้
แล้วเรากำลังมองหาที่ สิ่งที่เป็นจำนวนเต็ม
สันนิษฐานว่ามันเป็นจำนวน ระหว่างหนึ่งและสี่
นั่นคือสิ่งที่เรากำลังถามหา
>> เพื่อให้คุณทำสวิทช์ของ ชื่อตัวแปร
จากนั้นคุณตั้งขึ้นกรณีที่เป็นไปได้ ค่าที่มันอาจจะ
ดังนั้นกรณีหนึ่งบอกว่ามันเป็นต่ำ
แล้วคุณหยุดที่จะได้ออก สภาพของสวิทช์เพื่อให้
คุณไม่ได้ให้ไป
>> ใน case-- ต่อไป
ดังนั้นกรณีที่สองและกรณี three--
ถ้าเป็นกรณีที่สองมันเป็นเพียงแค่หยดลงไป บรรทัดแรกของรหัสที่เห็นเช่นเดียวกับ
กรณีที่สามจนกว่าจะเห็นการทำลาย
ดังนั้นเหตุผลที่คุณจะได้รับกรณีที่หนึ่งไปยัง เพียงพิมพ์ต่ำเป็นเพราะฉัน
มีการหยุดพักที่นี่
ถ้าผมพูดไม่สนใจ break-- นี้ ถ้าฉันโยน breakaway-- นี้
มันจะพิมพ์ที่ต่ำและจากนั้นมันจะ พิมพ์กลางและแล้วมันจะทำลาย
>> ดังนั้นการหยุดพักเป็นส่วนสำคัญ ของสวิทช์และเงื่อนไข
พวกเขาควรจะมี
กรณีใด ๆ ที่ไม่ได้ระบุไว้อย่างชัดเจน ได้รับการจัดการโดยค่าเริ่มต้น
ในกรณีที่สวิทช์และควรจะโยน
>> ผู้ชม: ดังนั้น 1, 2, 3, และ 4 จะเป็น n?
>> DAN: ค่าที่ n สามารถ
ใช่
ใช่?
>> ผู้ชม: ดังนั้นเมื่อคุณมี ที่ [ไม่ได้ยิน]
>> DAN: คุณจะพิมพ์ต่ำแล้ว มันจะพิมพ์กลางและ
แล้วมันจะทำลาย
>> ผู้ชม: ทำไมมันจะพิมพ์ กลางหาก [ไม่ได้ยิน]
>> DAN: ดังนั้นทุกอย่างภายใต้กรณี ก่อนที่จะแบ่งตกอยู่ภายใต้
ดังนั้นกรณีที่พิมพ์เป็นกรณีที่อยู่ภายใต้ หนึ่งตามที่เป็นอยู่นี้พิมพ์ต่อไปนี้
ใช่?
>> ผู้ชม: [ไม่ได้ยิน]
>> DAN: ดังนั้นตัวเลขนี้เป็นเพียงโดยเฉพาะอย่างยิ่ง ค่าที่ตัวแปรนี้
สามารถใช้ใช่มั้ย?
ไม่ว่าทำให้รู้สึก?
ใช่
>> ผู้ชม: [ไม่ได้ยิน]
>> DAN: ใช่กรณีที่สองจะพิมพ์ ตรงกลางแล้วหยุดพัก
>> ผู้ชม: [ไม่ได้ยิน]
>> DAN: ผมคิดว่าอะไรบ้าง
สิ่งที่ชนิดข้อมูลอื่น ๆ คุณสามารถสลับไป?
>> ผู้ชม: คุณสามารถสลับ กว่าชนิดของข้อมูลใด ๆ
แต่มันหมายถึงอะไรมากกว่าตัวอักษร และ ints และสิ่งที่ต้องการว่าเพราะ
ถ้าคุณกำลังเปลี่ยนไปชี้ ที่ไม่จริงทำให้รู้สึก
เปลี่ยนไปโหลดถ้ามันยังให้ คุณทำอย่างนั้นเพราะจุดลอย
ในความแม่นยำที่คุณจะไม่ได้จริงๆ ต้องการที่จะทำต่อไปว่า
ดังนั้นสวยมากเพียง ints และ ตัวอักษรและสิ่งที่ต้องการที่
>> DAN: ใช่มันเมื่อคุณมีอย่างชัดเจน ค่าที่คุณรู้ว่าผมคิดว่าอาจจะเป็น
สวิทช์ที่มีประโยชน์จริง
ดีหรือไม่?
ตกลง
>> ขอบเขตเป็นช่วงที่ประกาศ ตัวแปรขยาย
ดังนั้นในก้อนเล็ก ๆ น้อย ๆ ของรหัสฉันมี มันจะเต็มไปด้วยข้อผิดพลาด
และเหตุผลที่ผมประกาศ int นี้ ฉันอยู่ในขอบเขตนี้สำหรับวง
แล้วฉันพยายามที่จะอ้างอิงที่ ฉันนอกที่ขอบเขตห่วง
>> ดังนั้นโดยทั่วไปคุณสามารถคิดเกี่ยวกับขอบเขต เป็นอะไรที่คุณประกาศ
ที่มีอยู่ภายในชุดของวงเล็บปีกกาเท่านั้น อยู่ภายในวงเล็บปีกกาที่
และถ้าคุณพยายามและใช้ตัวแปรที่ ด้านนอกของวงเล็บปีกกาที่คุณจะ
ได้รับข้อผิดพลาดจากคอมไพเลอร์
ใช่?
>> ผู้ชม: ดังนั้นหนึ่งนี้ไม่ได้ทำงานหรือไม่
>> DAN: นี้ไม่ได้ผลใช่
สตริง
สตริงถ่าน *
พวกเขากำลังตรงเดียวกัน
พวกเขาเป็นเพียงตัวชี้ไปยังตัวอักษร
และสตริงใด ๆ ที่คุณมีควรจะจบ ด้วยเครื่องหมายทับขวาศูนย์ซึ่งเป็นเพียง
คการประชุม
>> มันถูกเรียกว่าเทอร์มิโมฆะ
และ NULL--
เงินทุนยังไม่มีทุน U เมืองหลวง L, ทุน L--
ไม่ได้เช่นเดียวกับ Terminator โมฆะ
นี้เป็นตัวชี้
นี้เป็นตัวละคร
พวกเขามีความแตกต่างกันมาก
จำได้
มันจะเป็นแบบทดสอบที่อาจจะ
ผมยังไม่ได้เห็นแบบทดสอบ
ใช่?
>> ผู้ชม: ดังนั้นเป็นโมฆะพูดตัวชี้?
>> DAN: ใช่
>> ผู้ชม: อะไร [ไม่ได้ยิน]
>> DAN: ถ้าพูด malloc เรียกว่าเมื่อคุณ ไม่ได้มีหน่วยความจำเพียงพอที่จะได้รับ
อะไรขนาดที่คุณกำลังถามหา malloc จะกลับมาเป็นโมฆะ
มันเป็นโดยทั่วไปเมื่อใดก็ตามที่ฟังก์ชั่นเป็น ควรจะกลับชี้คุณ
จำเป็นต้องตรวจสอบกับโมฆะเพราะ เป็นโมฆะ good-- สวย
มันเรียงลำดับของค่าขยะ
มันเป็นศูนย์เท่าที่ชี้ไป
>> เมื่อใดก็ตามที่คุณเรียกฟังก์ชัน กลับชี้ว่า
คุณจะต้องการที่จะตรวจสอบให้ แน่ใจหรือว่าตัวชี้ที่ไม่เป็นโมฆะ
เพราะเป็นโมฆะเป็นเรื่องธรรมดามาก
มันเรียงลำดับผลตอบแทนขยะ
ดังนั้นหากสิ่งที่ไม่ได้ไปขวา เพียงแค่กลับ NULL แทน
>> ผู้ชม: [ไม่ได้ยิน]
>> DAN: ใช่และที่นี้
>> ผู้ชม: [ไม่ได้ยิน]
>> DAN: สะกดมันเช่นนี้
มันเป็นเทอร์มิโมฆะ
มันเป็นตัวพิมพ์เล็ก N-U-L-L ถ้า คุณสะกดมัน
>> ผู้ชม: และฉันเพิ่งไป กลับมาและผ่านการทดสอบมัน
และถ้าคุณพยายามที่จะนำจุดลอย ค่าลงในสวิทช์ก็จะตะโกนใส่หน้าคุณ
กล่าวว่าคำสั่งต้องมีการแสดงออก ประเภทจำนวนเต็ม
>> DAN: มีคุณไป
แต่ใช่สิ่งที่เป็นคำถามอีกครั้งหรือไม่
>> ผู้ชม: [ไม่ได้ยิน]
>> DAN: ดังนั้นเงินทุนที่ยังไม่มีทุน U เมืองหลวง L, ทุน L คือ c สิ่งที่เกิดขึ้นจริง
มันเป็นตัวชี้โมฆะและจะ เพียง แต่ได้รับการปฏิบัติเช่นนี้
คุณจะไม่เคยพยายามสะกด ตัวละครที่เป็นโมฆะและเห็นใด ๆ
วิธีอื่น ๆ กว่านี้
ใช่?
>> ผู้ชม: ดังนั้นกลับไปถ่านสูงสุดหรือ สิ่งที่อยู่ในบันทึกก็จะได้
รวบรวมฟังก์ชั่นเดียวกัน เป็น [ไม่ได้ยิน]
>> ผู้ชม: ดังนั้นที่คุณหมายถึง กลับสูงสุดถ่านจาก getchar หรือ
สิ่งที่มันคืออะไร?
>> ผู้ชม: ใช่
>> ผู้ชม: ใช่ดังนั้นทั่วไป ระยะสำหรับทุกสิ่งเหล่านั้น
เป็นค่าแมวมอง
ดังนั้นเหมือนกลับ int สูงสุดจาก GetInt และถ่านสูงสุดจาก getchar มัน
ควรจะเป็นเช่นขวาทั้งหมดถ้า สิ่งเหล่านี้จะกลับมาอยู่กับเรา
สิ่งที่ผิดพลาด
>> สำหรับคำแนะนำเราก็เกิดขึ้นได้ ค่ายามนี้ที่ทุกคน
เห็นด้วยกับ
และนี่คือสิ่งที่คุณจะกลับ เมื่อสิ่งที่ผิดไป
ดังนั้นถ่านสูงสุดคือสิ่งที่เรากำลังใช้ เพื่อเป็นตัวแทนของบางสิ่งบางอย่าง
เช่นโมฆะหรือ getchar
>> ผู้ชม: ดังนั้นถ้าคุณกำลังทดสอบ getchar, คุณอาจจะเพียงแค่ใส่โมฆะ?
ที่จะสร้างความแตกต่างได้หรือไม่
>> DAN: คุณไม่สามารถเพียงแค่ตรวจสอบเป็นโมฆะ
คุณจะต้องตรวจสอบถ่านสูงสุดเพราะ ค่าตอบแทนจากการทำงานเป็น
ตัวอักษรไม่ชี้
ใช่?
>> ผู้ชม: คำถามนี้ถาม สำหรับความยาวสตริง
ไม่ว่ารวมถึงตัวละครที่เป็นโมฆะหรือไม่
>> DAN: เลขที่
และที่จริงวิธีการระยะเวลาในสตริง รู้ที่จะหยุดเพราะมันผ่านไป
อาร์เรย์ของตัวอักษรจนกว่าของคุณ มันเห็นตัวละครที่เป็นโมฆะ
แล้วมันก็เหมือนทุก ขวาฉันทำ
>> ผู้ชม: [ไม่ได้ยิน] ห้า?
>> DAN: สวัสดีจะเป็นห้า
อ้อ
ดังนั้นอาร์เรย์ที่มีอย่างต่อเนื่อง บล็อกของหน่วยความจำ
พวกเขาสามารถเข้าถึงได้ทันทีด้วยการพูดว่า ชื่อของอาร์เรย์แล้วในหยิก
จัดฟันสิ่งที่ดัชนีคุณต้องการไป เพื่อที่พวกเขากำลังจัดทำดัชนีจากศูนย์ผ่าน
ความยาวของ 1 ลบอาร์เรย์
>> และพวกเขากำลังประกาศตามประเภทของ สิ่งที่คุณกำลังจัดเก็บใน
อาร์เรย์ชื่อของอาร์เรย์แล้ว สิ่งที่มีขนาดของอาร์เรย์ที่
ดังนั้นนี่คืออาร์เรย์ถ่านของความยาว หกที่มีค่าเหล่านี้
ใช่?
>> ผู้ชม: [ไม่ได้ยิน]
>> DAN: ใช่
>> ผู้ชม: [ไม่ได้ยิน]
>> DAN: ถ้าคุณมีสิ่งที่เกิดขึ้น เข้าแถวทำแล้ว
เพื่อให้คุณสามารถระบุนี้แทนเป็น พูดถ่าน, สิ่งที่ชื่อของคุณ
อาร์เรย์เป็นวงเล็บว่างเท่ากับหยิก รั้ง H จุลภาค E จุลภาค L จุลภาค L จุลภาค
O จุลภาคตัวอักษรเป็นโมฆะ และวงเล็บปีกกา
ที่ยังจะทำงานเป็นประกาศ
>> ผู้ชม: [ไม่ได้ยิน]
>> DAN: แล้วคุณจะต้องมี ขนาดทำแล้ว
>> ผู้ชม: [ไม่ได้ยิน]
>> DAN: ใช่
righty ทั้งหมด
อาร์กิวเมนต์บรรทัดคำสั่งเป็นวิธีการของ ได้รับข้อมูลจากผู้ใช้เป็น
ข้อโต้แย้งหลัก
หลักจะใช้เวลาสองอาร์กิวเมนต์
จำนวนของการขัดแย้งที่จะถูก ผ่านไปตามแนวคำสั่งและ
เวกเตอร์สตริงหรืออาร์เรย์สตริง ทั้งหมดของข้อโต้แย้ง
>> ดังนั้นถ้าผมพูดที่เรียกว่าฟังก์ชั่นเช่น จุดออก 1 พื้นที่ 2 พื้นที่สาม
argc จะ 4
และ argv 0 จะเป็นจุดออก
Argv1 จะเป็น 1
argv2 จะเป็น 2 argv3 จะเป็น 3 ในกรณีที่โดยเฉพาะอย่างยิ่งที่
ใช่?
>> ผู้ชม: [ไม่ได้ยิน]
>> DAN: องค์ประกอบสุดท้ายในอาร์เรย์ เพราะอาเรย์คือความยาว argc บวก
หนึ่งใน ARGB, องค์ประกอบสุดท้าย เป็นตัวชี้โมฆะ
มันเป็น argc บวก 1
ดังนั้นในกรณีที่ฉันเพิ่งกล่าวว่ามัน จะได้รับการ argv 0 เป็นจุดออก
argv 1 คือ 1 argv2 เป็น 2 argv 3 คือ 3
argv 4 ซึ่งเป็นหนึ่งในขนาดใหญ่ กว่า argc จะเป็นโมฆะ
>> และนั่นคือตัวชี้โมฆะ
ใช่
และที่เพราะสตริงเป็น ดาวถ่านเป็นตัวชี้
ดังนั้นมันจะเป็นชนิดเดียวกันมี
ใช่?
>> ผู้ชม: สองคำถาม
ดังนั้นหนึ่งในสิ่งที่แตกต่างระหว่าง GetString ชนิดอื่นนอกเหนือจากนี้และ
ในเครื่องยนต์ของผู้ใช้หรือไม่
และทั้งสองจะถูกเก็บไว้ภายใน หน่วยความจำที่ผ่านมาของคุณ
ดังนั้นเหมือน GetString จะ เป็น [ไม่ได้ยิน]
>> DAN: อยู่ที่ไหนก็เก็บ?
ผมไม่ทราบว่ามันเก็บไว้
>> ผู้ชม: ดังนั้นจริงคุณจะรู้ว่าวิธีใด ๆ ทำงานที่คุณเรียกว่าเป็นข้อโต้แย้ง
จะถูกเก็บไว้ในกองหรือไม่
ดังนั้น argc และ argv ข้อโต้แย้งหลัก และพวกเขาอยู่ในกองหรือจริงๆ
เหนือสิ่งที่คุณคิดว่าเป็น จุดเริ่มต้นของสแต็ค
อะไรคือส่วนที่อื่น ๆ คำถาม?
>> ผู้ชม: ดังนั้นสิ่งที่ [ไม่ได้ยิน]
>> DAN: ใช่มันเป็นเพียงวิธีการที่แตกต่างกัน ในการได้รับข้อมูลจากผู้ใช้
หนึ่งนี้เล็กน้อยที่มีประสิทธิภาพมากขึ้นและ มันเป็นการง่ายกว่าสำหรับสคริปต์เพราะคุณ
ก็สามารถผ่านการขัดแย้งกับหลักของคุณ ฟังก์ชั่นมากกว่าที่จะต้องรอ
สำหรับผู้ใช้ถ้าคุณไม่ได้มีผู้ใช้ใด ๆ
>> ผู้ชม: และใช่ได้รับสาย จะเป็น [ไม่ได้ยิน]
มันจะเก็บสิ่งที่คุณต้องการ
>> DAN: ใช่?
>> ผู้ชม: [ไม่ได้ยิน]
>> DAN: ใช่ argv 0 รวมอยู่ด้วยเสมอ เฉือนจุดของการเรียกใช้ฟังก์ชัน
ใช่?
>> ผู้ชม: [ไม่ได้ยิน]
>> DAN: ใช่แต่ละข้อโต้แย้งที่มี สิ้นสุดวันที่ในลักษณะเป็นโมฆะเพราะพวกเขา
เป็นสตริง
>> ผู้ชม: [ไม่ได้ยิน]
>> DAN: ใช่ argv argc เป็นตัวชี้โมฆะ
>> ผู้ชม: [ไม่ได้ยิน]
>> DAN: Oh yeah
ใช่ขอโทษ
>> ผู้ชม: ดังนั้น [ไม่ได้ยิน]
>> DAN: ดังนั้นคำถามคือถ้าคุณมี บรรทัดคำสั่งจุดเฉือนจุดออก 1, 2,
จะจำนวนของบรรทัดคำสั่ง ข้อโต้แย้งที่มีสองหรือมันจะเป็นสาม?
>> ผู้ชม: ผมคิดว่ามันไม่ได้ เรื่องจริงๆ
ฉันมักจะบอกว่าโอ้คุณไม่ผ่าน อาร์กิวเมนต์บรรทัดคำสั่งใด ๆ เมื่อ
เห็นได้ชัดว่าคุณเรียกว่าฟังก์ชั่น
ดังนั้นผมจึงมีแนวโน้มที่จะพูดมากไม่รวม ฟังก์ชั่นจากบรรทัดคำสั่ง
ข้อโต้แย้งถึงแม้ว่ามันจะเป็น รวมอยู่ใน argv
>> DAN: แต่ถ้ามันเป็น test--
yeah-- และถ้าคุณพูดอะไรบางอย่าง เช่น argc เท่ากับ 3,
คุณอยู่ในสถานะที่ปลอดภัย
ใช่?
>> ผู้ชม: [ไม่ได้ยิน]
>> DAN: ผมคิดว่าถ้าแทนการเรียกร้องนี้ ใน argc และสตริงวงเล็บ argv
แต่ยังคงรูปแบบเดียวกันและที่เรียกว่าเพียงแค่ พวกเขามีสิ่งที่แตกต่างกันเช่น
และ b มันจะยังคงทำงานหรือไม่
และมันจะยังคงทำงาน คุณจะ just--
แทนการใช้ argc-- ที่คุณต้องการใช้และข
ใช่?
>> ผู้ชม: [ไม่ได้ยิน]
>> DAN: ดังนั้นคำถามคือ GetString เป็น จะเก็บความทรงจำในกอง
เพราะ GetString เป็น char *
จะเก็บความทรงจำในกองเพราะมัน ตอนนี้เรียก malloc ภายในที่เกิดขึ้นจริง
การดำเนินการของ GetString
ตกลงที่จะย้ายที่
>> การรักษาความปลอดภัย
ดังนั้นเพื่อให้มีความปลอดภัยอย่างแท้จริงที่คุณพึ่งพาไม่มี และคุณอนุญาตให้ไม่มีใครเข้าถึงใด ๆ
ข้อมูลของคุณซึ่งเป็นเหตุผลที่ ทุกคนสร้างเครื่องของตัวเอง
ระบบปฏิบัติการของตัวเองของพวกเขาทั้งหมด โปรแกรมจากรอยขีดข่วนและเห็นได้ชัด
ไม่ได้เชื่อมต่อไปยังเครื่องอื่น ๆ ผ่านทางอินเทอร์เน็ต
ดังนั้นเครื่องคอมพิวเตอร์ที่ไม่ปลอดภัย
พวกเขาเป็นจริง
เราต้องไว้วางใจคนอื่น
>> และความคิดของการรักษาความปลอดภัยที่เป็นที่ที่คุณอยู่ พยายามที่จะ จำกัด จำนวนของ
ความไว้วางใจที่คุณต้องการ
และหนึ่งในวิธีที่คุณทำอย่างนั้น คือผ่านการเข้ารหัส
การเข้ารหัสคือเป็นหลัก เรามีความลับ
>> บางครั้งเราต้องผ่านความลับของเรา พร้อมผ่านการพูดอินเทอร์เน็ตหรือ
สิ่งอื่น ๆ
และเราไม่ต้องการให้คน ทราบความลับเหล่านี้
ดังนั้นเราจึงเข้ารหัสลับของเราในทาง ที่เราหวังว่าจะไม่มีใครสามารถคิดออก
>> ดังนั้นเราจึง used--
ผ่านหลักสูตรของ class-- นี้
สิ่งที่ต้องการเข้ารหัสและซีซาร์ [ไม่ได้ยิน] ซึ่งมีทั้งมาก
วิธีการที่ไม่ปลอดภัยของการเข้ารหัสสิ่งที่
พวกเขากำลังง่ายที่จะคิดออกสิ่งที่พวกเขา และสิ่งที่เป็นความลับของคุณ
โลกแห่งความจริงที่ใช้มากขึ้น แผนการเข้ารหัสที่ซับซ้อน
และเราจะไม่ได้รับใน มากกว่านั้น
>> การแก้จุดบกพร่อง
GDB ที่ดีที่สุดคือ
ฉันจะความเครียดนี้อีกครั้ง
ใช้ GDB ตลอดเวลาทุก เวลาที่คุณมีปัญหา
คำสั่งที่มีประโยชน์ใน GDB เป็น ทำลายซึ่งคุณผ่านทั้งสาย
จำนวนชื่อฟังก์ชันเป็นหลัก ที่ในรหัสของคุณคุณต้องการที่จะหยุด
และสามารถที่จะควบคุม
>> พิมพ์ใช้ตัวแปรและพิมพ์ออกมา สิ่งที่ตัวแปรที่อยู่ที่ว่า
จุดในการดำเนินการของคุณ
ถัดไปจะเลื่อนการดำเนินการของคุณ พร้อมขั้นตอนเดียว
และขั้นตอนขั้นตอนในการทำงาน ในการดำเนินการของคุณ
>> สิ่งอื่น ๆ ที่จะถูกเรียกใช้ซึ่งเป็นวิธีการ คุณเรียกใช้รหัสของคุณจริง
ดำเนินการต่อไปจะใช้เวลาทั้งหมดขั้นตอนที่จำเป็น เพื่อไปยังจุดพักต่อไป
และมีหลายอื่น ๆ อีกมากมาย
มองพวกเขา
พวกเขากำลังดี
ใช่?
>> ผู้ชม: [ไม่ได้ยิน]
>> DAN: ใช่ซึ่งเป็นบั๊ก
ดังนั้นดีบักเป็นโปรแกรมที่ ช่วยให้คุณสามารถแก้ปัญหาโปรแกรมของคุณ
มันไม่ได้เป็นโปรแกรมที่พบข้อบกพร่องสำหรับ คุณคิดว่าจะดี
>> และครั้งสุดท้ายสำหรับผมคือการค้นหา
ดังนั้นประเภทของการค้นหาที่เราได้พูดคุย เกี่ยวกับในชั้นนี้มีการค้นหาเชิงเส้น
ซึ่งเป็นเพียงที่คุณมองผ่านแต่ละ องค์ประกอบของพื้นที่ค้นหาอย่างใดอย่างหนึ่ง
องค์ประกอบในเวลาจนกว่าคุณจะพบสิ่งที่ คุณกำลังมองหาหรือจนกว่าคุณจะไปถึง
ในตอนท้ายของพื้นที่การค้นหาของคุณที่ จุดที่คุณบอกว่าคุณไม่สามารถหา
องค์ประกอบที่คุณกำลังมองหา
และเรื่องนี้ต้องใช้เวลาที่ดีที่สุดอย่างต่อเนื่อง ซึ่งเป็น 0 จาก 1 และเส้นที่เลวร้ายที่สุด
เวลาซึ่งเป็น 0 ของ n
>> ค้นหา binary ที่ต้องการ องค์ประกอบสกปรก
คุณจะไปที่ตรงกลางขององค์ประกอบของคุณ ดูว่าองค์ประกอบที่คุณกำลังมองหา
มีขนาดใหญ่ขึ้นหรือเล็กลงกว่าองค์ประกอบ ว่าคุณจะอยู่ที่ตรงกลาง
มันเป็นเรื่องใหญ่ที่คุณบอกว่าด้านล่าง การค้นหาของคุณมีพื้นที่ของคุณ
สถานที่ตั้งปัจจุบันกลาง และคุณเริ่มต้นกระบวนการ
ถ้าเป็นขนาดเล็กที่คุณมองว่า ที่ยกกำลังใช่อะไรขึ้น?
>> ผู้ชม: [ไม่ได้ยิน]
>> DAN: ใช่
ประเภทใดของการจัดเรียงที่ถูกสอนใน ชั้นเป็นเกมที่ยุติธรรมสำหรับการทดสอบ
>> [หัวเราะ]
>> DAN: และความจริงที่ว่าคุณไม่ได้มี ที่จะทำมันสำหรับชุดปัญหามันยุติธรรม
เกมสำหรับการทดสอบ
>> ผู้ชม: เราสามารถไปกว่านั้นวิธียา่
>> DAN: มันจะหายไปกว่า
>> ลำโพงที่ 2: รหัสจริงสำหรับ [ไม่ได้ยิน] อยู่ใน study.cs50.net
ดังนั้นถ้าคุณมองไปที่ปัญหาการปฏิบัติ ในหน้าตัดจัดเรียงของ
study.cs50.net มีรหัส สำหรับการดำเนินการผสานการจัดเรียง
ดังนั้นคุณจึงไม่ต้องใช้ ด้วยตัวคุณเองคืนนี้
แต่ให้แน่ใจว่าคุณเข้าใจมันค่อนข้าง มากกว่าแค่การท่องจำมัน
>> ผู้ชม: [ไม่ได้ยิน]
>> ลำโพงที่ 2: หน้าตัดจัดเรียงใน study.cs50.net มีการปฏิบัติ
ปัญหาว่าถ้าคุณคลิกผ่าน ปัญหาที่ปลายสุดมี
การแก้ปัญหาซึ่งเป็นที่ผสาน การดำเนินการจัดเรียง
แต่ให้แน่ใจว่าคุณเข้าใจมัน มากกว่าแค่การท่องจำมัน
หรือคัดลอกมันลง
>> ผู้ชม: และที่ถูกต้องสมบูรณ์ ปัญหาสำหรับการสอบจะเป็น
สิ่งที่ต้องการที่นี่รายการ
รายการนี​​้ไม่สิ่งที่มีลักษณะเช่นหลังจาก หนึ่งในขั้นตอนของการเลือกการจัดเรียงหรือ
จัดเรียงแทรกหรืออะไรก็ตาม
หนึ่งซ้ำเต็มรูปแบบของรายการ
ดังนั้นแม้ว่าคุณจะไม่สิ้นสุดต้อง รหัสสำหรับมันที่คุณต้องเข้าใจมัน
พอที่จะรู้ว่ามันเป็นไป ที่จะปรับเปลี่ยนอาร์เรย์นี้
>> DAN: นั่นมันสำหรับฉัน
>> [APPLAUSE]
>> LUCAS: Hey ทุกคน
ชื่อของฉันคือลูคัส
ฉันจะพูดคุยเกี่ยวกับการเรียกซ้ำทุก ทุกประเภทที่เราได้เรียนรู้และ
นิด ๆ หน่อย ๆ ของตัวชี้ทั้งหมด
OK?
ดังนั้นครั้งแรกของทั้งหมดเรียกซ้ำ
มันหมายความว่าอะไรที่จะบอกว่า ฟังก์ชั่นเป็น recursive?
>> ผู้ชม: เรียกตัวเอง
>> LUCAS: ตกลงเรียกตัวเองใช่
ดังนั้นเช่นภาพนี้ยกตัวอย่างเช่น
มันเหมือนกับภาพที่อยู่ภายใน ของภาพและอื่น ๆ
ดังนั้นสำหรับตัวอย่างเช่นคุณสามารถ have-- แดน ที่ได้รับการพูดคุยเกี่ยวกับการค้นหาไบนารี
วิธีหนึ่งที่ค้นหา binary เป็น เวียนเป็นความจริงที่ว่าคุณ
พยายามที่จะหาจำนวน
ดังนั้นคุณจะไปที่ตรงกลาง
แล้วคุณตรวจสอบว่าตัวเลขที่มี ในด้านซ้ายและขวา
>> แล้วถ้าคุณพบว่าออกมาเป็นจำนวนเป็น จะอยู่ทางซ้ายก็เหมือนกัน
สิ่งที่ทำค้นหาอีกครั้ง แต่ เพียงแค่ด้านซ้ายของรายการ
นั่นคือวิธีที่มันฟัง เหมือนว่ามันจะเป็นแบบทั่วถึง
เพื่อที่ว่าทำไมพวกคุณต้องเวียนเกิด โซลูชั่นสำหรับการจัดเรียงเวียน
>> ตกลงดังนั้นนี่คือตัวอย่าง
จึงขอบอกว่าผมต้องการที่จะเลือก ตัวเลขทั้งหมดจาก 1 ถึง n
ฉันสามารถตระหนักดีว่าผลรวมของ n ตัวเลขเป็นบวก n n ลบ 1 ถึง 1
แต่แล้วถ้าฉันมองไปที่ n ลบ 1 บวก n ลบ 2 บวก 1 ที่เดียวกัน
สิ่งที่เป็นข้อสรุปตัวเลข ถึง n ลบ 1
ดังนั้นผมจึงสามารถพูดได้ว่าผลรวมของผลรวมเท่ากับ เท่ากับ n บวกผลรวมของ n ลบ 1
ไม่ว่าทำให้รู้สึก?
>> และฉันก็จะมีอย่างอื่น เรียกว่ากรณีฐานซึ่งก็คือ
ผลรวมของตัวเลขที่เพิ่มขึ้น ให้เป็นศูนย์จะเป็นศูนย์
ดังนั้นทันทีที่ฉันได้รับไปยังหมายเลข ศูนย์ฉันจะหยุดนับ
ไม่ว่าทำให้รู้สึก?
>> ดังนั้นนี่คือตัวอย่างของวิธีการ ฉันสามารถใช้ที่
ดังนั้นผมจึงมีฟังก์ชั่นนี้ในบาง
ที่ใช้เวลาจำนวนเต็ม n
ดังนั้นนี่คือครั้งแรกที่ผมตรวจสอบว่า n คือ น้อยกว่าหรือเท่ากับศูนย์
ดังนั้นถ้ามันน้อยกว่าหรือเท่ากับศูนย์ผม กลับเป็นศูนย์ซึ่งเป็นกรณีฐานของเรา
มิฉะนั้นผมก็สามารถกลับ n บวก ผลรวมของตัวเลขจาก
หนึ่งไปยัง n ลบหนึ่ง
ทำให้รู้สึก?
ตกลง
>> ดังนั้นนี่คือสิ่งที่ดูเหมือนว่า
คุณมีผลรวมของ 2 เท่ากับ 2 บวกผลรวมของ 1
และบางส่วนของที่ 1 เป็น 1 บวก ผลรวมของ 0 ซึ่งเป็น 0
ทำให้รู้สึก?
ดังนั้นหากเรามองไปที่กองของคุณ โปรแกรมนี้เป็นสิ่งที่ดูเหมือนว่า
>> ครั้งแรกที่เรามีหน้าที่หลัก
แล้วหน้าที่หลัก เรียกว่าผลรวม 2
แล้วผลรวม 2 เป็นไปที่จะบอกว่าโอ้ผลรวม 2 เท่ากับ 2 บวกผลรวมของการอย่างใดอย่างหนึ่ง
ดังนั้นฉันจะเพิ่มผลรวมของ 1 ถึงกอง
และผลรวมของ 1 ที่จะเรียกผลรวมของ 0 ซึ่งยังเป็นไปที่จะเพิ่ม
ไปยังกอง
แล้วแต่ละคนเหล่านี้ที่มี ที่ด้านบนของอีกคนหนึ่งต้องกลับ
ก่อนที่คนอื่น ๆ สามารถเก็บไป
>> ดังนั้นสำหรับตัวอย่างเช่นที่นี่ผลรวมของ 0, ครั้งแรกที่จะกลับ 0
และจากนั้นเลือกผลรวมของ 1
แล้วผลรวมของ 1 เป็นไปได้ กลับ 1 ผลรวมของ 2
และในที่สุดผลรวมของ 2 เป็นไป 3 เพื่อกลับไปที่หน้าหลัก
ไม่ว่าทำให้รู้สึก?
>> มันสำคัญมากที่จะเข้าใจว่า สแต็คเป็นคนที่ทำงานและพยายามที่จะ
ดูว่ามันทำให้รู้สึก
ตกลงดังนั้นการเรียงลำดับ
เหตุใดจึงต้องมีการเรียงลำดับความสำคัญ แรกของทั้งหมดหรือไม่
ทำไมเราควรจะดูแล?
ใคร?
ให้ฉันตัวอย่าง?
ใช่?
>> ผู้ชม: [ไม่ได้ยิน]
>> LUCAS: ใช่ตกลง
เพื่อให้คุณสามารถค้นหาได้อย่างมีประสิทธิภาพมากขึ้น
นั่นเป็นวิธีที่ดี
ดังนั้นสำหรับตัวอย่างเช่นเรามีจำนวนมาก สิ่งที่เป็นจริงในชีวิตของเราที่
ระบบจะจัดเรียง
ตัวอย่างเช่นพจนานุกรม
>> มันเป็นสิ่งสำคัญมากที่จะมีทั้งหมด คำในประเภทของคำสั่งบางอย่างที่เรา
สามารถเข้าถึงได้อย่างง่ายดาย
นั่นคือสิ่งที่เขาพูด
คุณสามารถค้นหาได้อย่างมีประสิทธิภาพมากขึ้น
คิดว่ามันยากที่จะมี พจนานุกรมคำที่อยู่ใน
ลำดับแบบสุ่ม
คุณจะต้องมองไปที่สวยมาก ทุกคำเดียวจนกว่าคุณจะพบ
คำที่คุณกำลังมองหา
>> หากคุณกำลังใช้ Facebook ยังเมื่อ คุณกำลังมองหาที่เพื่อนของคุณคุณ
จะเห็นว่า Facebook ของคุณใส่ เพื่อนใกล้ชิดด้านบนของคน
ที่คุณไม่ได้พูดคุยกับที่มาก
ถ้าคุณไปตลอดทางจนถึงด้านล่างของ รายชื่อเพื่อนของคุณคุณจะได้เห็น
คนที่คุณอาจจะไม่ได้ จำไว้ว่าคุณเป็นเพื่อนกับ
และนั่นเป็นเพราะทุกประเภท Facebook เพื่อนของคุณขึ้นอยู่กับว่า
ปิดที่คุณอยู่กับพวกเขา
>> ดังนั้นการจัดระเบียบข้อมูล
นอกจากนี้โปเกมอน
ดังนั้นคุณจะเห็นว่า Pokemons ทั้งหมด มีหมายเลข
และที่เหมือนง่าย วิธีการเข้าถึงข้อมูล
>> ผู้ชม: การเข้าถึงโปเกมอน
>> LUCAS: ใช่
>> ผู้ชม: [ไม่ได้ยิน]
>> LUCAS: อ้อ
ตกลงดังนั้นการจัดเรียงตัวเลือก
การจัดเรียงตัวเลือกที่จะเลือก มูลค่าไม่ได้เรียงลำดับที่เล็กที่สุดของรายการแต่ละ
เวลาในแต่ละซ้ำ
มันเป็นเหมือนการจัดเรียงที่คุณทำ ในหัวของคุณเมื่อคุณกำลังพยายามที่จะ
เรียงลำดับรายการในมือ
>> โดยทั่วไปสิ่งที่คุณทำคือคุณมอง สำหรับจำนวนที่เล็กที่สุด
คุณใส่ไว้ในรายการที่เรียงลำดับ
แล้วที่คุณมองหา จำนวนน้อยที่สุดต่อไป
แล้วคุณจะให้ทำ ที่และอื่น ๆ
>> ดังนั้นการจัดเรียงตัวเลือกเป็นพื้นคุณ เลือกทุกครั้งที่มีขนาดเล็กที่สุด
มูลค่าไม่ได้เรียงลำดับ
ใส่ในตอนท้ายของการจัดเรียง ส่วนหนึ่งของรายการ
และให้ทำอย่างนั้น
ดังนั้นเรามาดูสิ่งที่ได้อย่างรวดเร็ว นี้ดูเหมือนว่า
ดังนั้นนี่คือการจัดเรียง และรายชื่อไม่ได้เรียงลำดับ
>> ดังนั้นสำหรับการจัดเรียงของรายการ มันว่างเปล่าในตอนแรก
แล้วฉันจะเลือก จำนวนน้อยที่สุดที่นี่ซึ่งเป็น 2
ดังนั้นผมจึงได้รับหมายเลข 2 และฉันใส่ ด้านหน้าของรายการ
แล้วผมก็มองหาที่เล็กที่สุดต่อไป องค์ประกอบซึ่งเป็น 3
ดังนั้นผมจึงใส่มันในตอนท้าย ของรายการที่เรียงลำดับ
แล้วผมก็ให้ทำที่
ผมพบว่า 4 และวางไว้ในตอนท้าย
ค้นหา 5 และวางไว้ในตอนท้าย
>> และมองไปที่วิธีการทั้งหมดในครั้งนั้นว่า ฉันพูดใส่ไว้ในตอนท้ายคือ
โดยทั่วไปการแลกเปลี่ยนสองค่า
OK?
แล้วสุดท้ายคุณก็ มีองค์ประกอบหนึ่งมากขึ้น
จึงแยกแล้ว
>> OK เพื่อแทรกการจัดเรียง
จัดเรียงแทรกคุณกำลังจะไปยัง สิ่งที่มีการจัดเรียงและ
รายการไม่ได้เรียงลำดับ
สิ่งเดียวคือทุกครั้งที่ คุณกำลังเพิ่มองค์ประกอบที่จะเรียงลำดับ
รายการคุณเพียงแค่เลือกองค์ประกอบที่ ที่อยู่ในหน้าของรายการไม่ได้เรียงลำดับ
แล้วคุณจะพบว่าสิ่งที่ ตำแหน่งที่ควรจะเป็นในการเรียงลำดับ
ส่วนหนึ่งของรายการ
>> ลองมาดูสิ่งที่เป็นเช่นนี้ นี้ทำให้รู้สึกมากขึ้น
ดังนั้นในขั้นแรกตัวอย่างเช่นฉันพยายาม ใส่บ้านเลขที่สามใน
ส่วนที่เรียงลำดับของรายการ
ดังนั้นรายการที่ไม่ได้มีอะไร
ดังนั้นผมก็สามารถใส่หมายเลข 3
>> ตอนนี้ฉันต้องการที่จะเพิ่มจำนวน 5 ไป ส่วนที่เรียงลำดับของรายการ
ดังนั้นผมจึงมองไปที่หมายเลข 5
ผมสังเกตเห็นว่ามันเป็นมากกว่า 3
ดังนั้นผมรู้ว่ามันจะเป็นหลังจาก 3 มี
ดังนั้นผมจึงใส่ 3 และ 5
>> แล้วผมต้องการที่จะใส่หมายเลข 2
ผมสังเกตเห็นว่าหมายเลข 2 เป็นจริง สุดท้ายแล้วทั้ง 3 และ 5
ดังนั้นที่จริงผมต้องใส่มันทั้งหมด วิธีในการเริ่มต้นของรายการ
ดังนั้นฉันจะต้องชนิดของกะทั้งหมด องค์ประกอบในรายการที่จัดเรียงเพื่อให้ฉันสามารถ
ทำให้ห้องหมายเลข 2
>> แล้วฉันจะดูจำนวน 6
ฉันเห็นว่ามันควรจะเป็นหลังจาก 5
ดังนั้นผมจึงใส่มันมี
และในที่สุดฉันมองไปที่หมายเลข 4
และผมสังเกตเห็นที่ควร อยู่ระหว่าง 3 และ 5
และจากนั้นฉันใส่มันและมีการเปลี่ยนแปลง ทุกองค์ประกอบอื่น ๆ
ทำให้รู้สึก?
>> ฟองเรียง
ดังนั้นการจัดเรียงฟองเป็นพื้นสิ่งที่คุณกำลัง จะ do-- เราเรียกว่าฟอง
จัดเรียงเพราะคุณไปผ่าน list-- เป็นจริงดีกว่าถ้าฉันเพียงแค่แสดง
ที่คุณชอบเจ้านี่
และคุณกำลังจะไปเปรียบเทียบ ตัวเลขที่อยู่ติดกัน
และคุณกำลังจะไปแลกเปลี่ยนของพวกเขา ตำแหน่งถ้าพวกเขาไม่ได้
ในลำดับที่ถูกต้อง
>> ดังนั้นโดยทั่วไปสิ่งที่จะ เกิดขึ้นที่นี่เช่น
คุณมี 8 และ 6
คุณรู้ไหมว่าคำสั่งที่เรียงลำดับจะ จริง ๆ แล้วเป็น 6 และ 5 ใช่มั้ย?
เพื่อให้คุณกำลังจะเปลี่ยนคำสั่งซื้อ
แล้วฉันจะดู 8 และ 4 ที่นี่
และฉันทำสิ่งเดียวกัน
ผมเปลี่ยนอีกครั้ง
และในที่สุด 2 และ 8
ฉันยังสลับพวกเขา
>> มันเรียกว่าฟองเรียงเพราะหลังจากที่ แต่ละซ้ำเหล่านี้จริง
จำนวนมากที่สุดในรายการที่ได้รับทั้งหมด วิธีที่จะสิ้นสุดของรายการ
ไม่ว่าทำให้รู้สึก?
เพราะมันช่วยให้การแลกเปลี่ยนมัน และย้ายไปทางขวา
>> ตกลงดังนั้นนี่คือประโยคที่สอง
มันจะเป็นสิ่งเดียวกัน
ฉันจะทำอย่างใดอย่างหนึ่งและแลกเปลี่ยน แล้วสุดท้าย
ผมว่าไม่มีการแลกเปลี่ยน และรายการจะถูกจัดเรียง
ดังนั้นในฟองเรียงเราโดยทั่วไปให้ จะผ่านรายการและการแลกเปลี่ยน
สิ่งจนผมสังเกตเห็นว่าผมไม่ได้ทำ สัญญาใด ๆ ที่ทำซ้ำที่ซึ่ง
หมายถึงรายการที่ถูกจัดเรียงแล้ว
ทำให้รู้สึก?
>> ขอพูดคุยนิด ๆ หน่อย ๆ เกี่ยวกับการทำงานเวลา
ดังนั้นพวกคุณจำบิ๊ก O, โอเมก้า, และที?
ใช่?
ตกลงสิ่งที่เป็น Big O, แรกของทั้งหมดหรือไม่
>> ผู้ชม: [ไม่ได้ยิน]
>> LUCAS: ใช่มันเรียกว่ากรณีที่เลวร้ายที่สุด runtime ซึ่งก็หมายความว่ามันเป็น
เท่าไหร่ที่คุณคาดหวังว่าโปรแกรม ที่จะใช้ในการทำงาน
เช่นในแง่เเล้
ใน case-- n นี้
จำนวนขององค์ประกอบใน รายการในกรณีที่เลวร้ายที่สุด
เช่นในกรณีที่เป็นไปได้ที่เลวร้ายที่สุด
>> ดังนั้นสำหรับฟองเรียงตัวอย่างเช่น เรามี O ใหญ่ n ตาราง
ทำไมเรามีที่?
ทำไมฟองเรียง Big O n ตาราง?
>> ผู้ชม: [ไม่ได้ยิน]
>> LUCAS: ใช่ดังนั้นกรณีที่เลวร้ายที่สุดจะเป็น ที่ผมจะต้องทำซ้ำ n
ดังนั้นแต่ละซ้ำเป็นไป นำองค์ประกอบที่ใหญ่ที่สุดไปยังจุดสิ้นสุด
ของรายการ
ดังนั้นกรณีที่เลวร้ายที่สุดที่ฉันมี ที่จะทำสิ่งที่ครั้ง n
และในแต่ละครั้งที่ผมต้อง ทำสัญญาแลกเปลี่ยน n เพราะผมต้องเปรียบเทียบ
แต่ละสององค์ประกอบ
เพื่อที่ว่าทำไมมันยกกำลัง n เพราะมันเป็นครั้ง n n
>> แล้วเรียงลำดับตัวเลือกนี้ยังมี n ตาราง เพราะสำหรับแต่ละซ้ำฉันต้อง
มองไปที่ทุกองค์ประกอบเดียว ในรายการ
แล้วหาที่เล็กที่สุด ซึ่งหมายความว่าฉันต้อง
มองผ่านองค์ประกอบ n
และฉันต้องทำเช่นนั้นเพราะครั้ง n ฉันต้องเลือกทุกองค์ประกอบ n
>> จัดเรียงแทรกยัง n ตาราง เพราะสถานการณ์กรณีที่เลวร้ายที่สุดจะ
จะเป็นหนึ่งที่ผมต้องใส่ หมายเลข n ขวา?
ดังนั้นผมรู้อยู่แล้วว่าผมจะ ที่จะมี n ซ้ำ
แต่สำหรับแต่ละตัวเลขเหล่านั้นถ้าผมมี ไปดูที่ทั้งหมดของตัวเลขใน
รายการที่จัดเรียงและนำมันไปตลอดทาง ในด้านหน้าที่จะเป็น n ตาราง
เพราะมันจะเป็นครั้ง n n อีกครั้ง
ทำให้รู้สึก?
สิ่งที่เกี่ยวกับโอเมก้า?
>> ผู้ชม: [ไม่ได้ยิน]
>> LUCAS: มันเป็นสถานการณ์กรณีที่ดีที่สุด
ดังนั้นมันก็เหมือนในหลายครั้งสำหรับ การเรียงลำดับสถานการณ์กรณีที่ดีที่สุดคือ
เมื่อรายการจะถูกจัดเรียงอยู่แล้ว
เพื่อให้คุณไม่ได้จริงๆต้อง ที่จะทำอะไร
ฟองเรียงมีที่ดีที่สุด สถานการณ์กรณีที่ n
ที่พวกคุณรู้ว่าทำไม
>> ผู้ชม: [ไม่ได้ยิน]
>> LUCAS: ใช่ถ้าคุณติดตาม ไม่ว่าจะเป็นข้อมูลที่มีการปันส่วนการแลกเปลี่ยนใด ๆ หรือ
ไม่ได้ถ้าคุณมีสิ่งที่ต้องการกำหนดให้ ความจริงถ้ามีซ้ำถ้า
รายการจะถูกจัดเรียงอยู่แล้วโดยทั่วไป สิ่งที่จะเกิดขึ้นคือผมกำลังจะไป
พยายามที่จะสลับกันสอง องค์ประกอบที่อยู่ติดกัน
ฉันจะเห็นว่า ไม่มีการแลกเปลี่ยน
และฉันก็กลับมาทันที
>> ดังนั้นก็หมายความว่าฉันเพิ่งมีการ ผ่านรายการครั้งเดียว
ดังนั้นจึงเป็น n เพราะผมดู องค์ประกอบที่ n
ทำไมเลือกจัดเรียงตาราง n?
>> ใช่แม้ว่ารายการจะถูกจัดเรียงเพื่อ ซ้ำของการจัดเรียงตัวเลือกทุกฉัน
ต้องเลือกองค์ประกอบอย่างน้อย
ดังนั้นนั่นหมายความว่าฉันต้องออกไปดู ที่องค์ประกอบทั้งหมดในการคัดเลือก
รายการและหาขั้นต่ำที่ สำหรับแต่ละซ้ำ
ไม่ว่าทำให้รู้สึก?
>> และดาบแทรกเป็น n เพราะใน กรณีที่ฉันพยายามที่จะแทรก
ตัวเลขและทั้งหมดของตัวเลขที่เมื่อฉัน พยายามที่จะแทรกให้ผมเห็นว่าพวกเขา
อยู่ในตำแหน่งที่เหมาะสม
ฉันจะได้ไม่ต้องไปตรวจสอบอื่น ๆ ทั้งหมด ตัวเลขในรายการที่ไม่ได้เรียงลำดับ
เพื่อที่ว่าทำไมมันจะเป็น n
ทำให้รู้สึก?
และสิ่งที่เป็นที?
>> ผู้ชม: [ไม่ได้ยิน]
>> LUCAS: สิ่งขอโทษ?
พูดอีกครั้ง
>> ผู้ชม: [ไม่ได้ยิน]
>> LUCAS: แน่นอน
ดังนั้นคุณจะเห็นว่าการเลือกเท่านั้น เก็บไว้ในการผสานการเรียงลำดับมี Thetas
และนั่นเป็นเพราะคุณมีเพียงที ถ้าทั้งสอง Big O และโอเมก้าเหมือนกัน
ตกลง
และในที่สุดผสานการจัดเรียงอยู่ในบันทึกของ n
>> แล้วขณะที่แดนพูดผสานการจัดเรียง เป็นชนิดเช่นเดียวกับที่
คุณค้นหาไบนารี
เพื่อให้คุณได้รับรายชื่อ
และคุณกำลังจะลดลงครึ่งหนึ่ง
แล้วคุณจะตัดพวกเขา ในส่วนที่มีขนาดเล็ก
แล้วคุณผสานพวกเขา
พวกคุณจำไว้ว่าใช่มั้ย?
ตกลงขณะที่เขากำลังพูด
>> ตกลงตัวชี้
ดังนั้นสิ่งที่เป็นตัวชี้ได้หรือไม่
>> ผู้ชม: [ไม่ได้ยิน]
>> LUCAS: ที่อยู่
ตกลง
ฉันรู้ว่าเดวิดแสดงให้เห็นพวงของ วิดีโอของบิงกี้และสิ่งที่ชี้
กันและกัน
แต่ผมชอบที่จะคิดของตัวชี้ เป็นเพียงที่อยู่
ดังนั้นจึงเป็นตัวแปรที่เป็นไป ในการจัดเก็บที่อยู่
>> จึงเป็นเพียงตัวแปรพิเศษนี้ ที่เป็นสี่ไบต์นาน
โปรดจำไว้ว่าตัวชี้ไปยังสิ่งที่เป็น เสมอสี่ไบต์นานของเรา 32 บิต
เครื่องดังนั้นกรณีที่มี เครื่องใช้ไฟฟ้า
และมันก็มีสถานที่ ของตัวแปรภายในของมัน
>> ตกลงจึงมีหน่วยความจำนี้โดยทั่วไป
ดังนั้นบล็อกของหน่วยความจำแต่ละจริงมี ป้ายซึ่งเป็นที่อยู่ของ
หน่วยความจำ slotty
ดังนั้นนั่นหมายความว่าฉันจะมี ตัวชี้ชี้ไปที่
ใด ๆ ของที่อยู่เหล่านี้
ดังนั้นเหตุผลที่ว่าทำไมเราจะใช้ตัวชี้เป็น ถ้าผมต้องจำสถานที่
ตัวแปรเฉพาะที่เป็นหน่วยความจำ
>> และพวกคุณจำได้ว่าหนึ่งในบรรดา กรณีเป็นถ้าฉันมีฟังก์ชั่น
ถ้ามีจริงอยากให้คุณ แลกเปลี่ยนสำหรับจำนวนจริงฉันจริง
มีการส่งตัวชี้
ไม่ตัวแปร
ที่พวกคุณจำไว้ว่า?
between-- ความแตกต่าง
สิ่งที่เป็นชื่อหรือไม่
เรียกค่าและเรียก โดยการอ้างอิงใช่มั้ย?
>> ตกลงใช่
เพื่อเรียกค่า
เมื่อคุณเพียงแค่ส่งตัวแปร ทำงานคุณเพียงแค่ส่งค่า
ดังนั้นคุณจะส่งจริง สำเนาของตัวแปร
และโปรแกรมของคุณไม่สามารถดูแลน้อย เกี่ยวกับถ้าตัวแปรเดียวกันจริง
ทำสำเนา
>> และเรียกโดยการอ้างอิงหมายความว่า ฉันจริงส่งสำเนาของ
ตัวชี้ไปยังตัวแปรที่
ดังนั้นก็หมายความว่าฉันส่ง สถานที่ตั้งของตัวแปรที่
ดังนั้นความรู้สึกที่ฉันมีสถานที่ตั้งของ ตัวแปรเมื่อฉันเรียกใช้ฟังก์ชัน
กับคำแนะนำฉันสามารถที่จะเป็นจริง เปลี่ยนแปลงข้อมูลที่อยู่ในหลัก
ทำให้รู้สึก?
>> แม้ว่าตัวชี้เป็นสำเนา ชี้ยังคงมีอยู่ที่แท้จริงของ
ตัวแปรที่ฉันต้องการที่จะเปลี่ยน
ทำให้รู้สึก?
>> ดังนั้นการสร้างตัวชี้
โปรดจำไว้ว่าตัวชี้มักจะมี ชนิดที่ว่ามันชี้
ไปและจากนั้นดาว
แล้วคุณจะใส่ชื่อ
ดังนั้นจำไว้ว่าเมื่อใดก็ตามที่คุณมี สิ่งที่ดาวมันก็เหมือนตัวชี้ไปยัง
ว่าสิ่งที่ตัวแปร พิมพ์ที่คุณมี
>> ดังนั้นที่นี่ในดาวเช่นมัน ตัวชี้และจำนวนเต็ม
แล้วถ่านดาวเป็นตัวชี้ ดาวถ่านและอื่น ๆ
ใช่?
>> ผู้ชม: สิ่งที่ถ้าเรามี ตัวชี้ไปยัง n ดารา x
ฉันรู้ว่าการสร้างตัวชี้ไปยัง x
มันยังประกาศ x จำนวนเต็ม?
>> LUCAS: OK ดังนั้นเมื่อคุณพูด ​​n ดาว x, คุณไม่ได้สร้างตัวชี้ไปยัง
ตัวแปร x
คุณกำลังสร้างตัวชี้ชื่อ x
>> ผู้ชม: [ไม่ได้ยิน]
>> LUCAS: ดังนั้นเมื่อฉันบอก n ดาว x ฉัน บอกว่าเดี๋ยวก่อนในหน่วยความจำที่ฉันจะ
รับหนึ่งเหล่านี้สามกล่อง
และผมจะบอกว่าที่ เป็นไปได้ x ซึ่งเป็น
จะเป็นตัวชี้
และสิ่งที่น่าสนใจเกี่ยวกับตัวชี้ คือการที่เราบอกว่าพวกเขามี
4 ไบต์สำหรับเครื่อง 32 บิต
และให้เหตุผลว่าเป็นเพราะ 4 ไบต์ 32 บิต
>> และเครื่องที่มี 64 บิตจริง มีที่อยู่ชี้
ที่มี 64 บิตนาน
ดังนั้นมันก็หมายความว่าขนาดของ ที่อยู่ในเครื่องจะแตกต่างกัน
>> ดังนั้นการอ้างอิงและ dereferencing
มีสองผู้ประกอบการที่ พวกคุณควรจำไว้
แรกคือเครื่องหมาย
ที่สองคือดาว
ไม่ได้รับสับสนโดยดาวที่นี้ star เพราะจำได้ว่าใน
กรณีนี้คุณมี n ดาว
>> มันก็เหมือนเป็นสิ่งที่ทั้งหมดเข้าด้วยกัน
ไม่มีดาวพื้นที่ n เป็น
ดังนั้นก็หมายความว่ามันเป็นคนประเภท
โปรดจำไว้ว่าเมื่อคุณมี ดาวแปรแสงคุณ
พูดคุยเกี่ยวกับประเภท
>> เมื่อคุณมีเพียงดาวแล้ว ชื่อของตัวแปรก็หมายความว่า
คุณกำลัง dereferencing ชี้ที่ หมายความว่าคุณกำลังมองหาที่
ชี้การหาที่อยู่ของมัน ชี้ไปที่จะไปยังที่อยู่ที่
และกำลังมองหาที่เมื่อใดก็ตามที่ ที่คุณมี
ดังนั้นผมจึงบอกนักเรียนของฉันว่าเมื่อคุณมี ดาวคุณควรคิดว่ามันเป็น
อักษรย่อของเนื้อหาของ
>> ดังนั้นถ้าคุณมีตัวชี้และคุณ ทำชี้ดาวก็
เนื้อหาของตัวชี้
เพื่อให้คุณไปกับสิ่งที่มันชี้ไปที่ และดูที่เนื้อหาอย่างต่อเนื่อง
และเครื่องหมายเหมือนกัน สิ่งที่เป็นที่อยู่ของ
>> ดังนั้นถ้าฉันมีตัวแปรเเรกเช่นให้ บอกว่าฉันไม่ int เท่ากับ 3--
ถ้าผมต้องการที่จะหาที่อยู่ที่ ตัวแปรหน่วยความจำฉันก็จะทำ
เครื่องหมาย
ดังนั้นจึงเป็นที่อยู่ของ
ทำให้รู้สึก?
>> ดังนั้นนี่คือตัวอย่าง
นี่คือการขาดหายไป int ขและ int ค
ดังนั้น int เท่ากับ 3 หมายความว่า ฉันจะไปที่หน่วยความจำ
และฉันจะไปหาสล็อต และใส่หมายเลข 3 ที่นี่
>> แล้ว int ขเท่ากับ 4
ฉันจะทำสิ่งเดียวกัน
ไปที่หน่วยความจำและใส่หมายเลข 4 ในหนึ่งกล่อง
และ int เท่ากับ 5
หากล่องอื่นและใส่หมายเลข 5
>> ดังนั้นสิ่งที่เป็นสายที่ทำออกมานี้ ต่อปี n ดาวเท่ากับเครื่องหมาย
ดังนั้นครั้งแรกของทั้งหมด n ดาวต่อปี
สิ่งที่มันทำอะไร
>> ผู้ชม: [ไม่ได้ยิน]
>> LUCAS: ใช่ดังนั้น n ต่อปีดาวครั้งแรก ประกาศตัวชี้ที่เรียกว่าปี
และแล้วก็การกำหนดค่าของ ตัวชี้ว่าจะเป็นที่อยู่ของ
ดังนั้นเครื่องหมาย
แล้วถ้าฉันทำ PB ดาว สิ่งที่เป็น PB ดาว?
>> โอ้ขอโทษ
นี้ยังขาดหายไป PB ดาว n
ผมหมายถึงดาวคอมพิวเตอร์
ขอโทษด้วยครับ
มันเป็นสิ่งเดียวกัน
แต่ตอนนี้ฉันดี AR การสร้างตัวชี้ ไปและจากนั้นชี้ไปยังค
ใช่?
>> ผู้ชม: [ไม่ได้ยิน]
>> LUCAS: ใช่
ดังนั้นถ้าคุณไปที่หน่วยความจำและคุณจะไป กล่องที่เป็นตัวระบุสำหรับต่อปี
คุณจริงไป เห็นที่อยู่ของ
OK?
ใช่?
>> ผู้ชม: [ไม่ได้ยิน]
>> LUCAS: ใช่ตัวชี้ที่อยู่
อย่าลืมว่า
มันก็เหมือนกับการที่สำคัญที่สุด ส่วนที่เกี่ยวกับตัวชี้
มีการจัดเก็บและที่อยู่เป็น กับตัวแปรบาง
อะไรอีกหรือไม่
หากมีปัญหาอื่น ๆ
ตกลง
>> ดังนั้นตัวชี้และอาร์เรย์
จำได้ว่าตอนที่ผมทำ int อาร์เรย์ 3 โดยทั่วไปสิ่งที่ผมทำคือผมชนิด
ของประกาศในชี้
ดังนั้นอาร์เรย์เป็นชนิดเช่นตัวชี้ไปยัง สถานที่เฉพาะในหน่วยความจำในการที่ฉัน
จัดสรรสามช่องสำหรับจำนวนเต็ม
ไม่ว่าทำให้รู้สึก?
>> ดังนั้นเมื่อผมทำ int อาร์เรย์ 3 สิ่งที่ฉัน ทำโดยทั่วไปคือการสร้างสาม
ช่องในหน่วยความจำ
ดังนั้นผมเพียงแค่หาสามช่องในหน่วยความจำ
ดังนั้นถ้าผมทำแล้วอาร์เรย์ดาวมัน โดยทั่วไปหมายถึงเนื้อหาของอาร์เรย์
ซึ่งหมายความว่าฉันลบตัวชี้ฉันไป ไปยังสถานที่ที่มันชี้ไปที่
และฉันใส่หมายเลขหนึ่ง
>> แล้วถ้าฉันทำอาเรย์สตาร์พลัส 1 นั่นคือสิ่งเดียวกับการทำอาร์เรย์
วงเล็บหนึ่งซึ่งก็หมายความว่าฉันไป สถานที่ที่ว่ามันชี้ไปที่
แล้วบวก 1 ทำให้ ฉันเปลี่ยนตำแหน่งหนึ่ง
ดังนั้นผมจึงไปที่ตำแหน่งนี้จริง และใส่หมายเลขสอง
>> และแล้วในที่สุดเมื่อฉันทำ อาร์เรย์บวก 2, ฉันไปที่
ชี้อาเรย์ที่
แล้วผมก็ย้ายไปยังบล็อกหน่วยความจำ
และจากนั้นฉันใส่บ้านเลขที่สามที่นี่
ใช่?
>> ผู้ชม: อาร์เรย์ดังนั้นดาวเป็นเพียง บอกว่าจุดแรกมาก
และคุณสามารถเพิ่ม 1 เพียงเพราะ เราเท่านั้นจริงๆ
อ้างอิงว่าที่อยู่เป็นครั้งแรก
>> LUCAS: ใช่
ทำไมเราเช่นพูดอาร์เรย์ 0, 1 อาร์เรย์และอาร์เรย์ 2 หรือไม่?
ฉันพูดทำไมคุณทำ 0, 1, 2, 3 แทน 1, 2, 3?
หนึ่งในเหตุผลคือหนึ่งคอมพิวเตอร์ โปรแกรมเมอร์ชอบที่จะเริ่มต้น
นับตั้งแต่ 0
สองเป็นเพราะเมื่อคุณทำอาร์เรย์ 0, มันเป็นสิ่งเดียวกับการทำอาร์เรย์
บวก 0 ซึ่งหมายความว่าฉันจะไป ตำแหน่งนั้นและฉันทำไม่ได้
ข้ามบล็อกหน่วยความจำใด
ดังนั้นผมจึงไม่ย้ายบล็อกหน่วยความจำใด
ใช่?
>> ผู้ชม: [ไม่ได้ยิน]
>> LUCAS: ดังนั้นเธอจึงขอให้สิ่งที่เป็น ความแตกต่างระหว่างการทำ
นี้หรือทำ malloc
หนึ่งในความแตกต่างก็คือ int อาร์เรย์ 3 การสร้าง
อาร์เรย์ในกอง
และเมื่อฉันทำ malloc มัน สร้างในกอง
ไม่ว่าทำให้รู้สึก?
>> ดังนั้นวิธีที่จะ malloc จริงๆทำงานอย่างไร
ดังนั้นทำไมเรายังต้องใช้ malloc?
คอมไพเลอร์ของคุณชนิดของตัวเลขออกทั้งหมด ตัวแปรที่คุณประกาศ
และเขาสร้างพื้นที่สำหรับทุก ของพวกเขาในกอง
ดังนั้นตัวแปรทั้งหมดของคุณจะ ที่จะเป็นหนึ่งในกอง
ดังนั้นนี่คือตัวแปรสภาพแวดล้อม
>> ดังนั้นโดยทั่วไปพื้นที่สำหรับตัวแปรเหล่านั้น ในหน่วยความจำมีการจัดสรรที่
รวบรวมเวลา
ดังนั้นก็หมายความว่าคอมพิวเตอร์ของคุณมี ที่จะรู้ว่าทั้งหมดของตัวแปรเหล่านั้น
ก่อน
มันไม่จำเป็นต้องรู้ค่าสิ่งที่ คุณกำลังจะไปใส่ในพวกเขา
แต่จะต้องรู้ว่า หน่วยความจำที่คุณต้องการ
>> แต่ตอนนี้ขอบอกว่ายกตัวอย่างเช่น คุณกำลังสร้างอาร์เรย์หรือการ
สตริงที่คุณกำลังการ จากผู้ใช้
ระยะเวลาที่คุณไม่ทราบว่าสตริง เป็นไปได้เช่น
ดังนั้นคุณจึงไม่ทราบว่าวิธีการหลาย บล็อกหน่วยความจำคุณจัดสรรใช่มั้ย?
>> จึงไม่ทำให้รู้สึกจริงๆสำหรับ คุณจะบอกว่าใส่ 100 ตัวอักษร
และแล้วสิ่งที่ถ้าผู้เขียน 150?
คุณกำลังจะได้รับการเมา
>> ดังนั้นโดยทั่วไปคุณไม่สามารถมั่นใจได้ว่า หน่วยความจำที่คุณต้องการในการจัดสรร
เมื่อคุณรวบรวมโปรแกรม
คุณเพียงแค่รู้ว่าในเวลาทำงาน
เพื่อที่ว่าทำไมคุณมีกอง
ดังนั้นกองกำลังจะมีหน่วยความจำ ว่าคุณกำลังการจัดสรรในช่วง
ระยะเวลาของโปรแกรมการทำงาน
>> ดังนั้นโดยทั่วไปเมื่อคุณทำ malloc สิ่งที่ คุณกำลังทำคือการจัดสรรหน่วยความจำที่
runtime ซึ่งหมายความว่าคุณ การตัดสินใจที่ถูกต้องในช่วงเวลานั้นที่คุณ
ควรจะมีหน่วยความจำที่
เพื่อที่ว่าเมื่อคุณกำลังจัดสรรมัน
ไม่ว่าทำให้รู้สึก?
>> ดังนั้นจำสแต็คที่มีตัวแปร ที่สร้างขึ้นในเวลารวบรวม
แล้วกองมีตัวแปร ที่สร้างขึ้นตามที่คุณไป
กับ malloc ตัวอย่างเช่น
>> ผู้ชม: [ไม่ได้ยิน]
>> LUCAS: ดังนั้น GetString เป็น จะเรียก malloc
ให้ฉันพูดคุยเกี่ยวกับ malloc และ ฉันจะอธิบาย GetString
ดังนั้น malloc เป็นสิ่งเดียวกัน การจัดสรรหน่วยความจำ
ดังนั้นมันจะจัดสรร หน่วยความจำในกอง
และมันจะกลับตัวชี้ไปยัง ที่หน่วยความจำที่ได้รับการจัดสรรที่
>> ดังนั้นเมื่อคุณ do--
ที่นี่สำหรับยกตัวอย่าง
ชี้ดาว n
แล้วชี้เท่ากับ malloc ขนาดของนิ้วครั้ง 10
ฉันกำลังสร้างตัวชี้
แล้วผมกำหนดตัวชี้ไปที่ ค่าของตัวชี้ malloc ว่า
ให้ฉัน
>> ดังนั้นฉันขอ malloc คุณสามารถจัดสรร พื้นที่ 10 จำนวนเต็ม
นั่นคือสิ่งที่มันพูดว่า
และ malloc ให้ฉันกลับ ตัวชี้ไปยังสถานที่ที่
ทำให้รู้สึก?
ตกลง
ฉันและ GetString คือโดยทั่วไปทำ เรียกร้องให้ malloc เพื่อให้คุณสามารถจัดสรร
หน่วยความจำในช่วงรันไทม์
>> โปรดจำไว้เสมอเพื่อตรวจสอบเป็นโมฆะ เพราะ malloc จะกลับ null
หากไม่สามารถจัดสรรหน่วยความจำ
สมมติว่าคุณขอไร้สาระ จำนวนหน่วยความจำ
คอมพิวเตอร์ของคุณจะไม่เป็น สามารถจัดสรรที่มาก
>> ดังนั้น malloc เป็นเพียงการไป ที่จะกลับมาเป็นโมฆะ
ดังนั้นจำไว้เสมอเพื่อตรวจสอบว่า ตัวชี้ที่คุณได้จาก malloc เป็น
โมฆะหรือไม่เพราะถ้าเป็นคุณอาจ จะ dereferencing ตัวชี้และ
ก่อให้เกิดความผิดพลาดด้าน
และสุดท้ายอย่าลืม หน่วยความจำของคุณ
>> malloc คือการสร้างหน่วยความจำในกอง
และคุณจะต้องเพิ่มหน่วยความจำ ก่อนที่จะสิ้นสุดโครงการ
ตกลงนั่นคือทั้งหมดที่สำหรับฉัน
ขออภัยร็อบ
ขอบคุณ
>> [APPLAUSE]
>> LUCAS: คำถามสุดท้าย ก่อนที่ร็อบมา?
หรือไม่?
ใช่?
>> ผู้ชม: ฉันไม่เห็น นี้หนึ่งออนไลน์
คุณอัปโหลดไปยัง?
>> LUCAS: ผมคิดว่าเดฟเป็น อัปโหลดเร็ว ๆ นี้
>> เดฟ: มันจะถูกโพสต์
>> LUCAS: มันจะเป็นออนไลน์
>> ผู้ชม: มันขึ้น
>> LUCAS: มันได้หรือไม่
ตกลง
ใช่?
>> ผู้ชม: [ไม่ได้ยิน]
>> LUCAS: ใช่คุณควรจะฟรีทั้งหมด หน่วยความจำที่อยู่ในกอง
>> ผู้ชม: [ไม่ได้ยิน]
>> LUCAS: ใช่
เวลาที่คุณมี malloc วัฒนธรรม คุณควรจะมีวัฒนธรรมฟรี
หลังจากที่คุณหยุดใช้ตัวแปรที่
ดังนั้น malloc และฟรี เสมอกัน
เพื่อนที่ดีที่สุดของพวกเขา
ใช่
ร็อบ?
>> ROB: ฉันจะไปได้อย่างรวดเร็ว
และวิดีโอจะถูกนำขึ้น
ฉันมีไมค์ใน
>> ตกลงดังนั้นสัปดาห์ที่ห้าสิ่งที่
สิ่งแรกที่เราได้เป็นกอง
ดังนั้นจำไว้ว่ามีเพียงหนึ่งสแต็ค เฟรมต่อการเรียกใช้ฟังก์ชันที่ใช้งาน
เราจะเห็นว่าในครั้งที่สอง
และยังจำได้ว่าสิ่งที่จะไปจริง ในแต่ละเฟรมกองกำลังจะเป็น
ตัวแปรท้องถิ่นของฟังก์ชั่นของเรา ข้อโต้แย้งที่จะผ่านเข้ามาในของเรา
ฟังก์ชั่นพร้อมกับคู่ สิ่งอื่น ๆ ที่คุณทำไม่ได้จริงๆ
จำเป็นต้องกังวลเกี่ยวกับ
>> ดังนั้นนี่คือโปรแกรมตัวอย่างที่ แจ้งให้ทราบล่วงหน้าหลักคือ printfing ผลตอบแทน
ค่าของ foo 4
foo เป็นเพียงการไปกลับ ค่าของบาร์ 4 จุลภาค 6
และบาร์จะตั้งบางท้องถิ่น n ตัวแปรเท่ากับ 4 ครั้ง 6
แล้วกลับ n
>> ดังนั้นให้ดูที่กองตลอด ซ้ำที่เกิดขึ้นจริงของโปรแกรมนี้
จึงมีด้านล่างของสแต็คของเรา
โปรดจำไว้ว่ากองโตขึ้น
ดังนั้นที่ด้านล่างของสแต็คของเราเรา มีกรอบสแต็คสำหรับหลัก
เมื่อโปรแกรมเริ่มต้นที่สำคัญ อยู่เสมอจะเป็นที่
ด้านล่างของสแต็คของเรา
>> และสิ่งที่อยู่ภายในของเรา กองกรอบหลัก?
ดังนั้นแม้ว่าจะไม่มีท้องถิ่น ตัวแปรหลักเช่นฉันกล่าวก่อน
เราได้ argc และ RGV สละพื้นที่ ภายในของกองกรอบหลัก
ดังนั้นหลักอยู่ในขณะนี้ที่จะไป เรียก foo ฟังก์ชั่น
และนั่นหมายความว่า foo เป็นไปได้ ได้รับกรอบสแต็คของตัวเอง
>> ดังนั้นตอนนี้เรากำลังอยู่ภายใน foo ฟังก์ชั่น
และสิ่งที่ต้องการที่จะไปใน ฟูกรอบของสแต็ค?
ดี foo มี n อาร์กิวเมนต์
และ n เท่ากับ 4 เนื่องจากว่าเป็นสิ่งที่ หลักจะผ่านเป็นอาร์กิวเมนต์ foo ของ
>> ดังนั้นตอนนี้ foo จะเรียกบาร์
สิ่งที่บาร์จะมีภายใน ของกรอบสแต็คได้อย่างไร
มันมี x เท่ากับ 4 ปีเท่ากับหก
นั่นไม่ใช่สิ่งที่เรากำลังจะมี ในกรอบกองเพราะบาร์
นอกจากนี้ยังมีตัวแปร n ท้องถิ่น
n และเรากำลังจะตั้งเท่ากับ 24
>> ดังนั้นตอนนี้บาร์จะกลับ n
ดังนั้นบาร์จะกลับ 24 ถึง ฟูกรอบสแต็ค
และเนื่องจากบาร์อยู่ในขณะนี้กลับมาที่ หมายความว่าเรากำลัง popping กรอบสแต็ค
สำหรับบาร์ออกของสแต็ค
ดังนั้นสิ่งที่หน่วยความจำที่บาร์ได้ ใช้อยู่ในขณะนี้ออกจากกอง
>> ตอนนี้ foo ยังเป็นไป 24 เพื่อกลับไปที่หน้าหลัก
ดังนั้นตอนนี้ foo ที่จะกลับหน่วยความจำ foo ที่ถูกใช้ในการ 'ของ
กรอบสแต็คที่หายไปยัง
และตอนนี้เป็นหลักจะเรียก printf
ดังนั้น printf เป็นเพียงฟังก์ชั่นอื่น
เมื่อเราเรียก printf ก็เป็นไปได้ กองกรอบอีก printf
การเรียกใช้ฟังก์ชัน
>> สิ่งที่เราผ่าน printf?
นั่นคือสิ่งที่จะไป บนกรอบสแต็คของ
อย่างน้อยที่สุดเราก็ผ่าน ร้อยละที่ฉันทับขวา n และ
อาร์กิวเมนต์ 24
มันอาจจะมีมากขึ้นในการเป็นกองกรอบ ถ้า printf เกิดขึ้นจะใช้บางส่วน
ตัวแปรท้องถิ่น
เราไม่ทราบ
>> แต่ทั้งหมดที่จะไปในของ printf กรอบสแต็ค
ก็จะดำเนินการ printf
แล้ว printf ทำ
มันจะกลับมา
ในที่สุดหลักคือการทำ
หลักจะกลับมา
แล้วโปรแกรมของเราจะทำ
ใช่?
>> ผู้ชม: คุณเห็น [ไม่ได้ยิน]
ข้อโต้แย้ง [ไม่ได้ยิน]
พารามิเตอร์?
>> ROB: ดังนั้นมีความแตกต่างที่ลึกซึ้ง ระหว่างการขัดแย้งและพารามิเตอร์
และจริงๆในพูดทั่วไปคนมัก เพียงแค่ผสมให้เข้ากันตลอดเวลา
แต่พารามิเตอร์ที่เป็นทางการ ชื่อของสิ่งที่
>> ดังนั้น argc และ argv เป็น พารามิเตอร์หลัก
การขัดแย้งเป็นสิ่งที่คุณจริง ผ่านในเป็นพารามิเตอร์เหล่านั้น
จึงมีเมื่อฉันโทร foo 4, 4 เป็นเหตุผลที่ผมผ่านใน
และ n พารามิเตอร์ภายในของ foo ใช้เวลาอยู่กับค่า 4
ตั้งแต่ 4 เป็นอาร์กิวเมนต์
>> ผู้ชม: [ไม่ได้ยิน]
>> ROB: n คือตัวแปรท้องถิ่นที่บาร์
n คือยังท้องถิ่นเพื่อ foo แต่ เป็นพารามิเตอร์ foo
มันไม่ได้เป็นตัวแปรท้องถิ่น
ใช่?
>> ผู้ชม: [ไม่ได้ยิน]
>> ROB: บาร์ foo เป็นเพียงการโทรและ กลับมาตอบแทนสิ่งที่บาร์
>> ผู้ชม: [ไม่ได้ยิน]
>> ROB: ใช่เพียงเพื่อดูหลาย เฟรมสแต็ค
ใช่?
>> ผู้ชม: ทำไม foo เรียกว่า ก่อนที่จะ printf?
>> ROB: ทำไม foo เรียกก่อน printf?
เพื่อที่ผมจะได้แทนการทำบางสิ่งบางอย่าง เช่น int x เท่ากับ foo 4
แล้วพิมพ์ x
แต่ผมรวมฟังก์ชั่น โทรเข้ามาโต้แย้ง printf
>> แต่สังเกตเห็นว่าเราไม่สามารถจริง ดำเนินการเรียก printf จนกว่าเราจะ
คิดออกว่า foo จาก 4 เป็น
ดังนั้นเราจะประเมินนี้
และเพียงครั้งเดียวที่ทำจะ ที่จะกลับมาและประเมินผลนี้
ใช่?
>> ผู้ชม: ตั้งแต่บาร์ทั้งสอง [ไม่ได้ยิน]
มูลค่าทำไมเราไม่ได้ [ไม่ได้ยิน]
>> ROB: พวกเขาทั้งหมดควรจะเป็น int
ที่ไม่ได้จับเหนือ หลายที่ผ่านมา
ดังนั้นมันควรจะเป็นบาร์ int และ int foo เนื่องจากทั้งสองของคนเหล่านั้น
จะกลับจำนวนเต็ม
เป็นโมฆะเป็นเพียงว่าพวกเขาจะไม่ เพื่อกลับค่าที่เกิดขึ้นจริง
ใช่?
>> ผู้ชม: ถ้าคุณมีสายดังกล่าวข้างต้น กลับมา [ไม่ได้ยิน]
>> ROB บรรทัดข้างต้นกลับมา?
>> ผู้ชม: ใช่
เช่นหากคุณไม่ printf และ [ไม่ได้ยิน] มันจะพิมพ์สองครั้ง
>> ROB: ดังนั้นภายในของ foo?
ถ้าเรามี printf ที่นี่?
>> ผู้ชม: ใช่
>> ROB: ดังนั้นถ้าเรามีสิทธิ printf ที่นี่ก็จะพิมพ์ครั้งเดียว
เนื่องจากเรากำลังเรียก foo ครั้งขวา ที่นี่แล้วเราจะตี printf
จากนั้นเราจะเรียกบาร์
แล้ว foo จะกลับมา
และที่มัน
เราเท่านั้นที่เคยพบ printf ครั้ง
ใช่?
>> ผู้ชม: [ไม่ได้ยิน]
printf เรียก foo เพราะเราเป็นครั้งแรก เรียก printf แล้วเรากำลังผ่าน
ข้อโต้แย้ง
>> ROB: ดังนั้นในทางทฤษฎีไม่ได้ printf เรียก foo?
จึงไม่มี
เพียงเพื่อให้คเป็นไปได้ ดำเนินการสิ่งเหล่านี้ก่อนที่เราจะสามารถ
การเรียกใช้ฟังก์ชันทั้งหมดของการขัดแย้ง ฟังก์ชั่นต้อง
ได้รับการประเมินอย่างสมบูรณ์
เพื่อให้มีการประเมินนี้อย่างสมบูรณ์?
ใช่มันเป็นเพียงสตริง
มันเป็นเพียงค่า
>> แล้วเราจะต้องสมบูรณ์ การประเมินนี้
ครั้งนี้จะทำตอนนี้ทั้งหมดของ ข้อโต้แย้งของตนได้รับการประเมิน
และตอนนี้เราสามารถทำให้ โทร printf
ใช่?
>> ผู้ชม: หนึ่งคำถาม
หากคุณมีฟังก์ชั่นโมฆะต้อง คุณมีผลตอบแทนอัฒภาค?
>> ROB: คุณไม่อัฒภาคผลตอบแทน ถ้าคุณมีฟังก์ชั่นเป็นโมฆะ
ตกลง
ดังนั้นตอนนี้บางสิ่งที่กอง
ดังนั้นกองคือวิธีที่เรากำลังจะไปจัดการ กับการจัดการหน่วยความจำแบบไดนามิก
และความขัดแย้งโดยตรงกับ กองซึ่งเราจะเรียกโดยอัตโนมัติ
การจัดการหน่วยความจำ
>> ดังนั้นในสแต็คที่คุณไม่เคยมี ที่จะจัดการกับวิธีการที่ตัวแปรท้องถิ่น
กำลังได้รับการผลักดันและโผล่ออกทั้งหมด เหล่านี้กองเฟรมและทุกสิ่งที่
คุณไม่ต้องกังวลเกี่ยวกับเรื่องนี้
มันเป็นไปโดยอัตโนมัติ
ดังนั้นกองเป็นคู่มือ
และ [ไม่ได้ยิน]
มาจากฟังก์ชั่นเหล่านี้ malloc และฟรี
>> ดังนั้นนี่คือโปรแกรมอื่น
ทุกสิ่งที่เรากำลังทำคือ mallocing จำนวนเต็ม
เรากำลังจัดเก็บไว้ในดาว x
แน่นอนเราต้องตรวจสอบ เพื่อดูว่า x เป็นโมฆะ
จากนั้นเราจะเพิ่งตั้งสิ่งที่ x จะชี้ไปถึง 50
พิมพ์สิ่งที่ x จะชี้ไป print x และ x แล้วฟรี
>> ดังนั้นวิธีการนี​​้เป็นจริงจะไปดู ถ้าเรามองไปที่กองและกองของเราหรือไม่
ดังนั้นเราจะเริ่มต้นอีกครั้ง
ด้านล่างของสแต็คของเราก่อน
โปรดจำไว้ว่าเจ้ากองโดยตรง ตรงข้ามกับสแต็ค?
ดังนั้นเรากำลังจะมี ด้านบนของกองของเรามีขึ้น
>> ดังนั้นด้านล่างของสแต็คของเราเรามี กรอบสแต็คของเราสำหรับหลัก
แต่ก็มีพื้นที่สำหรับ argc, argv และเรา ตอนนี้มีตัวแปร x ท้องถิ่นซึ่ง
เป็นดาว int
ดังนั้นเรากำลังจะย้ำ ผ่านโปรแกรมนี้
สิ่งแรกที่เรามีคือ เรียกร้องให้ malloc
>> ดังนั้นเรากำลังทำเรียกร้องให้ malloc
malloc เป็นฟังก์ชัน
มันจะได้รับกรอบสแต็ค
สิ่งที่เราผ่านไป malloc?
ที่จะเข้าไปข้างใน ของกรอบสแต็ค
เรากำลังผ่านขนาดของ n ซึ่งคือ 4
เพื่อให้มีการส่งผ่านไปยัง malloc
>> สิ่งที่ไม่ malloc ทำอย่างไร
มันคว้าเราพื้นที่ในกองบางส่วน
ดังนั้นเรากำลังจะไปที่กอง
และเรากำลังจะคว้า 4 ไบต์จากกอง
จึงขอเพียงแค่ให้ที่ ที่อยู่โดยพลการ
0x123 เพียงแค่แกล้งทำเป็นว่าเป็น ที่อยู่ที่อยู่บนกอง
>> ดังนั้นสิ่งที่เป็นจริงภายในของที่ พื้นที่ของหน่วยความจำที่อยู่ที่ Ox123?
ขยะ
ดังนั้นเราจึงยังไม่ได้เก็บอะไรในนั้น
ดังนั้นเท่าที่เรารู้ว่ามัน จะเป็นอะไร
คุณไม่ควรจะถือว่าเป็นศูนย์
เป็นไปได้มากที่สุดไม่เป็นศูนย์
>> ดังนั้นตอนนี้ผลตอบแทน malloc
และเราจะทำอย่างไรเมื่อผลตอบแทน malloc?
เรากำหนดสิ่งที่มันกลับ
เราตั้งค่า x เท่ากับสิ่งที่ มันจะกลับมา
ดังนั้นมันคือสิ่งที่กลับมา?
มันกลับ 0x123 ตั้งแต่ที่เป็น ที่อยู่ของบล็อกของหน่วยความจำที่
การจัดสรรเพียงแค่ในกอง
>> ดังนั้นกลับ 0x123 x อยู่ในขณะนี้จะได้รับการตั้งค่า เท่ากับ 0x123 ซึ่ง pictorially,
เรามักวาดเป็น x มีที่เกิดขึ้นจริง ลูกศรชี้ไปยังบล็อกที่
แต่ x เป็นเพียงการจัดเก็บอยู่ที่
ดังนั้นตอนนี้เราจะต้องตรวจสอบว่า x เป็นโมฆะ
มันไม่ได้เป็นโมฆะ
เราแกล้งทำเป็นว่า malloc ที่ประสบความสำเร็จ
>> ดังนั้นตอนนี้ดาว x เท่ากับ 50
ดังนั้นดาวจำได้ว่ามันหมายความว่า ไปที่ที่อยู่ที่
ดังนั้น 0x123 เรากำลังจะไป ไปที่ที่อยู่ที่
เพื่อที่จะทำให้เรามีขึ้น
สิ่งที่เราทำตามที่อยู่ที่?
เรากำลังจัดเก็บ 50
>> ดังนั้นหลังจากบรรทัดนี้ว่าเป็นสิ่งที่ สิ่งที่จะไปให้มีลักษณะเหมือน
ดังนั้นตอนนี้ก็ไม่ได้อีกต่อไป ขยะมีขึ้น
ตอนนี้เรารู้ว่า 50 อยู่ในที่ อยู่โดยเฉพาะอย่างยิ่งเพราะ
เราตั้งค่าให้ว่า
OK?
ดังนั้นตอนนี้เรากำลังจะพิมพ์ฉ
>> ดังนั้นก่อนที่เราจะพิมพ์ดาว x
ดังนั้นสิ่งที่เป็นดาว x?
อีกครั้งดาว x หมายถึงการไปที่ สิ่งที่ x จะชี้ไปที่
ดังนั้น x ถูกจัดเก็บ 0x123 ไปที่
50 เราได้รับ
เพื่อให้พิมพ์ว่า f
และนั่นหมายความว่ามันจะพิมพ์ 50
แล้วผลตอบแทนที่
>> และแล้วเราก็มี printf ที่สอง
เราตอนนี้ร้อยละหน
ถ้าคุณยังไม่เห็นมันว่าเป็น เพียงแค่ว่าคุณพิมพ์ตัวชี้
ดังนั้นเราจึงมีฉันร้อยละร้อยละ ฉและทุกคนอยู่แล้ว
ดังนั้นร้อยละ, p พิมพ์ตัวชี้
>> ดังนั้น x เป็นตัวชี้
ดังนั้นถ้าเราจะพิมพ์ x ตัวเอง เรากำลังพิมพ์สิ่งที่เป็นจริงภายใน
x ซึ่งเป็น 0x123 ดังนั้นก่อน ฉพิมพ์จะพิมพ์ 50
ฉพิมพ์ครั้งที่สองที่เกิดขึ้น พิมพ์ 0x123 ใช่?
>> ผู้ชม: คุณใช้ร้อยละ x ในการพิมพ์ตัวชี้?
>> ROB: งั้นคุณใช้ร้อยละ x ในการพิมพ์ตัวชี้?
เพื่อให้คุณสามารถ แต่ร้อยละ x เป็นเพียง โดยทั่วไปสำหรับเช่นถ้าคุณมีบาง
จำนวนเต็มและคุณต้องการที่จะพิมพ์ เป็นเลขฐานสิบหก
นั่นเป็นเพียงวิธีการที่คุณทำอย่างนั้น
>> ในขณะที่ร้อยละงจะ พิมพ์เป็นทศนิยม
ที่ถูกเราจะได้รับร้อยละ ง ฉันเป็นเพียงจำนวนเต็ม
ร้อยละหนเป็นพิเศษ สำหรับคำแนะนำ
>> ดังนั้น x เป็นตัวชี้
เราต้องการที่จะใช้ร้อยละหน
แต่ร้อยละ x สามารถทำงาน
ใช่?
>> ผู้ชม: [ไม่ได้ยิน]
>> ROB: ใช่
อย่างน้อยนี้ call-- ดังนั้นฉัน ไม่ได้รวมไว้ในที่นี่
แต่ทั้งสองมีปากเสียงมีความจำเป็นต้อง ภายในกรอบของกองนี้
พร้อมกับตัวแปรท้องถิ่นใด ๆ printf เกิดขึ้นจะใช้
แล้วโทรไปเพื่อ printf ตอนนี้ ภายในของ printf กรอบสแต็คเป็น
ร้อยละ n พีเครื่องหมายและสิ่งที่ ค่าของ x คือซึ่งเป็น 0x123
ใช่?
>> ผู้ชม: [ไม่ได้ยิน]
>> ROB: มันจะพิมพ์อะไรบางอย่าง ที่มีลักษณะเช่นนี้
>> ผู้ชม: [ไม่ได้ยิน]
>> ROB: ดังนั้นมันพิมพ์ในรูปแบบที่อยู่
ดูเหมือนว่าที่อยู่
ใช่?
>> ผู้ชม: [ไม่ได้ยิน]
>> ROB: ทำไมคืออะไร?
>> ผู้ชม: [ไม่ได้ยิน]
>> ROB: เป็นตัวชี้นี้ทำไมไบต์ที่ 4?
ดังนั้นจึงมีทั้งกลุ่ม 0 ในหน้านี้
ดังนั้นจึงเป็นจริงๆ 0x0000000123
ในระบบ 64 บิตจะมี ทั้งกลุ่มของศูนย์มากขึ้น
ใช่?
>> ผู้ชม: [ไม่ได้ยิน]
>> ROB: ดังนั้น printf แรก เป็นไป print--
>> ผู้ชม: [ไม่ได้ยิน]
>> ROB: ใช่มันจะพิมพ์ สิ่งที่ x จะชี้ไปที่
สตาร์กล่าวว่านี่คืออะไร สิ่งที่ชี้ไปที่
คว้ามัน
ดังนั้นมันจึงเป็นสิ่งที่ชี้ไปที่?
50
คว้ามัน
นั่นคือสิ่งที่เรากำลังจะพิมพ์
ในขณะที่หนึ่งต่อไปเราไม่ เพียงแค่พิมพ์ x ตัวเอง
สิ่งที่อยู่ภายในของ F?
0x123
ตกลง
>> และแล้วในที่สุดเราได้ฟรี
สิ่งที่เราผ่านไปได้ฟรีหรือไม่
เรากำลังผ่าน x
เวลาที่ฉันแสดงจริงที่ มันอยู่ในกรอบสแต็ค
>> ดังนั้นเราผ่านค่า 0x123 ที่จะเป็นอิสระ
ดังนั้นตอนนี้ฟรีรู้สิทธิทั้งหมด ฉันต้องไปถึงกอง
และฟรีหน่วยความจำที่
มันไม่ใช้สิ่งที่ เป็นที่ที่อยู่ 0x123
>> ดังนั้นฟรีจะไปปล่อย ว่าจากกอง
ตอนนี้กองของเราเป็นที่ว่างเปล่าอีกครั้ง
เราไม่มีการรั่วไหลของหน่วยความจำ
ตอนนี้ฟรีจะกลับมา
ขอให้สังเกต x ที่ยังคง 0x123
แต่ที่ตอนนี้หน่วยความจำไม่ถูกต้อง
เราควร dereference x ไม่
ใช่?
>> ผู้ชม: การกลับ 0 ซ้ำซ้อน?
>> ROB นี้ returen 0 ซ้ำซ้อน?
ใช่
เราเพียงแค่ใส่ที่มีเพราะ เรามีหนึ่งคืนสำหรับอากาศ
ดังนั้นมันก็เหมือนใช่ช่วยให้ รวมถึงผลตอบแทน 0
ใช่?
>> ผู้ชม: [ไม่ได้ยิน]
>> ROB: ดังนั้นหลังจากที่ x ฟรี, เกิดอะไรขึ้นถ้า เราพยายามที่จะ dereference ตัวชี้?
เป็นไปได้ว่าไม่มีอะไรผิดพลาด
เป็นไปได้ว่าเรายังจะได้รับ 50
>> มันเป็นไปได้ยังว่าหน่วยความจำที่เป็น ขณะนี้ถูกนำมาใช้อย่างอื่น
ดังนั้นจึงเป็นพฤติกรรมที่ไม่ได้กำหนด
และไม่ได้กำหนดหมายความว่าอะไร สามารถเกิดขึ้นได้
ใช่?
>> ผู้ชม: [ไม่ได้ยิน]
>> ROB: ไม่มีดังนั้นถ้าคุณกำหนด x ไปเป็นอย่างอื่น
ดังนั้นถ้าที่นี่เรากล่าวว่า x เท่ากับ สิ่ง malloc else--
malloc event-- ขนาด
แล้วว่าบล็อกเดิม ของหน่วยความจำที่ไม่ได้เป็นอิสระ
และเราได้สูญเสียอย่างเป็นทางการ
นั่นคือหน่วยความจำรั่ว
เราได้สูญเสียข้อมูลทั้งหมด เพื่อป้องกันหน่วยความจำที่
ดังนั้นไม่มีทางที่เราสามารถที่เคยมันฟรี
ตกลงดังนั้นแล้วกลับ 0 หมายถึงการทำ
>> ทั้งหมดที่ถูกต้องเพื่อให้กองล้น
อะไรคือความคิดที่นี่?
ดังนั้นจำกองกำลังลง
สแต็คที่เกิดขึ้น
ดังนั้นนี่คือตัวอย่างจากการบรรยายที่ ผมคิดว่าที่สำคัญเป็นเพียงการไป
เรียก foo ฟังก์ชันนี้ซึ่งเป็นไป จะเรียกตัวเองซ้ำแล้วซ้ำ
ครั้งแล้วครั้งเล่า
>> ดังนั้นกองเฟรมจะไป ทำงานตรงเดียวกัน
ดังนั้นเรากำลังจะเริ่มต้นด้วยหลัก สแต็คเป็นกรอบด้านล่าง
แล้วหลักที่จะเรียก foo ซึ่ง เป็นไปได้กรอบสแต็ค
>> แล้ว foo จะเรียก foo อีกครั้งซึ่งเป็นไปได้
กองกรอบอื่น
และจากนั้นอีกครั้งและอีกครั้งและอีกครั้ง และอีกครั้งจนในที่สุดเราทำงาน
เป็นกอง
ดังนั้นนี่คือวิธีการที่เราได้รับ กองล้น
และที่จุดนี้คุณ seg ความผิด
หรือคุณต้องการจริงๆ seg ความผิดก่อน จุดนี้ แต่ใช่
>> ผู้ชม: ถ่ายโอนข้อมูลเป็นหลัก เช่นเดียวกับความผิด seg?
>> ROB: ดังนั้นคุณจะเห็นการแบ่งส่วน หลักความผิดทิ้ง
คุณจะได้รับการถ่ายโอนข้อมูลที่สำคัญเมื่อ คุณ seg ความผิด
และมันก็เหมือนการถ่ายโอนข้อมูลทั้งหมดของ เนื้อหาของหน่วยความจำในปัจจุบันของคุณเพื่อให้
ที่คุณสามารถลองและระบุ ทำไมคุณ seg โทษฐาน
ใช่?
>> ผู้ชม: [ไม่ได้ยิน]
>> ROB: ดังนั้นวิธีการที่ผิดส่วน มีกองล้น
ดังนั้นไม่จำเป็นต้อง
ความผิดส่วนหมายความว่าคุณกำลัง หน่วยความจำการสัมผัสในลักษณะ
คุณไม่ควรจะ
ดังนั้นวิธีหนึ่งที่เกิดขึ้นคือเมื่อ คุณสแต็คล้นเราเริ่มต้นสัมผัส
หน่วยความจำในแบบที่เราไม่ควรจะเป็น
ใช่?
>> ผู้ชม: [ไม่ได้ยิน]
>> ROB: ดังนั้นภายในวง จำกัด
เช่นนี้เป็นเหมือนไม่มีที่สิ้นสุดซ้ำ ห่วงและเพื่อให้เราได้รับอีก
กองกรอบแต่ละครั้ง
แต่ภายในของปกติ ไม่มีที่สิ้นสุดในขณะที่ one--
ดีให้ไม่ได้พิมพ์ f--
ทำอะไรบางอย่าง
สิ่งที่
>> เราจะไม่ได้รับ กองกรอบอื่น
เรากำลังจะให้วนลูป ผ่านการเรียนการสอนครั้งนี้ครั้งเดียว
สแต็คที่ยังไม่เติบโต
มันเป็นความจริงที่ว่าแต่ละ recursive โทรจะให้เรากรอบสแต็ค
นั่นเป็นเหตุผลที่เราได้รับกองล้น
ใช่?
>> ผู้ชม: ดังนั้นถ้าคุณบอกว่าจะได้รับ ในขณะที่วงแล้ว [ไม่ได้ยิน]
>> ROB: ดังนั้นถ้าภายในของวงในขณะที่ มี printf คุณยังจะ
ไม่ใช่ความผิด seg
ผมก็ไม่ได้ต้องการที่จะสร้างความสับสนให้สิ่งที่
มันจะห่วง
คุณจะได้รับกองเดียว กรอบ printf
>> printf แล้วจะกลับมา
แล้วคุณควรที่จะห่วงอีกครั้ง
คุณจะได้รับกองเดียว กรอบ printf
มันจะกลับมา
กรอบกองเดียว
เพื่อให้คุณไม่ได้รับที่ไม่มีที่สิ้นสุดนี้ ซ้อนขึ้นกรอบสแต็ค
>> ผู้ชม: [ไม่ได้ยิน]
>> ROB: ใช่
ดังนั้นกองล้นนี้เกิดขึ้น เพราะไม่มีเหล่านี้
เรียก foo จะกลับมา
ดังนั้นหากเรากลับมาแล้วเราจะ เริ่มสูญเสียเฟรมสแต็ค
แล้วเราจะไม่กองล้น
และนั่นคือเหตุผลที่คุณต้องกรณีฐาน สำหรับการทำงานส่วนบุคคลของคุณ
ใช่?
>> ผู้ชม: เป็นขนาดที่มีศักยภาพและ กองสำหรับกองเหมือนกันสำหรับ
โปรแกรมทั้งหมดหรือไม่
>> ROB: ประมาณ
เป็นขนาดที่มีศักยภาพของสแต็คและ กองเดียวกันสำหรับโปรแกรมทั้งหมดหรือไม่
ประมาณ
มีการสุ่มบางอย่างที่จะเป็น ที่กองเริ่มต้นและ
ที่กองเริ่มต้น
หากคุณเกิดขึ้นที่จะมีจำนวนมากทั้งจาก ตัวแปรระดับโลกและสิ่งที่คุณอาจ
จะออกไปจากพื้นที่บางส่วน สำหรับกองของคุณ
>> ในระบบ 64 บิตคุณจริง มีหน่วยความจำไม่มีที่สิ้นสุด
มีเพียงมาก
ระหว่าง 32 บิตและ 64 บิตที่ เป็นความแตกต่างอย่างมีนัยสำคัญ
>> คุณกำลังจะได้รับมากขึ้นทั้ง กองและพื้นที่กองบน 64 บิต
ระบบเพราะมีเพียง อยู่ที่ว่าพวกเขาสามารถใช้
แต่ในแต่ละระบบก็จะ จะประมาณจำนวนเดียวกันของสแต็ค
และพื้นที่กอง
ขวาทั้งหมด
>> ดังนั้นสิ่งสุดท้ายคือการสะสม
ดังนั้นคุณควรจะรู้ว่ากระบวนการนี​​้
มีสี่ขั้นตอนใหญ่
ดังนั้นคนแรกที่ควร ง่ายต่อการจำ
ก่อนการประมวลผล
มันมีก่อนคำนำหน้าในนั้น
ดังนั้นมันมาก่อนที่ทุกอย่างอื่น
>> สิ่งที่ต้องจำไว้เป็นกัญชา
ดังนั้นกัญชากำหนดและกัญชารวมถึง ในทุกที่
ผู้ที่มีทั้งหมดก่อนการประมวลผล คำสั่ง
เหล่านี้เป็นสิ่งที่ ก่อนประมวลผลจะดูแล
>> ดังนั้นสิ่งที่จะประมวลผลก่อนทำอย่างไร
มันเป็นสิ่งที่โง่จริงๆ
ทั้งหมดก็คือค​​วามสามารถในการมีสิ่งเหล่านี้ คัดลอกและตัดและวางการดำเนินงาน
>> ดังนั้นกัญชารวมถึง i0 มาตรฐานจุดชั่วโมง
อะไรคือสิ่งที่ทำ?
มันโลภมาตรฐานจุดชั่วโมง i0 ไฟล์และวางมันลงไปด้านบน
ที่ใดก็ตามที่มันบอกว่ากัญชารวมถึง มาตรฐานจุดชั่วโมง i0
>> และกัญชาใด ๆ ที่กำหนดว่าเราได้ เห็นสิ่งที่ว่าทำอะไร
คัดลอกของค่าที่กัญชา กำหนดถูกกำหนดให้เป็นและวางที่
ทุกที่ที่คุณจะใช้ค่า
ดังนั้น preprocessor ​​ก็ไม่จริง การดำเนินงานที่เรียบง่ายตามข้อความ
มันจะไม่มีอะไรที่สมาร์ท
ดังนั้นทุกอย่างอื่นเป็น ซับซ้อนมากขึ้น
>> ดังนั้นตอนนี้พรีโพรเซสเซอร์ที่เป็น เสร็จแล้วเราจะรวบรวม
ดังนั้นสิ่งที่จะรวบรวมความหมายว่าอย่างไร
ตอนนี้เรากำลังจะจากรหัสค รหัสการชุมนุม
ใช่?
>> ผู้ชม: [ไม่ได้ยิน]
>> ROB: ใช่เราจับได้ว่า
ดังนั้นการรวบรวม
เรากำลังจะจาก c เพื่อประกอบ
ดังนั้นนี่คือการเปลี่ยนแปลงภาษาที่เกิดขึ้นจริง
รวบรวมตัวเองหมายความว่าจะจาก ภาษาระดับที่สูงขึ้นเพื่อ
ภาษาระดับต่ำ
>> และ c คือภาษาระดับสูง เมื่อเทียบกับการชุมนุม
การชุมนุมคืออะไร
คำแนะนำที่มีความสวย มากทำให้ CPU ของคุณ
แต่คอมพิวเตอร์ของคุณยังคงไม่ ไม่เข้าใจการชุมนุม
มันเพียง แต่เข้าใจคนและศูนย์
ดังนั้นขั้นตอนต่อไปคือการประกอบซึ่ง นำเรามาจากคำแนะนำเหล่านี้ว่า
CPU ของคุณเข้าใจและจริง แปลพวกเขาเพื่อ
คนและศูนย์
>> ดังนั้น C ถึงการชุมนุมที่จะไบนารี
แต่ฉันไม่ได้มีปฏิบัติการยัง
ดังนั้นคิดของห้องสมุด CS50
เราได้ให้คุณมีฐานสำหรับ ห้องสมุด CS50 นี้ซึ่งมี GetString
และ GetInt และสิ่งที่
>> แต่ CS50 library--
ในและของ itself-- ไม่ปฏิบัติการ
แต่ไม่ได้มีหน้าที่หลัก
มันเป็นเพียงพวงของไบนารี ที่คุณสามารถใช้
ดังนั้นการเชื่อมโยงคือวิธีที่เรานำมารวมกันทั้งหมด ไฟล์ไบนารีที่แตกต่างกันเหล่านี้
เป็นปฏิบัติการที่เกิดขึ้นจริง
หนึ่งที่คุณสามารถพิมพ์ จุดเฉือนจุดออก
>> ดังนั้นนี้เป็นเหมือนแฟ้มที่คุณ เขียน - สิ่งที่โปรแกรมของคุณค่าเท่าใด
ceaser จุดค
แต่ตอนนี้มันได้รับการเรียบเรียง ลงไปที่ฐาน
ดังนั้น Ceaser จุด o
และนี่คือ CS50 ของเราห้องสมุดไบนารี
และพวกเขากำลังถูกรวม เป็นปฏิบัติการเดียว
ใช่?
>> ผู้ชม: [ไม่ได้ยิน]
>> ROB: ดังนั้นก่อนรวมถึงการจำ กัญชารวมถึงเป็นจริง
ขั้นตอนก่อนการประมวลผล
แต่ที่แยกต่างหาก
ถ้าคุณไม่ได้ใช้ฟังก์ชั่นใด ๆ ที่ อยู่นอกไฟล์เดียวของคุณแล้ว
ไม่มีคุณไม่จำเป็นต้องเชื่อมโยงอะไร ตั้งแต่คุณมีทุกอย่าง
>> ที่กล่าวว่า printf จะถูกเชื่อมโยงใน
ถ้าคุณเคยใช้ printf ว่าเป็นสิ่งที่ ที่ต้องมีการเชื่อมโยงใน
เพราะคุณไม่ได้เขียนว่า
และในความเป็นจริง printf โดยอัตโนมัติ เชื่อมโยงใน
คุณรู้วิธีที่บรรทัดคำสั่งหรือเมื่อ คุณพิมพ์ให้คุณเห็นมันมี
ลิตร CS50 เส้นประซึ่งมีการเชื่อมโยง ในห้องสมุด CS50?
printf และสิ่งที่ต้องการที่เป็นไป ที่จะเชื่อมโยงโดยอัตโนมัติ
ใด ๆ คำถามอื่น ๆ ในสิ่งที่?
>> ผู้ชม: [ไม่ได้ยิน]
>> ROB: การเชื่อมโยง?
เรามีทั้งกลุ่ม แฟ้มไบนารีที่แตกต่างกัน
นี่คือตัวอย่างที่ยอมรับ ที่เราใช้เป็นห้องสมุด CS50
เราได้รวบรวมและให้กับคุณ ไบนารีสำหรับห้องสมุด CS50 นี้
>> คุณต้องการใช้ GetString ในโปรแกรมของคุณ
ดังนั้นคุณจะไปและใช้ GetString
แต่ไม่มีรหัสไบนารีของฉันสำหรับ GetString เมื่อคุณคอมไพล์รหัสของคุณ
ลงคุณไม่สามารถเรียกใช้จริงของคุณ โปรแกรมเพราะ GetString สตริงเป็น
ยังไม่ได้กำหนดไว้อย่างสมบูรณ์
>> มันเป็นเพียงเมื่อคุณเชื่อมโยงในไบนารีของฉัน ที่มี GetString ว่าตอนนี้ทั้งหมด
สิทธิที่จะทำได้จริง ดำเนินการ GetString
ไฟล์ของฉันเสร็จสมบูรณ์
และผมสามารถทำงานนี้
ใช่?
>> ผู้ชม: การเชื่อมโยงแปลง ไบนารีเพื่อปฏิบัติการ?
ดังนั้นแม้ว่าคุณจะได้ไม่ต้องอื่น ๆ ห้องสมุดจะไม่ได้ยังคงอยู่
จำเป็นที่จะต้องแปล [ไม่ได้ยิน]
>> ROB: ดังนั้นปฏิบัติการ ยังคงอยู่ในไบนารี
มันเป็นเพียงแค่การรวมทั้ง พวงของไบนารี
>> ผู้ชม: ขอบคุณมาก
>> ROB: ไม่มีปัญหา
หากมีปัญหาอื่น ๆ
มิฉะนั้นเราก็พร้อม
ขวาทั้งหมด
ขอบคุณ
>> [APPLAUSE]
>> ผู้ชม: ขอบคุณ
>> ROB: ใช่