>> [เล่นเพลง]
>> Davin: สิทธิทั้งหมดผู้ชาย
ดังนั้นนี่คือการตรวจสอบ สำหรับการทดสอบครั้งแรก
คือทุกคนพร้อมสำหรับการ แบบทดสอบในวันพุธที่?
ALLISON: วู!
นักเรียน: วู!
Davin: ใช่
ALLISON: ใช่!
Davin: นั่นของผู้ชายคนพร้อม
ผู้ชายคนที่สองมืออย่างมีความสุข
ดังนั้นการตรวจสอบแบบทดสอบในวันนี้ก็จะ จะเป็นประมาณหนึ่งชั่วโมงครึ่ง
เรากำลังจะไปในช่วงที่สำคัญ แนวความคิดที่คุณควรรู้สำหรับการทดสอบ
เรากำลังจะไปกว่าการเขียนโปรแกรมบางอย่างโดย ตัวอย่างมือซึ่งเป็นแบบทดสอบทุก
และถ้าคุณมีคำถามรู้สึกฟรี ที่จะยกมือขึ้นและทุกอย่างของคุณ
เช่นนั้น
ดีจิสติกส์เกี่ยวกับ แบบทดสอบออนไลน์
ดังนั้นเรากำลังจะแยกคน ขึ้นไปในห้องพักที่แตกต่างกัน
ก็ขึ้นอยู่กับชื่อของพวกเขา
ดังนั้นถ้าคุณมีคำถามใด ๆ เกี่ยวกับการที่ จะไปหรือเกี่ยวกับสิ่งที่วัสดุที่เป็นเหมือน
คำอย่างเป็นทางการในสิ่งที่เกิดขึ้น จะอยู่ในแบบทดสอบ, ตรวจสอบออนไลน์
และนั่นคือทั้งหมดถึงวันที่
ดังนั้นหากมีคำถามไม่ เริ่มต้นด้วยเรากำลังจะเริ่มต้น
และนี่คือแอลลิสัน
>> [ปรบมือ]
>> ALLISON: OK ขอบคุณร็อบ
เห็นคุณค่าของมัน
Davin ควรจะมีการพลิกนี้
นี้เป็นรายการที่ไม่ครบถ้วนสมบูรณ์ของ หัวข้อเช่นเคยเป็น Davin เพียงกล่าวว่า
ศึกษาเอกสาร ออนไลน์เกี่ยวกับแบบทดสอบศูนย์
แต่นี้เป็น much-- สวย มันอยู่ในหลักสูตร
คือทุกสิ่งที่เราได้ไปแล้วกว่าป่านนี้
ทุกอย่างที่นี่เป็นเกมที่ยุติธรรม, เช่นเดียวกับสิ่งอื่น
ที่อาจได้รับการกล่าวถึงในการบรรยาย
>> ส่วนที่ฉันที่นี่คือ เพียงจำนวนมากของการตรวจสอบ
มีการออกกำลังกายเป็นคู่ ว่าพวกคุณอาจจะทำงานใน
แต่ส่วนใหญ่เราจริงๆ ต้องการที่จะได้รับการ Davin ด้วยรหัสผู้
โดยการออกกำลังกายมือ
>> ดังนั้นฉันจะบินผ่านนี้
ถ้าคุณมีคำถามใด ๆ หยุดฉัน
ยกมือของคุณ
ฉันสัญญาว่าฉันอาจจะเห็นคุณ
ถ้าไม่ได้เพียงแค่โบกมือไปรอบ ๆ
ฉันจะได้รับการพูดถึงอย่างรวดเร็ว
ผมหวังว่าทุกคนตกลงกับที่
>> ตกลงคำพิเศษ Davin อย่างเห็นได้ชัด ลืมที่จะพลิกผ่านสไลด์เหล่านี้
[หัวเราะ] คุณกำลังมีปัญหาชาย
ดังนั้นเคล็ดลับสำหรับการทดสอบศูนย์ การเขียนโปรแกรมการปฏิบัติบนกระดาษ
พวกคุณจะได้รับบางส่วน ปฏิบัติกับว่าตอนนี้มี Davin,
ดังนั้นคุณจะไม่สมบูรณ์ด้วยตัวเอง
ผมคิดว่าเรากำลังจะเป็นจริง ผ่านทั้งสองฟังก์ชั่น
ดังนั้นคุณจะได้รับการเตรียมความพร้อมที่มี
>> จะคุ้นเคยกับชุดปัญหาของคุณ
มีคำถาม ในแบบทดสอบก่อนหน้านี้
ที่จะขอให้คุณตัวอย่างเช่นโค้ด บางสิ่งบางอย่างที่คล้ายกันมากกับมาริโอ
ดังนั้นเป็นความคุ้นเคยกับ ปัญหาของคุณกำหนดได้เป็นอย่างดี
เป็นคำถามที่เราถามคุณ ในการเริ่มต้นในแบบฟอร์ม
ที่คุณกรอกจะ บริการคุณอย่างดี
>> ทำแบบทดสอบก่อนหน้านี้ภายใต้ ข้อ จำกัด ด้านเวลา
แบบทดสอบเหล่านี้มีความยาว
เวลาไปอย่างรวดเร็วจริงๆ
และบ่อยครั้งที่คุณไม่ได้ตระหนักถึงวิธีการ มันจะไปอย่างรวดเร็วจนคุณจริง
ใส่ตัวเองภายใต้ข้อ จำกัด เหล่านั้น
ดังนั้นถ้าคุณก็สามารถตัดออกคุณรู้ว่า 75 นาทีทั้งคืนนี้หรือวันพรุ่งนี้
จะใช้เวลาหนึ่งของแบบทดสอบเหล่านี้ภายใต้ ว่าคุณจะอยู่ในรูปร่างที่ดีขึ้นมาก
>> และยังสร้างแผ่นอ้างอิงของคุณ
โปรดจำไว้ว่าคุณได้รับหนึ่ง หน้าด้านหน้าและด้านหลัง
เป็นข้อมูลอ้างอิงสำหรับการทดสอบของคุณในวันพุธที่
การสร้างที่เป็นวิธีที่ดีในการศึกษา
สิ่งที่คุณกำลังมีปัญหา กับที่คุณต้องการรวมที่มี
อะไรที่ TFS ของคุณได้รับ เช่นนี้เป็นสิ่งที่สำคัญจริงๆ
คุณควรจะรู้ว่านี่เป็น บางทีสิ่งที่คุณมีในมี
ถ้าคุณไม่ได้จดจำพวกเขา
แม้ว่าคุณจะรู้ว่าพวกเขาจริงๆ ดีบางครั้งมีมันไว้อย่างนั้น
เป็นเพียงชนิดของความสะดวกสบายสำหรับคุณ ซึ่งฉันรู้ว่าแบบทดสอบเครียด
เพื่อความสะดวกสบายใด ๆ ที่คุณได้รับจะช่วยให้
สิทธิทั้งหมดนอกจากนี้ยังได้รับการนอนหลับและ กินและชอบสิ่งที่ปกติ
ที่เราบอกคุณแบบทดสอบ
>> ดังนั้นการเริ่มต้นออกง่าย ชนิดข้อมูลและขนาด
ขณะที่ผมกล่าวมานี้เป็นเพียงการไป ฉันจะได้รับการขว้างปาจำนวนมากสิ่งที่
ที่นี่ที่คุณควรรู้
ดังนั้นเราจึงมีตัวอักษรของเรา ที่เป็นหนึ่งไบต์ ints
ที่มีสี่ไบต์นาน ยาวซึ่งมีแปดไบต์
โดยทั่วไปก็เพียงแค่คุณ ต้องการที่จะถือจำนวนเต็มขนาดใหญ่
ลอยซึ่งเป็นสี่ คู่ที่แปด
อีกครั้งเพียงจะช่วยให้คุณมากขึ้น พื้นที่สำหรับการลอยของคุณ
แล้วพิมพ์ดาวดังนั้นใด ๆ ตัวชี้บนเครื่อง 32 บิต
ซึ่งเป็นสิ่งที่พวกคุณต้องการ จะรู้ว่าเป็นสี่ไบต์
>> ดังนั้นทุกสิ่งที่คุณควร รู้ว่าสิ่งที่อาจจะ
คุณต้องการที่จะมีใน แผ่นอ้างอิงของคุณ
ตกลงแปลงเลขฐานสอง เพื่อไบนารีแปลง
กับเลขฐานสิบหกไปมา ทุกสิ่งที่คุณควรรู้
ดังนั้นจากเลขฐานสอง
พวกคุณต้องการที่จะใช้เวลานาทีอย่างรวดเร็ว และพยายามคิดออกแต่ละเหล่านี้
แล้วบอกฉันว่าพวกเขา?
>> ฉันยังมีขนมในกระเป๋าของฉันเพื่อให้ทุกคน คำตอบที่ได้รับลูกอมโดยวิธีการ
และฉันมีจำนวนมากของมัน
ให้ฉันคว้านี้
ฉันจะให้นี้จะเกบ
เพื่อให้คุณสามารถส่งออกขนม ใครก็ตามที่เป็นสิ่งที่ดีและความร่วมมือ
>> ตกลงผมเห็นมือที่มีในด้านหลัง
>> นักเรียน: ใช่คนแรกคือ 42
>> ALLISON: ใช่คนแรกคือ 42, ที่ถูกต้อง
นักเรียน: [ไม่ได้ยิน]
[หัวเราะ]
ALLISON: สองหนึ่ง มีกลับมาในสีเหลือง?
นักเรียน: 110010
ALLISON: ถูกต้องและสิ่งนี้ หนึ่งที่ผ่านมาลงที่นี่ที่ด้านล่าง?
นอกจากนี้ใช่คุณรู้ว่าต้องการ?
เพียงแค่โยนออกขนม
วิธีการเกี่ยวกับลูกอมสำหรับทุกคนหรือไม่
>> นักเรียน: [ไม่ได้ยิน] เมื่อเรากำลังทำ
>> ALLISON: Shh
แล้วสุดท้าย
ใครอยากตอบ?
ที่นั่น
>> นักเรียน: 11100
>> ALLISON: 11100 ดูที่ว่า
ขอแสดงความยินดีงานที่ดีทุกคน
ตกลงทุกคนชนิดของการทำความเข้าใจ ขั้นตอนการทำเช่นนี้?
คุณได้ไปจากเลขฐานสอง วิธีที่ฉันมักจะทำมันถูกเขียนออก
อำนาจของ 2
ดังนั้นผมจึงบอกว่าโอเค 0 ครั้ง 2-0 ดังนั้น นั่นคือ 0, 1 ครั้งที่ 2 ครั้งแรกที่
เป็นที่ 2 เป็นต้นไปจะวิธีการที่
ไม่มีใครต้องการให้ฉันไปอย่างชัดเจน ผ่านตัวอย่างของไบนารี?
ตกลงเย็น
>> ทศนิยมให้เป็นเลขฐานสองจะคล้าย
ฉันมักจะเขียนออกอำนาจของ 2
เริ่มต้นด้วยหนึ่งที่ยิ่งใหญ่ที่สุด, แต่ไม่ได้ไปที่ผ่านมาทศนิยม
ที่คุณกำลังมองหา
แล้วชนิดของวิธีการทำงานของคุณ หลังการเพิ่มขึ้นสิ่งที่ตามความจำเป็น
>> และจากนั้นก็มีการเพิ่มมัน เช่นเดียวนอกจากนี้ยังปกติ
หากคุณเคยมีกรณีที่คุณอยู่ เพิ่มอีกสอง 1s ก็เห็นได้ชัดว่าจะกลายเป็น 2
2 ในไบนารีคือตอน 1 0 ดังนั้นคุณต้อง ในการดำเนินการ 1 ของคุณลงในช่องถัดมา
เย็น
>> เลขฐานสิบหกนี้อาจจะมีบางสิ่งบางอย่าง ที่เล็กน้อยไม่คุ้นเคย
ดังนั้นในขณะที่ร็อบก็แค่บอกฉัน ก่อนเคล็ดลับของเขานี้
เป็นเพียงการแยกขึ้น เป็นสี่ชิ้นไบต์, OK?
บิตขอโทษ
เห็น?
ขอบคุณร็อบ
นี่คือเหตุผลที่คุณอยู่ที่นี่ [เสียง] ตกลงดังนั้นเราก็ทำลายมันได้
เป็นสี่ชิ้นบิต
ดังนั้นด้วยไบนารีที่เลขฐานสิบหก เรามองไปที่แรกที่ 4
ซึ่งถ้าเรามีสี่ 1s ใน แถวสิ่งที่หมายเลขที่เป็นสัญลักษณ์ไม่?
>> นักเรียน: เอฟ
>> ALLISON: ดังนั้นในกรณีนี้ สิ่งที่เป็น 11111111 or-- ใช่?
นักเรียน: FF
ALLISON: เพอร์เฟก
ที่ดีเพื่อให้ลูกอมสำหรับคุณ
ตอนนี้สำหรับวิธีการเลขฐานสิบหกเลขฐานสองเรา เพียงแค่คิดเกี่ยวกับชนิดของมันในสิ่งที่ตรงกันข้าม
สำหรับแต่ละหมายเลขหรือตัวอักษรนั้น เรามีอยู่ในฐานสิบหกของเรา
เพียงแค่แปลงเป็นสี่บิต [หัวเราะ] เพื่อการแปลงสี่บิต
ดังนั้น 5 ในกรณีนี้สิ่งที่เป็น 5 ถ้า เรากำลังเป็นตัวแทนของมันมีสี่บิต?
>> นักเรียน: 010?
MM-HM
แล้วซึ่งเป็น จริงที่ 10 จะเป็นอย่างไร
1010
เพื่อให้เรามีที่นี่
ดังนั้นการแปลงระหว่างเลขฐานสิบหก และไบนารีจริงไม่ใช่ว่าไม่ดี
ถ้าคุณมองไปที่มันในสี่บิต ชิ้น, จะเป็นสีทอง
Everyone-- ใช่?
>> ปล้น: นี่คือโง่ แต่ฉันจำไว้เสมอ
เพราะควรจะเป็น 10
และไบนารีเป็นเพียง 10 10, so--
>> ALLISON: อ่ามีที่เราจะไป
>> ปล้น: Hey
>> ALLISON: Hey, ขนมสำหรับร็อบ
มีสิ่งที่ช็อคโกแลตที่ไม่ได้อยู่ในนั้น
เพื่อให้คุณสามารถมีบางส่วน
คณิตศาสตร์ดังนั้น ASCII
ประพฤติ
ดังนั้น ASCII คณิตศาสตร์เป็นพวกคุณ อาจจะยังจำได้
P ชุดที่ 2 กับ VISIONEER และ ซีซาร์ที่คุณได้จำนวนมากนี้
โปรดจำไว้ว่าตัวละคร พื้นฐานเพียงตัวเลข
เพื่อให้เราสามารถทำคณิตศาสตร์กับพวกเขา เช่นเดียวกับที่เราทำคณิตศาสตร์กับ ints
>> ดังนั้นเราจึงมีเพียงเล็กน้อย สิ่งที่ง่ายที่นี่
เรามีบางอย่างในที่ เริ่มต้นได้ที่ 65
และ B เท่ากับค่า ASCII ของ บวก 1, ถ่าน C เท่ากับ D ลบ 1,
และถ่าน D เท่ากับ 68
ดังนั้นแล้วเราจะไปพิมพ์ ทั้งหมดของพวกเขาในขณะที่เราเห็นที่นี่
และทุกคนสามารถบอกฉัน สิ่งนี้จะพิมพ์ออกมา?
นักเรียน: [ไม่ได้ยิน]
ALLISON: แน่นอนดังนั้น สิ่งหนึ่งที่สังเกตได้
ว่าเราจะพิมพ์ออก ตัวละครในแต่ละครั้งที่นี่
เราจะกำหนดแม้ว่า A และ B มี ints เมื่อเราประกาศไว้ดังกล่าวข้างต้น
เรากำลังพิมพ์พวกเขาเป็นตัวละครโดย C ร้อยละและงบ printf ของเรา
ดังนั้นพวกเขาทั้งหมดจะพิมพ์เป็นตัวอักษร
และแน่นอนค่า ASCII 65 จะ พิมพ์เป็น A. ค่า ASCII บวก 1
จะเป็น 66 ซึ่งจะ ภูมิใจที่จะ B. ดังนั้นในความเป็นจริงเรา
ได้รับ B C D. ทุกคนที่ดีมี?
คำถามใด?
น่ากลัว
>> ตกลงขอบเขต
ดังนั้นขอบเขตจะเห็นได้ชัดมาก สิ่งที่สำคัญที่จะเข้าใจที่นี่
จำนวนมากของคุณถ้าคุณ มีข้อผิดพลาดรวบรวม
และกล่าวว่าคุณไม่ได้ การเข้าถึงตัวแปรบาง
มันอาจจะเป็นเพราะคุณ กำหนดไว้ภายในวง
และพยายามที่จะเข้าถึงได้ ออกจากมันหรือในทางกลับกัน
>> ดังนั้นขอบเขตที่หลักของมัน, มันเป็นเพียงแค่กำหนดที่
เราบอกว่าตัวแปรที่มีอยู่ที่เรา สามารถเปลี่ยนได้ที่เราสามารถเข้าถึงได้
มันเป็นเพียงชนิดของคำพูดเหล่านี้ สถานที่เดียวที่คุณสามารถเข้าถึง
กับตัวแปรนี้
>> ดังนั้นทั้งสองขอบเขตที่เราพูดคุยเกี่ยวกับ ในชั้นเรียนมีโลกและท้องถิ่น
ตัวแปรดังนั้นทั่วโลกเราพูดคุยเกี่ยวกับ เมื่อคุณได้รับการกำหนดไว้ข้างต้นหลัก
ก็หมายความว่าทั้งหมดของคุณ โปรแกรมมีการเข้าถึงมัน
และมันมีอยู่นานเป็น ขณะที่วิ่งโปรแกรม, OK?
ท้องถิ่นหมายถึงว่ามันเป็น ขึ้นอยู่กับภูมิภาค
ดังนั้นเมื่อใดก็ตามที่คุณมีฟังก์ชั่นที่เฉพาะเจาะจง เช่นการแลกเปลี่ยนเรามักจะพูดคุยเกี่ยวกับ
เรามักจะพูดคุยเกี่ยวกับการแลกกับและ B. A และ B อยู่ในฟังก์ชั่นที่
พวกเขาไม่ได้อยู่ที่ใด
>> เช่นเดียวกับเมื่อคุณมีถ้า งบหรือลูป
เมื่อใดก็ตามที่เรามีตัวอย่างเช่นใน สำหรับวงเรามี int ฉันเท่ากับ 0
เรามีเงื่อนไขบางอย่างและเราปรับปรุง
ฉันเท่านั้นที่อยู่ภายใน การจัดฟันที่ห่วง
ถ้าคุณพยายามที่จะเข้าถึงได้อื่น ๆ คอมไพเลอร์ของคุณจะตะโกนใส่คุณ
มันจะเป็นเหมือนสิ่งที่คุณพยายามจะทำอย่างไร?
นี้ไม่ได้มีอยู่
เพื่อให้เป็นสอง ประเภทที่แตกต่างกันของขอบเขต
ไม่ว่าทำให้ความรู้สึกที่ทุกคนหรือไม่
>> ดังนั้นสำหรับตัวอย่างเช่นนี่นี้ เป็นเพียงบางโปรแกรมใช้งานง่าย
สิ่งที่พวกคุณคิดว่าเป็น จะเกิดขึ้นในแต่ละจุด
ที่เราพยายามที่จะพิมพ์?
ดังนั้นหนึ่งนี่นี้ สิ่งที่จะเกิดขึ้น?
นักเรียน: มันจะพิมพ์สาม
ALLISON: ขวา
มันจะพิมพ์สาม
สิ่งที่เกี่ยวกับที่นี่?
นักเรียน: มันจะไม่ทำงาน
ALLISON: มันจะไม่ทำงาน
คุณออกจากขอบเขตใช่มั้ย?
ตัวแปรท้องถิ่นไม่อยู่ ด้านนอกของฟันเหล่านี้ขวาทั้งหมดหรือไม่
และแล้วสิ่งที่เกี่ยวกับที่นี่?
>> นักเรียน: [ไม่ได้ยิน]
>> ALLISON: อะไรนะ?
ร็อบไป
>> Rob: ผมเพิ่งกล่าวว่า
ตัวแปรทั่วโลกควรจะเป็น ตัวแปรขีดทั่วโลก
>> ALLISON: อ่าใช่ขอโทษ
ขอบคุณร็อบ
ร็อบเช่นคอมไพเลอร์ที่อยู่อาศัยของเรา
เขาก็จะตะโกนใส่เราเมื่อเรา จำเป็นต้องใช้มัน [หัวเราะ] ใช่ว่า
ควรจะเป็นตัวแปรขีดทั่วโลก
ดังนั้นสมมติว่าว่า เป็นขีดระดับโลก
ตัวแปรสิ่งที่จะเกิดขึ้นที่นี่?
นักศึกษาที่จะทำงาน
ALLISON: มันจะทำงาน
ดังนั้นมันจะพิมพ์ดังนั้นเพียง เป็นตัวอย่างที่ง่ายมาก
ตกลงต้นแบบ
ดังนั้นเห็นได้ชัดเราจริงๆ เน้นสำหรับพวกคุณ
ที่จะทำให้การทำงานถ้ามัน ทำให้ความรู้สึกในโปรแกรมของคุณ
แต่แน่นอนเมื่อคุณ ทำให้การทำงานของคุณเอง
โดยทั่วไปแล้วคุณจะกำหนดพวกเขาหลังจากที่หลัก
และคุณจะพยายามที่จะเรียกพวกเขาในหลัก
และถ้าคุณไม่ได้ใช้ต้นแบบ คอมไพเลอร์ของคุณจะตะโกนใส่คุณ
>> ต้นแบบเป็นพื้น เพียงแค่บอกคอมไพเลอร์ของคุณ
ที่ฉันมีฟังก์ชั่นด้านล่างนี้หลัก
ฉันจะเรียกมันว่าก่อนที่ผมจะกำหนดมัน
เพียงแค่กดที่
ฉันสัญญาว่าจะกำหนดและคุณ จะมีทุกอย่างที่คุณต้องการ
>> ดังนั้นวิธีที่เราทำมันเป็นเพียงการกลับมาของคุณ ชนิดชื่อฟังก์ชันของคุณใส่ของคุณ
รายการ
มันเป็นพื้นบรรทัดแรก ของการประกาศฟังก์ชั่นของคุณ
มันเป็นความจริงทั้งหมดมันเป็น
แต่นี่เป็นเพียง ชนิดทั่วไปของรูปแบบ
>> ดังนั้นในตัวอย่างของเราที่นี่ ซึ่งพวกคุณควร
ได้เห็นในส่วน ในบางจุดที่เรามี
บางก้อน int ที่ ใช้เวลา int เข้าบางส่วน
และเรามีหลักของเรา ฟังก์ชั่นที่เรียกก้อน
และก้อนถูกกำหนดตามความเป็นจริง
>> ดังนั้นถ้าเราไม่ได้มีการใส่ก้อน int ที่ด้านบนเมื่อเราเรียกว่าลูกบาศก์
ภายในหลักคอมไพเลอร์ของเรา จะได้รับบ้าที่พวกเรา
มันคงเป็นเหมือนสิ่งที่ คุณกำลังพูดถึง?
Cube ไม่อยู่
ผมไม่ทราบว่าสิ่งที่คุณกำลังถามหา
และฉันก็จะหยุด
>> แต่เป็นเพราะเราทำต้นแบบของเรา ที่ด้านบนที่เราได้กล่าวว่า
คุณรู้ว่าเมื่อคุณเห็น ก้อนไม่ต้องกังวลเกี่ยวกับเรื่องนี้
ฉันสัญญาว่าจะกำหนดในภายหลัง
และมันจะช่วยให้คุณทำสิ่งที่คุณต้องการ
ดังนั้นถ้าคุณเคยมีฟังก์ชั่น ที่มีการประกาศหลังจากที่คุณเรียกมันว่า
เป็นครั้งแรกที่คุณจะต้อง มีมันเป็นต้นแบบที่ด้านบน
>> ใช่?
>> Rob: มันยกกำลังไม่ cubing
>> ALLISON: โอ้พระเจ้าของข้าพระองค์
ผมไม่ได้ have-- เกบผมคิดว่า คุณสำอางของเรา
พวกตกลงอดทนกับฉันที่นี่
ผมหวังว่าทุกคนได้รับความคิด
ตกลงดังนั้นนี้ควรจะมี รับการยกกำลังไม่ cubed
แต่ความคิดที่ยังคงเหมือนเดิม
ฟังก์ชั่นใด ๆ ที่เรากำลังเรียกร้องหลังจากที่ ความจริงที่ควรจะมีต้นแบบ
ทุกคนที่ดีกับที่?
ความผิดพลาดใด ๆ อื่น ๆ ?
ตกลง
ความผิดพลาดใด ๆ ที่นี่ก่อนที่เราจะเริ่มต้น, ร็อบ?
[หัวเราะ] OK เพื่อ structs
โดยทั่วไป structs ช่วยให้คุณ เพื่อสร้างชนิดข้อมูลของคุณเอง
มากเช่น int หรือถ่านหรือ ลอยก็แค่อีกประเภทหนึ่ง
ผมชอบที่จะคิดว่ามันเป็นเหมือน สร้างประเภทข้อมูลของคุณเอง
ดังนั้นมันจึงช่วยให้คุณสามารถทำเช่นนั้นได้
และมันถือประเภทที่แตกต่างกันของข้อมูล
>> ดังนั้นหากคุณจำไว้ในอาเรย์เรา สามารถเก็บสิ่งที่เป็นของประเภทที่คล้ายกัน
structs ช่วยให้เราสามารถถือหลาย สิ่งที่แตกต่างกัน
ดังนั้นในกรณีนี้ที่นี่เรา มีโครงสร้างที่เรียกว่านักศึกษา,
การตั้งชื่อที่นี่ที่ด้านล่าง
และเรามีบาง int id และชื่อสตริงบาง
ดังนั้นนี้เป็นเพียงชนิดข้อมูลอื่น
ขณะนี้เรามีชนิดของข้อมูลที่เรียกว่านักศึกษา
>> เพราะเราสามารถคิดของ ว่ามันเป็นเพียงแค่ชนิดข้อมูลอื่น
เราสามารถประกาศตัวแปร ขณะที่อื่น ๆ ที่เราจะใด ๆ
ดังนั้นแทนที่จะเพียงแค่มีความเหมือน นักเรียน int เราก็มีนักเรียน
นักเรียน 1
โอ้ดู
มันเป็นร็อบ
ดังนั้นที่นี่เรากำลังประกาศ struct หรือตัวแปร
เรียกว่านักเรียน 1 ประเภทนักเรียน
ดังนั้นมันจะมี id และชื่อที่เกี่ยวข้องกับมัน
>> และวิธีที่เราใช้เหล่านี้ องค์ประกอบภายในโครงสร้างของเรา
อยู่กับผู้ประกอบการจุดที่นี่
ดังนั้นในกรณีนี้เรา ประกาศนักศึกษาบางส่วน 1
เราได้รับมอบหมายให้ ID ที่จะเป็น 1
และเรากำหนดชื่อที่จะเป็นร็อบ
ตกลงทุกคนที่ดีกับที่?
ใช้มันเป็นเพียงแค่ like-- ใช่?
>> นักเรียน: ใช่ typedef-- เมื่อ เราจะต้องใช้ typedef?
>> ALLISON ดังนั้น typedef เพียง กล่าวว่า that-- ร็อบคุณ
สามารถถูกต้องฉันเกี่ยวกับเรื่องนี้ถ้าผม wrong-- แต่ typedef เป็นเพียงการประกาศจริง
มันเป็นชนิดที่คุณสามารถใช้ใช่มั้ย?
>> Rob: ใช่มันเป็นพื้น, จึงเป็นเพียงการสร้าง
นามแฝงหรือฉายาสำหรับประเภท
ดังนั้นคุณจึงสามารถพิมพ์ว่า [ไม่ได้ยิน]
ดังนั้น [ไม่ได้ยิน] มีอยู่ และตอนนี้เราก็มี
[ไม่ได้ยิน] หมายถึง ตรงเดียวกัน
และอื่น ๆ ที่นี่เรากำลังพิมพ์ผมคิดว่า บางชนิด struct 2 [ไม่ได้ยิน]
จึงเป็นเพียงชื่อเล่น สำหรับประเภทที่กำหนด
>> นักเรียน: String [ไม่ได้ยิน] ห้องสมุด ถูกพิมพ์ขึ้นเช่นถ่านดาว
>> ALLISON: เพื่อประโยชน์ของเราที่นี่ ถ้าคุณกำลังประกาศ struct,
เพียงแค่ทำ typedef struct
ตกลงดังนั้นก่อนนี้ เพียงตัวแปรปกติท​​ี่นี่
เราเข้าถึงได้ด้วยจุด
ถ้าเรามีตัวชี้ไปยัง struct เราสามารถจริง
ใช้ลูกศรซึ่งเป็นเย็นสวย
>> ดังนั้นในกรณีนี้เรามีตัวชี้ไปยัง นักเรียนที่ 1 เป็นประเภทนักเรียน
โปรดจำไว้ว่ามีของคุณ การก่อสร้างตัวชี้
คุณต้องการสิ่งที่พิมพ์ตัวชี้ของคุณ จะชี้ไปที่จะเป็นจุดเริ่มต้น
ดังนั้นเราจึงมีนักเรียนบางส่วนที่ 1 ที่นี่
และเนื่องจากนักเรียนนี้ 1 อยู่ในขณะนี้ชี้,
เราจริงสามารถไปนักเรียนชื่อ 1 ลูกศร แทนจุดเพราะมันเป็นตัวชี้
และกำหนดร็อบ
และตอนนี้ถ้าเราต้องการที่จะ เปลี่ยนร็อบกับ Davin,
นี้เป็นเพียงการแสดง วิธีที่แตกต่างที่จะทำมัน
>> ดังนั้นแทนที่จะใช้ลูกศรคุณ สามารถ also-- ผมจะจบเรื่องนี้แล้ว
ใช้เวลาที่คำถามที่คุณสามารถ ยังทำนักเรียนอ้างอิง 1
ที่บอกว่าเหมือนไป อะไรที่เป็นนักเรียนที่ 1 ซึ่ง
จะเป็น struct นักเรียนของเรา
เข้าถึงได้ด้วยจุดและองค์ประกอบ ที่คุณต้องการและจากนั้นกำหนดมัน
มีคำถามเป็น
นักเรียน: ใช่ดังนั้นวิธีการที่คุณมีมา ที่จะใช้ [ไม่ได้ยิน] เมื่อคุณอยู่
ทำดาวนักศึกษาโดยไม่ต้อง [ไม่ได้ยิน] นักเรียน?
ALLISON: เพราะนี้ คือการสร้างตัวชี้
ปล้น: เรากำลังจะพูดคุยเกี่ยวกับเรื่องนี้
ALLISON: เรากำลังจะพูดคุย เกี่ยวกับที่มาในการตรวจสอบ
ดังนั้นเพียงแค่ถือเข้าความคิดที่ว่า
หากยังคงรบกวนจิตใจคุณ ท้ายมาพูดคุยกับคนของเรา
>> ดังนั้นเหล่านี้จะตรงเดียวกัน
เรากำลังแสดงให้คุณทั้งสอง วิธีการที่แตกต่างกันที่จะทำมัน
นักศึกษาที่ 1 คือตอนนี้ตัวชี้ดังนั้น คุณสามารถเข้าถึงองค์ประกอบชื่อ
ภายใน struct ที่มีลูกศร
หรือคุณสามารถ dereference ตัวชี้ของคุณและ จากนั้นเข้าใช้งานได้ตามปกติ
ไม่ว่าทำให้ความรู้สึกที่ทุกคน?
หากสิ่งที่ตัวชี้ทั้งมีน้อย ทำให้เกิดความสับสนเกบจะพูดคุยเกี่ยวกับเรื่องนั้น
แล้วอาจจะ จะทำให้รู้สึกมากขึ้น
ใช่?
>> นักเรียน: ใช่ดังนั้นวิธีการที่เป็น นี้แตกต่างจาก?
ALLISON: เดิมหรือไม่
ดังนั้นนักเรียน 1 ในครั้งนี้ กรณีที่ไม่ได้เป็นตัวชี้
มันเป็นเพียงโครงสร้างที่แท้จริงของคุณ
>> นักเรียน: OK
>> ALLISON: ในขณะนี้ เป็นตัวชี้ไป struct
>> นักเรียน: OK แต่ไม่ได้ชนิดของ จบลงด้วยการทำงานที่เหมือนกัน [ไม่ได้ยิน]
>> ALLISON: มันมีประสิทธิภาพการทำงานที่เหมือนกัน
ไวยากรณ์ของคุณจะแตกต่างกันเพียงแค่
นักเรียน: OK
>> ALLISON: ใช่พวกเขาจะ ได้อย่างมีประสิทธิภาพเช่นเดียวกัน
มันก็แค่ขึ้นอยู่กับบริบท คุณอาจต้องการที่หนึ่งในช่วงอื่น ๆ
ใช่?
>> นักเรียน: เมื่อคุณทำ อ้างอิงถึง 1--
ALLISON: MM-HM?
นักเรียน: ทำไมคุณ มีวงเล็บ?
ALLISON: เพราะนักเรียน 1 เป็นตัวชี้
ดังนั้นคุณต้องให้แน่ใจว่าคุณ เพียง dereferencing ชี้
>> นักเรียน: OK
>> ALLISON: ดังนั้นในกรณีนี้ที่นี่ วงเล็บรอบ ๆ
หมายความว่าคุณกำลัง dereferencing นักเรียน 1
เพื่อให้คุณกำลังจะไปที่นักเรียน 1 คะแนนซึ่งเป็นโครงสร้างของคุณ
ดังนั้นตอนนี้คุณสามารถคิด มันเป็นโครงสร้างที่
เพื่อให้เราสามารถใช้การดำเนินการจุดของเราตามปกติ
ใด ๆ ที่คำถามอื่น ๆ ?
เย็น, น่ากลัว
>> ดังนั้นสิ่งสุดท้ายที่ผมคิดว่า เป็นสไลด์สุดท้ายของฉัน, วู!
OK เพื่อให้ลอยไม่แน่ชัดจุด
เราพูดคุยกันสั้น ๆ เกี่ยวกับ นี้ในระหว่างการบรรยาย
โดยทั่วไปเรามี จำนวนจริงมากมายหลาย
และถ้าใด ๆ ของพวกคุณ รักคณิตศาสตร์มี
ทุกประเภทของสิ่งดีๆกับเรา
>> แต่มีเพียบ จำนวนจริงจำนวนมาก
แต่พวกเขากำลังเพียง จำกัด บิตหลายอย่างที่เรามี
ดังนั้นคุณเสมอไป มีความไม่แน่ชัดคือทั้งหมด
และที่นั่นเป็นเพียงชนิดของ เหมือนสิ่งที่คุณควรรู้
ที่ว่าเราอาจขอให้คุณทำไม จุดลอยไม่แน่ชัดอยู่?
ดังนั้นสิ่งเดียวที่คุณควรรู้
และด้วยการที่ผมเปลี่ยน มันไปชี้
>> บิงกี้: สวัสดีครับ
ชื่อของฉันของบิงกี้
ฉันจะพูดคุยเกี่ยวกับตัวชี้
ใช่ตัวชี้เพื่อให้เป็นจริง ส่วนหนึ่งที่ชื่นชอบในหลักสูตรนี้
ดังนั้นเพียงเพื่อให้ชัดเจนในสิ่งที่อัลลิสัน พูดคุยเกี่ยวกับที่นี่จึงเป็นเหตุผลว่า
why-- แตกต่างที่นี่ ความแตกต่างใหญ่เป็นวิธี
สิ่งที่เราประกาศ
ดังนั้นดาวนักเรียนหมายถึงนี้ เป็นตัวชี้ไปที่นักเรียน
ในขณะที่การนำเสนอภาพนิ่งก่อนที่นักเรียนเป็น struct ที่เกิดขึ้นจริงเช่นเดียวกับนักเรียนที่เกิดขึ้นจริง
มีใด ๆ ของสิ่งเหล่านั้น
>> และเหตุผลที่ว่าทำไมเรา ต้องการ to-- ใช่ Davin?
>> Davin: อะไรลูกศรหมายถึงอะไร?
>> บิงกี้: หมายถึงลูกศร เหมือนกับนี้
เพื่อให้คุณไม่ได้จริงๆต้องลูกศร
เช่นถ้าคุณโปรแกรมเท่านั้น ใน C คุณก็สามารถใช้นี้
ขออภัยผมไม่ได้ว่ามันคืออะไร
คุณก็สามารถใช้รูปแบบนี้
>> แต่บางคนเมื่อ พวกเขาได้รับการออกแบบ C,
พวกเขาคิดว่าคน ใช้ไวยากรณ์ที่มาก
ว่าพวกเขาจะชอบมาเพียงแค่ขึ้น ที่มีโครงสร้างไวยากรณ์สำหรับมัน
และสิ่งนี้เกิดขึ้นใน รูปแบบของลูกศรนี้
และมันเป็นเรื่องดีจริงๆเพราะ มันเป็นสัญลักษณ์ของอะไรบางอย่าง
เหมือนเรากำลังจริงต่อไปนี้ ลูกศรนี้ชี้นี้
ไปยังพื้นที่ในหน่วยความจำบางส่วน
และเมื่อเราได้มีที่เราต้องการ มองไปที่ชื่อของนักเรียนนั้น
หากที่ทำให้ความรู้สึก
OK?
>> ดังนั้นนี่คือตรงเดียวกัน
ตรงนี้เป็นสิ่งเดียวกันเช่นนี้
พวกเขาได้รับการเรียบเรียงตรงเดียวกัน, OK?
และเหตุผลที่นี่ทำไมเรา malloc บางสิ่งบางอย่างเป็นเพราะในกรณีนี้
ตัวแปรของเราเป็นจริง เพียงตัวแปรตัวชี้
ดังนั้นเราจึงมีเพียงแค่ในบางพื้นที่ หน่วยความจำที่ถือตัวชี้
เราไม่ได้จริงๆมีพื้นที่ใด ๆ ที่มีโครงสร้างที่เกิดขึ้นจริง
>> ดังนั้นนี้จะต้องมีการดำเนินการในขั้นตอนที่สอง
เราต้องสร้าง หน่วยความจำในการวางโครงสร้างใน
และเราต้องสร้าง หน่วยความจำที่จะนำตัวชี้ใน
ดังนั้นพวกเขากำลังพื้นสอง ตัวแปรที่แตกต่างกันที่นี่
หนึ่งในนั้นคือประเภทนักเรียน ยกเว้นมันไม่ได้จริงๆมีชื่อ
และอีกคนหนึ่งเป็น ประเภทนักเรียนดาว
แล้วนักเรียน 1 คะแนน มีถ้าที่ทำให้รู้สึก
OK?
>> ดังนั้นเหตุผลที่ว่าทำไมเราใช้ ชี้เป็นเพราะทุกอย่าง
ในคอมพิวเตอร์ทุกตัวแปร ในคอมพิวเตอร์ที่มีสองสิ่ง
มันมีค่าของมัน
และมีที่อยู่ของมัน
และเป็นวิธีที่ดีที่จะ กรอบความคิดนี้มี
ปัญหามากมายเมื่อคุณ พยายามที่จะใช้ฟังก์ชั่น
และเราจะพยายามที่จะ มองเข้าไปในหนึ่งในบรรดา
คือมันจะ คิดของหน่วยความจำที่เป็นกล่อง
>> คุณมักจะคิดว่าของตัวแปร เมื่อคุณพูด ​​na เท่ากับ 5
คุณคิดของการวางลงในช่อง 5
ดังนั้นสิ่งที่ถ้าคุณต้องการที่จะผ่าน int ว่าในการทำงานหรือไม่?
คุณเพียงแค่ pass-- ฉันทำไม่ได้ know-- x ในการทำงาน
แต่สิ่งที่เกิดขึ้นคือ ปกติเป็นคนที่คุณ
จะคิดว่าสิ่งที่ต้องการฉัน ผ่านกล่องให้กับบุคคล
และมันไม่ได้จริงๆ เกิดขึ้นได้ในคอมพิวเตอร์
สิ่งที่เกิดขึ้นก็คือค​​ุณคัดลอกค่า จากกล่องกล่องของบุคคลนั้น
>> ดังนั้นสิ่งที่ผมพยายามจะบอกก็คือว่าถ้า คุณมีฟังก์ชัน sorry-- ที่นี่
ถ้าเรามีฟังก์ชั่นเช่นถึงห้าขึ้น ที่นั่นถ้าคุณพยายามที่จะผ่านตัวแปร
ก็แค่ไปคัดลอก
ถ้า NX เริ่มต้นเท่ากับ 3 ก็จะ เพื่อคัดลอกค่านี้ขึ้นอยู่กับตัวแปร
ขึ้นมี
ตกลงนี้เป็นชนิดของเหตุผล เหตุผลที่เราต้องการที่จะใช้ตัวชี้
เพราะแทนที่จะ ให้เพียงค่า
แทนเพียงแค่ผ่าน ค่าฟังก์ชั่น,
เราต้องการที่จะผ่านโดยการอ้างอิง
สิ่งที่เราเรียกผ่านโดยการอ้างอิงเป็นชนิด ของการให้กล่องฟังก์ชั่น
เพื่อให้การทำงานยังสามารถ เปลี่ยนค่าที่อยู่ในกล่องที่
>> ตกลงดังนั้นเพียงบางตัวชี้พื้นฐาน สิ่งที่คือการสร้างตัวชี้
คุณเพียงแค่ประกาศชนิดและ คุณใส่ดาวที่เหมาะสมหลังจากที่มัน
และประเภทเป็นเพียง สิ่งที่คุณกำลังชี้ไปที่
ดังนั้นถ้ามันดาว int, คุณกำลังชี้ไปที่ int
ถ้าเป็นดาวถ่าน, คุณกำลังชี้ไปที่แผนภูมิ
และถ้ามันเป็นดาวนักเรียน คุณกำลังชี้ไปที่นักเรียน
OK?
>> และพวกเขากำลังทั้งหมดยาว 4 ไบต์
เพราะตัวแปรนี้ มันไม่จริง
ต้องถือถ่าน, int หรือนักเรียน
เพียงต้องการที่จะถืออยู่
นั่นเป็นเหตุผลที่พวกเขากำลังทั้งหมด 4 ไบต์ ยาวนานในเครื่อง 32 บิตปกติ
OK?
ดังนั้นที่นี่ x เป็นตัวแปรที่ชี้ เป็น int จุดและการถ่าน จุด Z
ที่จะลอย
คำถามใด ๆ ที่นี่?
เย็น
และมีสอง สัญลักษณ์ที่แตกต่างกันพวกเขามี
ไปเก็บไว้ในใจเมื่อ มาถึงตัวชี้
ดังนั้นการอ้างอิงและ dereferencing เป็นคนที่ยิ่งใหญ่
ดังนั้นเครื่องหมายของ ชื่อตัวแปรจะช่วยให้คุณ?
นักศึกษาที่อยู่
บิงกี้: ที่อยู่
ดังนั้นถ้าคุณประกาศ int เท่ากับ 5 แล้วเครื่องหมาย
ของที่จะให้ที่อยู่
และคุณจริงสามารถลอง ในการพิมพ์ที่และดู
สิ่งที่อยู่ในความทรงจำ ตัวแปรของคุณมี
แล้ว dereferencing-- เพื่อให้ได้รับการอ้างอิง,
รับ dereferencing address-- เป็นตรงกันข้าม
ตกลงเช่นเดียวกับครั้งนี้ ตรงข้ามของส่วน,
ดาวอยู่ตรงข้ามของเครื่องหมาย
ดังนั้นวิธีการ dereferencing ไปที่นั่น
ดังนั้นถ้าคุณให้ฉัน star-- ไม่ know-- 50 ที่
จะพยายามที่จะไปที่ที่อยู่ของ จำนวน 50 ภายในของเครื่องคอมพิวเตอร์ของคุณ
ตกลงทำเหตุที่เราเห็น ว่าพวกเขาจะตรงข้าม?
เพราะสิ่งที่เกิดขึ้นถ้าคุณทำ บางอย่างเช่นดาวเครื่องหมาย?
ดีเครื่องหมายจะช่วยให้คุณอยู่ ของตัวแปรที่อยู่ของ
แต่หมายถึงดาวไปที่นั่น
>> ดังนั้นสิ่งที่เกิดขึ้นถ้าคุณ ไปที่ที่อยู่ของ?
คุณเพียงแค่จะไปใช่ไหม?
ดังนั้นจะไปยังที่อยู่ของ เป็นสิ่งเดียวกับ
นั่นเป็นเหตุผลที่พวกเขามักจะ เรียกว่ามันเหมือนกับนี้
และนี่จะเรียกว่า ผู้ประกอบการที่อยู่ตรงข้ามกับ
OK?
So Cool
>> ภายใต้ประทุนเช่น ถ้าเราประกาศ int x เท่ากับ 5
เรามีตัวแปร
และจำไว้ว่าที่ผมพูดทุก variable-- และนี่คือสิ่งที่ดี
ไปเก็บไว้ใน mind-- มันมีสอง สิ่งที่แตกต่างที่เกี่ยวข้องกับ
มันได้รับการแก้ไขและมูลค่า
OK?
>> ดังนั้นค่าในกรณีนี้คือ 5
และที่อยู่เป็นเท่าไหร่สมมติว่าผม ทำสิ่ง up-- ก็ 0x04
และเหตุผลเดียวที่ว่าทำไมเรามักจะ เป็นตัวแทนที่อยู่ในเลขฐานสิบหก
เป็นหนึ่งเพราะมันก็เหมือนกับการที่ดี
มันจะไปได้ดีกับไบนารี
มันง่ายที่จะแปลงไปและกลับจากไบนารี
และมันก็ไม่ได้รับการขนาดใหญ่เกินไปถ้า คุณมีจำนวนใหญ่มาก
ดังนั้นเราจึงต้องการที่จะใช้เลขฐานสิบหก ในที่อยู่การพิมพ์
แต่ผมจะเป็นตัวแทน นี้เป็นจำนวนเต็ม
มันเป็นเรื่องที่ดี
>> และดังนั้นจึงมีที่อยู่ 4 และคุณค่าของ 5
แล้วผมบอกว่าตัวชี้ int ดาว
ดังนั้นนี่คือการแจ้งให้ทราบชนิดที่แตกต่างกัน,
ตัวชี้ดาว Int เท่ากับ ที่อยู่ของ x
ดังนั้นสิ่งที่จะเป็นค่าของ PTR?
มันเป็นไปได้ ที่อยู่ของ x ลงที่นี่
OK เพื่อให้ค่าที่เป็นไปได้ เป็นเช่นเดียวกับที่อยู่
ที่ได้รับมอบหมายงานที่ฉันทำ
แล้ว PTR เป็นไปได้ ที่อยู่ของตัวเองซึ่งจะเปิดออก
ในกรณีนี้ 8, OK?
>> และจากนั้นผมสร้างสำเนาจำนวนเต็มใหม่
และผมบอกว่าสำเนา int เท่ากับไปที่นั่น
ดังนั้นไปกับสิ่งที่ ptr จะชี้ไปที่
ดีสิ่งที่ PTR นี้ได้?
ptr มี 0x04
เกิดอะไรขึ้นถ้าฉันพยายามที่จะไปที่นั่น?
ฉันจะได้พบกับคนที่มี x ที่อยู่และผู้ที่มีที่อยู่ 4
และผู้ที่มีสี่อยู่คือ x
ที่ทำให้รู้สึก?
ใช่?
>> นักเรียน: ในกรณีนี้ ตัวชี้ในกอง?
>> บิงกี้: ในกรณีนี้ คำถามที่ดี it's--
ฉันไม่ได้จริงๆคิดเกี่ยวกับเรื่องนี้ เมื่อมีการขึ้นอยู่เหล่านี้
แต่ถ้าเป็นเช่นทั้งหมด เหล่านี้เป็นตัวแปรท้องถิ่น
แล้ว x จะไปอาศัยอยู่ in-- ทุกอย่าง จะไปอาศัยอยู่ในกอง
เพื่อให้ทุกอย่างเป็นไปได้ จะชี้ไปที่กอง
คุณจะได้รับไปยังกองเมื่อ คุณเริ่มที่จะใช้ malloc ใช่มั้ย?
>> ดังนั้นถ้าคุณจำสแต็คเป็นทุกครั้ง คุณเรียกฟังก์ชั่นในโปรแกรมของคุณ
เหมือนหลักเช่นหรือใด ๆ ฟังก์ชั่นอื่น ๆ เช่น printf
ทั้งหมดของตัวแปรในท้องถิ่นที่มี จะได้รับการใส่ในกองกรอบ
และพวกเขากำลังจะได้รับ เหมือนซ้อนขึ้นในกอง
นั่นคือสิ่งที่เรียกว่าสแต็ค
และบรรดาตัวแปรท้องถิ่น จะไปอยู่ที่นั่น
และ heap-- และเรากำลังจะ ที่จะพูดคุยเพิ่มเติมเกี่ยวกับ later-- นี้
กองเป็นที่ที่ทุกคน จัดสรรแบบไดนามิกชีวิตของหน่วยความจำ
เย็น?
>> เราไปสไลด์นี้
ใช่?
>> นักเรียน: ทำไมไม่ได้ int คัดลอกกลับ 0x04?
>> บิงกี้: ทำไมไม่ได้ int คัดลอกกลับ 0x04?
>> นักเรียน: ทำไมไม่เป็นที่ [ไม่ได้ยิน]
>> บิงกี้: เพราะสิ่งที่เป็นคุณค่าของ PTR?
>> นักเรียน: 0x04
>> บิงกี้: 0x04
จะเกิดอะไรขึ้นถ้าคุณไปที่ 0x04?
สิ่งที่คุณได้รับ?
>> นักเรียน: โอ้, OK
บิงกี้: คุณเห็น?
นักเรียน: ใช่
บิงกี้: เพื่อให้คุณได้รับ 5
ดังนั้นสำเนาเป็นไปได้ 5 หากที่ทำให้ความรู้สึก
ใช่?
>> นักศึกษาสามารถเรามีอากาศ 5 ในกล่องค่า [ไม่ได้ยิน]
ถ้าเราใส่สำเนา int [ไม่ได้ยิน]
>> บิงกี้: เราจะ Int-- ใช่
ที่จะได้ทำ สวยมากในสิ่งเดียวกัน
แต่วิธีนี้เราสามารถผ่าน อยู่กับการทำงาน
และนั่นคือสิ่งที่เย็น ที่เรากำลังจะทำตอนนี้
>> ดังนั้นชนิดของการออกกำลังกายนี้เสมอมา on-- มากมักจะเกิดขึ้นในแบบทดสอบ
ดังนั้นจึงเป็นเรื่องที่ดีมากที่จะลอง ทำชนิดของสิ่งที่ตัวเองว่า
จึงพยายามที่จะติดตามสิ่งที่อยู่ และต้องการค่าของตัวแปร
อยู่ที่แต่ละจุด
ดังนั้นตรงนี้เป็น สิ่งที่เรากำลังจะทำ
ที่นี่เรามีขั้นตอนหนึ่ง สองสามสี่ห้า
หนึ่งสองสามสี่ห้า
และเรากำลังจะติดตาม ของค่าของ x และ
>> ดังนั้นสิ่งนี้จะทำถ้าเป็น รหัสรถเรากำลังพยายามที่จะทำถึงห้า
ดังนั้นเรากำลังพยายามที่จะได้รับใน ตัวแปรและเปลี่ยนค่าเป็น 5
และจำไว้ว่าการเปรียบเทียบของฉันของการมี กล่องและยื่นกล่องใครบางคน?
ดังนั้นหลักมีกล่องที่เรียกว่า x นี้
และมันมีค่า 3
และฉันพยายามที่จะส่งมอบ กล่องนี้ถึงห้า
>> และฉันต้องการที่จะเปลี่ยนห้า มูลค่าของกล่องนี้ถึง 5
และจากนั้นผมเพียงแค่พิมพ์ค่าของ x
นี่คือสิ่งที่ฟังก์ชันของฉัน นี่คือสิ่งที่ฉันพยายามที่จะทำ
ฉันแค่พยายามที่จะปรับปรุง ค่าของ x 5
มันเป็นที่ชัดเจนว่าการทำงานอย่างไร
>> ตกลงดังนั้นสิ่งที่เป็นไปได้ ค่าของ x และที่นี่
บรรทัดแรก, ก่อนมีสิทธิก่อน line-- ผมจะ say-- ของโปรแกรมได้หรือไม่
>> นักเรียน: น่าจะเป็นขยะ
>> บิงกี้: เพียงแค่สิ่งที่ขยะ
ดังนั้นฉันเพียงแค่ใส่ N / A ดังนั้น เราไม่ทราบจริงๆ
เหมือนไม่ได้อยู่ยัง เพราะเรายังไม่ได้เรียกว่าถึงห้า
int ไม่ได้ประกาศ
และ x เป็นไปได้ที่มีอยู่ ที่นี่ แต่เรามีไม่ได้จริงๆ
กำหนดค่าให้กับมันใด ๆ ตกลงเพื่อ?
>> และแล้วสิ่งที่เป็นไปได้ ค่าของ x และในจำนวนสอง?
>> นักเรียน: [ไม่ได้ยิน]
>> บิงกี้: x ดังนั้นเป็นไปได้ 3
นั่นเป็นเรื่องง่ายเพราะ เรากำลังกำหนด 3 ถึงมัน
และยังไม่ได้มีอยู่ เพราะเพียงแค่อาศัยอยู่ในห้า
ดังนั้นฉันจะมี 3 และไม่มีอะไร
หรือชอบขยะใด ไม่ได้กำหนดไว้จริงๆ
และตอนนี้เป็นสายสำคัญ
ที่นี่เรากำลังจะไป จริงโทรไปห้า
และจำไว้ว่าสิ่งที่ผมพูด
เราไม่เคยผ่านในกล่อง
เราเพียงแค่คัดลอกค่าของ กล่องกล่องอื่น
นั่นคือคอมพิวเตอร์ทุกเครื่องจะคัดลอก สิ่งจากที่หนึ่งไปยังอีก
>> ดังนั้นถึงห้าสิ่งที่มันไม่จริง เป็นสำเนาค่าของ x จะ
ดังนั้นสิ่งที่เป็นไปได้ที่นี่?
ค่าของ x และ
3 และ 3 เราจะคัดลอก มันมาจาก x เพื่อ
เย็น
>> ตอนนี้เราอยู่ที่นี่
และตอนนี้เรากำลังจะ การปรับปรุงเท่ากับ 5
สิ่งที่จะเกิดขึ้นในสายสี่
>> นักเรียน: [ไม่ได้ยิน]
>> บิงกี้: ได้รับการปรับปรุง แต่ x ก็ไม่ได้รับการปรับปรุง
เพราะ x ยังคงอาศัยอยู่ในหลักของมัน บล็อกที่แตกต่างกันอย่างสมบูรณ์ของหน่วยความจำ
มันเป็นตัวแปรที่แตกต่างกัน
เป็นตัวแปรอื่น
พวกเขาเกิดขึ้นได้ ค่าเดียวกันเพราะผม
คัดลอกสูงกว่ามูลค่าของ x
แต่ตอนนี้เมื่อฉันทำเท่ากับ 5 ก็ ไม่ได้ส่งผลกระทบจริงๆ x ในทางใดทางหนึ่ง
นี้เป็นส่วนที่ยุ่งยาก
มันทำให้รู้สึกกับทุกคน?
ใช่?
นักเรียน: คำถามเพิ่มเติมหนึ่งคุณมี 3
ทำไม already-- โอ้ไม่ก็ 3
ขออภัยไม่ทราบ
ผมอ่าน 5
>> บิงกี้: ใช่, 3, 3
>> นักเรียน: [ไม่ได้ยิน] ใช่
บิงกี้: และแล้วเรากำหนด 5 ถึง แต่ไม่ได้เปลี่ยนจริงๆ x
ดีหรือไม่?
นักเรียน: ใช่
บิงกี้: ใช่?
คุณสามารถอธิบายอีกครั้งว่า ได้รับการคัดลอก [ไม่ได้ยิน]
>> บิงกี้: OK ดังนั้นเมื่อคุณโทรไปห้า ของ x ดังนั้นบรรทัดนี้รหัสที่นี่
ถึงห้าของ x คืออะไร X?
x เพียง 3 ที่จุดนี้ใช่มั้ย?
ดังนั้นคุณก็สามารถคิดของการวาง 3 ที่นี่และลืมเกี่ยวกับ x
เพียงแค่ใส่ 3 ที่นี่
เช่นเดียวกับที่เรากำลังจะคัดลอกไป ค่าของ x เพื่อ int ที่มีขึ้น
OK?
>> ดังนั้นค่าของ x คือ 3
เรากำลังจะไปคัดลอก 3 ไป
และทุกบล็อกอื่น ๆ ของ หน่วยความจำของตัวแปรอื่น ๆ
เรียกว่าจะมี 3 เช่นเดียวกับ
ที่ทำให้รู้สึก?
ใช่?
>> นักเรียน: ถ้าคุณให้ถึงห้าเช่น มีมันเป็นจำนวนเต็ม x แทน,
ที่จะแก้ไขปัญหาทุกอย่าง?
>> บิงกี้: ถ้ามัน integer-- ไม่มี ที่จะไม่แก้ไขปัญหาทุกอย่าง
นั่นคือคำถามที่ดีมาก
มันไม่ได้เรื่องจริงๆสิ่งที่ คุณเรียกตัวแปรเหล่านั้น
อีกครั้งก็จะเป็นปัญหาของขอบเขต, เพราะพวกเขาไม่ได้ x เดียวกัน
พวกเขากำลังอย่างสมบูรณ์ ช่องว่างที่แตกต่างกันในหน่วยความจำ
นักเรียน: [ไม่ได้ยิน]
บิงกี้: ดังนั้นมันไม่ได้จริงๆ สำคัญว่าสิ่งที่คุณเรียกพวกเขา
แต่นั่นไม่ได้แก้ไขสิ่ง, OK?
คำถามเพิ่มเติมหรือไม่
ใช่?
>> นักเรียน: มันเป็นวิธีการกลับไป หมายเลขห้า [ไม่ได้ยิน]
บิงกี้: ตกลงเราไม่ได้ทำที่ยัง
ลองไปที่บ้านเลขที่ห้าแล้ว
>> นักเรียน: [ไม่ได้ยิน]
>> บิงกี้: อะไรนะ?
>> นักเรียน: คุณมีผลตอบแทนที่ทุกคน?
บิงกี้: เราไม่ได้มี กลับไปไม่ได้ในหลัก
แต่ผลตอบแทนหลัก 0 โดยอัตโนมัติ ถ้าคุณไม่กลับอะไร
ใช่?
>> นักเรียน: คุณสามารถทำให้ main-- หรือ คุณสามารถทำให้ถึงห้ากลับมา?
>> บิงกี้: เราอาจมี ถึงห้ากลับใช่
แต่แล้วเราจะต้องกำหนด x เท่ากับค่าตอบแทนของถึงห้า
ซึ่งจะเป็นเล็กน้อย โปรแกรมที่แตกต่างกัน
มันจะทำงาน
แต่สิ่งที่เราต้องการจะทำคือสิ่งที่เป็น สิ่งที่เรียกว่าการเปลี่ยนแปลงในสถานที่
ดังนั้นเราจึงต้องการที่จะเป็นจริง เปลี่ยนช่องที่และไม่ต้องกังวล
เกี่ยวกับการมีที่จะกลับมา ค่าหรืออะไร
OK?
>> นี้เช่นเดียวกับฟังก์ชั่นการแลกเปลี่ยน เดวิดได้แสดงให้เห็นในการบรรยายยกเว้นฉัน
เพียงจัดการกับตัวแปรหนึ่ง
และเขาใช้สองดังนั้น int a และ b และ แล้วตัวแปรชั่วคราวและ whatnot
OK?
ดังนั้นสิ่งที่บรรทัดสุดท้าย?
หลังจากที่ห้าผลตอบแทนก็ ก็จะหายไป
เราจะไม่ได้อีกต่อไปและ เพียง x จะยังคงอาศัยอยู่บน
>> และเดาอะไร x ไม่ได้เปลี่ยนค่าของมัน
หลังจากทั้งหมดเพราะเรา เพียงเปลี่ยนค่าของ
นั่นเป็นเหตุผลที่ x 3 ตลอด
OK?
ดี
ดังนั้นโปรแกรมนี้ไม่ได้ บรรลุสิ่งที่เราต้องการ
ตอนนี้ขอแก้ไขได้
>> และโปรแกรมการแก้ไขคือการใช้ตัวชี้
สิ่งที่เราทำคือเรามีสาม เส้นที่แตกต่างกัน
คนแรกคือเราไม่ได้ผ่าน x
เรากำลังผ่านที่อยู่ของ x
ดังนั้นแทนที่จะคัดลอกไป ค่าของกล่อง
ฉันยังคงไปคัดลอกไปบางสิ่งบางอย่าง
แต่ฉันคัดลอกไป ที่อยู่ของกล่อง
>> ดังนั้นถ้าผมส่งที่อยู่ของ กล่องถึงห้าแล้วถึงห้า
จะสามารถที่จะพบว่าใน หน่วยความจำและการเปลี่ยนแปลงค่าของมัน
>> ดังนั้นแล้วขึ้นมีฉันมี ที่ไม่ได้ int อีกต่อไป
เป็นดาว int
มันเป็นตัวชี้ไปยังจำนวนเต็ม
แล้วเพราะฉันผ่าน อยู่ที่นี่แล้วสิ่งที่ฉันทำ
ไม่เท่ากับ 5 เพราะ มีการถือครองที่อยู่
ดังนั้นสิ่งที่ฉันต้องการจะทำคือไปที่นั่นและ ปรับปรุงเนื้อหาของที่อยู่นี้
5
>> ตกลงเพื่อให้ผ่านไป ทั้งหมดของสายหนึ่งโดยหนึ่ง
ดังนั้นเมื่อผมเริ่มต้นที่นี่ผม ยังคงมีไม่มี /, N / A, N / A
สำหรับทุกอย่างในครั้งแรก สายเพราะฉันมีไม่ได้จริงๆ
สิ่งที่ยังประกาศ
แล้วแถวสองผมมี x เท่ากับ 3
int ดาวไม่อยู่ สิ่งเดียวกับก่อนที่จะ
>> ตอนนี้มันได้รับน่าสนใจ
ดังนั้นฉันจะผ่าน
และสมมติว่าที่อยู่ ของ x คือ 12 ในฐานสิบหก
ขอเพียงสมมตินี้
ฉันทำมันขึ้นมา
ดังนั้นสิ่งที่ฉันผ่านที่นี่ถึงห้า
ผมผ่าน 12
>> ดังนั้นสิ่งที่มีค่าไม่ได้?
>> นักเรียน: [ไม่ได้ยิน]
>> บิงกี้: ขอโทษ?
>> นักเรียน: [ไม่ได้ยิน]
บิงกี้: ใช่ชอบที่จะให้ สมมติว่าเราอยู่ที่นี่ตอนนี้
ฉันขอ
>> นักเรียน: [ไม่ได้ยิน]
>> บิงกี้: จะได้รับการริเริ่ม
>> นักเรียน: [ไม่ได้ยิน]
บิงกี้: เพราะเราผ่าน สิ่งที่จะทำงาน
ใช่?
>> นักเรียนที่อยู่ของ x
บิงกี้: มันจะ มีที่อยู่ของ x
และที่อยู่ของ x คือ 12 ดี
ดังนั้น x เป็นไปได้ 3 เพราะ เรายังไม่ได้เปลี่ยนจริงๆ x ยัง
และจากนั้นก็เป็นไปได้ 0x12 ดังนั้น ที่อยู่ของ x เพราะนั่นคือ
สิ่งที่เราส่งผ่านไปถึงห้า
>> และแล้วสิ่งที่เกิดขึ้น ถ้าเราพยายามที่จะไปที่นั่น?
สิ่งที่เราจะไปหา?
ดังนั้นถ้าคุณพยายามที่จะพิมพ์ดาว, เราจะทำตามที่อยู่นี้
และได้รับค่าที่อยู่ภายใน
และมีค่าเป็นเพียงแค่ ค่าเดียวกันที่ x
มีเพราะนั่นคือ ที่อยู่ของ x ซึ่งจะเป็น 3
เราจะดีหรือไม่?
>> ตกลงแล้วตอนนี้เราไปที่นั่นจริง
และสิ่งที่เราปรับปรุง อยู่ในที่อยู่นี้ 12
เราทำให้มัน 5
ดังนั้นตอนนี้ทั้ง x และดาวเป็น 5
>> ทำไมเป็นเช่นนั้น?
เนื่องจากที่อยู่ของ x คือ 12
และยังมี 12 เป็นค่าของมัน
ดังนั้นหากเราทำตาม 12 เราไม่ เพียงแค่จะไปหา x
ดังนั้นสิ่งที่เราจะทำอย่างไรกับ ดาวที่จะเกิดขึ้น
กับ x เพราะมี ที่อยู่ของ x
OK?
>> และนี้เป็นเหมือนปมของการแก้ไข
ดังนั้นตอนนี้เราสามารถ จากห้าจริง
เข้าถึงหน่วยความจำที่อาศัยอยู่ในหลัก
ดังนั้นหน่วยความจำนี้ไม่ได้อยู่ใน ห้าเหมือนก่อนที่อยู่นี้ 12
และเราก็สามารถที่จะไปที่นั่น และเปลี่ยนค่าเป็น 5
>> และจากนั้นเมื่อเรากลับมา เราลืมเกี่ยวกับ
เราลืมเกี่ยวกับดาว
และ x ยังคงห้า
ดังนั้นถ้าคุณต้องการที่จะ ใช้ฟังก์ชั่นการแลกเปลี่ยน,
คุณก็จะทำสิ่งเดียวกันแน่นอน ยกเว้นคุณจะต้อง int ดาวที่นี่
และอื่น ๆ และอื่น ๆ
OK?
เราจะดีหรือไม่?
เย็น
>> คำนวณตัวชี้ดังนั้น
นี้เป็นเรื่องยุ่งยากเล็กน้อย
ดังนั้นจึงปรากฎว่า ชี้เป็นเพียงจำนวนเต็ม
คุณสามารถคิดว่าพวกเขาเป็นจำนวนเต็ม
เพราะในความทรงจำที่คุณมีเช่น หน่วยความจำที่อยู่ศูนย์หนึ่งสองสาม
สี่ห้า
ดังนั้นเราจึงสามารถสรุปอยู่หน่วยความจำ
>> และนั่นคือสิ่งที่คุณมักจะทำอย่างไรเมื่อ คุณอยู่ในและอาเรย์ตัวอย่างเช่น
อาร์เรย์เป็นเช่นเดียวกับที่อยู่ติดกัน บล็อกของหน่วยความจำจำนวนมากของตัวอักษร,
ตัวอย่างเช่นจำนวนมาก ints
ดังนั้นหากคุณต้องการที่จะไป สอง int หรือ int ที่สาม
คุณก็สามารถสรุปสิ่งที่จะเป็นครั้งแรก ที่อยู่และคุณจะได้รับมี
ดังนั้นนี้เป็นประโยชน์มากสำหรับการที่
>> และสิ่งที่จะทำให้ ในใจ แต่เป็น
ว่ามันไม่ได้เป็นเช่นเดียวกับ คณิตศาสตร์ปกติในความรู้สึก
ว่าถ้าคุณจัดการกับพูดว่า ดาว int และคุณเพิ่ม 1 กับมัน
แล้วคุณจะไม่ เพื่อเพิ่ม 1 ไปยังที่อยู่,
คุณกำลังจะเพิ่ม 4 ไปยังที่อยู่
เพราะ int คือ 4 ไบต์
>> ดังนั้นนี้เป็นเหมือน เดินบนอาร์เรย์
ถ้าเรามีอาร์เรย์ของจำนวนมาก ints และ แล้วเราก็พยายามที่จะไปที่หนึ่งที่สอง
มันเป็นเพียงข้อสรุป ที่อยู่ของคนแรกบวก 1
แต่จะไม่ be-- เพียงสมมุติว่า ที่อยู่ของคนแรกคือ 4
ที่นี่ในกรณีนี้
และถ้าเรารวมดังนั้นนี้ เป็นสิ่งที่เกิดขึ้น
เรามี int
int x เท่ากับ 5
X มีค่า 5
และเราเริ่มต้นชี้นี้ int และและ int ดาวเท่ากับที่อยู่ของ x
>> สมมติว่าที่อยู่ของ x คือ 4
สิ่งที่จะเกิดขึ้น ตอนนี้ถ้าผมรวมเพิ่ม 1 ถึง Y?
มันจะจริง ผลรวม 4 แทนเพียง 1
ดังนั้นผมจึงเพิ่ม 1 แต่มันเป็นจริง เพิ่ม 4 เพราะคอมพิวเตอร์สมาร์ท
ดังนั้นมันจะเพิ่มจริงโดยครั้งที่ฉัน ขนาดของประเภทของตัวชี้
OK?
>> ดังนั้นถ้าเป็นถ่านยกตัวอย่างเช่น ถ้าเป็นถ่านและดาว
และถ้าเราเพิ่ม 1 แล้วจะนี้ เป็น 5 เพราะถ่านเป็น 1 ไบต์นาน
ดีหรือไม่?
>> และในที่สุดเราก็มาถึง ตัวชี้และอาร์เรย์
แต่กลับกลายเป็นว่าทุกครั้ง คุณจัดการกับอาร์เรย์
คุณจริงเกี่ยวกับตัวชี้
เหตุผลความคิดที่ดีมากสำหรับ นี้คืออาร์เรย์มีขนาดใหญ่มาก
ดังนั้นอย่าลืมที่ผมบอกว่า ทุกครั้งที่คุณผ่านสิ่งที่อยู่รอบ ๆ
คุณคัดลอกทุกอย่าง
ดังนั้นถ้าคุณมีอาร์เรย์ ที่จริงๆใหญ่จริงๆ
คุณไม่ได้จริงๆต้องการที่จะ คัดลอกทุกอย่างทุกครั้ง
คุณจะผ่านมันไปรอบ ๆ ไปยังอีก ฟังก์ชั่นเนื่องจากว่าเป็นเพียง
จำนวนมหาศาลของการทำงาน
ดังนั้นสิ่งที่คุณทำคือเพียงแค่ที่ผ่านมา ที่อยู่ของไบต์แรก
และจากนั้นการทำงานจะมีการเข้าถึง องค์ประกอบทั้งหมดที่อยู่ในแถวที่
เพื่อให้คุณผ่านอาร์เรย์ตามที่อยู่ของมัน ดังนั้นที่อยู่ของไบต์แรก
>> ดังนั้นถ้าเราประกาศ int แถว 3 ที่นี่เรารู้ว่า
วิธีการเข้าถึงองค์ประกอบแรก ใช้เครื่องหมายวงเล็บ
ถ้าคุณจำวงเล็บ สัญกรณ์อาร์เรย์วงเล็บ 0 เท่ากับ 1
อย่างนี้จะเป็นว่า เช่นเดียวกับที่เพียงแค่ไปที่นั่นและนำ 1
ตกลงเป็นสิ่งเดียวกัน
ดังนั้นสัญกรณ์วงเล็บที่นี่ จะเป็นเช่นเดียวกับทางรถไฟสายนี้
>> และคาดเดาสิ่งที่สัญกรณ์วงเล็บ สำหรับวงเล็บอาร์เรย์ 1 จะเป็นอย่างไร
มันก็จะเป็นสิ่งเดียวกันเช่นนี้
เพื่อเพิ่มหนึ่งไปยังอาร์เรย์
ย้ายหนึ่งพร้อมในหน่วยความจำ
ไปที่นั่นและนำ 2
OK?
และบรรทัดนี้เป็นสิ่งเดียวกัน
เราต้องการที่จะไปที่สาม กล่องดังนั้นอาร์เรย์บวก 2
ไปที่นั่นและวาง 3
ดังนั้นในความทรงจำอะไร จะเกิดขึ้นคือเรา
จะมี 1, 2 และ 3 สามองค์ประกอบของอาร์เรย์นี้
>> เราอาจจะมีการกระทำเช่นนี้โดยใช้ สัญกรณ์วงเล็บเราคุ้นเคย
ผมแค่อยากพวกคุณจะรู้ว่า ว่าพวกเขามีสิ่งที่เหมือนกัน
ตกลงคำถามเกี่ยวกับเรื่องนี้?
สวย
ตอนนี้ผมกำลังจะไปส่ง มันไปยังฮันนาห์
>> ฮันนาห์: ยาย Yee หอ
>> บิงกี้: พูดคุยเกี่ยวกับ สิ่งที่หน่วยความจำและบทความ
[APPLAUSE]
>> ฮันนาห์: สวัสดีเย็นดังนั้นเรา จะพูดคุยนิด ๆ หน่อย ๆ
เกี่ยวกับหน่วยความจำซึ่งเราก็ ที่ใช้ตัวชี้
ดังนั้นจึงมีสองส่วนหลักของ หน่วยความจำที่เรากำลังเกี่ยวข้องกับ
เรามีกองซึ่งเติบโต ขึ้นมาในด้านล่างและกองซึ่ง
ไปลงมาจากด้านบน
และกองกำลังที่จะถือ ทั้งหมดของตัวแปรเช่นของเรา
ดังนั้นแต่ละเรียกฟังก์ชั่นได้รับ กรอบเล็ก ๆ น้อย ๆ ของตัวเองในกอง
ดังนั้นในขณะที่เกบกล่าวก่อนหน้านี้ถ้าเรา เรียกใช้ฟังก์ชันอีกครั้งและอีกครั้ง
เรากำลังจะแตก สิ่งที่ขึ้นในกอง
>> และในทำนองเดียวกันกอง ซึ่งเริ่มต้นที่ด้านบน
จะถือทั้งหมดของหน่วยความจำ ที่เราจัดสรรแบบไดนามิก
ดังนั้นในขณะที่เราแบบไดนามิก จัดสรรหน่วยความจำ,
นี้จะลงมาทางด้านล่าง
สิ่งที่คู่ที่จะตระหนักถึงเมื่อ เรากำลังใช้กองและกอง
กับสแต็คถ้าเรามีเกินไป many-- สมมุติว่าเรียก recursive,
และเรากำลังเรียกใช้ฟังก์ชันอีกครั้ง และอีกครั้งและอีกครั้งและอีกครั้ง
และมันก็ซ้อนขึ้น ซ้อนซ้อนขึ้น
และมันจะผิดพลาดเป็นกอง
เรากำลังจะวิ่งออกมาจากหน่วยความจำ
ที่จะก่อให้เกิด ปัญหาสำหรับคอมพิวเตอร์
และที่เรียกว่ากองล้น
นั่นคือสิ่งที่คุณแน่นอน ควรจะตระหนักถึงและพยายามที่จะหลีกเลี่ยง
และกองต้องจำไว้ ไม่ได้ตั้งใจรั่วไหลของหน่วยความจำ
เวลาที่คุณใช้ malloc ใด ๆ ไม่ได้ ลืมที่จะเป็นอิสระหน่วยความจำที่
มิฉะนั้นมันจะเพียงแค่ จะอยู่ในกองเสีย
และคอมพิวเตอร์จะไม่ทราบว่า มันเป็นอิสระที่จะใช้หน่วยความจำที่
ดังนั้นผู้ที่มีสิ่งที่สอง จะต้องระมัดระวังกับเมื่อ
คุณจัดการกับ กองและกอง
คำถามใด ๆ กับเรื่องนี้?
น่ากลัว
>> ตกลงเย็น
ดังนั้นชนิดนี้ได้เช่นเดียวกัน ความคิดที่เป็นกองล้นที่
เรากำลังจะเกิน ขอบเขตของสิ่งที่หน่วยความจำ
ที่เราควรจะสามารถที่จะใช้
เพื่อใช้เช่นบัฟเฟอร์หรือคุณ ก็อาจคิดว่ามันเป็นอาเรย์
และเรากล่าวว่าตกลงเราจะไป สร้างอาร์เรย์เล็ก ๆ น้อย ๆ นี้ดี
มันจะเป็นสตริง
หรือมันจะตัวละครที่จัดเก็บ
และมันก็แค่ไปทักทาย
และมันเป็นเรื่องที่ไม่แน่นอน
นั่นแหล่ะ
>> แต่ถ้าผมเป็นคนชั่วร้ายและความต้องการที่จะ ทำอะไรไม่ดีกับอาร์เรย์นี้สิ่งที่
ฉันจะทำคือการพยายามที่จะเขียน ที่ผ่านมาในตอนท้ายของสตริง
และเป็นคุณจะเห็นว่า ฉันเขียนไกลพอ
ที่จริงผมจะมีผลต่อ ที่อยู่ผู้ส่ง
และถ้าฉันเริ่มต้นที่จะส่งผลกระทบต่อ ที่อยู่ผู้ส่ง,
ฉันส่งผลกระทบต่อวิธีการที่โปรแกรมจริงทำงาน
และแทนที่จะกลับมาที่คุณ รู้สตริงมีความสุขเช่นสวัสดีฉัน
สามารถทำสิ่งที่ไม่ดีเช่นไปที่ ที่อื่นในเครื่องคอมพิวเตอร์ของคุณยังคง
หน่วยความจำเปลี่ยนมัน สิ่งที่ฉันต้องการที่จะทำ
เพื่อให้เป็นสิ่งนี้จะมีลักษณะ เป็นถ้าฉันเพียงแค่ชนิดของที่เต็มไปมันขึ้น
ที่มีค่าขยะแบบสุ่ม ในกรณีนี้เพียงแค่
และแล้วเมื่อฉันจริง ได้ไปอยู่หน่วยความจำ,
ผมเริ่มกรอกด้วยบางสิ่งบางอย่าง ที่ทำในสิ่งที่ผมอยากจะทำ
คำถามใด ๆ กับหน่วยความจำล้น?
น่ากลัวบินขวา ผ่านสิ่งนี้
>> ตกลงดังนั้นเราพูดคุยกันมากของ เกี่ยวกับตัวชี้กับเกบ
เราจะได้รับจริงตัวชี้?
เราไม่ได้รับที่อยู่ในหน่วยความจำได้อย่างไร?
ดีที่เราสามารถใช้นี้ดี ฟังก์ชัน malloc โทรซึ่ง
เป็นไปได้ ชิ้นส่วนเล็ก ๆ ของหน่วยความจำ
โดยเฉพาะใน กองที่เรากล่าวถึง
และมันจะทำให้คุณกลับมา ตัวชี้ไปยังที่อยู่ในความทรงจำที่
และเหตุผลที่เรา จะต้องให้การ malloc
เป็นเท่าใดพื้นที่ในหน่วยความจำที่เราต้องการ
>> ดังนั้นคุณจะเห็นขนาดในไบต์
สมมติว่าเช่นหรือ ที่จริงในตัวอย่างนี้
เราจัดสรรเพียงพอ พื้นที่สำหรับ 10 จำนวนเต็ม
ดังนั้นอาจจะเป็นสิ่งที่เรากำลังจะต้องการ ที่จะทำให้ที่นี่เป็น array ของจำนวนเต็ม 10
ดังนั้นเราจะให้มันขนาดของ ints ซึ่ง เราเรียนรู้ก็คือว่าหลายไบต์?
นักเรียน: 4
ฮันนาห์: 4, ที่สวยงามและเรา ต้องการของผู้ที่ 10 ในแถว
เพื่อให้เรามีพื้นที่เพียงพอที่จะ เก็บทุก 10 จำนวนเต็มในกรณีนี้
สิ่งที่สำคัญสุด เวลาที่คุณเรียก malloc,
คุณต้องตรวจสอบสำหรับ null
หากคุณไม่ได้ตรวจสอบ null ดี malloc ถ้ามันวิ่งออกไปจากพื้นที่
และไม่สามารถให้การใด ๆ หน่วยความจำมากขึ้นก็จะกลับมาเป็นโมฆะ
ดังนั้นถ้าคุณไม่ได้ตรวจสอบ malloc อาจจะกลับมาเป็นโมฆะ
แล้วถ้าเราพยายามที่จะ dereference ชี้โมฆะ
เรากำลังจะได้รับความผิดส่วน, ซึ่งเราจะพูดถึงในตอนนี้
น่ากลัว
>> ตกลงคำถามกับ malloc?
ใช่?
>> นักเรียน: การตรวจสอบเป็นโมฆะ [ไม่ได้ยิน] ไม่ได้ทำแบบทดสอบได้หรือไม่?
>> ฮันนาห์: แน่นอนว่าคำถามคือ ไม่ได้ matter-- แบบทดสอบ,
คุณจะได้รับคะแนนออกหาก คุณไม่ได้ตรวจสอบเป็นโมฆะ?
ใช่คุณจะได้รับคะแนนออก ถ้าคุณไม่ได้ตรวจสอบเป็นโมฆะ
ทุกครั้งที่คุณโทร malloc ทั้งใน แบบทดสอบและ psets ของคุณและในชีวิตจริง
คุณต้องตรวจสอบสำหรับ null
คำถามที่ดี
>> GABE: ถ้าผมไม่ได้ฟรีหรือไม่?
ฮันนาห์: เกบอยากจะรู้ว่า สิ่งที่ถ้าเราทำไม่ฟรี
จากนั้นเราก็จะมี หน่วยความจำรั่วในกองของเรา
ใด ๆ ที่คำถามอื่น ๆ ?
ใช่?
>> นักเรียน: you-- สามารถไปกว่า หน่วยความจำล้นจริงอย่างรวดเร็วอีกครั้งหรือไม่
>> ฮันนาห์: แน่นอน
คำถามคือเราสามารถไปกว่า หน่วยความจำล้นอย่างรวดเร็วจริงๆ
ลองกลับไปที่สไลด์
ดังนั้นบัฟเฟอร์คุณก็สามารถ คิดว่ามันเป็นอาเรย์ใช่มั้ย?
คุณมีพื้นที่ในหน่วยความจำบางส่วน
และเมื่อครั้งแรกที่เราสร้างอาร์เรย์ของเรา เรารู้ว่าอาร์เรย์มีการแก้ไขขนาด
หรือบัฟเฟอร์ของเรามีขนาดคงที่
>> ดังนั้นสมมติว่าในกรณีนี้เรามีเพียงแค่ พื้นที่พอที่จะเขียนสตริงสวัสดี
ถ้าเราไปในอดีตที่ถูกผูกไว้ถ้าเราไปที่ผ่านมา สิ่งที่อาเรย์ของเราที่เราบอกว่ามันอาจจะค้างไว้
เราจริงสามารถเริ่มต้น เขียนในหน่วยความจำ
ว่าคอมพิวเตอร์ไม่ได้ ต้องการให้เราเขียนลงใน
โดยเฉพาะถ้าเราตี สิ่งที่ต้องการผลตอบแทน
ที่อยู่ของฟังก์ชั่นที่ เช่นชิ้นส่วนอื่น ๆ ของหน่วยความจำ
เป็นเพียงหนึ่งในของคุณ คอมพิวเตอร์ของคุณสามารถจริง
เปลี่ยนที่และเริ่มต้นที่จะทำสิ่งชั่วร้าย
ตอบคำถามของคุณ?
น่ากลัวอะไรอีกหรือไม่
ใช่?
>> นักเรียนดังนั้นกอง [ไม่ได้ยิน] คุณ กล่าวว่าไปจากด้านล่างขึ้นไป
ในช่วงที่กองไม่ หน่วยความจำไปจากที่เช่น
ด้านบนลงที่เกี่ยวข้องกับแต่ละทำลาย?
>> ฮันนาห์: วิธีทำ you-- เลื่อนไปปล้นที่นี้
>> Rob: มันจะเจริญเติบโตได้ในที่เดียวกัน ทิศทางเป็นกองโต
ฮันนาห์: OK
Rob: ผมได้รับสับสน
นี้จะเป็นสิ่งที่เป็นนามธรรม
ฮันนาห์: OK
ปล้น: นี่คือที่ถูกต้อง
ดังนั้นหากสแต็คที่มีการเจริญเติบโต ขึ้นแล้ว generally-- มัน
ไม่จำเป็นต้องเป็นเช่นนี้ แต่คุณสามารถประกาศ int x
จากนั้นคุณประกาศ int และ
จากนั้น int x โดยทั่วไปจะมี ลดลงในสแต็คกว่า int และ
แต่นั่นเป็นเพียงความเป็นจริง
ที่ไม่ชอบสิ่งที่เมล็ดพันธุ์ที่มีความสำคัญ
>> ปล้นดังนั้นคำถามอีกครั้งเป็นเพียง สิ่งที่เกิดขึ้นแต่ละเฟรมสร้างขึ้น
ดังนั้นการทำงานของแต่ละคนได้รับ ชิ้นเล็ก ๆ ของสแต็ค
และเป็นคุณขึ้นไปภายใน ชิ้นส่วนเล็ก ๆ น้อย ๆ อยู่ในกรอบที่
เราจะบอกว่าตัวแปร ภายในกรอบที่ยังเลื่อนขึ้น
มีคำถาม?
>> ปล้น: เพียงแค่จะเป็นไมค์
ฮันนาห์: โอ้ใช่
Rob: ผมจะพูดเป็นคุณ
ฮันนาห์: โอ้ใช่ตกลง
Rob: ข้อยกเว้นคือ สำหรับอาร์เรย์และ structs,
ที่อาร์เรย์ที่ต่ำกว่า ดัชนีในอาร์เรย์
และใน structs ที่สูงขึ้น ข้อมูลใน structs
ได้รับการรับรองเป็นที่อยู่ต่ำกว่า กว่ามูลค่าต่อมาในอาร์เรย์
ดังนั้นผู้ที่ได้รับการรับรอง
แต่ตัวแปรใด ๆ ภายใน เช่น int x และ int และภายในฟังก์ชัน
ไม่มีความสัมพันธ์ที่จำเป็น ระหว่างที่อยู่ของพวกเขา
ฮันนาห์: คำถามมากกว่าที่นี่อีก?
นักเรียนดังนั้นในบัฟเฟอร์ การไหลเพียง Buffer Overflow
เพียง แต่เกิดขึ้นเมื่อคุณ ได้เช่นเดียวกับที่ได้รับมอบหมาย
ปริมาณของอาร์เรย์ นั้นเป็นมากขึ้น?
เหมือนได้ไหม
ดังนั้นหากคุณกำลังถามหา อะไรบางอย่างจาก user--
>> ฮันนาห์: MM-HM
นักเรียน: พวกเขาสามารถบังคับ ให้คุณได้อะไรกลับ
ที่มีขนาดใหญ่กว่าสิ่งที่ คุณได้รับการจัดสรรสำหรับพวกเขา?
ฮันนาห์: แน่นอนดังนั้น คำถามก็คือโดยทั่วไป
ผู้ใช้สามารถให้คุณ มากกว่าที่คุณขอ?
นักเรียน: ใช่
ฮันนาห์: ดีคุณสามารถป้องกันไม่ให้ ผู้ใช้จากการทำที่
คุณอาจจะบอกว่าโดยเฉพาะไม่ได้ ให้ฉันมากกว่า x จำนวนโดยไบต์
ฉันได้รับเพียงคุณเท่านั้นที่ห้องพักสำหรับ x จำนวน ไบต์, x จำนวนตัวอักษร
นั่นคือสิ่งที่คุณต้องการเพื่อป้องกันไม่ให้
ใช่?
ความแตกต่างระหว่างสิ่งที่ กองล้นและหน่วยความจำล้น?
>> ฮันนาห์: OK เพื่อสแต็ค overflow-- โอ้สิ่งที่
ความแตกต่างระหว่างสแต็ค ล้นและหน่วยความจำล้น?
ดังนั้นเราจึงต้องการที่จะคิดแตกล้น ที่เกิดขึ้นเมื่อเรากำลังจริง
ซ้อนเหล่านี้เรียกฟังก์ชัน
สมมติว่าคุณมีฟังก์ชันเวียนเกิด เพราะเรารู้ว่าทุกครั้งที่คุณ
เรียกใช้ฟังก์ชันก็จะได้รับ กรอบของตัวเองในกอง
>> ดังนั้นเรากองขึ้นสูงเกินไปและ จากนั้นเราเริ่มที่จะล้น
และเราจะใช้หน่วยความจำมากเกินไปและ เราไม่ได้ออกจากที่ใดก็ได้
เราได้รับข้อผิดพลาดที่
>> บัฟเฟอร์ล้นอยู่ในโปรแกรม
เราต้องการอาจจะไม่จำเป็นต้องมี วิ่งออกมาจากหน่วยความจำในทางเดียวกัน
ที่เราอาจจะถ้าเรากำลังซ้อน โทรปลุกฟังก์ชั่นมากมาย
แต่เราเขียนผ่านมาหน่วยความจำ ที่เรารู้ว่าเราสามารถใช้
และที่ช่วยให้เราสามารถทำสิ่งชั่วร้าย
ใช่?
>> ปล้น: ใช่คุณอาจต้องการ เพียงแค่ทำซ้ำนี้
แต่คุณยังสามารถคิด ของกองล้น
เหมือนชนิดที่ระบุ ของหน่วยความจำล้น
หรือคุณเพียงแค่คิดว่าของคุณ สแต็คเป็นกันชนใหญ่จริงๆ
จากนั้นเมื่อคุณล้นคุณสแต็ค, มันเป็นชนิดเช่นหน่วยความจำล้น
แต่กองล้นเป็นเพียง คำเฉพาะที่ใช้ในการสแต็ค
ตัวเองล้น
>> ฮันนาห์: ขวาเพื่อที่จะ ทำซ้ำสำหรับวิดีโอ
คุณสามารถคิดแตกล้นเป็น ประเภทเฉพาะของหน่วยความจำล้น
เย็น?
คำถามใด ๆ เพิ่มเติมก่อนที่เราจะไป?
น่ากลัว
>> ตกลงเย็นดังนั้นขอพูดคุยเกี่ยวกับ บางข้อความผิดพลาดที่พบบ่อย
นี่คือสิ่งที่มี แสดงขึ้นในหลายแบบทดสอบ,
บางสิ่งบางอย่างเพื่อให้คุ้มค่า การมองที่สอง
ฉันแน่ใจว่าคุณได้พบ อย่างน้อยบางส่วนของเหล่านี้
ในขณะที่คุณกำลังทำชุดปัญหาของคุณ
เพื่อให้แน่ใจว่าคุณสามารถพูดคุย เกี่ยวกับพวกเขาในการตอบคำถาม
>> ดังนั้นคนแรกคือ ความผิดส่วน
และนั่นคือสิ่งที่เราได้ตลอดเวลา พยายามที่จะเข้าถึงหน่วยความจำ
ว่าเราไม่ได้รับอนุญาตให้เข้าถึง
เพื่อให้คุณได้เห็น migh นี้ ตัวอย่างเช่นในการแหกคุก
หากตร​​วจพบการปะทะกัน กลับ null และจากนั้นคุณ
พยายามที่จะทำอะไรบางอย่าง ด้วยค่า null ที่
คอมพิวเตอร์จะให้ คุณผิดส่วน
ดังนั้นหนึ่งสิ่งสำคัญที่ต้อง ทำเพื่อที่จะพยายามที่จะหลีกเลี่ยงปัญหานี้
อยู่เสมอตรวจสอบ null
>> คุณอาจจะยังได้เห็น ประกาศโดยนัยของการทำงาน
ดังนั้นนี่คือสิ่งที่เกิดขึ้น เมื่อแอลลิสันแสดงให้เห็นว่าคุณ
วิธีการที่เราทำต้นแบบใช่มั้ย?
ดังนั้นสมมติว่าเรามีบาง ฟังก์ชันที่เรากำหนด
สมมติว่าก้อน
และที่ไปที่ด้านล่าง การทำงานของเราภายใต้หลัก
>> ถ้าเราลืมที่จะบอกเกี่ยวกับคอมพิวเตอร์ ก้อนเมื่อหลักพยายามที่จะเรียกก้อน
คอมพิวเตอร์จะเป็นเหมือนโอ้เอ้ย
ฉันมีความคิดสิ่งที่หมายถึงไม่มี
ผมไม่ทราบว่าจะทำอย่างไรที่นี่
ดังนั้นต้นแบบกล่าวว่าไม่ต้องกังวล
ฉันจะบอกคุณ
>> มันจะมา
อย่าตะโกนมาที่ผม
อย่าให้ฉันโดยปริยาย การประกาศของฟังก์ชั่น
ดังนั้นถ้าคุณได้รับข้อผิดพลาดนี้อย่างใดอย่างหนึ่ง สิ่งที่คุณจะต้องการที่จะทำ
คือทำให้แน่ใจว่าคุณมีต้นแบบของคุณ
OK?
>> และสุดท้าย แต่ไม่ท้ายสุด ระบุไม่ได้ประกาศ
เป็นหลักเมื่อคุณพยายามที่จะใช้ ตัวแปรที่คุณยังไม่ได้ประกาศ
ดังนั้นทั้งหมดในทันทีที่คุณเริ่มต้น พูดเช่น n บวกบวก
และคอมพิวเตอร์กล่าวว่าสิ่งที่ n?
คุณไม่เคยบอกผมว่าเป็นสิ่งที่ n
>> ดังนั้นสิ่งหนึ่งที่คุณต้องให้แน่ใจว่าคุณ ไม่เป็นบอกคอมพิวเตอร์สิ่งที่ n คือ
ดังนั้นสำหรับตัวอย่างเช่น n อาจเป็นจำนวนเต็ม
แล้วคุณจะหลีกเลี่ยงข้อผิดพลาดนี้
คำถามใด ๆ เกี่ยวกับข้อผิดพลาดที่พบบ่อย?
ใช่?
>> นักเรียน: สำหรับปริยาย การประกาศของฟังก์ชั่น
มันอาจจะยังเป็นไปได้ว่าคุณมองข้ามอย่างใดอย่างหนึ่ง ของห้องสมุดที่คุณควร
ที่จะรวมมากกว่าเดิม?
>> ฮันนาห์: ขวาดังนั้น คำถามคือคุณสามารถ
ยังได้รับข้อผิดพลาดนี้ถ้าคุณ ลืมที่จะให้บริการ ได้แก่ ห้องสมุด
>> นักเรียน: ใช่
>> ฮันนาห์: แน่นอน เพราะในทางเดียวกัน
ว่าเราต้องการที่จะนำต้นแบบของเรา ก่อนที่จะมีฟังก์ชั่นหลัก
ถ้าเรามีห้องสมุดที่จะไป เป็นหลักรวมถึงต้นแบบ,
รวมถึงคำนิยาม ฟังก์ชั่น
คำถามที่ดี
>> นักเรียน: สำหรับการแบ่งส่วน ความผิดจะว่ายัง
เกิดขึ้นถ้าเราเช่นพยายาม ในการเข้าถึงตัวแปร
เหมือนที่แตกต่างกัน [ไม่ได้ยิน] กว่าที่จะมีการประกาศอะไรบ้าง?
ฮันนาห์: แน่นอนดังนั้นเราจะ ได้รับความผิดส่วน
ถ้าเราพยายามที่จะเข้าถึง ตัวแปรออกจากขอบเขต?
นั่นคือคำถาม?
นักเรียน: ใช่
ฮันนาห์: Beautiful
ดังนั้นอาจจะเป็นคุณกำลังจะได้รับ ข้อผิดพลาดที่ระบุไม่ได้ประกาศแทน
จึงเป็นเพียงจะบอกว่า ผมไม่ทราบว่ามันคืออะไร
เย็นอะไรอีกหรือไม่
ใช่ตกลงสวยงาม
>> ทั้งหมด righty ดังนั้นการเรียกซ้ำ
ดังนั้นที่ผมกล่าวถึงสองสามครั้ง ที่เราอาจได้รับกองล้น
เพราะเรากำลังเรียกร้องของเรา ฟังก์ชั่นซ้ำหลายครั้ง
เราได้รับทุกกองเหล่านี้ เฟรม, blah, blah, blah
แม้สิ่งที่เป็นฟังก์ชัน recursive?
ดีฟังก์ชัน recursive เป็น ฟังก์ชั่นที่เรียกตัวเองใด ๆ
>> บางสิ่งบางอย่างที่จะตระหนักถึงเมื่อคุณ มีการดำเนินการการทำงานซ้ำ
อย่าลืมที่จะรวมถึงกรณีฐาน
กรณีฐานเป็น จุดที่เราจบ
ดังนั้นสำหรับตัวอย่างเช่นถ้าเรากำลังเข้ารหัส พูด, Fibonacci ซ้ำ
เราต้องการที่จะให้แน่ใจว่าเมื่อเราได้รับ ไปที่ 0 หรือหมายเลข Fibonacci แรก
เลขสองตัวนั้นมีกรณีเหล่านี้ เพราะผู้ไม่ได้ขึ้นอยู่
ในสิ่งที่มาก่อน
ผู้ที่มีค่าของพวกเขาเอง
>> ข้อดีบางอย่างที่จะเรียกซ้ำซึ่งเป็น คำถามที่เราเคยเห็นในอดีตแบบทดสอบ
พวกเขาสามารถนำไปสู่​​การมากขึ้น กระชับรหัสที่สง่างาม
และมากของฟังก์ชั่น, จำนวนมากของขั้นตอนวิธีที่แตกต่างกัน,
จริงยืมตัวให้เรียกซ้ำ
ความหมายของพวกเขาอาจจะ เวียนเกิดในตัวของมันเอง
ดังนั้นฟีโบนักชีเป็นหนึ่ง
เป็นหนึ่งในปัจจัย
ผสานการจัดเรียงคือ one-- ทั้งหมด สิ่งที่คุณสามารถมองไปที่
ตกลงคำถามหรือข้อสงสัย
ใช่?
>> นักเรียน: เป็นกรณีมุม คล้ายกับกรณีฐานหรือไม่?
หรือเป็นที่อื่น ๆ บางส่วน ชนิดของ [ไม่ได้ยิน]
>> ฮันนาห์: แน่นอนดังนั้น กรณีที่เป็นมุม any-- ดังนั้น
เป็นกรณีที่มุมเดียวกับกรณีฐาน?
กรณีมุมเป็นสิ่งที่คุณ รหัสอาจทำงานแตกต่างกันเล็ก ๆ น้อย ๆ
กรณีฐานที่เกี่ยวข้องการจัดเรียงของใน ว่าพวกเขากำลังเช่นกรณีโดยเฉพาะอย่างยิ่ง
ที่คุณต้องการที่จะมองไปที่
แต่ความคิดของกรณีฐานที่เป็นที่ คุณต้องการฟังก์ชันเวียนเกิดของคุณ
ที่จะหยุดในบางจุด
มันไม่สามารถให้เรียกตัวเองตลอดไป
มันต้องการที่จะหยุดในบางจุด
>> ปล้น: ใช่บ่อยกรณีฐานของคุณ อาจจะเป็นตัวอย่างของฐานมุม
>> ฮันนาห์: ขวาเย็นอะไร?
>> นักเรียน: คุณช่วยอธิบาย ฐานนิด ๆ หน่อย ๆ เพิ่มเติมหรือไม่
ฉันไม่เข้าใจ [ไม่ได้ยิน] กรณีฐาน
>> ฮันนาห์: ของกรณีฐาน?
>> นักเรียน: กรณีฐานใช่
>> ฮันนาห์: Oh yeah นั่นเอง
ลองมาดูกัน
เรามีชอล์กกว่าที่นี่?
ใช่ที่เราทำ
ตกลงอย่างรวดเร็วจริงๆผมจะ พยายามที่จะเขียนขนาดใหญ่พอ
เพื่อให้คุณสามารถเห็นบนหน้าจอ
เรามาพูดถึงจริงๆ ได้อย่างรวดเร็วฟีโบนักชี
ดังนั้นผมจะให้คุณลำดับฟีโบนักชี
คุณสามารถดูคำนิยาม
>> โดยพื้นฐานแล้วจำนวนในแต่ละลำดับ คือผลรวมของตัวเลขสองก่อนหน้านี้
ตกลงดังนั้นวิธีการที่ฉัน เพียงแค่อธิบาย Fibonacci,
คุณสามารถได้ยินเสียงเรียกซ้ำตัวเองใช่มั้ย?
เมื่อฉันกล่าวว่าจำนวนแต่ละคนเป็น ผลรวมของตัวเลขสองก่อนหน้านี้
เราอาจกล่าวได้ตกลง
ดีที่ n ฟีโบนักชี เลขจึงขอ
บอกว่าเรามีฟังก์ชั่นนี้ เรียกว่าตอแหล fib-- ของ n
เป็นไปได้เท่ากับปด ของ n ลบ 1 บวกขอโทษ
เราจะไปยังบรรทัดถัดไป กว่าตอแหลตรงนี้ของ n ลบ 2
>> ตกลงดังนั้นนี้ใช้งานได้ดีถ้าคุณอยู่ กำลังมองหาที่เช่นศูนย์หนึ่ง
สองสามสี่ จำนวนฟีโบนักชีที่ห้า
ที่คุณสามารถพูดได้ว่า 5 เท่ากับ 2 บวก 3
แต่สิ่งที่ถ้าคุณอยู่ที่จุดเริ่มต้น?
สิ่งที่ถ้าคุณเพียงแค่กดปุ่ม เหล่านี้ก่อนสองค่า?
>> ที่จะได้รับ 1 นี้คุณไม่สามารถ กล่าวเพิ่มก่อนหน้านี้สอง
เพราะเป็นศูนย์ที่ and-- ผมไม่ทราบ
ดังนั้นในบางจุดที่เราต้องการที่จะหยุด
ในบางจุดที่เราต้องการจะบอกว่าสิ่งเหล่านี้ สองก็มีความหมายของตัวเอง
จำนวน 0 Fibonacci เป็น 0
และจำนวนฟีโบนักชีแรกคือ 1
>> ดังนั้นวิธีที่ฉันอาจรหัสนี้ผม จะบอกว่าถ้า n มีค่าน้อยกว่าสองคน
แล้วก็กลับมา n
และนั่นจะเป็นกรณีฐานของฉัน
นั่นเป็นวิธีที่ฉันรู้ที่จะหยุด ด้วยฟังก์ชั่นแบบทั่วถึง
ที่ชัดเจน?
น่ากลัว
สิ่งอื่นในการเรียกซ้ำ?
สวยงาม
>> ขออย่างรวดเร็วพูดคุยเกี่ยวกับ การค้นหาและเวลาทำงานการจัดเรียง
แล้วฉันจะให้ Davin บาง เวลาที่จะพูดคุยเกี่ยวกับการเขียนโปรแกรมตัวอย่าง
ดังนั้นนี่คือการค้นหาหลักและ ทุกประเภทที่คุณควรรู้เกี่ยวกับ
Guarantee-- ฉันไม่สามารถรับประกัน, เพราะผมยังไม่เคยเห็น quiz--
แต่เรื่องนี้ขึ้นมาทดสอบ หลังจากทดสอบหลังจากเลิก
ดังนั้นแน่นอนใช้แผนภูมินี้
เช่นใช้แผนภูมินี้
วางลงบนแผ่นโกงของคุณ
คุณจะเป็นคนที่มีความสุข
>> นี้บอกเราครั้งการทำงานของแต่ละ ของการจัดเรียงและค้นหาเหล​​่านี้ขั้นตอนวิธี
ดังนั้นการค้นหาเชิงเส้นที่คุณสามารถดูการทำงาน เวลาเดียวกันที่มีการค้นหาไบนารี
ไปกว่าสิ่งที่กลไกเหล่านี้ ทำความคิดทั่วไป
ดู pseudocode บาง หากไม่ได้รับรหัสตัวเอง
>> คุณจะเห็นการจัดเรียงฟองที่มีบน ผูกพันในกรณีที่เลวร้ายที่สุดของ n ยกกำลัง
ดังนั้นถ้าอาร์เรย์ของเราได้อย่างสมบูรณ์ ย้อนกลับไปก่อนที่เราต้องการในการจัดเรียง,
เราจะบอกว่านั่นคือ จะใช้ขั้นตอนที่ยกกำลัง n
แต่ในกรณีที่ดีที่สุดเพื่อให้ ขอบเขตล่างสำหรับกรณีที่ดีที่สุด
เป็นไปได้ว่าจะเป็น แล้วแยกอย่างสมบูรณ์แบบ
แล้วสิ่งที่เราต้องทำคือ ตรวจสอบว่ามีการแยก
มีคำถามที่นี่?
>> นักเรียน: เมื่อจะ คุณต้องการที่จะใช้การจัดเรียง?
การจัดเรียง
ฉันอยากรู้เพียง
>> ฮันนาห์: เมื่อคุณจะ ต้องการที่จะใช้การจัดเรียงตัวเลือก?
หนึ่งนี้?
หนึ่งที่ยกกำลัง n ในทั้งสองกรณี?
>> นักเรียน: [ไม่ได้ยิน]
>> ฮันนาห์: แล้วมันแตกต่างกันมาก
หากคุณมีความเฉพาะเจาะจง ข้อกำหนดสำหรับโปรแกรมของคุณ
สิ่งที่ต้องการเช่นถ้าเราเพียงแค่กล่าวว่า ใช้ sorry-- search--
ดำเนินการจัดเรียงที่คุณจะ อาจต้องการที่จะไป
สำหรับหนึ่งในคนที่ มีกรณีที่ดีที่สุดของ n,
หรือผูกไว้ที่ต่ำกว่าในกรณีที่ดีที่สุดของ n
แต่อาจจะมี บางสิ่งที่ต้องการพูด
แลกเปลี่ยนจริงๆ ราคาแพงด้วยเหตุผลบางอย่าง
แล้วคุณต้องการจะทำ การจัดเรียงฟองเพราะคุณ
ต้องทำมากมาย แลกเปลี่ยน, สิ่งที่ต้องการที่
ใด ๆ ใช่ other--?
>> นักเรียน: มันจะเป็น [ไม่ได้ยิน] ที่จะบอกว่า [ไม่ได้ยิน]
ฮันนาห์: นั่นเป็นสิ่งหนึ่งที่ ที่จะบอกคุณ
ถ้าคุณกำลังมองหาที่การดำเนินการ
วิธีที่ฉันจะจริง คิดเกี่ยวกับเหตุผลที่มันเป็น n
กำลังสองคือการที่เราต้องทำงาน ผ่านแถวของเรามีความยาว n,
ทำให้เวลาที่มากที่สุด, n แลกเปลี่ยนกัน
และเราจะต้องทำกระบวนการ n ครั้งนี้
>> ดังนั้นเมื่อคุณจะต้องทำมากที่สุด, n แลกเปลี่ยนและ n ไหลผ่านอาร์เรย์
มีจะได้รับการยกกำลัง n
แต่ใช่นี้จะถูกเปิดเผย ผ่านคู่นี้สำหรับห่วง
เป็นคำถามที่ asked-- หรือ ซ้อนกันสำหรับวงผมควรจะพูดว่า
OK?
>> แล้วรวมการจัดเรียงที่ คือการจัดเรียงที่เร็วที่สุดที่เราตอนนี้
หรือว่าเราได้ครอบคลุมใน CS50, รู้ว่าขั้นตอนวิธีหลักคือ
ความคิดของการทำลายลงในนี้ ชิ้นที่เรียงลำดับแล้ว
การควบรวมกิจการเข้าด้วยกันบิตแยกเหล่านี้
และจะได้รับเรา log n log n
คำถามใด ๆ เกี่ยวกับการค้นหาและ ทุกประเภทก่อนที่ผมจะผ่านมัน?
ลองมาดูกัน
>> โอ้รายการเชื่อมโยง
ขอโทษนะฉันมีหนึ่งหัวข้อเพิ่มเติม
ตกลง, น่ากลัว, รายการเชื่อมโยง
ปัญหากับอาร์เรย์, พวกเขามีขนาดคงที่
ดังนั้นถ้าคุณไม่ทราบว่าใหญ่ ใส่ของคุณเป็นไปได้,
คุณไม่ต้องการที่จะสร้างอาร์เรย์
เพราะถ้าเราสร้าง อาร์เรย์ที่มีขนาดเล็กเกินไป
เราอาจจะใช้เป็นหน่วยความจำล้น
>> ดังนั้นแทนที่จะเราสามารถทำอะไรบางอย่าง กับรายการที่เชื่อมโยงซึ่ง
ช่วยให้เรามีแบบไดนามิก โครงสร้างข้อมูลขนาด
ที่จะช่วยให้เราเก็บ จำนวนเงินที่มีความยืดหยุ่นมากขึ้นของข้อมูล
ดังนั้นในแต่ละโหนดในของเรา รายการที่เชื่อมโยงเรามีสองชิ้น
เรามีค่าที่เกิดขึ้นจริงที่จะเก็บ
เพื่อให้เป็นเพียงสิ่งที่คุณต้องการ เห็นในอาร์เรย์ตัวอย่างเช่น
และจากนั้นเรายังติดตาม ตัวชี้ไปยังสิ่งต่อไปในหน่วยความจำ
>> ซึ่งแตกต่างจากอาร์เรย์ซึ่ง เรารู้ว่าทุกคนจะ
เพื่อ be-- องค์ประกอบมากมายเป็นหนึ่งทั้งหมด หลังจากที่อื่นใน memory-- เชื่อมโยง
รายการอาจจะเป็นที่ใดก็ได้ในหน่วยความจำ
พวกเขากำลังสถานที่โดยพลการ
ดังนั้นถ้าเราจะ จริงไปพบพวกเขาเรา
จำเป็นที่จะต้องติดตาม สิ่งต่อไปในรายการของเรา
>> และจากนั้นก็เพื่อที่จะทราบ ที่รายการที่รวมคือ
ทั้งหมดที่เราต้องติดตามคือ องค์ประกอบแรกในรายการที่เชื่อมโยงของเรา
และที่จะช่วยให้เราสามารถปฏิบัติตามผ่าน
>> ดังนั้นนี่คือวิธีการที่คุณอาจกำหนดโหมด
นี้เป็นโอกาสที่ดี เพื่อใช้ประโยชน์จาก structs
เพราะคุณมีความคิดนี้ดี สำหรับโหนดให้ฉันมีสองชิ้น
ฉันมีค่าที่แท้จริงของตัวเอง
และแล้วฉันมีตัวชี้ไปยัง องค์ประกอบถัดไปในรายการที่เชื่อมโยง
ดังนั้นคุณจะเห็นเรามีจำนวนเต็ม n, ซึ่งจะเป็นมูลค่าที่เกิดขึ้นจริง
แล้วชี้ไปยัง โหนดที่เรียกว่าต่อไป
เพื่อให้เป็นไปได้ต่อไป องค์ประกอบในรายการที่เชื่อมโยงของเรา
นักเรียน: ใช่?
คุณมีเพื่อระบุว่า ดาวเป็นเช่น struct?
>> ฮันนาห์: ใช่ดังนั้นตั้งแต่นี้ เป็นเหมือนชนิดของ,
ดูเหมือนว่า recursive ความหมายในเราที่
ต้องรู้ว่าอะไรเป็นโหนด ภายในเพื่อหาโหนด
เพราะมันไม่จริง รู้ว่าสิ่งที่โหนดจะสมบูรณ์
จนกว่าเราจะได้รับไปยังจุดสิ้นสุดของเจ้านี่ และหลังจากนี้เราก็สามารถเรียกมันว่า
node-- ภายในของคำนิยามนี้, เราต้องการที่จะเรียกว่าโหนด struct
คำถามที่ดี
อะไรอีกหรือไม่
ใช่?
>> นักเรียน: ทำไมเรา ต้องบอกว่าโหนดสองครั้ง
เพราะเมื่อเราอยู่ใน [ไม่ได้ยิน] เราก็มีที่จะทำในอัฒภาค
แต่ตอนนี้เราต้องไปหาที่ struct โหนด? [ไม่ได้ยิน]
ฮันนาห์: ดังนั้นผมเชื่อว่า ในตัวอย่างที่ผ่านมา
เราได้เพียงแค่การสร้างตลอดเวลาที่คุณ อยากจะใช้นักเรียนหลังจากนั้นคุณ
ต้องใช้ struct node-- ฉัน sorry-- struct นักเรียน
นี้ได้รับอนุญาตให้เราหลังจากที่ความเป็นจริงเพียง การใช้โหนดเพิ่มรูปแบบใหม่เป็นหลัก
ทำให้รู้สึก?
ดังนั้นเราจะต้องกลับไปและ ดูรหัสก่อน
แต่ผมเดาว่า เราไม่ได้ใช้ typedef
และเราถามคำถามที่ ทำไมเราต้องใช้ typedef?
typedef ช่วยให้เราสามารถหลีกเลี่ยง struct คำในการเริ่มต้น
ใช่?
นักเรียน: การจัดเรียงของสิ่งที่ คำถามจะเกิดขึ้น
ในแง่ในแง่ของ โหนดและรายการเชื่อมโยง?
>> ฮันนาห์: ดังนั้นสิ่งหนึ่งที่เราอาจจะบอกว่า คุณอาจจะค้นหาผ่านทางรายการที่เชื่อมโยงหรือไม่?
ตกลงเพราะ เล็ก ๆ น้อย ๆ ที่ซับซ้อนมากขึ้น
กว่าถ้าเรากำลังค้นหา ผ่านแถว
เราก็สามารถดูองค์ประกอบศูนย์ องค์ประกอบหนึ่งองค์ประกอบสอง blah, blah,
blah
ถ้าเราต้องการที่จะค้นหา ผ่านรายการที่เชื่อมโยง
เราจริงจะต้องปฏิบัติตาม เขาวงกตเล็ก ๆ น้อย ๆ ของตัวชี้
จึงขอจริงไป ผ่านทางนี้ได้อย่างรวดเร็วจริงๆ
สิ่งที่เราจะทำใน สั่งซื้อ to-- สมมุติว่าเรา
ต้องการเพียงแค่ย้ำผ่าน รายการที่เชื่อมโยงทั้งหมดของเรา
เราจะเริ่มต้นที่หัว
และจากนั้นในการที่จะ ย้ายไปยังองค์ประกอบต่อไปนี้
แทนเพียงการเพิ่มโดยหนึ่ง เหมือนอย่างที่เราอาจจะผ่านในอาร์เรย์
เรากำลังจะไปจริง ทำตามตัวชี้ต่อไป,
เพื่อให้เราสามารถหาที่อยู่ใน หน่วยความจำองค์ประกอบต่อไปคือ
ดังนั้นผมรู้ว่ามันไม่พอที่จะ ใช้เวลาทั้งหมดนี้ในตอนนี้
แต่คุณจะต้องสไลด์เหล่านี้
เพื่อให้คุณสามารถไปผ่าน นี้เล็กน้อยช้ากว่า
แต่เป็นหลัก, สิ่งที่เราต้องการ ที่จะทำคือการทำตามคำแนะนำเหล่านี้
ผ่านความสมบูรณ์ของรายการที่เชื่อมโยง
ดังนั้นนี่คือคำถาม คุณอาจจะถาม
>> สิ่งที่จะเห็นด้วย แทรกสมมติว่า
เราต้องการที่จะนำองค์ประกอบใหม่ ที่ด้านหน้าของรายการที่เชื่อมโยงของเรา
เราจะต้องระวังให้มาก เกี่ยวกับคำสั่งที่เรา
กำหนดตัวชี้
เพราะสมมุติว่าผมแค่บอกว่าโอเค
ทำให้จุดหัวถึงองค์ประกอบใหม่นี้
เพียงแค่ทำให้มันชี้ไปที่ 1 แล้วเราได้ เป็นหลักที่หายไปส่วนที่เหลือของรายการของเรา,
เพราะผมจำไม่ได้ที่ 2 ชีวิต
>> ดังนั้นเราจึงต้องทำใน เพื่อที่เฉพาะเจาะจงมาก
ครั้งแรกที่เราทำใหม่ จุดองค์ประกอบที่ศีรษะ
และจากนั้นเราจะทำให้หัว ชี้ไปที่องค์ประกอบใหม่
ดังนั้นเรามาดูสิ่งที่ดูเหมือนว่า กับ arrows-- เช่นเดียวกับที่
เพื่อให้คุณมีใหม่ครั้งแรก จุดองค์ประกอบที่ศีรษะเก่า
และตอนนี้เรามีหัว ชี้ไปที่องค์ประกอบแรกใหม่
คำถามใด ๆ กับเรื่องนี้?
>> ตกลงนี่คือรหัสบางครั้งบางสิ่งบางอย่าง ดูนิด ๆ หน่อย ๆ ในภายหลัง
และตอนนี้ฉันจะเปลี่ยนมันไปยัง Davin สำหรับ GDB และนิด ๆ หน่อย ๆ ของการปฏิบัติ
การเข้ารหัสบนกระดาษ
สวยงาม
>> ปล้น: และร็อบ
>> ฮันนาห์: โอ้ Davin และร็อบ
ฉันขอโทษ
>> นักเรียน: วู!
>> ปล้นขอบคุณ
>> Davin: คุณต้องการที่จะบอกว่า ทุกอย่างรวดเร็วจริง?
Rob: ใช่ใช่
Davin: เมื่อฉันขึ้น
ตกลงขณะที่ร็อบทำให้ ไมโครโฟนที่ดังนั้นสิ่งที่เป็น GDB?
ทุกคนควรจะได้เห็นใน GDB ชั้นและในเวลาทำการ
และคุณควรจะใช้มัน
ดังนั้นสิ่งที่ GDB คืออะไร?
ใคร?
>> นักเรียน: มันเป็นบั๊ก
>> Davin: มันเป็นบั๊ก
และมันก็ไม่สิ่งที่ช่วยให้คุณจะทำอย่างไร?
เช่นทำไมเราชอบ GDB?
นักเรียน: ในการชะลอตัวลงโปรแกรม
Davin: ขวาเพื่อให้คุณสามารถเดิน ผ่านมันชอบฝีเท้าของมนุษย์
และเพื่อให้สิ่งที่เป็นบางส่วน คำสั่งที่คุณจะทำอย่างไร
ดีแตกน่าจะเป็น คำสั่งที่คุณชื่นชอบ
เพราะเห็นว่าจะช่วยให้คุณทำลาย โปรแกรมจริงและเดินผ่านมัน
ทีละบรรทัด
>> เรียกใช้ช่วยให้คุณสามารถเรียกใช้
ต่อไปเช่นการก้าวผ่าน
มีอะไรต่อไปและระหว่างขั้นตอน?
รอบอกว่าออกมาดัง ๆ
มันเป็นที่ถูกต้อง
>> นักเรียน: [ไม่ได้ยิน]
>> Davin: ใช่น่ากลัว
ดังนั้นเหมือนขั้นตอนต่อไปและถ้า you're-- สมมติว่าคุณมีฟังก์ชั่นที่คุณ
กำหนด
สมมติว่าในบางฟังก์ชั่นหลักของคุณ และคุณเพียงแค่กดปุ่มถัดไปถัดไป
ต่อไป
คุณจริงไป ดำเนินการฟังก์ชั่นที่
แต่คุณกำลังจะกระโดดข้ามมัน
ถ้าคุณกดขั้นตอนหรือ หรืออะไรก็ตามที่คุณ
จะกระโดดจริง ในการทำงานนั้น
และจากนั้นคุณสามารถกดต่อไป ที่จะเห็นสายที่แตกต่างกัน
ภายในฟังก์ชันนั้น
ใช่?
>> นักเรียน: มีวิธี เพื่อกระโดดเหมือนกลับออก?
Davin: เสร็จสิ้นใช่ จบด้วยการกระโดดให้คุณออก
ดังนั้นมันจะไปจบที่ ฟังก์ชั่นและจากนั้นคุณ
จะกลับมาอยู่ในหลักตัวอย่างเช่น
พิมพ์จะพิมพ์ออกมาครั้งหนึ่ง
สิ่งที่ผมมักจะใช้คือการแสดง
การแสดงผลจะพิมพ์ออกมา อย่างต่อเนื่องตลอดทั้งหมด
ของโปรแกรมของคุณ
>> ตัวอย่างเช่นถ้าคุณกำลัง ในการห่วงและคุณ
ต้องการที่จะเห็นวิธีการบางอย่างที่เปลี่ยนแปลง และคุณไม่ต้องการที่จะเหมือนอย่างต่อเนื่อง
จะทำเช่นการพิมพ์ พิมพ์พิมพ์จอแสดงผล
จะแสดงตัวแปรที่ อย่างต่อเนื่องทุกครั้งที่คุณตีต่อไป
และดำเนินการต่อ
ดังนั้น GBD ที่ GDB
>> นักเรียน: มีอะไรอย่างใดอย่างหนึ่ง ที่คุณ [ไม่ได้ยิน]
Davin: มันคืออะไร?
>> นักเรียน: มีอะไรยกกำลัง ตัวแปรท้องถิ่น
Rob: มีบางอย่างที่เป็นจริง เหมือนชาวบ้านหรือสิ่งที่
ฉัน can't--
>> Davin: มันอาจจะ สิ่งที่ต้องการที่ใช่
>> ฮันนาห์: ในชาวบ้าน?
>> Davin: นั่นแหล่ะ
ที่หนึ่ง
ปล้น: Beautiful
>> Davin: ใช่
>> นักเรียน: อะไรยังคงทำอย่างไร
>> Davin: มัน continues-- จึงเป็นเพียง จะยังคงโปรแกรมของคุณ
ดังนั้นถ้าคุณทำลายและตี ต่อไปก็จะ
เพียงแค่เรียกใช้โปรแกรมที่จนกว่า มันกระทบหยุดพักอีกครั้ง
ดังนั้นสำหรับตัวอย่างเช่นถ้าคุณ ยากจนในการทำงาน,
และคุณกำลังจะทำเหมือน ห่วงหรือสิ่งที่ต้องการที่
และคุณตีดำเนินการต่อก็จะ ดำเนินต่อไปและกลับไปพักที่
หรือมีการหยุดพักไม่มีมันจะ อย่างต่อเนื่องและจบโปรแกรม
>> Rob: ชอบดังนั้นเพียงแค่หยุดทำงาน ที่จุดพักแรก
คุณจะตีถ้าคุณแล้ว ตีอย่างต่อเนื่องก็จะเก็บ
ไปจนกว่าจะมีจุดพักต่อไป
แล้วดำเนินการต่อจะไป เพื่อจุดพักต่อไป
Davin: คำถามใด ๆ ที่อื่น ๆ ใน GDB?
ดังนั้นผมคิดว่าในอดีตที่ผ่านมา เราได้ถามคุณว่า
GDB เป็นและให้ ตัวอย่างของบางสิ่งที่คุณ
สามารถทำอะไรกับ GDB ดังนั้น ง่ายจริง แต่ใช่
มีคุณไป
และโหนด?
>> ปล้น: ใช่ดังนั้นทิศทางที่เป็นมันได้หรือไม่
นักเรียน: นั่นคือมัน
Davin รอ
Rob: ผู้ชายคนนี้?
Davin: ที่หนึ่ง
Rob: ผู้ชายคนนี้, โอ้ผมไม่ทราบ
ดังนั้นเราจึงไม่ชัดเจน สิ่งที่ฉันไม่ได้ยกกำลัง
รู้ว่าใครมัน was-- แต่คำถาม
เราไม่ทราบว่าสิ่งที่คุณ ถามเกี่ยวกับเรื่องนี้ดังนั้นเพียง
เพื่อชี้แจงบางสิ่งบางอย่าง
ดังนั้นก่อนเช่นฉันกล่าวก่อน typedef คุณมักจะใช้เพียง
สร้างชื่อเล่นสำหรับประเภท
ดังนั้นที่นี่ชื่อเล่นเรา สร้างเป็นประเภทนี้โหนด struct
>> ดังนั้นก่อนไม่สนใจโหนดในนี้ typedef ดังนั้นนี้หยิกโหนด struct
รั้งลงไปหยิกต่อไป รั้งเป็นชนิดที่โหนด struct
และเราจำเป็นต้องโหนที่ มีขึ้นเพราะเรา
ต้องอ้างอิงโหนดในที่นี่
ดังนั้นด้วยการเรียงลำดับของ struct recursive นี้ คุณต้องการที่จะให้นี้ struct ชื่อ
หรืออื่น ๆ ที่คุณทำไม่ได้ พูดโหนด struct ที่นี่
ขณะที่ก่อนกับนักเรียน เมื่อเราได้พิมพ์ผมคิดว่า
เราไม่ได้มีการบอกว่า นักเรียนมีขึ้นเพราะเรา
ไม่ได้มีการบอกว่า struct นักเรียนภายใน struct ตัวเอง
ดังนั้นจึงเป็นซ้ำว่า กองกำลังสหรัฐที่จะบอกว่ามีโหนด
>> โหนดนี้เป็นเพียงชื่อที่เรากำลัง ให้โหนดสำหรับ typedef
ดังนั้นโหนดที่ไม่ได้ เช่นเดียวกับการโหนที่
แต่โหนด struct นี้ เช่นเดียวกับโหนด struct ที่
Davin: ดังนั้นเมื่อใดก็ตามที่คุณโทร เช่นโหนดในฟังก์ชั่นหลักของคุณ
คุณไม่ได้ไป ต้องบอกว่าโหนด struct
คุณก็สามารถบอกว่าโหนดเพราะ โหนดต่างออกเป็นพื้น
คุณกำลังจะบอกว่าตกลง
แทนที่จะต้องเรียก โหนด struct ในรหัสของฉัน
ผมแค่อยากจะเปลี่ยนชื่อ เป็นโหนดที่จะทำให้มันง่ายขึ้น
>> ปล้น: ถ้าคุณเสมอ ใช้ typedef แล้วนี้
เป็นสถานที่เดียวที่คุณจะต้อง การประกาศตัวแปรที่มีโหนด struct
ดาราใช่
>> Davin: OK ดังนั้นส่วนสุดท้าย เป็นเรื่องยากที่จะสอน because--
ปล้น: อะไรนะ?
>> Davin: เพราะมันเข้ารหัสบนกระดาษ
ดังนั้นทุกปีเรามี โค้ดบนกระดาษคำถาม
ดังนั้นผมคิดว่าเมื่อปีที่แล้ว, 12 ออกจาก 80 คะแนนเป็นรหัสลงบนกระดาษ
ปีก่อนที่ 10 จาก 80, ปีก่อนที่ 20 จาก 100
จึงค่อนข้างน้อยของเหล่านี้
ดังนั้นคุณจะต้องสามารถ โค้ดขึ้นฟังก์ชันเหล่านี้ด้วยมือ
>> ดังนั้นผมจึงคิดว่าเราอาจจะผ่านไป คู่ของพวกเขาและดูว่าคนทำ
ชนิดของเดินผ่าน พวกเขาช้าด้วยคน
ดังนั้นโดยทั่วไป strlen และ atoi ได้รับความนิยมมาก
ปีที่แล้วผมคิดว่าเรามี GetPositiveInt และ RandomInt
แต่ธารดังนั้นอำนาจยัง บวกหนึ่งเกินไป
ขอเพียงผ่านไปอาจจะ หนึ่งหรือสองของเหล่านี้ร่วมกัน
อะไรคือสิ่งที่ผู้คนต้องการที่จะเห็น?
>> นักเรียน: atoi
นักเรียน: ใช่
Davin: atoi?
นักเรียน: [ไม่ได้ยิน]
Davin: ตกลงฉันจะ ที่จะทำมันขึ้นมาบนเรือ
คุณมีการตั้งค่า ถ้าผมทำมันได้ที่นี่หรือที่นั่น?
มีเกบบอกว่ามี
>> Rob: และนี่คือความคิดทั่วไป คำถามเหล่านี้การเข้ารหัส
พยายามที่จะเขียนบางสิ่งบางอย่าง
อย่าปล่อยให้มันว่างเปล่า
>> Davin: ใช่
Rob: ถ้าคุณได้รับ กลับชนิดที่ถูกต้อง
หรือบางทีเราอาจจะเอาไปให้ คุณ แต่ถ้าคุณสามารถจะทำได้เหมือน
เขียนลายเซ็นการทำงานโดยทั่วไป ถ้าคุณได้รับกรณีฐานที่ถูกต้อง
หรือกรณีที่มุมหรือ จดจำการตรวจสอบเป็นโมฆะ
ตราบใดที่คุณมี สิ่งแล้วบางทีเรา
สามารถให้คุณทั้งคู่ ชี้ปัญหา
ไม่เพียงแค่ปล่อยให้มันว่างเปล่า
>> Davin: ใช่และถ้าคุณ เป็นเพียงสมบูรณ์
นิ่งงันที่วิธีการ จริงเปลี่ยนเป็นรหัส
ถ้าคุณเขียน pseudocode, ที่ดีสวยเกินไป
ดังนั้นมันก็เหมือนมันเป็นคำถามที่หกจุด และคุณเขียน pseudocode ที่ถูกต้อง
คุณจะได้รับอย่างน้อยสองจุด
จึงไม่เพียงแค่ปล่อยให้พวกเขาว่างเปล่า
พยายามที่จะนำบางสิ่งบางอย่าง
>> Rob: มันจะต้องมีการ pseudocode ที่ถูกต้อง แต่
>> Davin: ใช่
Rob: ดังนั้นเราจึงมักจะมีน้อย ผ่อนปรนมีข้อบกพร่องใน pseudocode
Davin: OK เพื่อให้พวกคุณ อยากจะเห็น atoi
ตกลงดังนั้นเพียงนะ ดังนั้นสิ่งที่คุณต้องการจะทำ
คือคุณกำลังจะเป็น กำหนดชนิดของตัวเลขบางอย่าง
แต่จำนวนนี้ไม่ได้ จะเป็น int ใช่มั้ย?
สิ่งที่มันจะเป็นอย่างไร
>> นักเรียน: [ไม่ได้ยิน]
>> Davin: มันจะเป็นสตริงใช่มั้ย?
ดังนั้นหากคุณได้รับ string-- สมมุติว่า
>> ปล้นผมควรจะดึงการแก้ไข?
ฉันสามารถดึง up--
>> Davin: โอ้, คุณต้องการที่จะทำมัน on--
>> Rob: คุณต้องการที่คณะกรรมการหรือไม่
>> Davin: สิ่งที่คุณต้องการจะทำอย่างไร?
ผมหมายถึงว่าคุณต้องการที่จะทำมันด้วยมือ?
หรือคุณต้องการที่จะทำมันโดยคอมพิวเตอร์?
>> Rob: มันทำด้วยมือ
>> Davin: [หัวเราะ]
Rob: มันทำด้วยมือ
>> Davin: ตกลงดังนั้นจึงเป็นไปได้ atoi
ดังนั้นสิ่งที่พูดไปผมหมายความว่าเราจะ อาจจะให้กับคุณ
แต่สิ่งที่มันจะกลับมา?
>> นักเรียน: Int
>> Davin: มันจะกลับ int ใช่มั้ย?
So-- ฉันไม่ต้องการที่จะทำมันมี
ฉันจะทำมันที่นี่
>> Rob: คุณสามารถดึงมันลง แล้วดันขึ้นบน
>> Davin: ใช่
[หัวเราะ] การเปลี่ยนแปลงเกม
ตกลงดังนั้นจึงเป็นไปได้ atoi int, และสิ่งที่มันจะใช้เวลา?
ดาวถ่านดังนั้นเพียง สตริงดาววินาที, เช่นนั้น
>> Rob: ดีดาวดี
Davin นี้อาจจะไม่ได้อยู่ที่นั่นตกลง
ปล้น: ใช่
Davin: OK เพื่อครั้งแรก สิ่งที่คุณต้องการ do-- ฉัน
ไม่ทราบว่าใครมอง ที่ solutions-- ปฏิบัติ
แต่สิ่งที่คุณกำลังจะ เพื่อต้องการจะทำคือคุณ
จะต้องการที่จะมี ห่วงเพราะคุณ
จะต้องการจริง ก้าวผ่านสายนี้
ดังนั้น helpful-- จึงขอบอกว่า เราจะให้ห่วง
และเรากำลังจะก้าวผ่าน องค์ประกอบของสตริงทุก
นานเท่าไหร่ที่ว่าคืออะไร?
กี่ครั้งที่เรากำลังจะไป เพื่อย้ำในที่สำหรับวง?
นักเรียน: Sterln?
Davin: Sterln ใช่
ดังนั้นสมมติว่ามีความยาวเท่ากับ int sterln S
และอยากรู้อยากเห็นเพียงแค่ว่าทำไมมันเป็นเสมอชนิด ของดีกว่าที่จะทำนอกของลูปนี้หรือไม่?
เช่นทำไมมันจะดีกว่าที่จะเรียก ฟังก์ชันนี้ด้านนอกของวง?
เพียงแค่มีสุขภาพจิตดีได้อย่างรวดเร็วตรวจสอบ?
ใช่?
นักเรียน: เพื่อให้คุณไม่ได้ ต้องให้ตรวจสอบมัน
คุณก็สามารถ [ไม่ได้ยิน]
>> Davin: แน่นอนดังนั้นใช่ ว่าสิ่งที่เธอบอกว่า
ดังนั้นเราจึงไม่จำเป็นต้องให้การตรวจสอบมัน
ดังนั้นสำหรับตัวอย่างเช่นถ้าฉันโทร ฟังก์ชันนี้ภายในห่วง
แล้วฉันจะให้โทร ฟังก์ชันนี้หลายครั้ง
และที่ว่าจะลดลง ประสิทธิภาพของโปรแกรมของคุณ
ดังนั้นจึงเป็นเรื่องที่มีประโยชน์เสมอ ที่จะประกาศมันนอก
>> Rob: นั่นคือการกล่าวว่าเมื่อวันที่ ใด ๆ ของปัญหาเหล​​่านี้
สวยมากตราบใดที่คุณได้รับ การแก้ปัญหาการทำงานคุณจะได้รับเครดิตเต็มรูปแบบ
ดังนั้นไม่ต้องกังวลถ้าการออกแบบของคุณ เป็นที่น่ากลัวอย่างแน่นอน
มันอาจจะทำให้เราอารมณ์เสีย การอ่านรห​​ัสของคุณ
แต่ตราบใดที่การทำงาน คุณจะได้รับคะแนน
>> Davin: ใช่
ตกลงดังนั้นแล้วฉันจะไป ประกาศตัวแปรบาง
มันเป็นเพียงแค่จะเรียก int ผลรวม
และฉันจะตั้งค่านี้ เท่ากับศูนย์เช่นนั้น
และที่เพิ่งจะ ที่จะเป็นตัวยึด
เพื่อให้เป็นไปได้ สิ่งที่ผมกำลังจะกลับมา
ดังนั้นฉันจะไปในที่สุด กลับผลรวมออกจากโปรแกรมนี้
ดังนั้นผมจึงมีทั้งสองตัวแปร
ฉันมีความยาว
ฉันมีผลรวม
และตอนนี้ขอกระโดดลงไปในสายของเรา
>> เพื่อช่วยให้มีของเราห่วง
ดังนั้นสี่ int ฉันเท่ากับ 0 วัตต์ในขณะที่ ฉันมีค่าน้อยกว่าที่ฉันมีความยาวบวกบวก
และ now--
Rob: ดี
Davin: ตกลงตอนนี้ที่นี่ มาพร้อมเนื้อของรหัสของเรา
ดังนั้นคุณสามารถจริงทำ นี้โดยทั่วไปในหนึ่งบรรทัด
ดังนั้นใครที่ไม่ได้มีความคิด ของสิ่งที่เรากำลังจะทำต่อไปหรือไม่
ตกลงดังนั้นที่ตกลง
ดังนั้นเรากำลังทำอะไรที่จะบอกว่าผลรวม equals-- ให้ฉันวิ่งหนีผลรวม over-- นี้
เท่ากับผลรวม 10 ครั้งบวกเรา จะใช้ S ฉันลบหนึ่ง
อ้าง 0 หนึ่งอ้างทำเช่นนั้น
Rob: ใช้งานง่ายมาก
>> Davin: บดมัน
ตกลงดังนั้น someone-- ผมได้รับมัน, ผมได้รับมัน
ตกลงดังนั้นนี้เป็นอย่างชัดเจนขึ้น
สิ่งนี้หมายความว่าอย่างไร
ดังนั้นใครที่ไม่ทราบว่าสิ่งที่นี้หมายถึงอะไร?
ทุกคนสามารถดูนี้?
ไม่มีใครสามารถดูนี้ตกลง
ฉันจะ to--
>> Rob: ผมจะเขียน สูตรเพียงขวาที่นี่
Davin: OK, ร็อบจะทำมัน บนคอมพิวเตอร์ซึ่งคือความสนุก
ปล้น: โอ้พระเจ้าของข้าพระองค์
หรือฉันจะไม่
Davin: ยืนอยู่ข้าง
นักเรียน: ฉันมีคำถาม
Davin: ใช่นั่นเอง
นักเรียน: [ไม่ได้ยิน]
Davin: OK ดังนั้นมันจริง เช่นเพียงในทั่วไป
ถ้าคุณจะใส่เหมือน ใน int ประกาศนี้
ฉันมีความยาวเท่ากับ 0 จุลภาค เท่ากับ sterln, that--
>> นักเรียน: [ไม่ได้ยิน]
>> Davin: ที่ปรับเพราะ that--
นักเรียน: ทำไมคุณจะ จำเป็นที่จะต้องใช้ระยะเวลาใน?
ทำไมทำไม่ได้เราก็ [ไม่ได้ยิน] sterln วินาที, เช่นตลอดเวลา [ไม่ได้ยิน]
>> Davin: คุณหมายถึงที่นี่?
>> นักเรียน: ใช่
Davin: เพราะทุก เวลานี้สำหรับวงวิ่ง
ก็จะประเมินสภาพนี้
นักเรียน: ขวา
Davin: และถ้าคุณมี sterln ที่นั่นแล้วก็
จะมีการเรียกจริง ฟังก์ชั่นที่ทุกเวลาเดียว
ดังนั้นแทนที่จะเพียง เปรียบเทียบกับ int,
คุณกำลังจะได้รับการเรียกร้อง ฟังก์ชั่นและจากนั้นเปรียบเทียบ
ให้ค่าตอบแทน
ใช่จึงเป็นเพียงใช่
>> ดีตกลงดังนั้นตอนนี้ทุกคนสามารถดูได้
อะไร does-- นี้เป็นเหมือนนี้มัน
นี้เป็นแยมขวาที่นี่
มันหมายความว่าอะไร?
ผมทำอะไร?
ใช่ความคิด?
ใช่?
>> นักเรียน: ดีดังนั้นเมื่อ คุณกำลังเข้าสู่อาร์เรย์
คุณกำลังจะไป จากซ้ายไปขวา
เพื่อให้คุณกำลังจะไปใน ทศนิยมจากปุ่ม [ไม่ได้ยิน]
Davin: แน่นอน
นักเรียนดังนั้นแต่ละคน คุณต้องคูณ
สิ่งที่คุณเห็นเป็นค่าของ int โดย เวลาที่คุณได้รับที่จะย้ายที่หนึ่ง
>> Davin: ที่สมบูรณ์แบบที่สมบูรณ์แบบ ดังนั้นสำหรับตัวอย่างเช่นสมมุติ
บอกฉันให้ you-- ฉัน จะเขียนมากกว่าที่นี่
ไม่ฉันไม่ได้
ฉันจะเขียนมากกว่าที่นี่
สมมติว่าฉันให้คุณ 76 ใช่มั้ย?
สมมติว่าผมให้คุณ 76
นั่นเป็นสตริงจะเริ่มต้นด้วย, OK?
>> ดังนั้นระยะเวลาคืออะไร?
2 ใช่มั้ย?
ผลรวมเป็น 0
แล้วเรากระโดดในสำหรับวงของเรา
ตกลงย้ำแรกของ นี้สิ่งที่มันจะเป็นอย่างไร
มันจะเป็นผลรวมเป็น 0
ดังนั้นครั้งรวม 10 0
นั่นคือความหมาย
แล้วสิ่งนี้จะทำอย่างไร
นักเรียน: [ไม่ได้ยิน]
>> Davin: มันจะเปิดที่ ตัวละครที่เป็นจำนวนเต็มใช่มั้ย?
เป็นชนิดของเช่นเดียวกับคุณ ปัญหาถึงตรง light-- นี้
มันเหมือนกับมี ปัญหาการตั้งค่า VISIONEER
คุณจัดการกับค่า ASCII
ดังนั้นถ้าผมให้คุณเช่น เจ็ด แต่มันก็เป็นตัวอักษร
และคุณต้องการที่จะรู้ว่า ตกลงสิ่งที่หลักคือ?
ใช่คุณอาจจะใช่
เพื่อให้เป็นสิ่งหลักที่?
คุณสามารถลบ 0 จากมัน แต่คุณ ต้องลบ 0, ตัวละคร
>> และสถานที่ที่คนบางคน ได้รับการดีดกลับขึ้นมาพวกเขากำลัง
เช่น, OK, ดี, ฉันจะต้องรู้ ค่า ASCII สำหรับคำถามนี้?
ไม่มีคุณแน่นอนไม่ได้ จำเป็นต้องรู้ ASCII
ค่านิยมของเช่นตัวพิมพ์เล็ก พิมพ์ใหญ่ศูนย์
>> Rob: ไม่มีเหตุผลคือการที่เคย วางบนแผ่นโกง
>> Davin: แน่นอนไม่ได้ เสียพื้นที่ของคุณด้วย
คุณสามารถ literally-- เพียงแทน บอก 48 เช่นขวาขึ้น
มีที่เทียบเท่ากับ บอกว่าหนึ่งหนึ่ง apostrophe,
เช่นนั้นเหมือนกัน
>> ปล้น: คุณเกือบจะคิดว่า มันเป็นพระเจ้าใดถ้าฉันต้องการของฉัน
oops-- คุณเกือบจะคิดว่ามัน เช่นถ้าเรามีบางอย่างเช่นกัญชาที่
กำหนดเป็น 0 48
ที่จะไม่ทำงาน
แต่คิดว่ามันเป็นคำพูดเดียว 0 พูดเดียวและสำหรับทุกตัวอักษร
คิดว่ามันเป็นค่าคงที่ แสดงให้เห็นถึงค่า ASCII ที่
>> Davin: ใช่
ตกลงดังนั้นครั้งแรกที่ผ่านดังนั้น กับ 76-- ดังนั้นครั้งแรกที่ผ่าน
นี้เป็นเพียงตัวละคร 7 ลบตัวอักษร 0,
และผู้ที่มีเจ็ด integers-- ดีเหล่านั้น
เจ็ดพื้นที่ออกจากกัน อื่น ๆ ในแผนภูมิ ASCII หรืออะไรก็ตาม
เพื่อที่จะกลับ int 7
ดังนั้นตอนนี้ผลรวมเท่ากับ 7
>> ตกลงกันให้กระโดด ในนี้สำหรับวงอีกครั้ง
ตกลงตอนนี้มันเป็นผลรวม 10 ครั้ง
ดังนั้นคุณได้อย่างมีประสิทธิภาพ 7 ย้ายไปทางซ้าย
ที่ทำให้รู้สึก?
คุณได้อย่างมีประสิทธิภาพ ย้ายไปทางซ้าย
>> แล้วคุณ add-- นี้ เป็นไปได้ 6 ลบ 0
ที่ 6
ดังนั้นจึงเป็นไปได้ 70 บวก 6
76 ที่เป็นหมายเลขของคุณ
ดังนั้นไม่คำนึงถึงจำนวนสิ่งที่ ฉันให้คุณก็ช้าเพียง
จะไปเปลี่ยนค่าขนาดใหญ่ ไปทางซ้าย 1 ปัจจัยที่ 10
แต่ละครั้งในการวน, แล้วเพิ่มตามความจำเป็น
>> ในด้านหลัง?
นักเรียน: เราไม่ต้องทำ การตรวจสอบใด ๆ ในโปรแกรมได้หรือไม่
>> ปล้นดังนั้นเท่าที่ตรวจสอบ ไปสำหรับโปรแกรม
เราจะบอกคุณสวย มากสิ่งที่คุณจำเป็นต้องตรวจสอบ
ถ้าเราไม่ได้บอกคุณ อะไรแล้วโดยทั่วไป
สมมติว่าคุณต้องตรวจสอบสิ่งที่มากที่สุด
เช่นคุณอาจจะเพียงเพื่อความปลอดภัยคุณ อาจจะตรวจสอบเดี๋ยวก่อน S เป็นโมฆะ?
แล้วผมก็มีความคิดว่าจะกลับไม่มี
แต่เราจะบอกคุณ การจัดเรียงของสิ่งนี้
0, ผมไม่ทราบ
>> Davin: และทำไมคุณต้องการ เพื่อตรวจสอบถ้า S เท่ากับ null?
นักเรียน: [ไม่ได้ยิน]
Davin: เพราะถ่านดาว
มันเป็นตัวชี้
ดังนั้นยอมรับอย่างสมบูรณ์ ประกาศฉันจะบอกว่าโอเค
S เท่ากับ null เพราะมัน อาจจะเป็นตัวชี้ให้เป็นโมฆะ
ดังนั้นเมื่อใดก็ตามที่คุณมีตัวชี้ ในเส้นทางของคุณในแบบนี้
คุณอาจจะตรวจสอบ
เพราะถ้าคุณไม่ได้ตรวจสอบว่าและ แล้วคุณแล้วไปเป็นของคุณสำหรับห่วง
และคุณ doing-- วิ่งหนีลง
วิ่งหนีลง
>> Rob: ขออภัยที่มัน
>> Davin: ดังนั้นเช่นถ้า มันเป็นโมฆะและจากนั้นคุณ
ทำเช่นนี้สิ่งที่ผิดพลาด ที่คุณจะได้รับ?
นักเรียน: คุณกำลังจะได้รับความผิดชุด
Davin: คุณกำลังจะตั้ง ความผิดที่ถูกต้องเพราะคุณ
พยายามที่จะเข้าไปในดัชนี null
ดังนั้นคุณจะพยายามที่จะดัชนี ในหน่วยความจำที่คุณไม่ได้เป็นเจ้าของ
ดังนั้นนี่ถ้านี้เป็นโมฆะและ คุณทำเช่นนี้คุณจะวงจร
>> Rob: ผมยังคิดว่าในการสอบที่ เราถามคำถามนี้เราบอกคุณ
ที่คุณก็สามารถคิด มันเป็นจำนวนบวก
เพราะ atoi คาดว่ายัง ที่จะจัดการกับตัวเลขติดลบ
ดังนั้นคุณจะต้องกรณีพิเศษ
เฮ้เป็นตัวอักษรตัวแรก เส้นประซึ่งในกรณีที่ตกลง
ตอนนี้ก็เป็นจำนวนเต็มลบ
เราจะบอกคุณทุกประเภทของสิ่งเหล่านี้
เราจะบอกสิ่งที่คุณต้องการที่จะจัดการกับ
Davin: ใช่
ดังนั้นฉันแน่ใจว่าบางคนอาจจะ have-- ถ้าคุณเริ่มมองหาที่สอบเก่า
คุณเคยเห็น sterln
ที่ได้รับความนิยมอย่างใดอย่างหนึ่ง
และผมคิดว่าใน sterln คุณต้อง จะตรวจสอบนี้สำหรับ null กลับ
0 หรือสิ่งที่ต้องการที่
เช่นเดียวกับที่คุณมีการตรวจสอบเป็นโมฆะ
และถ้าคุณไม่ได้ว่า เป็นจุดปิดที่ทดสอบ
ดังนั้นต่อไปไม่ทุกคน รู้สึกตกลงกับ atoi?
ไม่มีใครต้องการที่จะ ไปกว่าชิ้นส่วนอีกครั้งหรือไม่
Rob: ใช่แล้วผมคิดว่า เรายังบอกคุณคุณ
สามารถสรุปทุกอย่างเท่าไหร่ว่า พวกเขากำลังจริงป้อนตัวเลข
ที่คุณไม่ต้องกังวลเกี่ยวกับ เหมือนตัวอักษรที่อยู่ในสตริงดังนั้น
Davin: ใช่
ใช่?
นักเรียน: คุณสามารถไป กว่าหนึ่งเวลามากขึ้นเมื่อ
คุณใช้คำพูดคู่และพูดเดียว?
>> Davin: แน่นอนดังนั้นคำพูดคู่มาก ก็เป็นคำพูดคู่นี้จะมี
ดังนั้นถ้าคุณเป็นสองเท่าของราคา อะไรที่เป็นสตริง
ดังนั้นเช่นถ้าผมมีนี้ 0 กว่าที่นี่ และฉันทำอย่างนี้ที่เป็นสตริง
ที่ไม่มีตัวอักษร
ดังนั้นผมจึงไม่สามารถหาค่า ASCII ของฉัน แผนภูมิเพราะสตริงใช่
>> ตกลงคำถามอื่น ๆ ?
ใช่?
>> นักเรียน: เพื่อให้คุณได้ แล้วตอบนี้
แต่เช่นเดียวกับเมื่อเรากำลังจริง เขียนนี้ในการตอบคำถาม,
ที่คุณต้องการให้เราเขียนด้วย slashes zeroes [ไม่ได้ยิน]
Davin เลขที่
คำถามคือคุณควร ใส่เฉือนผ่านศูนย์
เพื่อแสดงให้เห็นว่าพวกเขากำลังศูนย์?
ไม่มีเราจะคิดออก
ใช่ขอบคุณพวกเขากำลังดี
ตกลงอะไรอีกหรือไม่
ไม่มีใครต้องการ to-- ดังนั้นฉันคิดว่า เราเคยทำงานนิด ๆ หน่อย ๆ เมื่อเวลาผ่านไป
คุณต้องการที่จะเห็นอีกคนหนึ่งหรือ?
นักเรียน: RandomInt
>> Davin: RandomInt ตกลงว่า
เพื่อขอทำ RandomInt
ฉันจะทำมันที่นี่
ดังนั้น RandomInt เป็นจริงง่ายมาก
ผมคิดว่า atoi น่าจะเป็นหนึ่งในที่ยากที่สุด ที่เราได้ถามในปีก่อนหน้า
นักเรียน: [ไม่ได้ยิน]
>> Davin: อะไรนะ?
Rob: ผมเห็นว่ามันเป็นชนิด ของสามารถดูได้จากที่นี่
Davin: มันคืออะไร?
Rob: ผมไม่คิดว่ามันเป็น going-- ผมคิดว่า มันจะวิ่งออกไปทางขวา
Davin: ตกลงดังนั้นฉันจะทำอย่างใดอย่างหนึ่ง
และแล้วคุณก็วางมันลงบนหน้าจอ
>> ปล้นสิทธิทั้งหมด
>> Davin: คุณต้องการที่จะเป็นนักเขียนของฉันได้อย่างไร
>> ปล้น: ใช่
>> Davin: ดี
ตกลงฉันสามารถลบนี้หรือไม่?
>> นักเรียน: ใช่
>> Davin: นั่นอย่างหนัก
(ร้อง) คุณกำลังทำ สิ่งที่คุณทำ
และทำในสิ่งที่คุณทำไม่ได้
สิทธิ์ทั้งหมด
>> ตกลงถ้าผมจำไม่ผิดที่ แบบทดสอบ RandomInt ก็ชอบ
ตกลงฉันจะให้คุณทั้งสอง ตัวเลขเช่นข
และฉันต้องการให้คุณให้ฉัน RandomInt ระหว่างตัวเลขเหล่านั้น
ดังนั้น RandomInt จะ จะใช้เวลาสอง numbers--
ดังนั้น RandomInt-- และมัน จะกลับ int
>> ดังนั้นสิ่งที่เป็นค่าตอบแทนหรือไม่
ผมแค่บอกคุณ
int ใช่มั้ย?
เช่นนี้แล้วก็ จะใช้เวลาสอง ints
ดังนั้นมันจะใช้เวลา int และ int B, เช่นนั้น
ดังนั้นสิ่งที่เป็น RandomInt จะทำคือมันจะ
เพื่อกลับไปบางค่าแบบสุ่ม ในระหว่างทั้งสองค่า
ดังนั้นจึงเป็นไปได้มากขึ้น กว่าน้อยกว่าข
ดังนั้นผมคิดว่าคุณอาจจะคิดว่า เป็นขนาดเล็กของทั้งสองค่า
ดังนั้นหากเรากำลังติดต่อกับ แบบแผนฟังก์ชั่นอะไร
ที่เราเห็นได้ว่า ทำให้เรามีสิ่งสุ่ม?
นักเรียน: Drand
Davin: Drand ว่า
ดังนั้นคุณจะอาจจะ ต้องการที่จะใช้ drand ของคุณ
เพื่อให้คุณสามารถพูด int สุ่มและเราจะ เพียงแค่บอกว่ามันเท่ากับ 0 ตอนนี้
และพวกเขากำลังที่เรากำลังจะบอกว่า ตกลงเท่ากับสุ่ม drand 48
และสิ่งนี้จะกลับมา?
อะไรฟังก์ชันนี้ให้คุณ?
>> นักเรียนระหว่าง 0 และ 1
>> Davin: ใช่ระหว่าง 0 และ 1
ดังนั้นมันจะ be--
>> ปล้น: และนี้เป็นเท่าไหร่ผมคิดว่า เราจะบอกคุณนี้
เช่นคุณสามารถใช้ drand 48
คุณสามารถตรวจสอบนี้ในการสอบที่ผ่านมา
แต่เราอาจจะบอกว่าคุณ สามารถใช้ drand 48 ซึ่ง
กลับลอยระหว่าง 0 และ 1
>> Davin: ใช่ใช่ฉัน ค่อนข้างมั่นใจว่าในการสอบ
มันบอกว่าคุณอาจ ต้องการที่จะใช้ drand ใช่
ดังนั้นมันจะกลับมา ค่าระหว่าง 0 และ 1 บางส่วน
และแล้วสิ่งที่เป็นคุณ จะต้องการจะทำอย่างไร?
ดีที่คุณต้องการคูณคูณ รอผมคิดว่ามันเป็นเช่นนี้ขอโทษ
ฉันจะทำเช่นนี้
ฉันไม่รู้
>> ดังนั้นขลบ
ดังนั้นทำไมขลบ?
ดังนั้นสมมติว่า drand จะช่วยให้คุณกลับมา ตกลง int-- ฉันจะทำส่วนที่เหลือ,
ดังนั้นบวก
ดังนั้นสิ่งที่ does-- และเป็นขลบ
ดังนั้นสมมติว่า drand ที่ช่วยให้คุณกลับมา ค่าสูงสุดมันอาจเป็นไปได้
ให้คุณ
อะไรที่จะเป็น?
นักเรียน: 1
>> Davin: 1 ใช่มั้ย?
ดังนั้นหากนี้คือ 1 และคุณ คูณโดย b ลบ,
ดีที่เป็นเพียง ความแตกต่างระหว่างลบ A.
และถ้าคุณแล้วเพิ่มที่ กลับขึ้นไปบนว่าเป็นสิ่งที่?
เป็นพื้น b
ที่ทำให้รู้สึก?
>> นักเรียน: ใช่
>> Davin ดังนั้นถ้าเป็นสูงสุด คุณค่ามันอาจจะเป็นไปได้
มันเป็นไปได้ 1
แล้วนี้เป็นเพียง ความแตกต่างระหว่างทั้งสอง
เพิ่มในดังนั้นนี่คือ จะกลับมาแบบสุ่ม
และในกรณีที่มุมที่ drand จะช่วยให้คุณกลับมาที่ 1
สุ่มจะเป็นเพียงการได้อย่างมีประสิทธิภาพได้รับการข
แต่ที่สูงสุดที่จะสามารถ
ดังนั้นถ้ามันเป็นไปได้น้อยกว่า ที่นี้จึงขอบอกว่าเหมือน 0.9
เป็นอย่างนั้น 0.9 คูณ b ลบ เป็นไปได้น้อย
กว่าความแตกต่างระหว่างขลบ
>> แล้วถ้าคุณเพิ่มว่า ไปแล้วค่าที่
ไปได้มากกว่าเพราะ คุณกำลังเพิ่มบางสิ่งบางอย่างลงบนมัน,
แต่มันก็เป็นไปได้น้อยกว่าข
เพื่อให้คุณกำลังจะได้รับการสุ่ม จำนวน drand เพราะคุณกำลังเรียกร้อง
และแรนด์ที่สุ่มหมายเลขที่ จะเป็นหนึ่งในระหว่าง
และข
ที่ทำให้รู้สึก?
>> ปล้น: เพียงที่จะนำมันใน ตัวเลขที่เป็นรูปธรรมดังนั้น
สมมุติว่าเราต้องการที่จะเลือก สุ่มตัวเลขระหว่าง 7 และ 10
ดังนั้นขลบเป็นช่วงของเรา
ดังนั้นจึงเป็นช่วงของสาม ตัวเลขที่เราต้องการที่จะเลือกจาก
แล้วคูณ ว่าระหว่าง 0 และ 1 1
หากที่แล้วทำให้เรา some-- ขอบอกว่าจะช่วยให้เรา 1.5
>> แล้ว 1.5 เราต้องการที่จะไป 7-10
ดังนั้น 1.5 บวก 7 นำเรา กลับเข้ามาใน 7-10 ช่วงของเรา
และจากนั้นเราจะเก็บไว้ภายใน จำนวนเต็มดังนั้นจึงตัดทอนลงไป 8
และจากนั้นเราก็กลับมาที่
ดังนั้นขลบเป็นช่วงของเรา
กะมันได้เป็นตัวเลข ที่เราต้องการอยู่ในช่วงที่
ดังนั้นระหว่างวันที่ 7 และ 10 และแล้วเรา สามารถกลับสิ่งที่เราจบลงด้วย
>> Davin: ใช่ดี
>> Rob: ขอบคุณ
>> Davin: ใช่อะไรขึ้น?
>> นักเรียน: เราทำงานกับชนิดของใด ๆ ข้อผิดพลาด ASCII เมื่อ we're-- ถ้า drand เป็น
กลับลอย [ไม่ได้ยิน]
>> ปล้นดังนั้นเช่นเดียวร็อบกล่าวว่า เพราะสุ่มไม่ได้ int,
ดังนั้น drand จะลอย
ดังนั้นแล้วก็คูณออก
และคุณอาจได้รับบาง ชนิดของตัวเลขลอย
และจากนั้นก็จะตัดทอน
>> นักเรียน: OK
Davin: ใช่
ปล้นและถ้าคอมไพเลอร์จะเตือน คุณเกี่ยวกับการเช่นเดียวกับการสูญเสียของความแม่นยำ
โยนเพียง int ใน มีและมันก็เป็นสิ่งที่ดี
Davin: ใช่?
>> นักเรียน: มันจะมี ความน่าจะเป็นอย่างเดียวกับการ,
เหมือนขหรือ [ได้ยิน]
>> ปล้นดังนั้นเท่าไหร่ฉันจริง wondering-- เป็น RandomInt คาดไว้
จะเป็นตัวเลขจากน้อยกว่า B?
เช่นถ้าเป็นระหว่าง 7 และ 10 สิ่งที่เป็นไปได้หรือไม่
7, 8, และ 9 หรือ 7, 8, 9, 10?
Davin: ผมลืม
เมื่อถึงตรงปัญหา
>> Rob: ผมคิดว่ามันเป็น 7, 8, 9
>> Davin: มันโดยเฉพาะกล่าวว่าหนึ่ง รวมและเป็นเอกสิทธิ์เฉพาะของ
>> ปล้น: ใช่
>> Davin: แต่ผม don't-- ฉัน not--
>> ปล้นดังนั้นผมคิดว่าเหล่านี้คือ ไม่รวมซึ่งในกรณีนี้
มีความเท่าเทียมกัน น่าจะเป็นของ 7, 8, และ 9
มีความน่าจะเป็น 10 ไม่ได้
Davin: ใช่?
นักเรียน: ฉันมีคำถาม
เราต้องการที่จะกำหนดฟังก์ชัน ผลตอบแทนที่ได้ไม่คุ้มค่า แต่อาร์เรย์
จากนั้นสิ่งที่จะเป็น ไวยากรณ์หลังจากที่กลับมา?
>> Davin: ตกลงเป็นอย่างนั้นคุณ would-- หลังจากกลับ?
ดังนั้นสมมติว่าคุณได้ประกาศ อาเรย์ที่มีขึ้น
แล้วคุณก็จะกลับมา ชื่อของอาร์เรย์
>> นักเรียน: OK ขอขอบคุณ
แล้วก็กลับมาพร้อมกับเเรก
Davin: โอ้รอขอโทษ
คำถามคือวิธีการ คุณจะกลับอาร์เรย์
>> Rob: แม้ว่ามันจะไม่ได้ ได้รับการประกาศอาร์เรย์
ในกองหรืออะไรอย่างนั้น
มันจะต้องมีอะไรบางอย่าง malloced เพราะ malloc
เป็นวิธีการที่คุณได้รับรอบ จัดสรรหน่วยความจำอัตโนมัติ
>> Davin: ใช่
Rob: วิธีที่คุณจะได้รับรอบขอบเขตท้องถิ่น
>> Davin: แต่คุณจะ เพียงแค่กลับ name-- ของ
>> นักเรียน: [ไม่ได้ยิน] มันไม่ได้เป็นอย่างใดอย่างหนึ่ง ค่าตัวอย่างเช่นตัวเลขสองดังนั้น
[ไม่ได้ยิน]
>> Davin: คุณไม่สามารถกลับจำนวนหลาย
คุณไม่สามารถเช่น return--
>> นักเรียน: ฉันพูดคุยเกี่ยวกับการกลับ อาร์เรย์หรือสิ่งที่ต้องการ
>> Davin: ใช่ดังนั้นคำถามคือ ฉันสามารถคืนค่าหลายค่า
คุณไม่สามารถคืนค่าหลายค่า
คุณไม่สามารถเหมือนกลับมาแล้ว กลับขหรือสิ่งที่ต้องการ
เพราะหลังจากที่คุณกลับมาที่คุณ กลับออกมาจากการทำงาน
และจากนั้นการทำงานจะทำและ เช่นร็อบกล่าวว่าเป็นในกอง
>> ดังนั้นสิ่งที่หน่วยความจำที่เพิ่งได้รับ กลับไปยังเครื่องคอมพิวเตอร์
ทุกอย่างได้รับการลืมโดยทั่วไป
ดังนั้นหากคุณต้องการที่จะกลับไปหลาย ค่าที่คุณต้องกลับอาร์เรย์
และวิธีที่คุณทำอย่างนั้นจะ mallocing
แล้วคุณจะกลับมา x เช่นนั้น
โดยทั่วไปคุณเพียงแค่กลับชื่อ
และเมื่อคุณกลับมา บางอย่างเช่นนี้คุณ
ไม่จริงกลับค่า
>> ดังนั้นสมมติว่าคุณเก็บไว้ ค่าในอาร์เรย์
คุณไม่ได้จริง กลับค่าเหล่านั้น
เช่นถ้าผมกลับ int ฉัน จริงๆกลับสำเนาของค่า
แต่ถ้าฉันจะกลับมา บางอย่างเช่นนี้
ฉันกลับมาอ้างอิง กับค่าเหล่านั้น
ดังนั้นฉันกลับมาโดยทั่วไป อยู่หน่วยความจำไปยังค่า
ที่ทำให้รู้สึก?
นักเรียน: ใช่
Davin: ดี
ใช่?
>> นักเรียน: เมื่อคุณอยู่ โดยใช้ drand กว่าที่นี่
คุณไม่ต้องใส่ srand ก่อนที่?
>> Davin: ไม่ไม่ผมไม่คิดอย่างนั้น
>> ปล้น: ใช่เพื่อทำคุณมี จะพูดอะไรเกี่ยวกับ srand?
การเริ่มต้นของคุณไม่เคยบอก srand ที่ทุกคนจะทำ srand ของ null
ดังนั้น drand ในการทำงานจะเป็นของตัวเอง
และมันจะเมล็ดโดยอัตโนมัติด้วย เวลาปัจจุบันคือสิ่งที่มันใช้
Davin: ใช่?
นักเรียน: คุณ [ไม่ได้ยิน] กับตัวเลขหรือไม่
Davin: ใช่คุณสามารถ
นักเรียน: เพื่อให้คุณสามารถ พูดเหมือน 4 ครั้งที่ 2
สิ่งที่เป็นคุณไม่สามารถคิด แล้ว int สี่ไบต์
only--
>> Davin: ผมหมายถึงการตอบคำถามที่คุณสามารถ
[หัวเราะ]
>> ปล้น: mm ไม่
Davin: ใช่ใช่คุณสามารถ
ถ้าพวกเขาถามคุณว่าใหญ่ int คือ คุณจะไม่สามารถเช่นเดียวกับสี่หรือแปด
ปล้น: โอ้ดังนั้นหาก คำถามเฉพาะ
เช่นถ้ามันเป็นปัญหาการเข้ารหัส, คุณควรจะพูดว่าขนาดของ int
ถ้ามันเป็นตารางหรือ มันบอกว่ากี่ไบต์,
คุณไม่ควรกรอกข้อมูลลงในขนาดของ ints
>> นักเรียน: [หัวเราะ]
>> Davin: ขวาจึงเป็นเหตุผลว่าทำไม ขนาดของ int ที่สำคัญที่นี่?
ดังนั้นเช่นถ้าเรากำลังจะ 32 บิต หน่วยประมวลผลหรือสิ่งที่ต้องการที่
แล้วมันจะเป็นสี่ไบต์
แต่ในบางส่วนของใหม่ สิ่งที่มันอาจจะเป็นอะไร?
มันอาจจะเป็นแปดใช่มั้ย?
ดังนั้นเจ้านี่ถ้าคุณเพียงแค่ยากรหัสสี่ แล้วในบางเครื่องก็จะทำงาน
บางเครื่องก็จะไม่ทำงาน
แต่ถ้าแบบทดสอบที่เรากำลัง เช่นวิธีการใหญ่คือ int?
ใส่สี่
ปล้นขวา
Davin: ใช่?
นักเรียน: งั้นเพราะเรากำลังประกาศ [ไม่ได้ยิน] ที่อยู่ในฟังก์ชั่น,
เราควรจะใส่ 3 ภายในฟังก์ชันที่?
หรือเราสามารถใช้มันนอก?
Davin: คุณสามารถใช้มัน นอกฟังก์ชันที่
ดังนั้นเขาจึงขอได้ฟรี
>> นักเรียน: สูญเสียการติดตาม ของที่ [ไม่ได้ยิน]
>> ปล้น: โอ้, ฟรีไม่ happen-- ที่เป็นส่วนหนึ่งของความมหัศจรรย์ของ malloc
คือการที่คุณไม่ได้ จำกัด ขอบเขตท้องถิ่น
คุณมีการควบคุมเต็มรูปแบบผ่าน ระยะเวลาที่ตัวแปรของคุณมีชีวิตอยู่
ดังนั้นเราจึงเรียก malloc ที่นี่ก็อาจจะ เป็นฟังก์ชันแยก
มันอาจจะเป็น 10 ชั่วโมงต่อมา ที่ในที่สุดเราก็โทรฟรี
>> Davin: ดังนั้นสำหรับตัวอย่างเช่นคู่ สัปดาห์ต่อจากนี้เมื่อคุณจน
ทำสะกดพจนานุกรมของคุณ psets คุณจะ
จะมีฟังก์ชั่นบางอย่างที่ สร้างตันของโหนด
ดังนั้นคุณ mallocing ตัน ของโหนดในการทำงานนี้
และจากนั้นในภายหลัง ฟังก์ชั่นแยกต่างหากคุณ
จะต้องการที่จะเป็นอิสระโหนดเหล่านั้นทั้งหมด
เพื่อให้คุณสามารถแท้จริงเพียงแค่ผ่านไป ฟรีตัวชี้เพื่อให้อยู่หน่วยความจำ
กับสิ่งที่คุณ malloced
และที่จะได้รับการปรับ
คุณไม่จำเป็นต้องที่จะเป็นอิสระ, เช่นในฟังก์ชันเดียวกัน
ใช่?
>> นักเรียนดังนั้น malloc ตัวแปร [ไม่ได้ยิน] นอก?
นั่นคือสิ่งที่คุณพูด?
Davin: รอบอกว่า?
ขอโทษ
>> นักเรียน: ถ้าตัวแปร malloc สามารถเป็นอิสระที่ใดก็ได้ในรหัส
จากนั้นพวกเขาสามารถเข้าถึงได้ ที่ใดก็ได้ในรหัส?
คุณสามารถเก็บไว้ในประเทศหรือไม่
>> Davin: โอ้เธอถาม เหมือนตัวแปร like--
>> Rob: เพื่อให้คุณยังคงต้อง มีการเรียงลำดับของการอ้างอิงบางส่วน
เพื่อป้องกัน malloc ของหน่วยความจำ
ดังนั้นที่นี่เรากำลังกลับมา x
นักเรียน: โอ้
Rob: ถ้าเราไม่ได้กลับ x ที่นี่และครั้งนี้เป็นโมฆะเพียง
แล้วเราจะมีการเข้าถึงไม่ ตัวชี้ที่ถูก malloced,
และก็รั่วไหลของหน่วยความจำ
>> นักเรียน: OK
>> Davin ดังนั้นเช่นสมมติว่าคุณ มีนี้เช่นขวาที่นี่
ปล้นเลขที่
Davin: ในฟังก์ชั่นหลักของฉันฉันไม่สามารถ เพียงโทร x นี้และจะเป็นเหมือนตกลง
ในการทำงานนี้ผมทำอย่างนี้
>> ปล้นขวา
>> Davin: ดังนั้นฉันจะเรียก x ใน เหมือนหลักหรือสิ่งที่ต้องการที่
คุณไม่สามารถทำเช่นนั้นได้
คุณกำลังจะกลับสิ่งที่
แต่สิ่งที่คุณจะกลับมา?
คุณกำลังจะได้กลับมาอยู่หน่วยความจำ
และเนื่องจากคุณกลับหน่วยความจำ ที่อยู่ที่สามารถเข้าถึงได้จากที่อื่น
คำถามใด ๆ เพิ่มเติมหรือไม่
ใช่?
>> นักเรียน: เป็นฟังก์ชั่นดังกล่าวข้างต้น การตรวจสอบ [ไม่ได้ยิน]
>> Davin: ทำไมฉันไม่จำเป็นต้องทำเช่นนั้น?
นักเรียน: [ไม่ได้ยิน]
Davin: เพราะคุณ ไม่ mallocing อะไร
จึง not-- ใช่มัน ไม่ชอบสตริง
มันเป็นตัวชี้ที่ใดที่หนึ่ง
เหล่านี้เป็นค่าเพียง
นักเรียน: OK
Davin: ใช่
อะไรอีกหรือไม่
Rob: ครับ?
นักเรียน: แต่เมื่อคุณ [ไม่ได้ยิน]
>> Rob: ดังนั้นเพื่อที่จะเป็นอิสระ หน่วยความจำที่เราจะบอกว่าที่นี่
ดังนั้น x เป็นตัวชี้ของเราที่จะ บล็อกของหน่วยความจำ
เราเป็นอิสระชี้ว่า
และเราจะไม่จำเป็นต้องทำมันที่นี่
เราสามารถทำมันได้ทุกที่
แต่คุณโทรฟรีที่ สิ่งที่ผลตอบแทน malloc
ดังนั้น malloc นี่กลับ สิ่งที่จะถูกเก็บไว้ใน x
ดังนั้นเราจึงสามารถโทรฟรีใน x
คำถามใด ๆ ที่ผ่านมา?
>> Davin: คำถามใด ๆ ที่ผ่านมา?
ใช่?
>> นักเรียน: ขออภัยคุณสามารถอธิบายอีกครั้ง เหตุผลที่คุณจะเป็นอิสระในการมี?
ทำไม [ไม่ได้ยิน]
>> Davin: สำหรับที่นี่?
>> นักเรียน: ใช่เช่นขวาหลังจาก
Davin: คุณอาจ ไม่ต้องการฟรีที่นี่
Rob: คุณอาจจะไม่
Davin: ใช่ว่าเรื่องนี้จะไม่ทำอะไรเลย
นี้จะเหมือนการสร้าง หน่วยความจำทำสิ่งนั้น
และแล้วทันที ลืมเกี่ยวกับมันใช่
>> Rob: แต่เราอาจจะทำเช่น ที่นี่ด้วยเหตุผลบางอย่าง
เราอาจจะบอกว่า int ดาว และผลตอบแทนเ​​ท่ากับอาร์เรย์
ทำสิ่งบางอย่างกับ Y, อาจจะพิมพ์เนื้อหา
และแล้วในที่สุดเรากำลังทำ
เราสามารถเป็นอิสระและ
นักเรียน: [ไม่ได้ยิน]
Davin ผมควรจะเลื่อนลงมา?
ขอบคุณ
Rob: ดี
>> Davin: ตกลงที่มัน
Rob: สิทธิทั้งหมดที่ดี
โชคดี
>> Davin: ถ้าคุณมีคำถามส่งอีเมลถึงเรา
โชคดี