>> เจสัน Hirschhorn: ยินดีต้อนรับ A5 ให้ทุกคน
เรามีสัปดาห์ที่น่าตื่นเต้นไปข้างหน้าของเรา ส่วนใหญ่เป็นเพราะมีจำนวนมากดังนั้นใหม่
ใบหน้าในห้องนี้
มันยอดเยี่ยม
จำนวนมากของคุณอยู่ที่นี่โดยอุบัติเหตุ ซึ่งเป็นที่ดียิ่งขึ้น
ดังนั้นหวังว่าคุณจะให้เข้าร่วมกับเรา
>> ในสัปดาห์นี้เราจะใช้จ่าย เป็นกลุ่มของส่วน
เตรียมพร้อมสำหรับการตอบคำถาม
ดังนั้นต่อวาระการประชุมของเราเรากำลังจะพูดคุย บิตเกี่ยวกับทรัพยากรสำหรับการเรียนที่
แต่ยังสำหรับการทดสอบและจากนั้นอีกครั้ง ใช้จ่ายจำนวนมากของการพูดในชั้นเรียน
เกี่ยวกับคำถาม
เมื่อเราดำเนินการเสร็จแล้วตอบของคุณ คำถามหรือถ้าคำถามของคุณ
ธรรมชาตินำเราไปสู่​​การเขียนโปรแกรมบางอย่างผม มีปัญหาตัวอย่างจาก midterms
ที่ผ่านมาว่าเราจะมีชีวิตอยู่รหัสในส่วน ร่วมกันที่ยังนำมาขึ้นอื่น ๆ
หัวข้อที่ดีที่จะครอบคลุม
>> ดังนั้นครั้งแรกที่เราได้ผ่านไปแล้วสำหรับ สองสามสัปดาห์ที่ผ่านมาเพื่อเตือนให้คุณ
ผู้ชายมีตันของทรัพยากร สำหรับหลักสูตรนี้
มากของพวกเขาจะเป็นประโยชน์อย่างไม่น่าเชื่อ กับคุณที่คุณยังคง
การศึกษาสำหรับการทดสอบ 0 เพราะ มันเป็นบ่ายวันอังคาร
ดังนั้นทั้งหมดที่คุณได้รับ การศึกษาสำหรับบิต
>> มีเอกสารประกอบการบรรยายและแหล่งที่มาเป็น รหัสที่คุณควร
แน่นอนตรวจสอบ
ดูกางเกงขาสั้น
ตรวจสอบ study.cs50.net
แล้วด้านล่างจำนวน ทรัพยากรอื่น ๆ
>> อีกครั้งคำถาม 0 วันพรุ่งนี้ ที่ 01:00
หากคุณยังไม่ได้ดำเนินการตรวจสอบ ออกมาเกี่ยวกับการทดสอบ 0 เอกสาร
หน้าแรกหลักสูตรที่จะคิดออก ที่คุณกำลังการตอบคำถาม
คำถามเริ่มต้นที่ 01:10 และ สิ้นสุด 70 นาทีต่อมา
ดังนั้นถ้าคุณแสดงขึ้นหลังจากที่ 1:10 คุณ จะได้รับนาทีน้อยกว่าที่หลาย ๆ
กว่า 70 ที่จะตอบคำถาม
เพื่อให้แน่ใจว่าคุณอยู่ที่นั่นในเวลา
ถ้าคุณเป็นนักเรียนขยายหรือมี บางพิจารณาการทดสอบอื่น ๆ ก็
อาจจะไม่เป็นที่ 01:00 วันพรุ่งนี้
แต่อีกครั้งให้ตรวจสอบเกี่ยวกับการทดสอบ 0 เอกสารที่จะให้แน่ใจว่าคุณรู้ว่าเมื่อไหร่
คุณกำลังการตอบคำถาม
ที่ผมเขียน 75 นาทีขึ้นที่นี่
ผมคิดว่าเป็นขวาไม่ 70
>> ครอบคลุมทุกวัสดุจาก 0 สัปดาห์ บรรยายสัปดาห์ที่แล้วในวันพุธที่
และอีกครั้งในการตอบคำถามนี้ต่อที่ เอกสารคุณจะได้รับหนึ่งในสองด้านและ 8
1/2 โดย 11 แผ่นกระดาษที่คุณได้รับ เพื่อใช้เป็นบันทึกในระหว่างการทดสอบ
หลายคนหากไม่ได้คนส่วนใหญ่มี พบว่าวิธีที่เป็นประโยชน์มากที่สุดคนหนึ่ง
เพื่อการศึกษาสำหรับการทดสอบคือการ ทำให้แผ่นการศึกษา
หนึ่งในหมู่ของพวกเขาเอง
ดังนั้นมองไปที่คนที่ผ่านมาถ้า คุณเคยเห็นคนที่ผ่านมา
เอื้อมมือออกไปเพื่อน ๆ ที่จะเห็นสิ่งที่ พวกเขากำลังวางบนพวกเขา
>> แต่มือลงวิธีที่ดีที่สุดที่คุณสามารถ การศึกษาคือการไปผ่านทุกอย่างและ
ลดลงมันลงไปในสิ่งที่ควรหรือไม่ควร ไม่ได้อยู่บนแผ่นที่
กระดาษเนื่องจากว่าเป็นเพียงจริงๆ วิธีที่เป็นประโยชน์สำหรับคุณเพื่อให้แน่ใจว่า
คุณจะผ่านทุกอย่างและ มีความคุ้นเคยกับมันบาง
คนส่วนใหญ่เราจะพบถึงแม้ว่าพวกเขา มีแผ่นกระดาษนั่งขวา
ต่อไปกับพวกเขาในการตอบคำถามที่ไม่ได้เปิด ไปเพราะอีกครั้งที่มาก
กระบวนการของการที่จะผ่านข้อมูล ได้ช่วยให้พวกเขาเรียนรู้มัน
>> ไม่มีใครมีคำถามใด ๆ เกี่ยวกับคำถาม 0?
มีทุกคน -
ฉันจะไม่ทำแสดงของมือ
ไม่เป็นไร
ผมจะขอให้ผู้ที่ เริ่มเรียน
แต่ผมไม่ต้องการที่จะทำให้คุณ ทั้งหมดไม่ได้ยกมือของคุณ
ดังนั้นฉันต้องการกล่าวว่า - ใช่, AVI, ไปข้างหน้า
>> AVI: สิ่งที่จะเป็นสิ่งที่มีประโยชน์ ใส่หนึ่งเพจเจอร์?
>> นักเรียน: นั่นขึ้นอยู่กับคุณ
>> เจสัน Hirschhorn: คุณจะได้รับ ใช้วิจารณญาณของคุณ
สิ่งที่มีประโยชน์ที่จะนำมาหนึ่งเพจเจอร์ ถ้าคุณกำลังสับสนเกี่ยวกับ O ใหญ่
runtime ประเภทที่แตกต่างกันของการค้นหา และทุกประเภทใส่ว่ามีใน
แผนภูมิสำรวยมีประโยชน์
วิธีการที่ถ้าคุณถามว่าเมื่อวันที่ แบบทดสอบคุณไม่ต้องพยายามร่าง
มันออกมาหรือเหตุผลผ่านรันไทม์
คุณก็สามารถคัดลอกมันลง
ถ้าคุณดูที่แบบทดสอบผ่านมาจำนวนมาก ครั้งมีคำถามเวลาที่ทำงาน
เพื่อที่จะเป็นตัวอย่างที่ดีของ สิ่งที่จะต้องวางอยู่บนหนึ่งในเพจเจอร์ของคุณ
>> สิ่งที่ดีอื่น ๆ ที่จะนำมาถ้าคุณ สับสนเกี่ยวกับวิธีการประกาศ
ฟังก์ชั่นหรือสิ่งที่ชิ้นส่วนที่แตกต่างกันของ การประกาศฟังก์ชันที่มีการเขียน
ว่ามีรุ่นทั่วไป แล้วอาจจะยกตัวอย่างเช่น
หากคุณกำลังสับสนเกี่ยวกับตัวชี้ แผนภาพของวิธีการทำงานเป็นตัวชี้
อาจจะเป็นประโยชน์จริงๆ
หากคุณกำลังสับสนเกี่ยวกับการเรียกซ้ำ ตัวอย่างฟังก์ชันเวียนเกิดที่มี
นอกจากนี้ยังสามารถพิสูจน์ให้เป็นประโยชน์จริงๆ
ไม่ที่ให้คุณความคิดบางอย่าง
>> AVI: คุณจำเป็นต้องเข้าใจ กระบวนการรวบรวมทั้งหมดเช่น
วิธีการที่ว่าผลงานทั้งหมดหรือไม่
>> เจสัน Hirschhorn: ทุกอย่าง ที่ได้รับการคุ้มครองได้
ปรากฏขึ้นในการตอบคำถาม
คำถาม -
แต่อีกครั้งบางสิ่งบางอย่างที่จะเป็น น้ำหนักมากกว่าคนอื่น ๆ
บางสิ่งบางอย่างได้เกิดขึ้นอีกครั้ง และอีกครั้งในชั้นเรียนใน
การบรรยายและส่วน
สิ่งอื่น ๆ ที่ไม่ได้มี มาที่มักจะ
>> เราได้พูดคุยกันมากเกี่ยวกับการรวมและ # l-บางสิ่งบางอย่างและสิ่งที่หมายถึงใน
การรวบรวม
เราได้พูดคุยกันมากเกี่ยวกับ GDB, ยึด, ธงที่แตกต่างกันที่เราใช้เมื่อ
เรารวบรวมสิ่งที่และสิ่งที่ make15 เช่นจริงๆ
หมายถึงและจริงๆไม่
เรายังไม่ได้พูดคุยมากเกี่ยวกับ ทุกขั้นตอนเดียวใน
การรวบรวม
เราได้พูดคุยเกี่ยวกับเรื่องนี้ยังคง
ดังนั้นจึงยังคงมีบางสิ่งบางอย่างที่คุณ ควรจะคุ้นเคยกับ
แต่อีกครั้งที่เราจะไม่ได้ -
สิ่งที่เกิดขึ้นบ่อยครั้งมากขึ้นในชั้นเรียน มีแนวโน้มที่จะเกิดขึ้นมากขึ้น
และมักจะเป็นมากขึ้น ถ่วงน้ำหนักในการตอบคำถาม
>> เย็น
คำถามอื่น ๆ เกี่ยวกับการทดสอบ 0?
>> ตกลงดังนั้นฉันใส่รายชื่อของ หัวข้อบนกระดาน
ฉันก็ผ่านหลักสูตร
ฉันเดินผ่านส่วนความคิดเห็นจาก เมื่อคืนที่ผ่านและภาพนิ่งเหล่านั้นที่จะเกิดขึ้น
กับรายการที่ไม่ครบถ้วนสมบูรณ์ของหัวข้อ ที่เราได้รับการคุ้มครองเพื่อให้ห่างไกลใน CS50
และสิ่งที่อาจ ปรากฏในการตอบคำถาม
ดังนั้นฉันจะไม่ผ่านไป ทุกหนึ่งเดียวของเหล่านี้
ที่จะใช้เวลามากขึ้น เวลากว่าที่เรามีตอนนี้
แต่ผมใส่นี้ขึ้นที่นี่เพื่อหวังเขย่าเบา ๆ หน่วยความจำของคุณเป็นสิ่งที่อาจจะ
หรืออาจจะไม่เป็นที่คุ้นเคยกับคุณ
>> และฉันชอบที่จะใช้จ่ายเป็นจำนวนมาก ส่วนการตอบคำถามเกี่ยวกับ
เหล่านี้หัวข้อหัวข้อที่ ไม่ได้ครอบคลุมที่นี่
เราสามารถเขียนรหัสเทียม
เราสามารถเขียนโค้ดจริง เพื่อให้แน่ใจว่าคุณ -
ฉันสามารถตอบคำถามของคุณและช่วยให้ ทุกคนเข้าใจพื้นฐาน
จำนวนมากของหัวข้อเหล่านี้เพื่อให้คุณจะรู้สึก เตรียมความพร้อมและความสะดวกสบายที่จะเข้าสู่
ในวันพรุ่งนี้ทดสอบ
ดังนั้นอ่านผ่านรายการ
คุณหวังว่าจะได้มาส่วน กับคำถามบางส่วนเช่นกัน
เมื่อคุณพร้อมที่จะยกมือของคุณ และเราจะเริ่มต้น
>> เก็บไว้ในใจคำถามที่คุณมี ไม่มีคำถามโง่
เราเคยได้ยินว่าจำนวนมาก
และคำถามที่คุณมีและฉันยินดีที่ การเดิมพันที่คนอื่น ๆ อีกมากมายทั้ง
นั่งอยู่ที่นี่และดู ออนไลน์ได้เป็นอย่างดี
ดังนั้นคุณจะสามารถช่วยให้ผู้คน โดยการถามคำถาม
มาร์คัส
>> MARCUS: ระหว่างกองและ กองจะมีก่อนการจัดสรร
ร้อยละของหน่วยความจำที่กำหนดให้เป็น นี้สำหรับกองหรือกองหรือไม่
หรือวิธีการทำงานที่ว่า?
>> เจสัน Hirschhorn: Great คำถาม
ฉันจะกลับมาติดตามนิด ๆ หน่อย ๆ
ไม่ทุกคน -
กรุณาซื่อสัตย์ที่นี่
ฉันรู้ว่าฉันขอให้คุณที่จะยกระดับของคุณ มือในหน้าของเพื่อนของคุณ
แต่จะมีคนที่รู้สึก อึดอัดกับกองและกอง
และต้องการที่จะไปกว่าที่ และสิ่งเหล่านั้นหมายถึงอะไร
ยกมือของคุณหาก -
ตกลง
ขอบคุณ
ดังนั้นเราจะไปกว่ากองและ กองอย่างรวดเร็วจริงๆแล้ว
ย้ายเข้ามาตอบคำถามของคุณ
>> ดังนั้นหากเราวาดออกจากกล่องที่จะเป็นตัวแทน หน่วยความจำในคอมพิวเตอร์ของคุณสิ่งที่บาง
สิ่งที่ไปในกล่องนี้
หลัก
ฟังก์ชั่นหลัก
ที่ไม่สำคัญไป
>> นักเรียน: [ไม่ได้ยิน]
>> เจสัน Hirschhorn: ดังนั้นเราจะ วางหลักลงที่นี่
อะไรที่จะไปในกล่องนี้
>> นักเรียน: ฟังก์ชั่นที่คุณเรียก
>> เจสัน Hirschhorn: ฟังก์ชั่น ที่เราเรียกว่า
และพวกเขาจะไปอยู่ที่ไหน
>> นักศึกษา: ในกอง
>> เจสัน Hirschhorn: พวกเขา ไปในกอง
ดังนั้นเรากำลังจะเรียกสิ่งนี้ว่า สิ่งที่ลงที่นี่กอง
และขึ้นด้านบนเรามีกอง
ดังนั้นหน่วยความจำไม่ได้เป็นเช่นเดียวกับกล่องนี้
แต่มันเป็นจริงสวยเหมือนกัน
มันจะเป็นจำนวนมากของกล่องกว่า ขึ้นไปขึ้นอยู่กับว่าขนาดใหญ่ของคุณ
คอมพิวเตอร์หรือวิธีการใหญ่หน่วยความจำของคุณ
>> ที่ได้นำมาอ้างอ้าง-"ด้านล่าง" เป็นกอง
และมีสิ่งที่หลาย ๆ ที่ไปในกอง
และผู้ที่ขึ้นอยู่กับฟังก์ชั่น ที่คุณมีในรหัสของคุณ
คุณมักจะมีฟังก์ชั่นหนึ่งในของคุณ รหัสเรียกว่าหลักจึงมีเสมอ
ส่วนลงที่นี่ใน สแต็คที่ทุ่มเทให้กับหลัก
>> ส่วนเหล่านี้ในกอง จะเรียกว่ากองเฟรม
เมื่อคุณเรียกใช้ฟังก์ชันอื่นพูดหลัก เรียกฟังก์ชันการค้นหาแบบไบนารี
เราใส่กรอบอื่นในกอง
โดยเฉพาะอย่างยิ่งเราจะไป บริจาคก้อนของหน่วยความจำของเรา
คอมพิวเตอร์ในการจัดเก็บค้นหาแบบไบนารีท้องถิ่น ตัวแปรและเรียกใช้ไบนารี
รหัสการค้นหา
>> ดังนั้นเราจึงเรียกค้นหาแบบไบนารี
ในหน่วยความจำอันนี้เรากำลังจะ ในการจัดเก็บตัวแปรท้องถิ่นของตน
เรากำลังจะไปเก็บสาย printf ของ
สิ่งที่เกิดขึ้นฟังก์ชั่นที่เป็น จะถูกเก็บไว้ที่นั่น
ค้นหา binary เป็นไปที่จะดำเนินการ
มันเป็นไปเพื่อให้การดำเนินการ
เป็นคำใน C สิ่งที่หมาย ฟังก์ชั่นที่ควร
เสร็จสิ้นการดำเนินการได้อย่างไร
>> นักเรียน: กลับมา
>> เจสัน Hirschhorn: กลับมา
ดังนั้นเมื่อใดก็ตามที่คุณเห็นคำสั่งกลับให้ สิ้นสุดการทำงาน
เมื่อความนิยมที่
ค้นหาเพื่อไบนารีจะตีกลับ
เป็นส่วนหนึ่งของหน่วยความจำนี้จะเป็นหลัก เป็นอิสระขึ้น
และที่สำคัญจะกลับไปดำเนินการ
ดังนั้นหลักจะหยุดที่ใดก็ตามที่เป็นโทร ค้นหาแบบไบนารีได้รับค่าตอบแทนบางส่วน
และดำเนินต่อไป
กรอบกองนี้จะหายไป
>> ถ้าเราเรียกฟังก์ชัน recursive ซึ่ง เป็นฟังก์ชันที่เรียกตัวเองกว่า
และมากกว่าที่เราอาจจะได้รับ - บอกว่าเรา ได้ค้นหาไบนารีซ้ำ
เราอาจจะได้รับรุ่นค้นหา binary หนึ่ง ค้นหาแบบไบนารีสองค้นหาแบบไบนารี
สามค้นหาแบบไบนารีสี่ ค้นหาแบบไบนารีห้า
แล้วนี้ค้นหา binary สุดท้ายห้า จะตีกรณีฐานและสแต็ค
เฟรมจะกลับไปและให้ปิด จนกว่าเราจะได้รับกลับไปที่หลัก
เราสามารถไปกว่าการเรียกซ้ำในบิต
แต่ทั้งหมดนี้คือการบอกว่าถ้าคุณ การเรียกฟังก์ชั่นหลายครั้ง
จะมีหลายกอง เฟรมในกอง
>> กองในมืออื่น ๆ เพิ่มขึ้น ที่นี่ไม่ได้สำหรับฟังก์ชั่น
ไม่ได้สำหรับตัวแปรท้องถิ่น
มันสำหรับจัดสรรแบบไดนามิก ตัวแปร
ดังนั้นเหล่านี้เป็นตัวแปรที่สามารถ เริ่มต้นได้ในอย่างใดอย่างหนึ่งหลักหรือ
ทำงานที่สายหลัก
ที่ใดก็ได้ในรหัสของพวกเขา สามารถเริ่มต้นได้
ในการเริ่มต้นและแบบไดนามิก ตัวแปรจัดสรร
เราทำในสิ่งที่ฟังก์ชั่นใน C ใช้งานหรือไม่
>> นักเรียน: Malloc
>> เจสัน Hirschhorn: Malloc
คุณโทร malloc
คุณจะได้รับพื้นที่ของหน่วยความจำ
และพื้นที่ของหน่วยความจำที่ อยู่บนกอง
และพื้นที่ของหน่วยความจำที่อยู่ จนกว่าจะมีคุณโทรฟรี
>> ดังนั้นตัวแปรจัดสรรแบบไดนามิกใน กองจะอยู่ได้นานเท่าที่คุณ
ต้องการให้พวกเขาอยู่และพวกเขาจะไม่ ไปจนกว่าคุณจะ
บอกพวกเขาหายไป
คุณสามารถสร้างพวกเขาในการทำงานอย่างใดอย่างหนึ่ง
สแต็คที่ฟังก์ชั่นที่ กรอบจะหายไป
แต่ตัวแปรที่จะยังคงมีอยู่ ในกองจนกว่าจะมีการปลดปล่อย
ที่อาจเกิดขึ้นโดยการทำงานที่เรียกว่า ค้นหาแบบไบนารีหรืออะไรก็ตาม
>> ดังนั้นผู้ตัวแปรที่กองอยู่ที่นั่น ให้นานที่สุดเท่าที่คุณต้องการ
พวกเขาจะอยู่ที่นั่น
และพวกเขาได้รับการใส่ที่นี่
แล้วที่หน้าหนึ่งได้รับการวางมี
พวกเขาให้ได้รับการเติมเต็มในและพวกเขา อยู่ที่นั่นจนคุณโทรฟรี
>> และเป็นหลักกองและกอง ได้รับคำถามของ Marcus,
เติบโตต่อกันและกัน
และถ้าพวกเขาทำงานเป็นอีกคนหนึ่งที่คุณได้ ใช้เพิ่มหน่วยความจำของคุณใน
คอมพิวเตอร์และโปรแกรมของคุณจะออกจาก เพราะคุณไม่ได้มีหน่วยความจำที่มากขึ้น
เหลือที่จะใช้
ในระหว่างที่พวกเขามี สิ่งอื่น ๆ ที่อาจเกิดขึ้น
แต่สำหรับขอบเขตของหลักสูตรนี้คุณ ไม่จำเป็นต้องกังวลเกี่ยวกับการที่
>> เพื่อให้เป็นคำตอบ กับคำถามของคุณ
ไม่ต้องเป็นห่วงนะ
แต่นั่นก็เป็นคำตอบที่ยาว
ทั้งหมดที่คุณต้องรู้คือ กองและสแต็คจะ -
หนึ่งเริ่มที่ด้านล่าง
กองไม่
กองที่มีขึ้น
พวกเขาจะเติบโตใกล้ชิดกับอีกคนหนึ่ง
>> และถ้าพวกเขาสัมผัสที่เป็นปัญหา
คุณวิ่งออกมาจากหน่วยความจำ
แต่ก็ยังมีนอกเหนือไปจากการรู้ที่ พวกเขามีสิ่งที่จะถูกเก็บไว้ทั้งใน
กองและกอง
เคอร์ติ
>> CURTIS: เมื่อพวกเขาชนกัน คือการที่กองล้นหรือไม่
>> เจสัน Hirschhorn: เมื่อพวกเขาชนกัน ที่ไม่ล้นกอง
กองล้นเป็นพื้นที่ที่แตกต่างกัน ที่เราสามารถไปกว่าถ้าคุณต้องการที่จะ
ตกลงเราจะกลับมาที่ว่าในบิต
>> นักเรียน: อะไรคือคำที่เรียกว่า เมื่อพวกเขาตีกัน
กองและกองหรือไม่
>> เจสัน Hirschhorn: สำหรับตอนนี้ ไม่ต้องกังวลเกี่ยวกับ
เพิ่งรู้ -
ฉันจะตอบคำถามว่า หลังเลิกเรียน
ถ้าพวกเขาวิ่งเข้ามาในแต่ละอื่น ๆ ที่คุณวิ่งออกมา ของหน่วยความจำเพราะมีไม่มาก
มีพื้นที่
>> นักเรียน: ขออภัยสิ่งที่เป็นความผิด seg ของ?
>> เจสัน Hirschhorn: ส่วน ความผิดพลาดสามารถเรียกว่าสำหรับ -
มันขึ้นอยู่กับว่าทำไมความผิด seg ของที่เรียกว่า
บางครั้งกองล้นของคุณก็จะ กล่าวว่าความผิดพลาดเป็นข้อผิด seg ของ
>> นักเรียน: สิ่งที่เกี่ยวกับ dereferencing null ตัวแปร?
คือความผิด seg ของ?
>> เจสัน Hirschhorn: dereferencing null ตัวชี้ -
ตกลงดังนั้นถ้าคุณมีตัวชี้ที่คุณ ตั้งค่าเท่ากับโมฆะตัวชี้จำ
อยู่หน่วยความจำเก็บ เป็นค่าของพวกเขา
และตัวชี้โมฆะเป็นหลัก การจัดเก็บ 0, 0 th-
ที่อยู่ในตัวแปรที่
ดังนั้น 0x, 0, 0, 0, 0, และอื่น ๆ
ที่อยู่ 0 th-ในความทรงจำที่ไม่ ในภาพของเราที่มีขึ้น
ที่ไหนสักแห่งที่สงวนไว้ สำหรับคอมพิวเตอร์
เราไม่ได้รับอนุญาตให้สัมผัสมัน
>> ดังนั้นเมื่อโปรแกรมของคุณรันถ้า สิ่งที่พยายามที่จะไปที่หน่วยความจำ
ที่อยู่ 0 มันรู้ว่า ที่เป็นค่าว่าง
มันรู้อะไรที่ควรจะมี
ดังนั้นถ้าคุณพยายามและใช้สิ่งที่มี และรักษาสิ่งที่ต้องการหรือมี
พยายามที่จะไปยังตำแหน่งที่คุณอยู่ จะได้รับความผิด seg ของหรือข้อผิดพลาด
ไม่ว่าจะตอบคำถามของคุณหรือไม่
>> และตอนนี้เราจะกลับไป กองล้น
สิ่งที่อยู่ในสแต็คที่พวกคุณมี เห็นมาก่อนใน - ขอวาดใกล้ชิด
ขึ้นจากกรอบสแต็ค
ทุกคนจะเห็นว่า?
ดังนั้นเราจึงมีกรอบสแต็คของเรา
เรากำลังบันทึกอาร์เรย์ในท้องถิ่นเป็น ตัวแปรในการทำงานนี้
ดังนั้นพูดอาร์เรย์ของเรามีห้าจุด
ทั้งห้าของผู้ที่จะถูกเก็บไว้ ในกรอบกองที่
>> ถ้าเราเริ่มเขียนเกิน ขอบเขตของอาร์เรย์นี้ -
ดังนั้นหากเราเริ่มต้นการเขียนลง ขอบอกว่าเป็น 0
ผู้ที่มีห้าดัชนี ของอาเรย์ของเรา
ถ้าเราเริ่มเขียนเป็นดัชนีที่ 5 ซึ่ง เราไม่ได้มีเวลาที่เรามี
อาร์เรย์ของขนาด 5 เราเริ่มเขียนลงใน ดัชนีที่ 6, 7, 8, 9, เราจะได้รับกอง
ข้อผิดพลาดมากเกิน
>> โดยทั่วไปก็ไม่ได้ -
คุณอาจจะได้รับเป็นปัญหา ถ้าคุณไปกว่าหนึ่ง
แต่โดยทั่วไปแล้วคุณจะได้รับเป็น ปัญหาส่วนใหญ่ถ้าคุณไปกว่าโดยการจับสลาก
และคุณจะไปไกลกว่าที่คุณเขียน ในช่วงที่อยู่ที่การกลับมาของ
ฟังก์ชั่นซึ่งตั้งอยู่ที่ ด้านล่างของกรอบสแต็ค
>> เพราะใช่มั้ย?
คุณ - ใน - ขอโทษ
ไม่ได้ "เพราะขวา."
>> ในกรอบสแต็คที่คุณมี ตัวแปรท้องถิ่นของคุณ
ที่ด้านล่างสุดของกอง กรอบเป็นที่อยู่ผู้ส่ง
นั่นคือสิ่งที่ฟังก์ชั่น ไปเมื่อมันมากกว่า
และถ้าคุณเขียนทับกลับมาที่ อยู่แล้วเมื่อกองกรอบนี้
เมื่อคุณกำลังจะผ่านกอง กรอบและดำเนินการแต่ละบรรทัดคุณ
จะไปยังที่อยู่ใหม่ของคุณกลับมา ที่เขียนมีแทน
อย่างใดอย่างหนึ่งที่เกิดขึ้นจริง
และนั่นคือวิธีที่เราได้เห็น การละเมิดความปลอดภัยบางอย่าง
สามารถเกิดขึ้นได้กับคอมพิวเตอร์
>> ดังนั้นกองล้นในระยะสั้นคือเมื่อ คุณเขียนทับส่วนหนึ่งในกอง
คุณควรที่จะใช้ในท้องถิ่น ตัวแปรที่คุณควรจะใช้และ
โดยเฉพาะอย่างยิ่งเมื่อคุณเริ่มต้นการเขียนทับ สิ่งที่สำคัญเช่น
กลับที่อยู่
และที่ที่คุณจะได้รับข้อผิดพลาด
หรืออาจจะได้คุณสามารถเริ่มต้น แม้กระทั่งการเขียนลง -
บอกว่าค้นหา binary เป็น สิทธิเหนือหลัก
ถ้าคุณเขียนทับมากคุณ สามารถเขียนเป็นหลัก
แต่โดยทั่วไปแล้วคุณจะได้รับข้อผิดพลาดก่อนที่จะ แล้วเนื่องจากคอมพิวเตอร์รู้
คุณกำลังทำสิ่งที่คุณ ไม่ควรทำ
ใช่
>> นักเรียน: อะไรคือความแตกต่าง ระหว่างกองล้น
และหน่วยความจำล้น?
>> เจสัน Hirschhorn: หน่วยความจำล้น เป็นประเภททั่วไปมากขึ้น
สิ่งที่ผมได้อธิบายเพียง
>> นักศึกษา: ดังนั้นกองล้นเป็น ตัวอย่างของหน่วยความจำล้น
>> เจสัน Hirschhorn: แน่นอน
นี้เป็นอาร์เรย์เราสามารถคิดเป็น กันชนพื้นที่สำหรับสิ่งที่จะไปค่ะ
นี้เป็นหน่วยความจำล้นกอง
เราอาจจะมีหน่วยความจำล้นกอง
ถ้ามีบัฟเฟอร์ซึ่งมักจะมี เป็นอาร์เรย์กองและเรา
เขียนทับขอบเขตเหล่านั้นแล้วเราจะ มีหน่วยความจำล้นกอง
>> ? และนอกเหนือขอบเขตของหลักสูตรนี้ พวกเขากำลังตรวจพบบิตที่แตกต่างกัน
คอมไพเลอร์ที่มีความพิเศษ วิธีการตรวจสอบแต่ละ
แต่หน่วยความจำล้นเป็นทั่วไปมากขึ้น ชนิดของสิ่งที่ฉันอธิบาย
ซึ่งเป็นหน่วยความจำล้นกอง
ไม่ว่าจะตอบคำถามของคุณหรือไม่
หวาน
>> ได้มีคำถามอื่น ๆ ที่เกี่ยวข้อง ไปยังกองหรือกองหรือไม่
ใช่
>> นักเรียน: ฉันรู้ว่าคุณต้องสายฟรี เพราะพวกเขาอยู่ในกอง
และคุณไม่ต้องการที่จะรั่วไหลของหน่วยความจำ
แต่คุณจะต้องเป็นอิสระตัวแปรทั่วโลก และสิ่งที่ต้องการที่
หรือพวกเขาเป็นอิสระโดยอัตโนมัติ
>> เจสัน Hirschhorn: เป็นคำถามที่ดี
ดังนั้นใน CS50.H เราจะสร้างสิ่งนี้ สำหรับคุณที่เรียกว่าสาย
สตริงเป็นจริงคืออะไร
>> นักเรียน: Char ดาว
>> เจสัน Hirschhorn: ดาวถ่านชี้ กับตัวละครที่มีตัวชี้ไปยัง
อาร์เรย์ของตัวอักษร
นั่นคือสิ่งที่เป็นสตริง
ดังนั้นเราจึงจำเป็นที่จะปลดปล่อยมันเพราะ GetString ซึ่งเราใช้มาก -
ชื่อสตริงเท่ากับ GetString -
ที่ mallocs สำหรับเราหน่วยความจำบางอย่างใน กองแล้วกลับชี้ไปยัง
อักษรตัวแรกของที่ สตริงดาวถ่าน
>> ดังนั้นประหนึ่งว่าถ้าคุณยังไม่ได้รับ เขียนฟรีที่ใด ๆ ของสายของคุณ
ที่คุณได้เรียกว่าห่างไกลคุณมี การรั่วไหลของหน่วยความจำบาง
แน่นอนว่าเรายังไม่ได้พูดคุยเกี่ยวกับ มันจึงไม่มีใครในอากาศ
ปัญหาสำหรับการทำมัน
แต่ก้าวไปข้างหน้าใช่
เมื่อคุณเรียก GetString คุณ mallocing พื้นที่บางส่วนในกอง
และถ้าคุณไม่ได้โทรฟรีในภายหลังว่า สตริงคุณมีหน่วยความจำรั่ว
ที่ตอบคำถามของคุณหรือไม่
>> ใช่
>> นักศึกษา: ดังนั้นจะทำอย่างไรที่เราจะใช้ ขวาฟรีก่อนที่จะกลับ?
เหมือนอยู่ในขอบเขตของผมคิดว่าถ้า ที่เราพูดเช่น int main ภายใน
ขอบเขตของรหัสที่ภายในนั้น วงเล็บปีกกาขวาก่อน -
คุณรู้ว่าคุณต้องการ มักจะใส่กลับ
คุณใส่ฟรีก่อนที่
>> เจสัน Hirschhorn: ดังนั้นคุณสามารถวางฟรี ทุกที่ที่คุณต้องการให้ฟรี
เพราะสิ่งเหล่านี้จะถูกจัดสรรแบบไดนามิก ตัวแปรเพราะพวกเขาสามารถ
อยู่นอกเหนือขอบเขตของโดยเฉพาะอย่างยิ่ง ฟังก์ชั่นถ้าคุณโทร malloc ใน
ฟังก์ชั่นที่แยกจากกันตัวอย่างเช่น GetString คุณสามารถโทรฟรีในหลัก
คุณไม่จำเป็นต้องที่จะเรียกว่า ในฟังก์ชั่นที่เฉพาะเจาะจง
malloc ที่เรียกว่า
แต่คุณไม่จำเป็นที่จะเรียกว่า ก่อนที่จะให้ผลตอบแทนหลัก
>> และมันขึ้นอยู่จริงๆ
มันขึ้นอยู่กับเหตุผลที่คุณ malloced ที่ พื้นที่ในสถานที่แรก
บางคนจะเรียก ฟรีสวยได้อย่างรวดเร็ว
บางคนจะได้โทรฟรีจนถึง ในตอนท้ายของโปรแกรมของพวกเขา
และพวกเขาจะไปถึง และทุกอย่างฟรี
มันขึ้นอยู่กับเหตุผลที่คุณจะเรียกว่า malloc
>> นักเรียน: และสิ่งที่คุณจะพูดว่า ถ้าคุณเรียกใช้ GetString?
คุณจะบอกว่าฟรีอะไร
>> เจสัน Hirschhorn: ดังนั้นไวยากรณ์สำหรับฟรี เป็นเพียงฟรี paren เปิดปิด
paren และชื่อของตัวชี้
ดังนั้นถ้าคุณเขียนชื่อสตริงเท่ากับ GetString คุณใส่ชื่อของที่นี่
นั่นคือชื่อของตัวชี้
และรู้ที่จะเป็นอิสระหน่วยความจำที่
>> นักศึกษา: ดังนั้นเมื่อมันเพิ่มหน่วยความจำที่ ชี้ยังคงชี้ไปยังสถานที่ที่
ในหน่วยความจำได้หรือไม่
หรือเป็นตัวชี้ยังอบของ อยู่ว่ามันชี้ไปที่
>> เจสัน Hirschhorn: เราควรพยายามที่
เราควรที่รหัส
ลองกลับมาเมื่อเราได้รับการ รหัสรหัสและขอที่
และถ้าคุณต้องการที่จะคิดออกคำตอบ นั้นคุณยังสามารถรหัสที่
ขณะเดียวกัน
แต่นั่นเป็นคำถามที่ดี
>> นักเรียน: มันเป็นไปได้ที่จะ สิ่งที่ฟรีในไม่ช้าเกินไป
เพื่อให้คุณยังคงจำเป็นต้องใช้สำหรับโปรแกรมของคุณ และคุณปลดปล่อยพื้นที่หน่วยความจำที่
>> เจสัน Hirschhorn: ใช่
มันเป็นไปได้ถ้าคุณบางอย่างฟรี แล้วคุณจะใช้มันอีกครั้งคุณจะ
วิ่งเข้ามาในข้อผิดพลาด
แต่ที่อยู่กับคุณเพราะคุณเป็นอิสระ บางสิ่งบางอย่างและจากนั้นก็เรียกได้ในภายหลัง
เพื่อให้เป็นความผิดพลาดของโปรแกรม
แต่ใช่
คุณสามารถเขียนว่า
>> คำถามใด ๆ เพิ่มเติมเกี่ยวกับ -
ใช่
>> นักศึกษา: ดังนั้นหากคุณควรจะเพียงแค่ อิสระโดยทั่วไปก่อนที่จะ
โปรแกรมสิ้นสุดลงที่หมายความว่าถ้า โปรแกรมจะสิ้นสุดลงและคุณไม่ได้เป็นอิสระมัน
หน่วยความจำที่ยังคงที่กำหนดหรือไม่
>> เจสัน Hirschhorn: ถ้าโปรแกรมของคุณจะสิ้นสุดลง และคุณลืมบางสิ่งบางอย่างที่จะเป็นอิสระแล้ว
หน่วยความจำที่ได้รับการจัดสรรตลอด อายุการใช้งานของโปรแกรมของคุณ
เมื่อโปรแกรมปิดอย่างสมบูรณ์ หน่วยความจำที่ไม่ได้ไป
จะอยู่ที่นั่นตลอดไป
คอมพิวเตอร์เป็นสมาร์ทพอที่จะรู้ ว่าเมื่อโปรแกรมปิดมัน
ควรกำจัดทั้งหมดของหน่วยความจำที่ ที่เกี่ยวข้องกับโปรแกรมที่
>> แต่มีเครื่องมือที่คุณสามารถเรียกใช้ กับโปรแกรมการตรวจสอบถ้าเมื่อ
โปรแกรมเสร็จแล้วคุณลืม ฟรีหน่วยความจำบาง
และสำหรับปัญหาต่อไปของคุณที่ตั้ง ที่คุณจะใช้ malloc และการใช้
ตัวชี้ที่คุณจะทำงานนี้ โปรแกรมในโปรแกรมของคุณเพื่อดูว่า,
เมื่อผลตอบแทนหลักคุณมีบาง สิ่งที่ถูกทิ้งไว้ unfreed
>> ดังนั้นพวกเขาจะไม่อยู่ malloced ตลอดไปในเครื่องคอมพิวเตอร์ของคุณ
ที่จะสิ้นเปลืองเพราะ อย่างรวดเร็วคอมพิวเตอร์
จะวิ่งออกมาจากหน่วยความจำ
แต่ถ้าพวกเขาทำงานจนกว่าจะสิ้นสุดของคุณ โปรแกรมและพวกเขาไม่ได้เป็นอิสระของคุณและ
โปรแกรมออกที่ยังคงเป็นปัญหา ว่าเครื่องมือนี้จะช่วยให้คุณอยู่
>> นักเรียนสินค้าที่ Valgrind?
>> เจสัน Hirschhorn: มันเป็น เรียกว่า Valgrind
และคุณจะ -
>> นักเรียน: แต่เราไม่จำเป็นต้องรู้ สำหรับคำถามที่ว่า?
ฉันหมายความว่ามันได้รับการพูดคุยเกี่ยวกับ นิด ๆ หน่อย ๆ ในการบรรยาย
>> เจสัน Hirschhorn: ดังนั้น Valgrind เป็นชื่อของเครื่องมือที่
รู้ว่าสิ่งที่มันไม่เป็น เพียงพอสำหรับการตอบคำถาม
แต่คุณไม่ได้ใช้มันยังอยู่กับคุณ ปัญหาการตั้งค่าเพราะเราไม่ได้มี
ชุดปัญหาที่ได้รับการจัดการอย่างชัดเจน ด้วย malloc หรือคุณใช้ malloc
เพื่อให้คุณไม่ได้ใช้ Valgrind ยัง
แต่คุณจะใช้งานได้เร็ว แทนที่จะในภายหลัง
>> นักศึกษา: คุณสามารถทำซ้ำ สิ่งที่ Valgrind คืออะไร
>> เจสัน Hirschhorn: ขอโทษ?
>> นักศึกษา: คุณสามารถทำซ้ำสิ่งที่ วัตถุประสงค์ของการ Valgring คืออะไร
>> เจสัน Hirschhorn: Valgrind คือชื่อ -
เช่น GDB จะช่วยให้คุณแก้ปัญหาโปรแกรมของคุณ valgrind จะช่วยให้คุณคิดออกว่า
สิ่งที่ยังไม่ได้รับการปลดปล่อย เมื่อโปรแกรมของคุณปิด
ดังนั้นคุณจะใช้มันในโปรแกรมของคุณ
และออกจากโปรแกรมของคุณและมันจะบอกว่า โปรแกรมของคุณเรียกว่า malloc จำนวนมากนี้
ครั้งสำหรับหลายไบต์นี้และคุณ เพียง แต่เรียกว่าฟรีนี้หลายครั้ง
และเพื่อให้คุณซ้ายไบต์จำนวนมากเหล่านี้ โดยไม่ถูกปล่อยให้เป็นอิสระ
หรือมันจะบอกคุณได้ทุกอย่างเป็นอิสระ
งานที่ดี
>> นักเรียน: OK
และก็เรียกว่า Valgring?
>> เจสัน Hirschhorn: V-A-L-G-R-I-N-D
>> นักเรียน: คำถามเกี่ยวกับตัวชี้
เพื่อบอกว่าคุณได้ n ดารา x เท่ากับสิ่งที่
นั่นเท่ากับสิ่งที่คุณกำลังวาง นั่นคือสิ่งที่ถูกใส่ใน
สิ่งที่ x จะชี้ไปยัง หรือตัวชี้ของ x?
>> เจสัน Hirschhorn: คุณสามารถ ทำซ้ำคำถามหรือไม่
เราสามารถวาดมันในขณะที่คุณบอกว่ามันได้หรือไม่
>> นักเรียนในการทดสอบจริง คนที่คุณส่งให้เรามันเป็นเหมือนถ่าน
ความจริงดาวเท่ากับหิน CS50 ใช่ไหม
ดังนั้นหมายความว่าที่หิน CS50 ความจริงคือสิ่งที่จะชี้ไปที่?
>> เจสัน Hirschhorn: คุณกำลังพูดถึง เกี่ยวกับดาวถ่านในสตริงวิธี
ว่าทำงานอย่างไร
ใช่
ตกลง
ลองวาดรูปนี้ที่นี่
>> [SIDE สนทนา]
>> เจสัน Hirschhorn: ดังนั้นตัวแปรนี้ เป็นไปได้ของถ่านดาว
วิธีการใหญ่เป็นตัวแปร ประเภทถ่านดาว?
กี่ไบต์?
>> นักเรียน: สี่
>> เจสัน Hirschhorn: มันเป็นสี่ไบต์
กี่สิทธิเป็นตัวแปร int ชนิดดาว?
>> นักเรียน: สี่
>> เจสัน Hirschhorn: สี่ไบต์
ถ้าเป็นตัวชี้แล้วมันอยู่เสมอ สี่ไบต์เพราะคำแนะนำของพวกเขา
ค่าที่อยู่ในหน่วยความจำ
และที่อยู่ของหน่วยความจำใน CS50 เครื่องใช้สี่ไบต์ยาว
ดังนั้นเมื่อเราเรียก GetString หรือเมื่อเรา พูด stringname เท่ากับและจากนั้นใน
ราคาคู่ใส่สตริง เราจะวาง -
ดีที่แตกต่างกันเล็กน้อย
เราจะไม่ getString เป็นตัวอย่าง
หรือสิ่งที่ถ่านดาว เท่ากับสตริง
ขออภัยให้ฉันตัวอย่างเช่น ที่คุณอ่าน
>> นักเรียนความจริงดาวถ่านเท่ากับ "หิน CS50" ในเครื่องหมายคำพูด
>> เจสัน Hirschhorn: ดังนั้นแห่งนี้นี้ เราจะเรียกตัวแปรนี้ของเรา
วัตถุประสงค์ทั่วไป
เราได้สร้างตัวแปรที่เรียกว่า x
เป็นประเภทถ่านดาว
มันเป็นตัวชี้ให้กับชุดที่ ของตัวละคร
ดังนั้นลงที่นี่ -
>> ดังนั้นนี่คือวิธีการที่จะนี้ ทำงานในหน่วยความจำ
นี้จะจัดเก็บอยู่ในหน่วยความจำ
มันจะเก็บที่อยู่หน่วยความจำของ ตัวอักษรตัวแรกในอาร์เรย์
และจากนั้นเมื่อคุณทำตาม ตัวชี้ที่คุณจะ
ได้รับตัวอักษรตัวแรก
>> และถ้าคุณกำลังอ่านเรื่องนี้เช่น สตริงคอมพิวเตอร์ของคุณเป็นสมาร์ท
พอที่จะรู้อ่านเรื่องทั้งหมดนี้ จนกว่าจะได้รับการฟันเฟือง 0
แต่ถ้าคุณกำลังอ่านมันเป็นตัวละครที่ เวลาดังนั้นคุณ iterating ผ่าน
สายนี้แล้วคุณก็จะอ่าน ตัวละครในเวลาจนกว่าคุณจะไป
เครื่องหมาย 0
ที่ไม่อาจตอบของคุณ คำถามว่า
>> นักเรียน: ใช่ แต่คุณยังไม่ได้ malloced พื้นที่ที่
สำหรับยังชี้ว่า
>> เจสัน Hirschhorn: ดังนั้นฉันไม่ได้ค่อนข้างแน่ใจว่า ว่าสิ่งที่คุณกำลังมองหาที่
เพราะผมไม่ได้ทำแบบทดสอบที่
ที่ควรจะเป็นประโยชน์ ทรัพยากรจาก TF อื่น
ถ้าคุณกำลังสร้างสตริงที่ สแต็คหรือเป็นตัวแปรท้องถิ่นก็จะ
เพียงแค่เป็นอาร์เรย์ของค่าใช้จ่ายมากกว่า โดยทั่วไปดาวถ่านชี้ไปที่
สตริงอื่น
แต่ผมไม่ทราบว่า
ที่อาจจะชี้ไปยังอีก สตริงในกองได้เป็นอย่างดี
ใช่
>> นักเรียน: ฉันรู้ว่าคุณจะต้อง จัดสรรหน่วยความจำถ้าตัวชี้เป็น
ได้รับการประกาศภายใน ฟังก์ชั่นอื่น
คุณต้องการที่จะทำสิ่งเดียวกันถ้าหากมันเป็น ถูกประกาศภายในของหลัก
คุณใช้มันภายในของหลัก?
>> เจสัน Hirschhorn: ดังนั้นใช่
คุณสามารถประกาศตัวชี้ใด ๆ หน่วยความจำที่อยู่ในหน่วยความจำ
มันสามารถจะเป็นที่อยู่หน่วยความจำของท้องถิ่น ตัวแปร แต่อาจเกิด
คนไม่ประกาศอยู่หน่วยความจำ ตัวแปรท้องถิ่นเพราะพวกเขาไป
ไปเมื่อฟังก์ชั่นที่ส่งกลับซึ่ง คือเหตุผลที่เราสิ่ง malloc ทั่วไป
แต่ใช่คุณสามารถประกาศตัวชี้ กับตัวแปรท้องถิ่นอื่น
มันเป็นเพียงแค่โดยทั่วไปไม่ได้ทำ
แต่ฉันสามารถดูที่ว่า สิ่งที่เฉพาะเจาะจงหลังเลิกเรียน
ใช่
>> นักเรียน: ผมคิดว่านี่คือการจัดเรียง ของสิ่งที่ถูกถาม
มันไม่แปลกที่จะมีการเริ่มต้น ชี้ไม่เป็น
ที่อยู่ แต่เป็นสิ่งที่ ดูเหมือนว่าค่า
ดูเหมือนว่า CS50 เป็นสิ่งที่อยู่ภายใน สิ่งที่มีการชี้ไปที่และ
ไม่ได้อยู่ที่เกิดขึ้นจริงใช่มั้ย
>> เจสัน Hirschhorn: เพื่อให้เป็น ไม่ได้กรณีที่แม้ว่า
นั่นไม่ใช่สิ่งที่เกิดขึ้น
เมื่อคุณประกาศดาวถ่าน, มันเป็นเรื่องที่อยู่ในหน่วยความจำ
ชี้ทุกคนที่อยู่ในหน่วยความจำ ชี้ไปที่สิ่งอื่น
อย่างอื่นที่อาจจะอยู่ใน กอง แต่มักจะอยู่บน
กองในวิธีที่เราจะเห็นมันใช้
แต่ stringname เท่ากับสองครั้งคำพูด "getString" เราจะเห็นว่าเรา
สามารถมองผ่านและรหัสที่ว่า
สตริง GetString ไม่ได้ถูกบันทึกไว้ใน ตัวแปรที่หรือสิ่งที่สตริง
ชื่อไม่ได้ถูกบันทึกไว้ในที่ ตัวแปรเพราะนั่นไม่ใช่วิธีการ
การทำงานของตัวชี้
ไม่ที่ทำให้รู้สึก?
>> นักเรียน: ใช่
>> เจสัน Hirschhorn: OK
หวังว่าที่ไม่ได้ ทำให้เกิดความสับสนกับทุกคน
แต่ถ้ามันเป็นเราสามารถมองไปที่มันอีกครั้ง ในบิตเพราะเรากำลังจะเป็นจริง
รหัสอะไรบางอย่างที่จะหวังว่า ทำงานกับสตริงและช่วยให้คุณรู้สึก
สะดวกสบายมากขึ้นกับพวกเขา
>> คำถามอื่น ๆ ที่เกี่ยวข้องกับเหล่านี้ หัวข้อหรือหัวข้ออื่น ๆ ที่
ผมจะนำกลับมาได้หรือไม่
และ -
ตอนนี้
ใช่ Alden
>> ALDEN: ดังนั้นนี่คือที่ไม่เกี่ยวข้องอย่างสมบูรณ์ แต่เราก็สามารถไปกว่า
อย่างรวดเร็วจริงๆสิ่งที่เราจำเป็นต้องรู้ เกี่ยวกับความแตกต่างระหว่าง 32 และ
เครื่อง 64-bit?
>> เจสัน Hirschhorn: ใช่
ดังนั้น 32 บิตเป็นจำนวนไบต์?
>> ALDEN: มันเป็นสี่ไบต์
>> เจสัน Hirschhorn: มันเป็นสี่ไบต์
และ 64 บิตเป็นจำนวนไบต์?
>> นักเรียน: แปด
>> เจสัน Hirschhorn: แปดไบต์
ดังนั้นอีกครั้งแปดบิตเป็นหนึ่งไบต์
เครื่องใช้ CS50 ของคุณคือ เครื่อง 32 บิต
ดังนั้นที่อยู่หน่วยความจำ สี่ไบต์ยาว
มี 2​​ มีถึง 32 อยู่หน่วยความจำ
0-2 ถึง 32 ลบ 1
และผมไม่ได้บวก แต่ที่ อาจขอบเขตของสิ่งที่คุณต้อง
รู้ว่าสำหรับเครื่อง 32 บิตที่หน่วยความจำ ที่อยู่มีอีกสี่ไบต์ยาว
และนั่นคือจำนวนเงินสูงสุด ของที่อยู่หน่วยความจำ
>> นอกจากนี้ชนิดข้อมูล -
นี้อาจจะมีสิ่งที่เป็น กันดีว่าเป็นมูลค่า noting
ขนาดของชนิดข้อมูลขึ้นอยู่กับ เครื่องที่คุณกำลังทำงานกับ
ดังนั้นถ่าน, ตัวเดียวเป็นวิธีการที่ ไบต์จำนวนมากในเครื่อง CS50 ของเราหรือไม่
หนึ่งไบต์
และเป็นจริงหนึ่งไบต์เป็น ได้ดีบนเครื่อง 64 บิต
>> และชนิดข้อมูลส่วนใหญ่เป็นหมายเลขเดียวกัน ไบต์ในเครื่องทั้งสอง
แต่บางชนิดข้อมูลจะแตกต่างกัน ในเครื่องทั้งสอง
เพื่อที่จะเป็นที่อาจเกิดขึ้น สิ่งเดียวที่คุณจำเป็นต้องรู้
>> แต่แม้ที่ผมคิดว่า อยู่นอกเหนือขอบเขต -
ฉันบวกเกือบถ้าคุณมองย้อนกลับไป แบบทดสอบที่เก่าก็บอกว่าสมมติ
การเข้ารหัสปัญหาที่คุณกำลังใช้ เครื่อง 32 บิต
แต่มีไปพร้อมกับที่ใน กรณีที่คุณสนใจมี
ชนิดข้อมูลที่เหมือนกัน ขนาดในเครื่องทั้งหมด
>> ถ้าคุณเคยเห็นสิ่งที่ต้องการ uint32_t คุณอาจจะหรืออาจจะ
ไม่ได้เห็นว่า
นั่นเป็นชนิดข้อมูล
ที่บอกว่าเป็น 32 บิตไม่ว่า สิ่งที่เครื่องนี้อยู่ใน
ดังนั้นเมื่อมีคนเขียนแบบพกพา รหัสพวกเขาอาจจะไม่ใช้ ints
พวกเขาจะใช้แทนข้อมูลอื่น ๆ เหล่านี้ ชนิดที่ว่าพวกเขารู้ว่าจะเป็นแบบเดียวกัน
ขนาดในเครื่องเดียวทุก
ฮาร์
>> ฮาร์: ผมมีคำถามเกี่ยวกับ การรวบรวม
ดังนั้นถ้าคุณกำลังเขียนโปรแกรมที่ใช้ ห้องสมุดเช่น CS50 หรือสิ่งที่
เช่นนั้นฉันรู้ว่าห้องสมุดที่ มีในบางจุดเป็น
รวบรวมและเชื่อมโยงเข้ามา
แต่วิธีการมากที่เกิดขึ้นในระหว่าง การสะสมของโปรแกรมของคุณหรือไม่
เป็นส่วนหนึ่งของกระบวนการสิ่งที่ห้องสมุดที่ เกิดขึ้นเมื่อคุณกำลัง
รวบรวมโปรแกรมของคุณเองหรือ
>> เจสัน Hirschhorn: ดังนั้นขอไปกว่า โดยทั่วไปขั้นตอนของกระบวนการนี​​้
คุณเขียนของคุณคไฟล์.
ในแฟ้มของคุณค. คุณ # include ของคุณ ห้องสมุดส่วนหัวเช่น cs50.h.
อะไรที่คมชัดรวมถึง สายทำในการเขียนโปรแกรมของคุณหรือไม่
Akchar
>> AKCHAR: มันจะเพิ่มต้นแบบของ ฟังก์ชั่นจากส่วนหัว
แฟ้มในไลบรารี
>> เจสัน Hirschhorn: แน่นอน
จะเพิ่มฟังก์ชั่นต้นแบบเหล่านั้น รหัสของคุณ
ดังนั้นเมื่อรหัสของคุณจะถูกรวบรวมใน ระยะแรกคอมไพเลอร์รู้
ที่ฟังก์ชั่นเหล่านี้จริงๆอยู่และ ที่พวกเขาได้รับการกำหนดว่า
ไฟล์. ชั่วโมงไม่รวม คำจำกัดความของฟังก์ชั่นเหล่านี้หรือว่า
พวกเขาทำงานจริง
Cs50.h เพียงแค่มีบางสิ่งบางอย่างที่บอกว่า GetString เป็นสิ่งที่จริงที่
สามารถเกิดขึ้นได้
และกล่าวว่า standardio.h printf เป็น สิ่งที่จริงที่สามารถเกิดขึ้น
>> ส่วนหัวดังนั้นภาษาคของคุณด้วย. ไฟล์ที่ได้รับกลายเป็นบางส่วน
รหัสเครื่องสามารถอ่านได้ซึ่งในที่สุด ได้รับกลายเป็นไบนารี
รหัส, 0 และ 1
และนั่นคือรหัสที่ในที่สุด ได้รับการดำเนินการ
-l สาย CS50 - ตัวอย่างเช่น เมื่อคุณกำลังเขียนเสียงดังกราว -
แล้วคุณมี l-CS50, คุณพิมพ์ที่ว่าค่ะ
และคุณจะเห็นว่า
เมื่อคุณเขียนให้คุณจะ เห็นเส้นที่ขึ้นที่นี่
และเราจะเห็นว่าในที่สองเมื่อ เรารหัสหรือในภายหลังเมื่อเรารหัส
>> แต่สายที่ CS50-ลิตรทำอะไรบางอย่าง บิตที่แตกต่างกว่า
# include cs50.h.
อะไรบรรทัดที่ l-CS50 ทำอย่างไร
avi?
>> AVI: ผมอยากจะบอกว่ามันเชื่อมโยง ห้องสมุดฟังก์ชั่น
เรียกเช่น. ไฟล์ o
>> เจสัน Hirschhorn: ดังนั้นมาก ใกล้ถ้าไม่จุดบน
l-CS50 ใช้แฟ้มไบนารีและ ผสานกับแฟ้มไบนารีของคุณ
ดังนั้น cs50.h มีจุดในการเปลี่ยนไม่มี cs50.h จากภาษา C เพื่อ binary ทุก
เวลาเดียวที่มันถูกใช้
ที่จะโง่เนื่องจากว่า จะเสียเวลามาก
ดังนั้นจึงได้รับการเรียบเรียงแล้ว และกลายเป็นที่ปฏิบัติการ
และตอนนี้ก็เป็นไปได้รวม ไฟล์ของคุณที่ท้าย
ดังนั้นผู้ที่ 1 และ 0 ที่จะไป จะรวมกับคนที่คุณ
0 และในตอนท้าย
ดังนั้นตอนนี้คุณจะมีจริงที่เกิดขึ้นจริง 1 และ 0 ของที่กำหนดวิธีการ GetString,
ตัวอย่างเช่นการทำงานหรือวิธี printf, ตัวอย่างเช่นการทำงานของ
>> และสำหรับข้อมูลเพิ่มเติมมี คอมไพเลอร์สั้น ๆ ที่ช่วยให้เนทที่
คุณควรตรวจสอบที่จะไป ผ่านขั้นตอนเหล่านี้
แต่ -
ใช่
>> นักเรียน: พวกเขามักจะอยู่ในไฟล์ o. เมื่อพวกเขากำลังในรูปแบบห้องสมุด
พร้อมที่จะผสานการเชื่อมโยง - เช่น พวกเขาอยู่ในรหัสเลขฐานสองหรือไม่
>> เจสัน Hirschhorn: OK
อะไร -
>> นักเรียนสินค้าที่เสมอกรณี ห้องสมุดเมื่อคุณเชื่อมโยงได้อย่างไร
>> เจสัน Hirschhorn: ใช่
ดังนั้นจึงมี. s ไฟล์ซึ่งจะเป็น รหัสเครื่องซึ่งจะเป็น
ความลับกับคุณ
คุณไม่จำเป็นต้องกังวลเกี่ยวกับการที่
แต่โดยทั่วไปใช่พวกเขาจะ เป็น. ไฟล์ o พร้อมที่จะไป
>> นักศึกษา: ดังนั้นเมื่อคุณส่งสินค้าไป ห้องสมุด, คุณเพียงส่ง
เอช. และ o.
คุณไม่ส่งค. หรือ s.
>> เจสัน Hirschhorn: ดังนั้น -
และนี่คือในระยะสั้นนี้เช่นกันถ้า ข้อมูลนี้น่าจะมา
เล็ก ๆ น้อย ๆ ได้อย่างรวดเร็ว
แต่สั้นในคอมไพเลอร์ พูดคุยเกี่ยวกับเรื่องนี้เป็นอย่างดี
เมื่อคุณส่งห้องสมุดถ้าคุณส่ง เอช. ไฟล์ส่วนหัวที่บรรดา
ต้นแบบฟังก์ชั่นและ 1 และ 0 นั่นคือทั้งหมดที่คุณจำเป็นต้องให้
คุณไม่จำเป็นต้องที่จะให้วิธีการที่ ฟังก์ชั่นการทำงานของคไฟล์.
เพราะจุดที่เป็นนามธรรมหรือ ชี้ APIs, จุดที่ SPL นี้
ห้องสมุดแบบพกพา Stanford ก็ เพื่อให้คุณไม่ต้องกังวลเกี่ยวกับวิธีการใหม่
GRect ทำงานหรือวิธีการย้ายงาน หรือวิธีการเพิ่มผลงาน
ทั้งหมดที่คุณต้องรู้คือการเพิ่มที่ เป็นฟังก์ชั่นที่คุณสามารถ
ใช้และมันไม่นี้
ดังนั้นคุณไม่จำเป็นต้องรู้วิธี ก็เขียนใน C. คุณเพียงแค่ต้อง
รู้ว่าที่นี่มีฟังก์ชั่นสิ่งที่พวกเขา ทำและที่นี่มี 1 และ 0
เมื่อคุณต้องการที่จะใช้พวกเขา
>> เย็น
คำถามใด ๆ เพิ่มเติมเกี่ยวกับคอมไพเลอร์ หรือหัวข้ออื่น ๆ ในคณะกรรมการหรือไม่
>> นักเรียน: ฉันมีคำถาม ฟังก์ชั่นการใช้ซ้ำ
คำถามเกี่ยวกับการเรียกซ้ำ
ผมมีความรู้สึกที่จะเกิดขึ้น
เพื่อให้ได้อย่างรวดเร็วผ่าน เรียกซ้ำกับการที่เฉพาะเจาะจง
เช่นฟังก์ชั่นแฟ
เพราะนี่เป็นตัวอย่างที่ มักจะมาขึ้นหรือจะใช้
เพื่อแสดงให้เห็นการเรียกซ้ำ
>> ดังนั้น "4" การอ่านเป็นปัจจัย 4
และสิ่งที่ไม่ 4 ปัจจัยหมายถึงอะไร
สิ่งที่จะทำอย่างไร
คุณจะคำนวณปัจจัย 4?
4 ครั้ง 3 ครั้ง 2 ครั้งที่ 1
>> ดังนั้นวิธีที่จะเขียน 4 ปัจจัยอื่น คือการเขียนนี้
4 ครั้ง 3 ปัจจัย
เพราะ 3 ปัจจัยคือ 3 ครั้ง 2 ครั้งที่ 1
ดังนั้น 4 ครั้ง 3 ปัจจัยคือ 4 ครั้งที่ 3 ครั้งที่ 2 ครั้งที่ 1
นี่คือเหตุผลที่ปัจจัยเป็นใหญ่ ผู้สมัครสำหรับการเรียกซ้ำเพราะ
ชัดเจนว่ามีอะไรบางอย่างที่ เกิดขึ้นซ้ำแล้วซ้ำแล้วซ้ำอีกใน
ขนาดเล็กจำนวนมากในสิ่งที่จนกว่า คุณถึงจุดสิ้นสุด
เมื่อคุณมาถึง 1, 1 ปัจจัยคือ 1
คุณไม่สามารถไปไกล
0 ปัจจัยที่ถูกกำหนดให้เป็น 1
ดังนั้นเมื่อคุณได้รับที่จะ 1 หรือ 0, คุณ ที่ปลายและคุณสามารถ
เริ่มที่จะกลับขึ้น
ดังนั้นถ้าเราอยากจะเขียนซ้ำ ฟังก์ชั่นในการคำนวณปัจจัย,
ที่เรากำลังจะเขียนบาง pseudocode ที่ตอนนี้
ก่อนที่เราจะเขียน pseudocode ที่ -
ฉันจะให้พวกคุณไม่กี่นาที การเขียนรหัสเทียมหรือเพียงแค่คิด
เกี่ยวกับมัน - มีสองสิ่งที่ทุก ความต้องการฟังก์ชั่นซ้ำ
สิ่งที่ทั้งสองสิ่งที่มีอะไรบ้าง
>> JACK: มันมีการเรียกตัวเอง
>> เจสัน Hirschhorn: โนอาห์?
โอ้แจ็ค
เอาเลย
>> JACK: มันมีการเรียกตัวเอง
>> เจสัน Hirschhorn: ดังนั้นซ้ำ ฟังก์ชั่นจำเป็นต้องมีการเรียกซ้ำ,
เรียกร้องให้ตัวเอง
ที่หนึ่ง
และสิ่งที่เป็นสิ่งอื่น ๆ
>> JACK: กรณีฐาน
>> เจสัน Hirschhorn: กรณีฐาน
กรณีฐานคือที่นี่คือเมื่อเราหยุด
ดังนั้นการทำงานของคุณได้รับการเรียกว่า
กรณีฐานมาก่อน
คุณต้องการที่จะทราบว่าคุณอยู่ที่ปลาย
และถ้าคุณไม่ได้อยู่ที่ท้ายที่สุดคุณ โทรซ้ำของคุณ
และคุณจะไปผ่านฟังก์ชั่นนี้อีกครั้ง ตรวจสอบกรณีฐานของคุณอีกครั้ง
หากคุณไม่ได้ท้ายที่สุดคุณทำ อื่นโทรซ้ำ,
และอื่น ๆ และอื่น ๆ
>> นั่นเป็นเหตุผลที่ฟังก์ชั่นซ้ำเสมอ ต้องการผู้ที่กรณีฐานและผู้ที่
โทรซ้ำ
หากคุณไม่ได้มีการเรียกซ้ำมัน จะไม่เป็นฟังก์ชั่นซ้ำ
หากคุณไม่ได้มีกรณีฐาน คุณจะไปและตลอดไป
ก็จะไม่มีที่สิ้นสุด
และกรณีฐานเสมอมาก่อน เพราะคุณมักจะต้องการที่จะตรวจสอบ
ถ้าคุณอยู่ที่ปลายแรก
ดังนั้นก่อนที่เราจะทำบาง pseudocode ทำไม คุณไม่ใช้เวลาสักครู่เพื่อคิดเกี่ยวกับ
วิธีการทำงานของปัจจัยซ้ำ จะได้รับการเขียน
>> นอกจากนี้ให้มากที่สุดเท่าที่คุณกำลังทำเขียน มันออกมาบนแผ่นกระดาษเป็น
สิ่งที่คุณจะต้อง ทำในการทดสอบในวันพรุ่งนี้
ดังนั้นการปฏิบัติที่อาจจะดีที่จะทำให้ แน่ใจว่ารหัสที่คุณกำลังเขียน
ลงบนแผ่นกระดาษ -
หรือคุณสามารถทำเช่นนั้นได้
คุณจะรู้ว่าที่มีเครื่องหมาย
คุณจำไวยากรณ์
เพราะคุณไม่สามารถที่จะมี คอมไพเลอร์บอกคุณทำผิดพลาด
>> นอกจากนี้ตามเส้นที่ในวันพรุ่งนี้เมื่อ คุณมีการเข้ารหัสปัญหาถ้าคุณ
จะรีบไปเวลาหรือถ้าคุณเป็นอย่างมาก สับสนเป็นวิธีการที่คุณควรจะ
เขียนสิ่งที่โดยเฉพาะอย่างยิ่งในคมัน จะ behoove คุณเขียนหลอกรหัส
หรือเขียนความเห็นในได้เป็นอย่างดี
เพราะมีเครดิตบางส่วนสำหรับ คำถามจำนวนมากเกี่ยวกับการตอบคำถาม
ดังนั้นคุณอาจต้องรีบหรือคุณ เพียงแค่อาจจะสับสน
เขียนในความคิดเห็นหรือหลอกรหัส มักจะเป็นวิธีที่คุณ
สามารถได้รับเครดิตบางส่วน
>> ดังนั้นอย่าปล่อยให้บางสิ่งบางอย่าง ว่างในการตอบคำถาม
มีบทลงโทษสำหรับการไม่ได้ วางสิ่งค่ะ
ในความเป็นจริงวางในรหัสหลอกหรือ ความเห็นจะไปช่วยปราบ
คิดออกถ้าคุณรู้ว่าสิ่งที่จริง คุณกำลังพูดถึงและอาจจะได้รับรางวัล
คุณมีเครดิตบางส่วนสำหรับการที่
>> นอกจากนี้ตามเส้นที่เขียนไว้อย่างชัดเจน
ถ้าเราไม่สามารถจริงๆสิ่งที่คุณกำลังเขียน เราจะไม่โทรหาคุณ
เวลาเที่ยงคืนวันพรุ่งนี้ตัวเลข สิ่งที่คุณเขียน
เรากำลังจะใช้เวลาปิดจุด
เขียนไว้อย่างชัดเจนเพื่อให้เราสามารถได้ยินหรือเปล่า เราสามารถอ่านสิ่งที่คุณเขียน
>> และถ้ามันบอกว่าสองประโยค ไม่ได้เขียนย่อหน้า
ทำตามคำแนะนำ
เขียนไว้อย่างชัดเจน
และเขียนในความเห็นเหล่านั้นหรือ pseudocode คำถามที่อาจ
ที่ได้รับรางวัลบางส่วนเครดิต
>> ตกลงขอไปที่ปัจจัย
ดังนั้นเราจึงมีปัจจัยฟังก์ชั่น
ถ้าฉันเป็นจริงเขียนนี้ใน C สิ่งที่ฉันจำเป็นต้องใส่ก่อนที่ชื่อ
ของการทำงานหรือไม่
ประเภทผลตอบแทนซึ่งในการนี​​้ กรณีที่เราจะให้มัน int
แล้วภายในวงเล็บปีกกาเป็น สิ่งที่จะไปภายในวงเล็บปีกกากับ
ฟังก์ชั่นหรือไม่
>> นักเรียนประเภทอาร์กิวเมนต์
>> เจสัน Hirschhorn: ข้อโต้แย้งของมัน
ดังนั้นปัจจัยอาจจะ ใช้อาร์กิวเมนต์
มันอาจจะใช้เวลาเพียงหนึ่งอาร์กิวเมนต์
และเราจะบอกว่ามันจะใช้เวลา จำนวนเต็มเรียกว่า x
และอีกครั้งเมื่อเขียนเป็นต้นแบบของ ฟังก์ชั่นหรือการเขียนฟังก์ชั่น
ในรหัสของคุณก่อนที่จะกำหนดว่าคุณ เขียนชนิดข้อมูลและชื่อของ
ตัวแปรสำหรับการทำงานที่ว่ามีเพียง
ดังนั้นคุณสามารถส่งผ่านบางส่วนในจำนวนนี้ ฟังก์ชั่นก็จะถูกเรียกว่า x
ภายใน
>> เรามีฟังก์ชั่นแฟคของเรา
เราจำเป็นต้องมีสองสิ่งที่กรณีฐาน และโทรซ้ำ
กรณีฐานสำหรับปัจจัยคืออะไร
คนที่เขียนมันออกมาและผู้ที่ไม่ได้ พูด แต่สิ่งที่เป็นฐาน
กรณีปัจจัย?
>> นักศึกษา: ถ้า n มีค่าน้อย กว่า 2, 1 คืน
>> เจสัน Hirschhorn: ถ้า n เป็น น้อยกว่า 2, 1 คืน
ฉันชอบที่เนื่องจากว่า ดูแล 0 และ 1
ดังนั้นเราจะทำ x <2, 1 คืน
ถ้าเราได้รับผ่าน 0, ถ้าเราได้รับ ผ่านไป 1 ฟังก์ชั่นนี้จะ
ทันทีกลับ 1
ถ้าเราได้รับผ่านบางส่วนมากขึ้นจำนวน กว่าหรือเท่ากับ 2 เรากำลังจะ
มีการเรียกซ้ำของเรา
>> และเพื่อให้เป็นวิธีที่จะทำงาน
สามารถคนอื่นที่ทำงานเกี่ยวกับเรื่องนี้ ที่ไม่ได้พูดยังให้ฉัน
โทรซ้ำสำหรับการทำงานนี้ ใน pseudocode?
ถ้าเราได้รับการส่งผ่านไปใน x จำนวน และมันเป็นเรื่องที่ยิ่งใหญ่กว่า 2 สิ่งที่
ที่เราต้องการจะทำอย่างไร
นอกจากนี้เรายังมีตัวอย่างที่เขียนไว้ใน ด้านที่อาจจะให้คำแนะนำ
>> นักเรียน: Call x ครั้ง ปัจจัยของ x ลบ 1?
>> เจสัน Hirschhorn: แน่นอนขวา
เรากำลังจะกลับ x ครั้ง ปัจจัยของ x ลบ 1
และว่าแม้ว่าที่ผมเขียนขึ้น โดยทั่วไปสิ่งที่คุณกล่าวว่าในภาษาอังกฤษ
ฟังก์ชั่นนี้ปัจจัย จะได้รับการเรียกอีกครั้ง
มันจะรันบน x ลบ 1
มันจะกลับมาพร้อมกับจำนวนเต็มบางส่วนและ แล้วมันจะคูณสองเหล่านี้
ร่วมกันและค่าที่จะได้รับ กลับไปยังสิ่งที่เรียกว่า
ฟังก์ชั่นปัจจัยที่อาจ เป็นตัวอย่างของคนอื่น
ฟังก์ชั่นนี้ปัจจัย
>> เพื่อให้เป็นตัวอย่างของการเวียนเกิด ฟังก์ชั่นมาก
ฟังก์ชั่นซ้ำง่ายๆ
แต่ส่วนใหญ่ของพวกเขาจะเป็นเช่นนี้
หากคุณต้องการซ้ำท​​ี่ดี ท้าทายสำหรับการทดสอบให้ลองเขียนโปรแกรม
ค้นหาแบบไบนารีซ้ำ
เพราะถ้าคุณได้ค้นหาไบนารี ปัญหาตั้งสามคุณอาจทำมัน
ซ้ำในวงในขณะที่
>> แต่มันยังสามารถเขียน ซ้ำ
คุณจะต้องมีการเขียนของคุณเอง ฟังก์ชั่นแยกต่างหากที่จะใช้เวลาบางส่วน
อาร์กิวเมนต์บรรทัดคำสั่งแตกต่างกัน - หรือ ไม่อาร์กิวเมนต์บรรทัดคำสั่งบางอย่าง
ข้อโต้แย้งที่แตกต่างกันเพียงปกติ
แต่คุณสามารถเขียนค้นหาแบบไบนารี ซ้ำได้เป็นอย่างดี
>> นักศึกษา: ดังนั้นคุณอาจจะได้เขียนยัง แทน x ลบ 1 คุณ
อาจมีการเขียน x ลบ ลบหรือคุณอาจจะมี
เขียนลบลบ x
คุณสามารถได้อย่างรวดเร็วเพียงแค่อธิบายว่าทำไม เหล่านั้นจะเป็นสิ่งที่แตกต่างกัน
ต้องการสิ่งที่แตกต่างระหว่าง x ลบลบและลบลบ x?
>> เจสัน Hirschhorn: ไม่ฉันไม่ได้ จะไปลงที่
แต่ผมจะพูดคุยกับคุณเกี่ยวกับเรื่องนี้หลังจาก ชั้น x ลบลบลบลบ x
พร่อง x 1
แต่พวกเขาทำมันแตกต่างกันเล็กน้อย
แต่ผมไม่ต้องการที่จะไปลงที่
คำถามอื่น ๆ เกี่ยวกับการเรียกซ้ำ หรือฟังก์ชั่นนี้
ที่ไม่จริงแม้แต่ pseudocode
ที่พื้นในรหัส C คุณจะเขียนนี้
>> ตกลงคำถามอื่น ๆ เกี่ยวกับหัวข้อที่นี่?
ใช่
>> นักเรียน: ฉันมี rundown รวดเร็วของ ลอยจุดและความแม่นยำ
>> เจสัน Hirschhorn: ลอย จุดและความแม่นยำ
สามารถคนอย่างรวดเร็วจริงๆ ให้ฉัน rundown ของ
ลอยจุดและความแม่นยำ
ทุกท่านต้องทำเช่นนี้สำหรับคุณ ปัญหาการตั้งค่าเพื่อให้คุณกำลังทั้งหมด
คุ้นเคยกับมัน
หรืออาจจะไม่ทั้งหมดของคุณ
ใคร?
ให้ฉันเป็นจุดเริ่มต้น
ลอยจุดและความแม่นยำ
สิ่งที่เป็นปัญหาหรือไม่
ใช่
วิกตอเรีย
>> VANESSA: วาเนสซ่า
>> เจสัน Hirschhorn: วาเนสซ่า
ขอโทษ
>> VANESSA: มีเพียงจำนวน จำกัด ของ ของตัวเลขที่สามารถแสดง
เพราะคุณอยู่ในในของเรา กรณีระบบ 32 บิต
ดังนั้นคุณชนิดของต้อง ทำให้ตัวเลขบาง
>> เจสัน Hirschhorn: เพื่อให้เป็น ตรงขวา
มีเพียงจำนวนหนึ่งของเป็น ตัวเลขที่สามารถแสดง
หากคุณคูณตัวเลขสองมีขนาดใหญ่มาก มันอาจจะล้นจำนวน
ของคุณมีช่องว่างที่จะเป็นตัวแทน จำนวนเต็ม
นั่นเป็นเหตุผลที่บางครั้งเราใช้ ยาวยาวแทน int
ที่มีช่องว่างมากขึ้น
ที่สามารถถือจำนวนมาก
>> ความแม่นยำลอยจุดจะทำอย่างไรกับ ว่า แต่ยังมีจะทำอย่างไรกับ
ความจริงที่ว่าตัวเลขทศนิยมเป็น ไม่ได้เป็นตัวแทนเสมอ
ขอโทษ
ผมขอนำกลับมานี้ขึ้น
เลขฐานสิบ 1.0 ไม่ได้เสมอ แทนเหมือนที่คุณคาดหวัง
1.000000000
บางครั้งมันเป็นแสดงเป็น 1.000000001 หรือ 0.999999999
มันอาจจะถึง 89 โยน ในบางแห่งมี
ดังนั้นตัวเลขทศนิยมที่ไม่ แสดงว่าเหมือนกับที่คุณต้องการ
คาดว่าพวกเขาจะเป็นตัวแทน
>> ดังนั้นในการกำหนดปัญหา -
ว่าเป็นเรื่องที่สอง -
ตั้งสองปัญหาที่เราจัดการกับ หมายเลขจุดลอยเมื่อเราต้องการ
พวกเขาจะเป็นตัวแทนของสิ่งที่เราต้องการ พวกเขาจะเป็นตัวแทนของจำนวน
ของเหรียญหรือจำนวนของเซ็นต์, เราคูณด้วย 100
เรากลมพวกเขา
แล้วเราตัดทุกอย่าง หลังจุดทศนิยม
นั่นคือเพื่อให้แน่ใจว่าพวกเขาจะ จริงเท่ากับว่าสิ่งที่เราต้องการ
พวกเขาให้เท่ากับ
>> เพราะเมื่อคุณใช้สิ่งที่ ลอยและเปิดเป็น int คุณ
ตัดทุกอย่างไปทางขวา ของจุดทศนิยม
เพราะมีบางจุดลอย ไม่แน่ชัด, 100.000 อาจจะ
แสดงเป็น 99.999999999
และถ้าคุณเพียงแค่ตัดออกทุกอย่างเพื่อ ที่เหมาะสมทันทีที่คุณกำลังจะ
ได้รับหมายเลขที่ไม่ถูกต้อง
ใช่
>> นักเรียน: ผมมีคำถาม เกี่ยวกับการคัดเลือกนักแสดง
สิ่งที่สั่งซื้อที่ไม่ได้เกิดขึ้นมีอะไรบ้าง
หากคุณต้องการทำลอยวงเล็บ 1 แบ่ง 10, ไม่ได้ทำ 1 หารด้วย 10
แล้วได้รับ 0.1 จากนั้นเปิด ลงลอย?
>> เจสัน Hirschhorn: ถ้าคุณทำ ลอย 1 หารด้วย 10 -
>> นักเรียน: ใช่แล้วเท่ากับ -
ดีก็จะปกติ มีความเท่าเทียมกันใน -
ใช่
คุณต้องการที่จะให้มันลอยใช่ไหม
>> เจสัน Hirschhorn: ตกลงดังนั้นเรากำลังจะ การใช้งานที่ทำต่อไปในการหา
คำตอบของคำถามเหล่านี้ ผ่านการเข้ารหัส
เพราะคุณอาจจะมีจำนวนมาก คำถามเหล่านี้นาทีและเป็นวิธีที่ดี
การแก้พวกเขาจะผ่านการเข้ารหัส
ดังนั้นเรากำลังจะรหัสนี้ในขณะนี้ และจากนั้นเราจะกลับไป
รหัสคำถามที่คุณมี
>> ดังนั้นบรรทัดแรก -
ผมไม่ควรจะเขียนมัน - สิ่งที่เป็น สิ่งแรกที่เราต้องการจะทำเมื่อเรา
เปิดไฟล์ใหม่ใน Gedit?
>> นักเรียน: รวม
>> เจสัน Hirschhorn: รวมอะไร
>> นักเรียน: ห้องสมุด CS50
>> เจสัน Hirschhorn: OK
อะไรที่เราควรจะรวมอยู่
เรากำลังจะไปตรวจสอบสิ่งที่เกิดขึ้น เมื่อคุณโยนสิ่งที่จะลอย
แต่เราทำในสิ่งที่จำเป็นต้องมีถ้าเรา จะเขียนโปรแกรม C?
>> นักเรียน: มาตรฐาน I / O
>> เจสัน Hirschhorn: stdio.h
เราจริงไม่จำเป็นต้องนี้ โปรแกรม cs50.h แม้ว่ามันจะเป็น
มักจะเป็นประโยชน์ที่จะรวมไว้
แต่เราไม่เคยต้อง stdio.h
>> นักศึกษา: เมื่อเขียนโปรแกรมใน C?
>> เจสัน Hirschhorn: เมื่อเขียนโปรแกรมใน C.
>> ดังนั้นผมจึงบันทึกเป็นไฟล์นี้ค.
ฉันจะได้รับบางส่วนเน้นไวยากรณ์ดี
ที่ผมเขียนเป็นโมฆะภายในหลัก
สิ่งที่ไม่เป็นโมฆะหมายความว่าอย่างไร
>> นักศึกษา: ไม่ได้ใช้ใด ๆ อาร์กิวเมนต์บรรทัดคำสั่ง
>> เจสัน Hirschhorn: หมายถึงความว่างเปล่าในการนี​​้ กรณีที่หลักไม่ได้ใช้ใด ๆ
อาร์กิวเมนต์บรรทัดคำสั่ง
ในกรณีอื่น ๆ ก็หมายความว่าฟังก์ชั่น ไม่ใช้อาร์กิวเมนต์บรรทัดคำสั่ง
หรือฟังก์ชั่นถ้าผมจะเขียนเป็นโมฆะ หลัก (void) ที่จะบอกว่าหลัก
ไม่กลับอะไร
ดังนั้นเป็นโมฆะเพียงหมายถึงอะไร
สิ่งที่ผมจะเขียนถ้าผมต้อง ใช้อาร์กิวเมนต์บรรทัดคำสั่ง?
>> นักเรียน: int อาร์คสตริงอาร์โวลต์
>> เจสัน Hirschhorn: int argc argv สตริง
เป็นสิทธิที่?
>> นักเรียน: มันวงเล็บ argv ถ่านดาว
>> เจสัน Hirschhorn: ดังนั้นคุณสามารถเขียน วงเล็บสตริง argv หรือ argv ถ่านดาว
วงเล็บ แต่คุณต้องวงเล็บ
เพราะ argv เป็นอาร์เรย์ ของสตริงจำ
มันไม่ใช่แค่หนึ่งสตริง
ดังนั้นสตริง argv เป็นที่นี่ที่ สายหนึ่งที่เรียกว่า argv
วงเล็บ argv สตริงที่นี่ อาร์เรย์ของสตริง
ดังนั้นวงเล็บ int argc argv สตริง จะเป็นสิ่งที่ฉัน
อาจจะเขียน
>> ดังนั้นคุณจึงต้องการที่จะบันทึกในจำนวนเต็ม
>> นักเรียน: ใช่จำนวนเต็ม
หรือในการลอย
>> เจสัน Hirschhorn: ในลอย?
เหมือนลอย x เท่ากับ 1 หารด้วย 10
>> เจสัน Hirschhorn: OK
ฉันจะพิมพ์ออกมาลอยใน printf?
คืออะไร?
>> นักเรียน% ฉ
>> เจสัน Hirschhorn: f%
อะไรจำนวนเต็ม
งหรือฉัน
สิ่งที่สตริงหรือไม่
>> นักเรียน: s
>> เจสัน Hirschhorn: s
ฉันจะได้รับสายใหม่ได้อย่างไร
>> นักเรียน: n แบคสแลช
>> เจสัน Hirschhorn: สิ่งใดที่ฉันกลับมา ถ้าทำงานหลักถูกต้องหรือไม่
>> นักเรียน: 0
ฉันจะต้องเขียนเส้นที่แม้ว่า?
>> นักเรียน: เลขที่
ตกลงเราจะไม่เขียนมันแล้ว
ทุกคนสามารถอ่านได้หรือไม่
ดูเหมือนบิตขนาดเล็ก
ทุกคนสามารถมองเห็นหรือควร ฉันจะทำให้มันใหญ่
ผมคิดว่ากล้องที่เราจะทำ มันบิตขนาดใหญ่แม้ว่า
>> เจสัน Hirschhorn: ถ้าผมต้องการที่จะเปิดการทำงานนี้ . c ไฟล์ลงในปฏิบัติการสิ่งที่
ฉันจะเขียน?
>> นักเรียน: ตรวจทดสอบ
>> เจสัน Hirschhorn: ขอโทษ?
>> นักเรียน: ตรวจทดสอบ
>> เจสัน Hirschhorn: ตรวจทดสอบ
เราได้พูดคุยเกี่ยวกับ บรรทัดนี้ก่อนหน้านี้
เสียงดังกราว
อะไรเสียงดังกราวหรือไม่
ชื่อของคอมไพเลอร์
สิ่งที่สายนี้
>> นักเรียน: ตั้งขึ้นสำหรับการใช้ GDB
>> เจสัน Hirschhorn: ชุด มันขึ้นอยู่กับการใช้งานของ GDB
บรรทัดนี้สิ่งที่
>> นักเรียน: รหัสที่มา
>> เจสัน Hirschhorn: นั่น แฟ้มแหล่งที่มา, คไฟล์.
สิ่งใดที่ทั้งสองสายจะทำอย่างไร
หรือทั้งสองไม่ได้สาย
>> นักเรียน: มันชื่อมันทดสอบ
>> เจสัน Hirschhorn: ดังนั้น o รีบกล่าวว่า ชื่อมันมีอะไรบางอย่างที่แตกต่างกัน
และที่นี่คุณจะเรียกมันว่าการทดสอบ
ถ้าฉันไม่ได้มีที่ใน สิ่งที่มันจะตั้งชื่อนี้
>> นักเรียน: a.out
>> เจสัน Hirschhorn: a.out
สิ่งนี้จะทำอย่างไร
>> นักเรียน: ลิงค์ห้องสมุดคณิตศาสตร์
>> เจสัน Hirschhorn: มันเชื่อมโยง ในห้องสมุดคณิตศาสตร์
เราไม่ได้รวมห้องสมุดคณิตศาสตร์ แต่ ตั้งแต่ที่ร่วมกันเพื่อให้พวกเขาได้
ทำให้เขียนเสมอรวม ห้องสมุดคณิตศาสตร์
และเช่นเดียวกันนี้รวมถึง ห้องสมุด CS50
>> ตกลงดังนั้นหากเรารายการตอนนี้เรามี ปฏิบัติการที่เรียกว่าการทดสอบ
ที่จะดำเนินการเรื่องนี้ผมเขียนทดสอบ
ผมเห็นว่าจุดลอยของฉัน ตามที่คาดไว้เท่ากับ 0
ไม่ว่า -
ดังนั้น -
>> นักเรียน: แล้วถ้าคุณใส่ลอยตอนนี้ เหมือนที่คุณโยนมันลอย -
>> เจสัน Hirschhorn: โพลล์ 1 ถึงลอยได้หรือไม่
>> นักศึกษา: ไม่โยนสิ่งที่เต็ม -
ใช่
หากคุณเพียงแค่ไม่ว่าจะ ที่ทำให้มันเป็น 0.1?
>> เจสัน Hirschhorn: ตกลงอย่างรวดเร็วจริงๆ 1 หารด้วย 10, ผู้ที่มี
จำนวนเต็มถูกแบ่งออก
ดังนั้นเมื่อคุณแบ่งจำนวนเต็มพวกเขากำลัง 0, และคุณประหยัดที่ 0
ลอยเพราะเฉือนเป็น แบ่งจำนวนเต็มเพียง
ดังนั้นตอนนี้เรากำลังเปลี่ยนบางสิ่งบางอย่าง ลงลอย
>> ลองดูสิ่งที่เกิดขึ้น
เราจะทำให้การทดสอบ
ดังนั้นตอนนี้เราจะเห็นว่าเฉือนที่ไม่ได้ แบ่งจำนวนเต็มมันก็ลอย
ส่วนจุดที่
เพราะหนึ่งในข้อโต้แย้งของ ได้รับการโยนไปลอย
ดังนั้นตอนนี้มันก็บอกว่าการรักษานี้ ส่วนเหมือนที่เรากำลังติดต่อกับ
จุดที่ลอยไม่ได้กับจำนวนเต็ม
และเพื่อให้เราได้คำตอบที่เราคาดหวัง
>> ลองดูสิ่งที่เกิดขึ้น -
อุ่ย
ถ้าผมอยากจะพิมพ์ทศนิยมมากขึ้น จุดว่าฉันจะทำอย่างนั้น
>> นักเรียน: จุดจุดฉหรือเป็นจำนวนมาก ตำแหน่งทศนิยมตามที่คุณต้องการ
>> เจสัน Hirschhorn: ดังนั้นฉันพิมพ์ 10 จุดทศนิยม
และตอนนี้เราจะเห็นเราได้รับ บางสิ่งที่แปลก
และที่จะไปกลับไปที่คำถามของคุณ เกี่ยวกับจุดลอยไม่แน่ชัด
มีสิ่งที่แปลกที่เก็บไว้ในที่นี่
>> ตกลงที่ไม่ตอบคำถามของคุณหรือไม่
คุณไม่ต้องการอะไรอีก รหัสได้อย่างรวดเร็ว
>> นักเรียน: ฉันแค่อยากจะดูหรือ ไม่ได้ถ้าคุณอิสระขึ้นตัวชี้บางอย่าง
ไม่ว่าจะเป็นตัวชี้ว่ายังคงมีการเก็บไว้ใน มันอยู่ในสิ่งที่มันเคยเป็น
ชี้ไปก่อนหน้านี้
>> เจสัน Hirschhorn: ตกลง จึงขอทำอย่างนั้น
PTR ดาวถ่านนี้สร้างตัวแปร เรียกว่า PTR ประเภทถ่านดาว
ฉันจะเขียน malloc อย่างไร
Alden?
>> ALDEN: เพียง malloc
แต่แล้วมันจะต้องมีขนาดของและ ในกรณีนี้ผมคิดว่าคุณต้องการ
จะชี้ไปยังถ่าน
ดังนั้นมันจะเป็นถ่าน
>> เจสัน Hirschhorn: OK เพื่อให้มากขึ้น ทั่วไป, Inside -
ขอแก้ไข
ภายใน malloc ที่คุณต้องการจำนวน ของไบต์ในกอง
โดยทั่วไปสิ่งที่เราได้เห็นว่าเรา ทำคือการที่เรากำลังจะ malloc
สตริงเช่นหรือ อาร์เรย์ของจำนวนเต็ม
ดังนั้นหากเราต้องการจำนวนเต็ม 10 หรือ 10 ตัวอักษร 10 จะทำให้เรามี 10
แล้วขนาดของตัวอักษรจะให้ เราขนาดของตัวอักษรที่อยู่ใน
กรณีนี้เป็น 1 ไบต์
เราได้รับ 10 ไบต์
ถ้าเราจะเขียนขนาดของ int, ที่จะทำให้เรามี 40 ไบต์
>> มากขึ้นโดยทั่วไปภายในของ malloc คือจำนวนของไบต์ที่คุณต้องการ
ในกรณีนี้เราได้รับ 1 ไบต์
ซึ่งดูเหมือนว่าการใช้งานแปลก ของ malloc แต่สำหรับเรา
เพื่อทำให้ความรู้สึก
ดังนั้นจึงมีว่า
>> เรากำลังจะเรียกฟรี
เราจะกำจัดมันและเราใช้ PTR อีกครั้ง
และสิ่งที่คุณไม่ต้องการที่จะตรวจสอบ
>> นักเรียน: ฉันแค่อยากจะตรวจสอบว่า หรือไม่ได้มีอะไร
ภายในของมัน
>> เจสัน Hirschhorn: ดังนั้นไม่ว่า มันชี้ไปที่อะไร
>> นักเรียน: ใช่ว่าไม่ว่าจะเป็น มันยังคงมีอยู่หน่วยความจำ
>> เจสัน Hirschhorn: ดังนั้นคุณจึงต้องการ ในการตรวจสอบค่าของ PTR หรือไม่
>> นักเรียน: ใช่ว่า
>> เจสัน Hirschhorn: สิ่งใดที่ฉันเขียนที่นี่ ถ้าผมต้องการที่จะตรวจสอบค่าของ
จุด - สิ่งที่จอร์แดน ค่ากล่าวว่า
หรือสิ่งที่ถูกเก็บไว้ภายในของ PTR?
>> นักเรียนที่อยู่ในหน่วยความจำ
>> เจสัน Hirschhorn: ที่อยู่หน่วยความจำ
ดังนั้นถ้าผมเขียนเพียงแค่นี้ก็จะ ให้ฉันค่าของ PTR
และฉันจะพิมพ์ออกมา อยู่หน่วยความจำได้หรือไม่
สิ่งที่สตริงรูปแบบ สำหรับที่อยู่หน่วยความจำได้หรือไม่
>> นักเรียน% พี
>> เจสัน Hirschhorn:% พี
% s เป็นสตริง
% พีเพื่อชี้
เป็นสิทธิที่?
ที่เหมาะสม
ดังนั้น PTR เท่ากับ -
ก็ยังคงมีบางสิ่งบางอย่างอยู่ในนั้น
นี่อาจจะเป็นมากขึ้น คำถามที่น่าสนใจ
อะไรบรรทัดที่ทำอย่างไร
>> นักศึกษา: ความผิดพลาด Seg
>> เจสัน Hirschhorn: อะไรนะ?
>> นักเรียน: ฉันคิดว่ามัน seg ความผิดพลาด
>> เจสัน Hirschhorn: หืมม?
>> นักเรียน: ฉันคิดว่ามันจะเป็นความผิด seg
>> เจสัน Hirschhorn: ดังนั้นบรรทัดนี้ ของรหัส PTR, ดาว, สิ่งที่
ไม่ดาวหมายถึงอะไร
>> นักเรียน: เนื้อหาของ
>> เจสัน Hirschhorn: ใช่
ไปที่จะได้รับเนื้อหาของ
ดังนั้นนี่จะไปถึงหน่วยความจำ ที่อยู่ที่นั่นและให้ฉันที่
ผมใช้ c% ที่นี่เพราะมี เป็นตัวละครที่เก็บไว้ที่นั่น
ดังนั้นเรากำลังจะไปที่ที่เราอยู่ เพิ่งเห็น - หรือมันอาจจะเป็น
นิด ๆ หน่อย ๆ ที่แตกต่างกันนี้ เวลาที่เราเรียกใช้โปรแกรม
แต่เราจะไปยังที่อยู่ที่ ซึ่งเรารู้ว่ายังคงมีอยู่
และดูสิ่งที่มี
>> ดังนั้นมันไม่ได้เป็นความผิด seg
มันก็ไม่ได้ทำให้เรามีอะไร
มันอาจจะให้เราจริง บางสิ่งบางอย่างเราก็ไม่สามารถดูได้
และที่จะไปกลับไปที่ความคิดนี้ -
และเราจะไม่ได้รับมากเกินไปใน นี้เพราะที่เกิน
ขอบเขตของหลักสูตรนี้
แต่เราพูดคุยเกี่ยวกับที่นี่ถ้าเรา ไปเกินขอบเขตของอาร์เรย์โดย
1 เราอาจจะไม่ได้รับในปัญหา
>> บางครั้งเมื่อคุณเพิ่งออกไปโดยที่ 1 คุณกำลังทำบางอย่างผิดปกติและคุณ
อาจจะได้รับในปัญหา
แต่คุณไม่เคยได้รับในปัญหา
มันขึ้นอยู่กับวิธีการมากของสิ่งที่ไม่ดีคุณ ไม่ว่าคุณกำลังจะได้รับในปัญหา
ซึ่งไม่ได้บอกว่าจะเลอะเทอะ ด้วยรหัสของคุณ
แต่มันเป็นเรื่องที่จะบอกว่าโปรแกรมจะไม่ เสมอออกแม้ว่าคุณจะไปที่ไหนสักแห่ง
คุณไม่ควรที่จะไป
>> ตัวอย่างที่ดีของที่มีจำนวนมาก คนที่อยู่ในปัญหาของพวกเขาตั้ง 3 ซึ่ง
เป็น 15 ไม่ได้ตรวจสอบ ขอบเขตของคณะกรรมการ
เพื่อให้คุณมองไปทางซ้ายมองไป ขวามองไปด้านบนมอง
ไปที่ด้านล่าง
แต่คุณไม่ได้ตรวจสอบเพื่อดูว่าด้านบน เป็นจริงไปได้บนกระดาน
และคนจำนวนมากที่ไม่ว่าและ เปิดที่อยู่ในโปรแกรมของพวกเขาทำงาน
อย่างสมบูรณ์แบบเพราะในกรณีที่คณะที่ ที่เก็บไว้ในหน่วยความจำถ้าคุณไปหนึ่ง
ดังกล่าวข้างต้นหรือตรวจสอบว่าหน่วยความจำ ที่อยู่มีไม่อะไร
โดยเฉพาะอย่างยิ่งที่น่ากลัวเกี่ยวกับที่ ดังนั้นโปรแกรมของคุณไม่ได้
จะตะโกนใส่หน้าคุณ
>> แต่เรายังจะใช้เวลาปิดจุดถ้า คุณไม่ได้ตรวจสอบว่าเพราะคุณ
กำลังทำสิ่งที่คุณไม่ได้ ควรที่จะทำและคุณอาจมี
อากาศในปัญหา
ราคาที่แม้ว่าคุณอาจไม่ได้
ดังนั้นนี้คือการแสดงให้เห็นว่าใช่ เรายังคงสามารถไปกับมัน
และเราจะไม่ได้รับใน ปัญหาในกรณีนี้
ถ้าเราพยายามที่จะทำอ่าน 100 ตัวอักษรต่อไปเราต้องการ
อาจจะได้รับในปัญหา
และคุณสามารถอ่านรห​​ัสที่อยู่ถัดจาก 100 ตัวอักษรถ้าคุณต้องการด้วยการทำบางอย่าง
การเรียงลำดับของการวน
ใช่
>> นักเรียน: เนื่องจากเราได้รับมอบหมายว่า พื้นที่ค่าจริงเราจะไม่
จริงจะสามารถที่จะเห็นอะไร
เราควรพยายามด้วยการตั้งค่าที่ เท่ากับชอบคหรืออะไร
>> เจสัน Hirschhorn: Great คำถาม
ฉันจะตั้งค่าที่ว่า -
สิ่งที่บรรทัดของรหัสฉันจะเขียนในบรรทัด เจ็ดที่จะทำสิ่งที่คุณกล่าวว่า
>> นักเรียน: Star PTR เท่ากับเดียว อ้างคท้ายคำพูดเดียว
>> เจสัน Hirschhorn: ดังนั้นที่วาง ตัวอักษร C, ในสถานที่นั้น
เพราะอีกดาวที่ วิธีการไปที่มี
และเมื่อนำมาใช้ในด้านซ้ายมือของ ผู้ประกอบการที่ได้รับมอบหมายที่เท่ากับ
ลงเราจะไม่ได้รับที่ มูลค่ามากตามที่กำหนดค่าที่
ตอนนี้ขอดูสิ่งที่เกิดขึ้น
>> เรานำสิ่งที่มี และมันก็มี
เราเรียกว่าฟรี
บางสิ่งที่อาจจะเกิดขึ้น ในกอง
ดังนั้นจึงไม่ได้มีอีกต่อไป
แต่อีกครั้งที่เราไม่ได้รับ ปัญหาสำหรับไปที่นั่น
>> ฉันทำเช่นนี้ออกมาในรหัสเพื่อแสดงให้เห็นถึง ที่มากของเหล่านี้
คำถามที่คุณมีที่พวกเขากำลัง ที่น่าสนใจจริงๆ
คำตอบเป็นจำนวนมากเวลา
และพวกเขากำลังคำถามที่ดีจริงๆ
และคุณสามารถคิดพวกเขาออกใน ของคุณเองหากยกตัวอย่างเช่น
เราไม่ได้อยู่ในส่วน
ใช่
>> นักเรียน: เพราะคุณไม่ได้ส่ง ชี้ทุกที่คุณจะต้อง
ใช้ malloc?
>> เจสัน Hirschhorn: ดังนั้นนี้ไปกลับ คำถามแรกของคุณ
[? ?]
มันเป็นเพียงตัวแปรในประเทศหรือไม่
malloc ที่นี่ไม่ได้เป็นที่น่าสนใจ
การใช้ malloc ที่นี่ไม่ได้ ที่น่าสนใจเพราะมันเป็น
เพียงตัวแปรท้องถิ่น
>> นักศึกษา: ดังนั้นคุณสามารถทำถ่าน PTR ดาวเท่ากับสวัสดี?
>> เจสัน Hirschhorn: โอ้
ดังนั้นเราจะได้รับกลับในขณะนี้ คำถามแรกของคุณ
ฉันคิดว่าคุณไม่พอใจ กับคำตอบของฉัน
OK?
เช่นเดียวกับที่
>> นักเรียน: ใช่
รอ
>> เจสัน Hirschhorn: และสถานที่ที่ คุณต้องการที่จะพิมพ์ออกมา
ดังนั้นเราจะพิมพ์ออกสตริงเช่นนั้นหรือไม่
>> นักเรียน: ที่น่าสนใจ
>> เจสัน Hirschhorn: ดังนั้นนี้พูดอย่างนี้ อาร์กิวเมนต์ที่มีชนิดของตัวละคร
ดังนั้นนี้ควรจะเป็นตัวละคร
>> นักเรียน: เพียงแค่ใช้เวลาหนึ่งก่อน
>> เจสัน Hirschhorn: ดังนั้นนี้ คือสิ่งที่ฉันกล่าวว่าก่อนที่จะ
เช่นฉันกล่าวว่ายังไม่ได้จัดเก็บ สตริงภายในตัวชี้ตัวแปร
มันเก็บ -
>> นักเรียน: ค่าแรก ของสตริง
>> เจสัน Hirschhorn: ที่อยู่ของ ค่าแรกของสตริง
ถ้าเราจะพิมพ์ออกมานี้เรากำลัง ได้รับค่าที่อยู่ภายในตัวชี้
และเราจะเห็นว่ามันเป็นจริง อยู่หน่วยความจำ
>> ไม่ที่ทำให้รู้สึก?
ขอโทษ
รอไม่ว่าคำตอบของคุณ คำถามแม้ว่า
>> นักเรียน: ใช่
>> เจสัน Hirschhorn: บรรทัดของรหัสนี้เป็น การสร้างสตริงและหลังจากนั้นอีก
ตัวชี้ตัวแปรที่ชี้ สตริงที่อาร์เรย์ที่
ใช่
>> นักศึกษา: ดังนั้นถ้าเราไปหน่วยความจำหนึ่ง อยู่ต่อไปเราจะได้รับต่อชั่วโมงหรือไม่
มันได้รับการจัดเก็บเป็นสตริง?
>> เจสัน Hirschhorn: เช่นเดียวกับเราได้ -
ดังนั้นนี่คือที่มีค่าที่จะทำ
นี่คือการคำนวณจุดที่คุณผู้ชาย ได้เห็นมาก่อนและควรจะ
ค่อนข้างพอใจกับ
นี้จะคล้ายกับการเขียน -
ถ้าเราจะเขียนบรรทัดของรหัสนี้ เราได้เห็นสัญกรณ์อาร์เรย์ก่อน
นี้จะให้เราสอง ค่าในอาร์เรย์นี้ชั่วโมง
>> ถ้าเราทำอย่างนี้นี้ยังควรให้ เราค่าที่สองในอาร์เรย์
เพราะมันเป็นไปไม่ได้กับหน่วยความจำ ที่อยู่ของสิ่งแรก แต่
อยู่หน่วยความจำของสิ่งที่มากกว่าหนึ่ง
แล้ว dereferences ประกอบดาว ตัวชี้ที่
และอีกครั้งที่เรามาดู
เราได้รับเอชอีกครั้ง
>> นักเรียน: สิ่งที่ไม่ตรง dereference หมายถึงอะไร
>> เจสัน Hirschhorn: dereference เป็นคำแฟนซีสำหรับการเดินทางไปยัง
ไปที่นั้นและได้รับสิ่งที่มี คือการ dereference ตัวชี้
มันเป็นเพียงคำแฟนซีสำหรับที่
>> นักศึกษา: ถ้าเราต้องการที่จะพิมพ์ สตริงทั้งสามารถเรา
ทำเครื่องหมายชี้?
>> เจสัน Hirschhorn: ตกลงเราเป็น จะหยุดที่นี่
พวกเราจะไปสิ้นสุดที่นี่
เครื่องหมายจะช่วยให้คุณที่อยู่ของ สถานที่ดังนั้นเมื่อคุณทำเครื่องหมายของ
ตัวแปรจะช่วยให้คุณอยู่ ที่ตัวแปรที่ถูกเก็บไว้
ตัวชี้เครื่องหมายที่จะทำให้คุณ ที่อยู่ของ PTR PTR ที่อยู่ในหน่วยความจำ
>> เราไม่ได้จะไปใน กับตัวอย่างนี้
คุณสามารถคิดออกเหล่านี้ สิ่งที่ตัวคุณเอง
แต่ครั้งนี้อาจแม้จะผา บิตเกินกว่าสิ่งที่คุณจำเป็นต้องรู้เพื่อ
ขอบเขตของการนี​​้ระยะกลาง -
หรือตอบคำถามนี้แทน
ขอโทษ
>> เราจะเดินหน้าต่อไปเพราะผมจะ ชอบที่จะทำอย่างใดอย่างหนึ่งปัญหาการเข้ารหัส
ก่อนที่เวลาจะขึ้น
และเราจะให้รหัสสิ่งที่ผมคิดว่า เป็นที่น่าสนใจที่สุดของเหล่านี้
ตัวอย่าง atoi
ดังนั้นนี่เป็นคำถามที่ คำถามที่สองปีที่ผ่านมา
และฉันมีไว้ในคณะกรรมการที่นี่
>> คนถูกถามเกี่ยวกับการตอบคำถาม -
พวกเขาได้รับ tesxt น้อยมากขึ้นใน คำถาม แต่ผมตัดออก
ข้อความเพราะมันเป็นที่ไม่จำเป็น สำหรับวัตถุประสงค์ของเราในขณะนี้
มันเป็นเพียงแค่พื้นหลังบาง กับสิ่งที่ได้ atoi
แต่คุณทุกคนรู้และมีความ คุ้นเคยกับ atoi
>> ผมขอแนะนำให้คุณรหัสนี้ บนแผ่นกระดาษ
ฉันยังแนะนำให้คุณใช้กลยุทธ์ที่ ที่เราได้ไปแล้วกว่า
จำนวนมากในส่วนของเรา
ก่อนให้แน่ใจว่าคุณเข้าใจ สิ่งที่ atoi ของการทำ
วาดภาพหรือมากับ ภาพจิตของมันอยู่ในหัวของคุณ
ถัดไปเขียนออก pseudocode นี้
ในการตอบคำถามถ้าทั้งหมดที่คุณได้รับคือ pseudocode อย่างน้อยคุณ
ใส่อะไรลง
แล้วแผนที่ pseudocode ที่ลงบน C. หากคุณมีการตรวจสอบในของคุณ
pseudocode เช่นตรวจสอบว่าสิ่งที่ เป็นที่ 1 ที่แผนที่บนถ้า
สภาพและอื่น ๆ
และในที่สุดรหัสโปรแกรมใน C.
>> ดังนั้นกลับไป atoi ไปและใช้เวลาห้านาที รหัสนี้บนแผ่น
กระดาษซึ่งอาจจะเกี่ยวกับ ระยะเวลาที่คุณจะใช้เวลาใน
คำถามที่จะ atoi รหัส
ห้าถึง 15 นาทีห้าถึง 12, ห้าถึง 10 นาทีเป็นเรื่องเกี่ยวกับจำนวนเงินที่
เวลาที่คุณจะใช้จ่ายเกี่ยวกับเรื่องนี้ คำถามในแบบทดสอบ
ดังนั้นใช้เวลาห้านาทีตอนนี้กรุณา
และถ้าคุณมีคำถามใด ๆ เพิ่ม มือและฉันจะมารอบของคุณ
>> [CONVERSATIONS SIDE]
>> เจสัน Hirschhorn: OK ดังนั้น ที่ห้านาที
ที่อาจจะเกี่ยวกับปริมาณของ เวลาที่คุณต้องการใช้จ่ายในการที่เกี่ยวกับการทดสอบที่
อาจจะต่ำสุดของช่วงเวลานั้น
เราจะสรุปในบิต
ให้เราเริ่มต้นการเข้ารหัสนี้
และถ้าเราไม่ได้รับทั้งหมดทางผ่าน คำตอบนี้และนี้
คำถามทดสอบที่มีอยู่อีกครั้ง 2011 เป็นฤดูใบไม้ร่วงเมื่อคำถามนี้
ปรากฏตัวในการทดสอบ
>> และมันก็คุ้มค่าที่แปดจุด ในการตอบคำถามแล้ว
แปดจุดที่อยู่ในระดับไฮเอนด์ของ จำนวนของจุดบางสิ่งบางอย่างที่มีค่า
คำถามส่วนใหญ่จะอยู่ในช่วง หนึ่งถึงหกจุด
ดังนั้นนี่คือความท้าทายมากขึ้น คำถามเพื่อตรวจสอบว่า
ทุกคนสามารถได้รับฉันเริ่มต้นได้อย่างไร
>> โดยทั่วไปสิ่งที่เราจะ ที่จะต้องการจะทำอย่างไรกับนี้
ทำงาน atoi เหตุผล?
สิ่งที่เราต้องการจะทำอย่างไร
ดังนั้นเรากำลังจะเขียน pseudocode บาง
>> นักเรียน: แปลงตัวอักษร เป็นจำนวนเต็ม
>> เจสัน Hirschhorn: แปลงตัวอักษร เป็นจำนวนเต็ม
ตกลง
ดังนั้นวิธีการที่จำนวนตัวอักษรที่เรา จะต้องไปผ่าน
>> นักเรียน: ทั้งหมดของพวกเขา
>> นักเรียน: ตัวละครทั้งหมด ในสตริง
>> เจสัน Hirschhorn: ทั้งหมดของ ตัวอักษรในสตริง
ดังนั้นหากเราต้องการที่จะไปผ่านทุก ตัวละครในสตริงสิ่งที่เป็นสิ่งที่
ใน C ที่เราเคยเห็นที่ได้รับอนุญาต เราจะผ่านไปทุก
ตัวละครในสตริง?
>> นักศึกษา: สำหรับวง
>> เจสัน Hirschhorn: สำหรับวง
ดังนั้นเราจะห่วงผ่าน ตัวละครทุกตัวใน s
>> แล้วเราเป็นสิ่งที่จะต้องการที่จะทำ เมื่อเราได้รับตัวละครรึเปล่า
บอกว่าเรากำลังจะผ่านไป 90
เราได้รับ 9
มันเป็นตัวละคร
สิ่งที่เราต้องการจะทำอย่างไรกับ ตัวละครที่ 9?
>> นักเรียน: ลบมันออกมาจากตัวละคร 0?
>> นักเรียนเพิ่ม 0?
>> เจสัน Hirschhorn: ลบ มันออกมาจากตัวละคร 0?
>> นักเรียน: ใช่
>> เจสัน Hirschhorn: ทำไม คุณต้องการที่จะทำเช่นนั้น
>> นักเรียน: [ไม่ได้ยิน]
มูลค่า
int ค่าของมัน
>> เจสัน Hirschhorn: ตกลงดังนั้นเราจึงใช้เวลา 9 ตัวอักษรที่ลบจาก
0 ตัวละครที่จะได้รับ เลข 9 ที่เกิดขึ้นจริง
หวาน
และคุณจะรู้ว่าตัวละครที่ 9 ลบ 0 ตัวละครคือ 9?
แผนภูมิสิ่งที่คุณไม่ดู?
>> นักเรียน: มีเหตุผลเก้า สถานที่ระหว่าง 9 และ 0
หรือคุณอาจจะมองไปที่ตาราง ASCII
>> เจสัน Hirschhorn: ตาราง ASCII
แต่ใช่คุณถูกต้องเช่นกัน
ดังนั้นเราลบ 0
ดังนั้นตอนนี้เรามีจำนวนเต็ม 9
และเราทำในสิ่งที่ต้องการจะทำอย่างไรกับที่
ถ้าเรามี 90 ก็จำนวนเต็มแรก เราได้สิ่งที่เราต้องการจะทำอย่างไร
>> นักเรียน: ฉันใส่ในจำนวนเต็มชั่วคราว อาร์เรย์แล้วทำคณิตศาสตร์กับมัน
หลังจากนั้นจะทำให้มันกลายเป็นที่สิ้นสุด
>> เจสัน Hirschhorn: OK
>> นักศึกษา: คุณสามารถเริ่มต้นที่จุดสิ้นสุดของ อาร์เรย์และแล้วก้าวไปข้างหน้าเพื่อ
ว่าทุกครั้งที่คุณเดินหน้าต่อไป คุณคูณด้วย 10
>> เจสัน Hirschhorn: OK
ที่เสียงเหมือนสวย ความคิดที่น่าสนใจ
เราสามารถเริ่มต้นที่จุดสิ้นสุดของอาเรย์ของเรา และเราสามารถใช้ strleng
เราสามารถใช้ strleng ที่นี่
เราจะได้รับความยาวของสตริงของเรา
เราเริ่มต้นในช่วงปลาย
และ + คนแรกเราก็ใช้เวลาที่ จำนวนเต็มและบางทีเราสร้างเช่น
ตัวแปรจำนวนเต็มใหม่ขึ้นด้านบนที่ เราเก็บทุกอย่าง
ดังนั้นเราจึงห่วงผ่านถ่านทุก s จาก กลับไปที่หน้าเราลบ 0
แล้วเราจะเอามันและขึ้นอยู่กับ ซึ่งมันก็คือเราคูณ
โดยอำนาจของ 10
เพราะคนแรกที่สิ่งที่เราทำ คูณตัวขวาสุดโดย?
>> นักเรียน 10 0
>> เจสัน Hirschhorn: 10 0
สิ่งใดที่เราคูณสอง ตัวขวาสุดโดย?
>> นักเรียน: [ไม่ได้ยิน]
>> เจสัน Hirschhorn: อะไรนะ?
>> นักเรียน: 10 ถึง 1
>> เจสัน Hirschhorn: 10 ถึง 1
ตัวขวาสุดที่สาม
>> นักเรียน 10 ถึง 2
>> เจสัน Hirschhorn: 10 ถึง 2
>> นักเรียน: ขอโทษนะฉันไม่เข้าใจ สิ่งที่เรากำลังทำอยู่ที่นี่
>> เจสัน Hirschhorn: ตกลง ขอกลับไปแล้ว
ดังนั้นเรากำลังจะได้รับ ผ่านในสตริง
เพราะเรากำลังเขียน atoi
ดังนั้นเราจึงได้รับการส่งผ่านไปในสาย
บอกว่าเรากำลังจะผ่านไป ในสาย 90
>> สิ่งแรกที่เรากำลังจะทำคือการตั้ง ตัวแปรจำนวนเต็มใหม่ที่เรากำลัง
เพียงแค่จะสร้าง เป็นจำนวนเต็มใหม่ของเรา
นั่นคือสิ่งที่เรากำลังจะ ที่จะกลับมาในตอนท้าย
เราจำเป็นต้องไปผ่านทุกตัวอักษรใน สตริงเพราะเราได้กำหนด
ที่เราจำเป็นต้องสัมผัสกันอย่างใดอย่างหนึ่งและ แล้วเพิ่มเป็นจำนวนเต็มใหม่ของเรา
>> แต่เราไม่สามารถเพียงแค่เพิ่มเป็นจำนวน
เราก็ไม่สามารถใช้เวลา 9 และ เพิ่ม 9 ถึงจำนวนเต็มของเรา
มันขึ้นอยู่กับสิ่งที่เกิดขึ้น มันอยู่ในสาย
เรากำลังจะต้องคูณ โดยอำนาจของ 10
เพราะนั่นคือวิธีการที่ฐาน 10 ผลงาน
>> ดังนั้นเรากำลังจะได้รับที่เกิดขึ้นจริง ตัวอักษรหรือตัวเลขที่เกิดขึ้นจริง
จำนวนโดยการลบตัวละคร 0 จากตัวละคร 9 เหมือนที่เราทำกับ
ลบตัวอักษรทุนจาก สิ่งที่ตัวละครของเรามีหนึ่งใน
ปัญหาเหล​​่านั้น
ดังนั้นเราจริงจะได้รับหมายเลขจาก 0 ถึง 9 บันทึกเป็นจำนวนจริงและเราจะ
คูณด้วยพลังงานจาก 10 ขึ้น กับสถานที่ที่เราอยู่ในสาย
แล้วเรากำลังจะเพิ่มกลับ เป็นตัวแปรจำนวนเต็มใหม่ของเรา
>> ดังนั้นสิ่งนี้จะมีลักษณะที่จะ ได้ - เราจะวาดกว่าที่นี่
ถ้าเราได้รับการส่งผ่านไปในสาย 90 -
>> นักเรียน: [ไม่ได้ยิน]
>> เจสัน Hirschhorn: แต่ atoi ใช้สตริง
ดังนั้นเรากำลังจะผ่านไป ที่ถือค​​รอง
เราจะได้รับการส่งผ่านไปใน 90
เราไปจากด้านหลังไปด้านหน้า
เราใช้ 0
>> นักเรียน: ฉันขอโทษ
อาจจะเป็นคนโง่
ถ้าเราได้รับการส่งผ่านไปในสตริง ทำไมเป็น 90 สิ่งที่เรากำลัง
ได้รับการส่งผ่านไปมีอะไรบ้าง
90 เพราะเป็นจำนวนเต็ม
>> เจสัน Hirschhorn: เพราะ atoi ใช้เวลา สตริงและเปลี่ยนมันเป็นจำนวนเต็ม
ตัวแทนของสตริงที่
แต่สาย 90 ไม่ได้เป็นจำนวนเต็ม 90 หรือ 90 จำนวน
สาย 90 เป็นอาร์เรย์ของทั้งสองหรือ ตัวละครทั้งสามค่อนข้าง 9
ตัวอักษร 0 ตัวอักษรและ 0 ทับขวาตัวอักษร
>> และเรากำลังเขียน atoi เพราะสำหรับ ตัวอย่างเช่นเมื่อคุณใช้คำสั่ง
อาร์กิวเมนต์บรรทัดและจะถูกบันทึกไว้ใน argv ก็บันทึกเป็นสตริง
แต่ถ้าคุณต้องการที่จะรักษามันเป็นตัวเลข คุณต้องการที่จะแปลงเป็น
เลขที่เกิดขึ้นจริง
ซึ่งเราได้ชุดใดชุดหนึ่งปัญหาของเรา
ซึ่งที่เราทำในจำนวน ของชุดปัญหาของเรา
ทุกคนที่เอาจำนวนเต็ม เป็นอาร์กิวเมนต์บรรทัดคำสั่ง
เพื่อที่ว่าทำไมฟังก์ชัน atoi ของเรา ใช้เวลาสตริง
>> ดังนั้นอีกครั้งในตัวอย่างของเราที่นี่เรา จะใช้เวลาหนึ่งที่ผ่านมา
เรากำลังจะลบตัวอักษร 0 จากนั้นเพราะตัวละคร 0
ลบออกด้วยอักขระ 0 จะช่วยให้คุณ 0 จำนวนจริงตามที่
คณิตศาสตร์ ASCII ที่เราทำ
>> เพราะตัวละครจะแสดงเป็น แตกต่างจากของพวกเขาที่เกิดขึ้นจริง -
เป็นตัวละครที่ยกตัวอย่างเช่น ตัวพิมพ์เล็กเป็น 97
มันไม่ - โอ๊ะ!
มันไม่ใช่สิ่งที่คุณคาดหวัง ให้เป็น 0 ตัวอย่างเช่น
ดังนั้นคุณต้องลบ ตัวละครที่จะได้รับ 0
>> ดังนั้นเรากำลังจะทำที่นี่ เพื่อให้ได้จำนวนที่เกิดขึ้นจริง
และจากนั้นเราจะคูณด้วย พลังงานจาก 10 ขึ้นอยู่กับที่
ที่อยู่ในสายแล้วใช้เวลาที่ และเพิ่มผู้ถือสถานที่ของเรา
ตัวแปรเพื่อให้เราสามารถขึ้นมาด้วย จำนวนเต็มใหม่ของเราสุดท้าย
ไม่ที่ทำให้รู้สึกถึงทุกคนหรือไม่
>> ดังนั้นเราจะไม่ให้รหัสนี้ ตอนนี้เพราะเรา
ที่ได้รับในเวลาสั้น
ฉันขอโทษสำหรับระยะเวลาของการที่
แต่นี้คือสิ่งที่หวังว่าคุณจะ จะสามารถที่จะทำในคำถาม - ที่
อย่างน้อยที่สุดได้รับ pseudocode นี้ เขียนออกมา
>> แล้วถ้าเราจะเขียน pseudocode จริงเราสามารถทำเช่นนี้
สวยได้อย่างรวดเร็ว
แต่ละบรรทัดของความเห็นของเราที่เราเขียน นี่แปลว่าเกี่ยวกับ
หนึ่งบรรทัดของรหัส C
ประกาศตัวแปรการเขียนใหม่ ห่วงการลบบางบาง
คูณและการกำหนดบางส่วน
เราต้องการอาจยังต้องการที่จะ เขียนเส้นผลตอบแทน
นอกจากนี้เรายังอาจต้องการที่จะใส่ การตรวจสอบบางอย่างในที่นี่
ใช่
>> นักศึกษา: ดังนั้นเราจึงสามารถรักษา ในฐานะที่เป็นสายที่เกิดขึ้นจริง
เพราะผมรู้ว่ามันเป็นเพียงแค่ที่อยู่
เช่นเดียวกับวิธีการที่คุณจะได้รับความยาวของ สตริงถูกส่งผ่าน
>> เจสัน Hirschhorn: ดังนั้นวิธีการทำ ความยาวของสายได้หรือไม่
strlen
>> นักเรียน: strlen ใช่
แต่คุณสามารถใส่ในฐานะ อาร์กิวเมนต์สำหรับการที่
>> เจสัน Hirschhorn: ดังนั้น strlen ใช้เวลาดาวถ่าน
และเป็นไปตามดาวถ่านที่และมัน ช่วยให้การนับจนกว่าจะได้รับการ
เครื่องหมาย 0 strlen เป็นจริง หนึ่งในโปรแกรมอื่น ๆ ที่เรา
กำลังจะรหัส
นั่นเป็นอีกคนหนึ่งที่ดีที่จะรหัส
หนึ่งที่ง่ายขึ้นเล็กน้อยเพราะถ้า คุณจะคิดเกี่ยวกับการที่
แนวคิด -
ผมก็บอกว่ามันออกมาดัง ๆ - strlen ดังต่อไปนี้ ชี้และช่วยให้ไปและ
การนับและการติดตามจน คุณมาถึงเครื่องหมาย 0
>> นักเรียน: ตกลงได้มัน
>> เจสัน Hirschhorn: ดังนั้นที่ดีที่สุดของ โชคดีในการตอบคำถาม 0 วันพรุ่งนี้
หากคุณมีคำถามใด ๆ ที่ฉันจะ จะอยู่นอกหลังจากนี้
อย่าลังเลที่จะส่งอีเมลฉัน
เอื้อมมือออกไปลุยด้วยตัวคุณเองถ้าคุณ ไม่ได้อยู่ในส่วนของฉันหรือได้รับของฉัน
อีเมลถ้าคุณต้องการมัน
>> หากคุณต้องการที่จะแปลกออกและเพียงแค่ส่ง อีเมล์อีเมล์หมดไส้หมดพุงฉันจะ
ส่งคุณกลับมาเหมือนหน้ายิ้ม, หรือเหมือนเรื่องตลกหรือสิ่งที่
ดังนั้นอย่าลังเลที่จะทำเช่นนั้นได้เป็นอย่างดี
โชคดีอีกครั้งและผมจะ เห็นคุณในสัปดาห์หน้าทั้งหมด