>> DAVID ลัน: ขวาทั้งหมดยินดีต้อนรับกลับ
นี่คือ CS50
นี่คือจุดเริ่มต้นของสัปดาห์ที่เจ็ด
ดังนั้นจึงได้รับในขณะดังนั้นฉันคิดว่าเราต้องการ ใช้ทัวร์ลมกรดจากที่เรา
ซ้ายปิดและสถานที่ที่เราตอนนี้จะ
>> ดังนั้นสิ่งนี้อาจจะมีที่นี่ ก่อให้เกิดความทุกข์บางอย่างในตอนแรก
แต่หวังว่าคุณจะเริ่มต้นในการ ปรับตัวให้ชินกับสิ่งที่นี้หมายถึงที่นี่ -
ดาวที่เป็นตัวแทนของตัวชี้ซึ่งเป็น เพียงแค่สิ่งที่ในแง่ของคนธรรมดามากขึ้น?
ดังนั้นจึงเป็นที่อยู่
>> ดังนั้นจึงเป็นที่อยู่ของ บางสิ่งบางอย่างในความทรงจำ
และเราเริ่มที่จะกลับชั้นเปลือก สองสามสัปดาห์ที่ผ่านมาสิ่งที่ต้องการ
GetString และอื่น ๆ ฟังก์ชั่นดังกล่าว ตลอดเวลานี้ได้รับกลับมา
ที่อยู่ของสิ่งที่อยู่ในหน่วยความจำเช่น ที่อยู่ของตัวอักษรตัวแรกใน
ลำดับบาง
>> ดังนั้นเราจึงยังแนะนำ valgrind ซึ่ง คุณจะเริ่มต้นที่จะใช้สำหรับปัญหานี้
ตั้งโดยเฉพาะอย่างยิ่งสำหรับการต่อไป ปัญหาการตั้งค่าเช่นกัน
และ valgrind ทำอะไรสำหรับเรา?
มันจะตรวจสอบการรั่วไหลของหน่วยความจำและมัน นอกจากนี้ยังตรวจสอบการทำผิดกฎเกี่ยวของหน่วยความจำ
>> มันสามารถมีความน่าจะเป็นบางอย่างที่ตรวจสอบว่า รหัสของคุณเป็นไปสัมผัสหน่วยความจำ
ที่มันก็ไม่ควร
ดังนั้นไม่จำเป็นต้องรั่ว แต่ถ้าคุณ ไปไกลเกินกว่าขอบเขตของบาง
อาร์เรย์และคุณทำงานจริง valgrind และก่อให้เกิดพฤติกรรมที่ว่าในขณะที่
valgrind กำลังทำงานในโปรแกรมของคุณ การทำงานภายในของมันคุณจะได้รับ
ข้อความเช่นนี้ - "ที่ไม่ถูกต้องเขียนจาก ขนาด 4 "ซึ่งจำคู่ของ
สัปดาห์ที่ผ่านมานั่นหมายความว่าฉันมีความตั้งใจ เช่นเดียวกับหนึ่ง int ไกลเกินไป
เกินขอบเขตของอาร์เรย์
และอื่น ๆ 4 ขนาดขนาดหมายถึงที่นี่ ของ int นั้น
>> ดังนั้นจะให้ความมั่นใจในความเป็นจริงว่า เอาท์พุท valgrind ของรูปแบบของมัน
เป็นเพียงเลวร้าย
มันยากจริงๆที่จะดูผ่านระเบียบ สำหรับข้อมูลที่น่าสนใจ
ดังนั้นสิ่งที่เราได้ทำที่นี่ที่ตัดตอนมาเพียง บางส่วนของคู่อื่น ๆ
เส้นที่น่าสนใจ
แต่ตระหนักว่า 80% ของ valgrind ของ เอาท์พุทเป็นไปได้บิตของ
ความว้าวุ่นใจ
>> เพียงแค่มองหารูปแบบเช่นนี้ - ที่ไม่ถูกต้องที่ถูกต้องไม่ถูกต้องอ่าน 40 ไบต์
และจำนวนบล็อกบางอย่างแน่นอน คำหลักที่หายไปเช่นเดียวกับที่
และสิ่งที่คุณหวังว่าจะเห็นเป็นบางส่วน ชนิดของการตรวจสอบของสิ่งที่ทำงาน
ความผิดพลาดเป็นจริงค่ะ
ในกรณีนี้ที่นี่ในสิ่งที่สายของ รหัสของฉันเกิดข้อผิดพลาดที่เห็นได้ชัด?
>> 26 ในไฟล์ที่เรียกว่า memory.c ซึ่งเป็น ตัวอย่างเช่นที่เรากำลังเล่นกับ
ในช่วงเวลานั้น
ดังนั้นมันอาจจะไม่ได้อยู่ใน malloc
มันอาจจะเป็นในรหัสของฉันแทน
ดังนั้นเราจะเห็นสิ่งนี้อีกครั้ง และอีกครั้งก่อนที่จะยาว
>> ดังนั้น scanf นี้ขึ้นมาใน คู่ของรูปแบบป่านนี้
เราเห็น sscanf สั้น
มันเป็นสิ่งที่จำนวนของ คุณดำดิ่งลงไปในของคุณ
เตรียมการสำหรับการตอบคำถาม
และ scanf เป็นจริงสิ่งที่ CS50 ห้องสมุดที่ได้รับใช้ใต้
เครื่องดูดควันสำหรับค่อนข้างบางเวลาในการสั่งซื้อสินค้าบางอย่าง ได้รับข้อมูลจากผู้ใช้
>> ตัวอย่างเช่นถ้าฉันย้ายไปยัง CS50 เครื่องใช้ที่นี่ให้ฉันเปิดขึ้น
ตัวอย่างเช่นในวันนี้ว่าที่เรียกว่า scanf-0.c และมันง่ายสุด
มันเป็นเพียงไม่กี่บรรทัดของรหัส
แต่มันแสดงให้เห็นถึงวิธีการที่จริงๆ getInt ได้รับการทำงานทั้งหมดในเวลานี้
>> ในโปรแกรมนี้ที่นี่ใน 16 เส้น แจ้งให้ทราบว่าผมประกาศ int
ดังนั้นตัวชี้ไม่มีอะไรที่มีมนต์ขลัง มีเพียง int
จากนั้นในบรรทัดที่ 17 ผมแจ้งให้ สำหรับจำนวนผู้ใช้โปรด
จากนั้นในช่วงปลายปี 18 ผมใช้ scanf ที่นี่
และฉันระบุชนิดเช่น printf, ที่ฉันคาดหวังอ้าง
ไม่ได้นำมาอ้างผมเปอร์เซ็นต์
>> ดังนั้นผมคิดเป็นร้อยละของหลักสูตร หมายถึง int
แต่สังเกตเห็นสิ่งที่สอง อาร์กิวเมนต์ scanf คือ
วิธีที่คุณจะอธิบายที่สอง อาร์กิวเมนต์หลังจากจุลภาค?
ว่าคืออะไร?
>> มันเป็นที่อยู่ของ x
ดังนั้นนี้เป็นประโยชน์เพราะด้วยการให้ scanf กับที่อยู่ของ x สิ่งที่จะ
ที่ช่วยให้การทำงานที่จะทำอย่างไร?
ไม่เพียง แต่ไปที่นั่น แต่ยังทำในสิ่งที่?
>> ทำการเปลี่ยนแปลงมัน
เพราะคุณสามารถไปที่นั่นมันเรียงลำดับจาก เช่นแผนที่ไปยังตำแหน่งในหน่วยความจำ
และ scanf ตราบเท่าที่คุณจัดให้มีหรือ ฟังก์ชั่นด้วยเช่นแผนที่ที่ใด
ฟังก์ชั่นสามารถไปที่นั่นและไม่เพียง แต่ มองไปที่ค่า แต่มันยังสามารถ
เปลี่ยนค่าที่ซึ่งจะเป็นประโยชน์ถ้า มุ่งหวังในชีวิต scanf คือการ
สแกนข้อมูลจากผู้ใช้โดยเฉพาะ จากแป้นพิมพ์
f และหมายถึงการจัดรูปแบบเช่นเดียวกับ printf, F หมายถึงการจัดรูปแบบ
สตริงที่คุณต้องการพิมพ์
>> ดังนั้นในระยะสั้น, 18 บรรทัดนี้ก็บอกว่า ลองอ่านจาก int ของผู้ใช้
แป้นพิมพ์และเก็บไว้ภายในของ x ที่ อะไรก็ตามที่อยู่ x เกิดขึ้นอยู่ที่
แล้วสุดท้าย 19 เส้นเพียงแค่พูดว่า, ขอบคุณสำหรับ int ในกรณีนี้
>> เพื่อให้ฉันไปข้างหน้าและทำให้เรื่องนี้
เพื่อให้ scanf 0
ให้ฉันไปข้างหน้าและขยาย
ฉันจะไปและทำงานนี้ด้วย จุดเฉือน scanf 0
จำนวนการเข้า?
50
ขอบคุณสำหรับ 50
ดังนั้นจึงค่อนข้างง่าย
>> ตอนนี้มันเป็นสิ่งที่ไม่ทำอะไร
มันไม่ได้ทำทั้งกลุ่ม จากการตรวจสอบข้อผิดพลาด
ตัวอย่างเช่นถ้าฉันไม่ให้ความร่วมมือ และฉันไม่ต้องพิมพ์ในจำนวน แต่
แทนฉันเขียนสิ่งที่ต้องการ "สวัสดี" นั่นเป็นเพียงชนิดของแปลก
และหนึ่งในสิ่งที่ CS50 ห้องสมุดได้รับการทำสำหรับเราสำหรับบางคน
เวลาขณะนี้ reprompting ว่า และ reprompting
>> จำวลีลองใหม่อีกครั้งใน cs50.c, และนั่นคือเหตุผลที่ว่าใน getInt
ห้องสมุด CS50 เป็นจริงทั้ง พวงของสายยาวเพราะเรา
การตรวจสอบสำหรับสิ่งที่โง่เช่นนี้
ผู้ใช้ไม่ได้ให้ เราในความเป็นจริง int?
เขาหรือเธอให้เราบางสิ่งบางอย่าง เช่นตัวอักษรที่เรียงตามตัวอักษร?
ถ้าเราต้องการที่จะตรวจสอบ และตะโกนใส่พวกเขา
>> แต่สิ่งที่ได้รับน่าสนใจมากขึ้น ในตัวอย่างต่อไปนี้
ถ้าฉันไป scanf-1.C เป็นหนึ่งในสิ่งที่ สิ่งที่มีการเปลี่ยนแปลงพื้นฐานใน
เช่นนี้ต่อไปหรือไม่
ฉันใช้ char * แน่นอน แทน int
>> ดังนั้นนี้เป็นที่น่าสนใจเพราะ char * จำเป็นจริงเพียง
สิ่งเดียวที่เป็นสตริง
ดังนั้นจึงรู้สึกเหมือนอาจจะเป็นซูเปอร์ การดำเนินงานที่เรียบง่ายของ GetString
แต่ฉันกลับปอกเปลือกชั้น จาก CS50 ห้องสมุดดังนั้นฉัน
เรียกนี้ char * ในขณะนี้
ดังนั้นขอดูว่าถ้าที่ใดก็ได้ เราไปอย่างผิดปกติ
>> 17 สาย -
ผมพูดอีกครั้งโปรดให้ฉันบางสิ่งบางอย่าง ในกรณีนี้สตริง
และจากนั้นในบรรทัดถัดไปผมเรียก scanf, อีกครั้งให้มันรหัสรูปแบบ,
แต่ร้อยละเวลานี้ s
และแล้วเวลานี้ฉัน ให้มันบัฟเฟอร์
>> ตอนนี้สังเกตเห็นฉันไม่ได้ใช้ เครื่องหมาย
แต่สิ่งที่เป็นที่ตกลงอาจเป็นเหตุผลที่นี่?
เพราะเป็นสิ่งบัฟเฟอร์แล้ว
มันมีอยู่แล้วชี้
มันมีอยู่แล้วที่อยู่
>> และขอคำนี้ "สับสน" ให้ฉัน เพียงแค่เรียกมันเช่นสำหรับ
ความง่าย
แต่ฉันเรียกมันว่า buffer เพราะใน โดยทั่วไปในการเขียนโปรแกรมถ้าคุณมี
หน่วยความจำอันซึ่งสตริงจริงๆ เพียงคุณอาจเรียกมันว่าบัฟเฟอร์
เป็นสถานที่ในการจัดเก็บข้อมูล
>> คล้ายกับสิ่งต่าง ๆ เช่น YouTube, เมื่อ พวกเขากำลังบัฟเฟอร์เพื่อที่จะพูดว่า
ก็หมายความว่ามันดาวน์โหลดบิตจาก อินเทอร์เน็ตและเก็บไว้ใน
อาร์เรย์ท้องถิ่นก้อนท้องถิ่นของหน่วยความจำเพื่อ ที่คุณสามารถดูได้ในภายหลังโดยไม่ต้อง
มันกระโดดข้ามหรือแขวนอยู่บน คุณในขณะที่เล่น
>> ดังนั้นจึงไม่มีปัญหาอะไร แต่ที่นี่ เพราะฉันบอก scanf คาดว่า
สตริงจากผู้ใช้
นี่คือที่อยู่ของคน หน่วยความจำอัน
ใส่สตริงที่มี
จำกัด นั่นคือเหตุผลที่ทำให้ เรามีปัญหา แต่?
>> ว่าคืออะไร?
ฉันอนุญาตให้เข้าถึง ส่วนหนึ่งของหน่วยความจำที่?
คุณจะรู้ว่าผมไม่ทราบว่า
เพราะได้รับการเริ่มต้นบัฟเฟอร์ อะไร?
ไม่ได้จริงๆ
และดังนั้นจึงเป็นสิ่งที่เราได้รับการเรียก ค่าขยะซึ่ง
ไม่ได้เป็นคำที่เป็นทางการ
มันก็หมายความว่าเรามีความคิดว่าไม่มีบิต จะอยู่ภายในสี่ไบต์ที่
ฉันได้รับการจัดสรรเป็นกันชน
>> ฉันไม่ได้เรียกว่า malloc
ฉันแน่นอนไม่เรียกว่า GetString
ดังนั้นใครรู้ว่าสิ่งที่เป็นจริงที่ ภายในของ buffer?
และยังบอก scanf สุ่มสี่สุ่มห้าไปที่นั่น และใส่สิ่งที่ผู้ใช้พิมพ์
>> ดังนั้นมีโอกาสที่จะก่อให้เกิดสิ่ง ในรหัสของเราถ้าเราทำงานได้หรือไม่
อาจ segfault
อาจจะไม่ แต่มันอาจจะ segfault
และที่ผมพูดอาจจะไม่เพราะบางครั้ง ที่คุณทำบางครั้ง
คุณไม่ได้รับ segfault
บางครั้งคุณเพียงได้รับโชคดี แต่ กระนั้นก็เป็นไปได้
ข้อผิดพลาดในโปรแกรมของเรา
>> เพื่อให้ฉันไปข้างหน้าและรวบรวมนี้
ฉันจะทำมันด้วยวิธีโรงเรียนเก่า
ดังนั้นชนเสียงดังกราว 0, scanf-1, scanf-1.C ป้อน
โอ๊ะโรงเรียนเก่าเกินไป
ลองมาดูกัน
ผมไม่ไปไหน
โอ้บัฟเฟอร์ char *
โอ้ขอบคุณ -
บันทึกตกลง -
โรงเรียนเก่ามาก
ทั้งหมดที่ถูกต้องจะได้รับในขณะที่
>> ดังนั้นผมจึงได้บันทึกไว้เพียงไฟล์หลังจากที่ การทำชั่วคราวที่
เปลี่ยนช่วงเวลาที่ผ่านมา
และตอนนี้ฉันได้รวบรวมมัน ด้วยตนเองด้วยเสียงดังกราว
และตอนนี้ฉันจะไปข้างหน้า และเรียกใช้ scanf-1 ใส่
String โปรด
ผมจะพิมพ์ใน "Hello."
>> และตอนนี้ที่นี่เป็นที่ที่ตรงไปตรงมา printf สามารถเป็นที่น่ารำคาญเล็ก ๆ น้อย ๆ
มันไม่ได้เป็นจริงจะ segfault ในกรณีนี้
printf เป็นเพียงเล็กน้อยพิเศษเพราะ ก็สุดเพื่อให้ใช้กันโดยทั่วไปว่า
หลัก printf จะทำ เราชอบและตระหนัก
ที่ไม่ได้เป็นตัวชี้ที่ถูกต้อง
ให้ฉันใช้มันกับตัวเองที่จะเพียงแค่พิมพ์ ออกในวงเล็บโมฆะแม้
แม้ว่ามันจะไม่จำเป็นอะไร ตัวเราเองคาดว่า
>> ดังนั้นเราจึงไม่สามารถจริงๆได้อย่างง่ายดายทำให้เกิด segfault กับการนี​​้ แต่อย่างชัดเจนนี้
ไม่ใช่พฤติกรรมที่ฉันต้องการ
ดังนั้นทางออกที่ง่ายคืออะไร
ทั้งใน scanf-2 ให้ฉันเสนอว่า แทนการจัดสรรจริงเพียง
char * ให้ฉันเป็นเพียงเล็กน้อยอย่างชาญฉลาดเกี่ยวกับ นี้และแจ้งให้เราจัดสรรบัฟเฟอร์
เป็นลำดับจาก 16 ตัวอักษร
>> ดังนั้นผมจึงสามารถทำเช่นนี้ในสองวิธี
ฉันอย่างสามารถใช้ malloc
แต่ผมสามารถกลับไปสัปดาห์ที่สองเมื่อ ผมจำเป็นต้องมีทั้งกลุ่ม
อักขระ
นั่นเป็นเพียงอาร์เรย์
เพื่อให้ฉันแทน redefine บัฟเฟอร์ เป็นอาร์เรย์ของ 16 ตัวอักษร
>> และตอนนี้เมื่อฉันผ่านบัฟเฟอร์ใน -
และนี่คือสิ่งที่เราไม่ได้ พูดคุยเกี่ยวกับในสัปดาห์ที่สอง -
แต่คุณสามารถรักษาอาร์เรย์เป็น แม้ว่ามันจะอยู่
ในทางเทคนิคที่เราได้เห็นพวกเขากำลัง แตกต่างกันเล็กน้อย
แต่ scanf จะไม่ทราบถ้าคุณผ่านมัน ชื่อของอาร์เรย์เพราะสิ่งที่
เสียงดังกราวจะทำเพื่อเราเป็นหลัก รักษาชื่อของอาร์เรย์ที่เป็น
ที่อยู่ของก้อน 16 ไบต์
>> ดังนั้นนี่คือที่ดีขึ้น
ซึ่งหมายความว่าตอนนี้ที่ฉันสามารถหวังว่า ทำต่อไปนี้
ผมขอซูมออกอยู่ครู่หนึ่งแล้ว จะทำให้ scanf-2 รวบรวมตกลง
ตอนนี้ให้ฉันทำอะไรได้เฉือน scanf-2
String โปรด "Hello." และมัน ดูเหมือนจะทำงานในเวลานี้
>> แต่คนที่สามารถนำเสนอสถานการณ์ ในสิ่งที่มันอาจจะไม่ยังคงทำงาน?
อ้าง?
บางสิ่งบางอย่างนานกว่า 16 ตัวอักษร
และที่จริงเราสามารถเป็น เล็ก ๆ น้อย ๆ ที่แม่นยำยิ่งขึ้น
บางสิ่งบางอย่างอีกต่อไปแล้ว 15 ตัวอักษร, เพราะจริงๆเราจำเป็นต้องเก็บไว้ในใจ
ว่าเราต้องเป็นศูนย์เครื่องหมายทับขวาที่ โดยปริยายในตอนท้ายของสตริง,
ซึ่งเป็นกัน scanf จะมัก ในการดูแลของเรา
>> เพื่อให้ฉันทำสิ่งที่ชอบ -
บางครั้งเราก็สามารถ ปล่อยให้มันเป็นอย่างนั้น
OK เพื่อให้เราได้เกิดในขณะนี้ แบ่งส่วนความผิดของเรา
ทำไม?
เพราะฉันพิมพ์ไปกว่า 15 อักขระและเพื่อให้เราได้จริง
หน่วยความจำสัมผัสที่จริงผม ไม่ควรมี
>> ดังนั้นจริงๆสิ่งที่แก้ปัญหาที่นี่?
ดีสิ่งที่ถ้าเราต้องการสตริงอีกต่อไป?
ดีเราอาจจะทำให้มันเป็น 32 ไบต์
ดีสิ่งที่ถ้าที่ไม่นานเพียงพอหรือไม่
วิธีการเกี่ยวกับ 64 ไบต์?
เกิดอะไรขึ้นถ้าที่ไม่ยาวเพียงพอหรือไม่
วิธีการเกี่ยวกับ 128 หรือ 200 ไบต์?
จริงๆสิ่งที่เป็นวิธีการแก้ที่นี่ใน กรณีทั่วไปถ้าเราไม่ทราบ
ความก้าวหน้าของสิ่งที่ผู้ใช้จะพิมพ์?
>> มันเป็นเพียงชนิดของความเจ็บปวดขนาดใหญ่ในลา, จะซื่อสัตย์ซึ่งเป็นเหตุผลที่
CS50 ห้องสมุดมีสายไม่กี่โหลจาก รหัสที่ใช้เรียก
getString สตริงในทางที่เราทำไม่ได้ ต้องรู้ล่วงหน้าว่า
ผู้ใช้จะพิมพ์
โดยเฉพาะอย่างยิ่งถ้าคุณมองกลับไปที่ cs50.c จากสองสัปดาห์ที่ผ่านมาคุณจะเห็น
GetString ว่าไม่จริง ได้ใช้ scanf ในลักษณะนี้
แต่ก็อ่านตัวละครตัวหนึ่ง ได้ตลอดเวลา
>> เพราะสิ่งหนึ่งที่ดีเกี่ยวกับ การอ่านเป็นตัวละครตัวหนึ่งที่เราสามารถทำได้
รับประกันตัวเองอยู่เสมอ มีอย่างน้อยหนึ่งถ่าน
ผมสามารถประกาศถ่านและจากนั้นใช้ เหล่านี้ขั้นตอนทารกอย่างแท้จริงที่จะเพียงแค่
อ่านตัวละครตัวหนึ่งในที่ เวลาจากแป้นพิมพ์
และแล้วสิ่งที่คุณจะเห็น GetString ไม่เป็นเวลาที่มันไหลออกมาจากทุก
พูด, 16 ไบต์ของหน่วยความจำจะใช้ malloc หรือญาติของมันไป
จัดสรรหน่วยความจำมากขึ้นการคัดลอกเก่า หน่วยความจำเข้าไปใหม่และจากนั้นรวบรวมข้อมูล
พร้อมรับตัวละครตัวหนึ่งในเวลา, และเมื่อมันวิ่งออกไปจากที่
หน่วยความจำอันโยนมันออกไปคว้า เป็นก้อนขนาดใหญ่ของหน่วยความจำชุดเก่า
เข้าไปใหม่ซ้ำแล้วซ้ำอีกและ
และมันก็เป็นความเจ็บปวดอย่างแท้จริงที่จริง ใช้สิ่งที่ง่ายเป็น
ได้รับข้อมูลจากผู้ใช้
>> ดังนั้นคุณสามารถใช้ scanf
คุณสามารถใช้ฟังก์ชั่นอื่นที่คล้ายคลึงกัน
และจำนวนมากที่มีตำราและออนไลน์ ตัวอย่างทำ แต่พวกเขากำลังทั้งหมด
ความเสี่ยงที่จะมีปัญหาเช่นนี้
และในที่สุดได้รับการ, segfault เป็นชนิดที่น่ารำคาญ
มันไม่ดีสำหรับผู้ใช้
>> แต่ในกรณีที่เลวร้ายที่สุดสิ่งที่ไม่ มันลึกซึ้งใส่ของคุณ
รหัสที่มีความเสี่ยง?
บางชนิดของการโจมตีที่อาจเกิดขึ้น
เราได้พูดคุยเกี่ยวกับการโจมตีดังกล่าวเป็นหนึ่ง - ล้นสแต็ค
แต่โดยทั่วไปถ้าคุณได้รับอนุญาตให้ หน่วยความจำล้นเหมือนที่เราทำ
สองสามสัปดาห์ที่ผ่านมามีเพียงการเขียน มากไปกว่า "สวัสดี" ใน stack คุณ
แน่นอนสามารถใช้เวลามากกว่าอาจ คอมพิวเตอร์หรืออย่างน้อยได้รับข้อมูลที่ว่า
ไม่ได้เป็นของคุณ
>> ดังนั้นในระยะสั้นนี้คือเหตุผลที่เรามี ที่ล้อการฝึกอบรม
แต่ตอนนี้เราเริ่มที่จะพาพวกเขาออกไป เป็นโปรแกรมที่เราไม่จำเป็นต้อง,
จำเป็นต้องป้อนข้อมูลจากผู้ใช้
แต่ในกรณีของปัญหาที่กำหนดหก, ใส่ของคุณจะมาจากขนาดใหญ่
ไฟล์พจนานุกรมที่มี 150 บาง คำพันแปลก
>> ดังนั้นคุณจะไม่ต้องกังวลเกี่ยวกับ การป้อนข้อมูลโดยพลการของผู้ใช้
เราจะให้สมมติฐานบางอย่าง เกี่ยวกับไฟล์ที่
คำถามใด ๆ เกี่ยวกับตัวชี้หรือ scanf หรือผู้ใช้ป้อนในทั่วไป?
>> ขวาทั้งหมดเพื่อให้ดูอย่างรวดเร็วแล้วที่หนึ่ง ตามหัวข้อจากสองสัปดาห์ที่ผ่านมา
และนั่นก็คือค​​วามคิดของ struct นี้
ไม่ว่า - ความคิดของนี้ struct ซึ่งเป็นอะไร
struct ไม่ทำอะไรให้เรา?
>> กำหนด -
เสียใจ?
กำหนดชนิดตัวแปร
ดังนั้นการจัดเรียงของ
เรากำลังจริงรวมสองหัวข้อ
ดังนั้นด้วย typedef, จำได้ว่าเราสามารถ ประกาศของเราเองเช่น
ไวพจน์, สตริงเหมือนถ่าน *
แต่การใช้ typedef struct และเราสามารถ สร้างโครงสร้างที่แท้จริงของเราเองข้อมูล
>> ตัวอย่างเช่นถ้าผมกลับไปสู่​​ Gedit ที่นี่รอสักครู่และฉันไปข้างหน้า
และทำสิ่งที่ต้องการให้ฉันช่วย นี้เป็นสมมติว่า, structs.c
ชั่วคราวฉันแค่ไป ไปข้างหน้าและรวมถึง
standardio.h, เป็นโมฆะหลัก int
จากนั้นในที่นี่สมมติว่าฉันต้องการ การเขียนโปรแกรมที่จัดเก็บ
นักเรียนหลายชุดจาก บ้านตัวอย่างเช่น
ดังนั้นมันก็เหมือน registrarial ฐานข้อมูลของการจัดเรียงบาง
>> ดังนั้นถ้าฉันต้องชื่อนักศึกษาคนหนึ่งผม อาจจะทำบางสิ่งบางอย่างเช่นชื่อ char *
และฉันจะทำสิ่งที่ชอบ -
จริงให้ใช้ CS50 ห้องสมุด รอสักครู่เพื่อให้นี้
เล็กน้อยง่ายเพื่อให้เราสามารถยืม หลายสิบคนจากบรรทัดของรหัส
และขอเพียงแค่ให้มันง่าย
เราจะเก็บสตริง, และตอนนี้ getString
>> ดังนั้นผมจึงเรียกร้องในขณะนี้ที่ฉันได้เก็บไว้ชื่อ ของนักเรียนบางส่วนและที่บ้านของ
นักเรียนบางเพียงแค่ใช้ตัวแปร เช่นเดียวกับที่เราทำและในหนึ่งสัปดาห์
แต่คิดว่าตอนนี้ผมต้องการให้การสนับสนุน นักเรียนหลาย ๆ
ทั้งหมดขวาดังนั้นสัญชาตญาณของฉันที่จะทำ สตริง name2 ได้รับสตริง GetString
House2 ได้รับ GetString
แล้วนักเรียนที่สามของเรา ขอทำ NAME3 GetString
>> ขวาทั้งหมดดังนั้นนี่คือความหวังที่โดดเด่น คุณเป็นชนิดของโง่
เนื่องจากกระบวนการนี​​้เป็นจริงไม่เคย จะจบและก็แค่ไป
ทำให้รหัสของฉันดูแย่ลง และแย่ลงและแย่ลง
แต่เราแก้ปัญหานี้เช่นกันในสัปดาห์ที่สอง
สิ่งที่แก้ปัญหาค่อนข้างสะอาดของเรา เมื่อเรามีหลายตัวแปรของ
ประเภทข้อมูลเดียวกันที่เกี่ยวข้องทั้งหมด แต่ เราไม่อยากให้เรื่องนี้เป็นระเบียบที่เลวร้าย
ของตัวแปรชื่อเดียว?
เราทำอะไรแทน?
>> ดังนั้นฉันคิดว่าฉันได้ยินสถานที่ไม่กี่
เรามีอาร์เรย์
หากคุณต้องการหลายกรณี บางสิ่งบางอย่างทำไมเราไม่ทำความสะอาดทั้งหมดนี้
ขึ้นมาและเพียงแค่พูดให้ฉัน อาร์เรย์เรียกชื่อ?
>> และสำหรับตอนนี้ขอรหัสยาก 3
แล้วให้ฉันอาร์เรย์อีก ที่เรียกว่าบ้านและแจ้งให้เราสำหรับ
ขณะนี้ยากรหัส 3
และฉันได้ทำความสะอาดอย่างหนาแน่นขึ้น รับประทานอาหารที่ฉันเพิ่งสร้าง
ตอนนี้ฉันยังคงรหัสยาก 3 แต่แม้ 3 แบบไดนามิกอาจมาจาก
ผู้ใช้หรือ argv หรือเช่น
ดังนั้นนี่คือการทำความสะอาดแล้ว
>> แต่สิ่งที่น่ารำคาญเกี่ยวกับเรื่องนี้ก็คือ ตอนนี้ถึงแม้ว่าชื่อเป็นอย่างใด
เชื่อมโยงลึกซึ้ง บ้านของนักเรียน -
มันเป็นนักเรียนที่ผม ต้องการที่จะเป็นตัวแทน -
ตอนนี้ผมมีสองอาร์เรย์ที่เป็นคู่ขนาน ในแง่ที่ว่าพวกเขากำลัง
วงเล็บขนาดเดียวกันชื่อและ 0 แผนที่น่าจะยึดบ้าน 0,
และชื่อวงเล็บ 1 แผนที่ ยึดบ้าน 1
ในคำอื่น ๆ นักเรียนที่อาศัยอยู่ใน บ้านหลังนั้นและที่นักเรียนคนอื่น
อาศัยอยู่ในบ้านอื่น ๆ ที่
แต่แน่นอนนี้อาจจะ ทำมากยิ่งขึ้นหมดจด
>> ดีก็สามารถจะทำได้ในความเป็นจริง
และแจ้งให้เราไปข้างหน้าและเปิด ขึ้น structs.h และคุณจะ
ดูความคิดนี้ที่นี่
ขอให้สังเกตว่าที่ผมเคยใช้ typedef เป็นคุณ พาดพิงถึงช่วงเวลาที่ผ่านมาในการประกาศของเรา
ชนิดข้อมูลของตัวเอง
แต่ฉันยังใช้คำหลักอื่น ๆ เรียกว่า struct ซึ่งทำให้ผมใหม่
โครงสร้างข้อมูล
>> และโครงสร้างข้อมูลที่ผมเรียกร้องที่เกิดขึ้น มีสองสิ่งที่อยู่ภายใน
มัน - สตริงเรียกชื่อและ สตริงที่เรียกว่าบ้าน
และชื่อของฉันจะมอบให้กับ นี้โครงสร้างข้อมูลที่เกิดขึ้น
จะเรียกว่านักเรียน
ฉันจะเรียกมันว่าอะไรที่ฉันต้องการ แต่ความหมายนี้ทำให้
รู้สึกถึงฉันในใจของฉัน
>> ดังนั้นตอนนี้ถ้าผมเปิดเป็นรุ่นที่ดีกว่า ของโปรแกรมที่ผมเริ่มเขียน
มีให้ฉันเลื่อนไปด้านบน
และมีเส้นบางมากขึ้นรหัสของ ที่นี่ แต่ให้ฉันมุ่งเน้นสำหรับ
ขณะที่หนึ่ง
ผมเคยประกาศนักเรียนที่เรียกว่าค่าคงที่ และรหัสยาก 3 สำหรับตอนนี้
แต่ตอนนี้แจ้งให้ทราบว่าการทำความสะอาด รหัสของฉันเริ่มที่จะได้รับ
>> ในบรรทัดที่ 22 ผมประกาศ อาร์เรย์ของนักเรียน
และสังเกตเห็นว่านักเรียนเห็นได้ชัดคือ ขณะนี้ชนิดข้อมูล
เพราะที่ด้านบนของไฟล์นี้, แจ้งให้ทราบล่วงหน้า เราได้รวมไฟล์ส่วนหัวที่
ที่ฉันดึงขึ้นเพียงแค่ช่วงเวลาที่ผ่านมา
และไฟล์ส่วนหัวที่ค่อนข้างง่ายมี นิยามของนักเรียนนี้
>> ดังนั้นตอนนี้เราได้สร้างข้อมูลของฉันเอง ชนิดที่ผู้เขียนของปี C
ที่ผ่านมาไม่ได้คิดล่วงหน้า
แต่ไม่มีปัญหา
ฉันสามารถทำให้ตัวเอง
ดังนั้นนี่คืออาร์เรย์เรียกว่านักเรียน, สมาชิกแต่ละคนมี
เป็นโครงสร้างนักเรียน
และฉันต้องการสามของคนเหล่านั้น ในอาร์เรย์
>> และตอนนี้ส่วนที่เหลือจะทำอะไร ของโปรแกรมนี้ทำอะไร?
ผมจำเป็นต้องมีบางสิ่งบางอย่างเล็ก ๆ น้อย ๆ โดยพลการ
ดังนั้นจากออนไลน์ 24 เป็นต้นไป ผมย้ำ 0-3
จากนั้นผมก็ขอให้ผู้ใช้ ชื่อของนักเรียน
และแล้วฉันจะใช้ GetString เป็นมาก่อน
แล้วผมก็ถามหาบ้านของนักเรียน, และฉันจะใช้ getString เป็นมาก่อน
>> แต่แจ้งให้ทราบล่วงหน้า - ใหม่เล็กน้อย ชิ้นส่วนของไวยากรณ์ -
ฉันสามารถดัชนียังคงนักเรียนที่ i, แต่ฉันจะได้รับข้อมูลเฉพาะที่
ภายในสนามของ struct?
ดีว่าเห็นได้ชัดว่าสิ่งที่ ชิ้นใหม่ของไวยากรณ์?
มันเป็นเพียงจุดประกอบ
>> เราไม่เคยเห็นจริงๆแบบนี้มาก่อน
คุณได้เห็นมันใน pset ห้าถ้าคุณได้ พุ่งในแล้วกับแฟ้มบิตแมป
แต่จุดก็หมายความภายในนี้ struct หรือหลายเขตข้อมูลให้จุด
ชื่อหรือให้ฉัน dot บ้าน
นั่นหมายถึงการไปภายในของ struct และได้รับข้อมูลเหล่านั้นโดยเฉพาะอย่างยิ่ง
>> ส่วนที่เหลือของโปรแกรมนี้ทำอะไรได้บ้าง
มันไม่ทั้งหมดที่เซ็กซี่
ขอให้สังเกตว่าผมย้ำ 0-3 อีกครั้ง และฉันเพียงแค่สร้างภาษาอังกฤษ
วลีเช่นดังนั้นจึงอยู่ในดังกล่าวและ เช่นบ้านที่ผ่านในชื่อจุดจาก
นักเรียนที่ i ของพวกเขาและ บ้านเช่นกัน
>> แล้วท้ายสุดคือตอนนี้เราจะเริ่มต้นเพื่อให้ได้ ทางทวารหนั​​กเกี่ยวกับเรื่องนี้ในขณะนี้ว่าเรา
คุ้นเคยกับสิ่งที่ malloc และ ฟังก์ชั่นอื่น ๆ ได้รับ
ทำทุกอย่างในเวลานี้
ฉันจะมีให้เป็นอิสระทั้งชื่อทำไม บ้านและแม้ว่าฉัน
ไม่ได้เรียก malloc?
>> GetString ไม่
และนั่นก็คือค​​วามลับสกปรกน้อยสำหรับ เป็นเวลาหลายสัปดาห์ แต่มี GetString
รับหน่วยความจำรั่วทั่ว วางภาคการศึกษาทั้งหมดป่านนี้
และในที่สุดจะ Valgrand เปิดเผยเรื่องนี้กับเรา
>> แต่มันไม่ใช่เรื่องใหญ่เพราะฉันรู้ว่า ว่าฉันก็สามารถฟรีชื่อ
บ้านและถึงแม้ว่าในทางเทคนิคไป เป็นซุปเปอร์เซฟซุปเปอร์ฉันควรจะ
การทำข้อผิดพลาดการตรวจสอบนี่คือบางส่วน
สัญชาตญาณของคุณจะบอกคุณคืออะไร?
ผมควรจะตรวจสอบ ก่อนที่ฉันจะเป็นอิสระในสิ่งที่เป็น
สตริงอาคาซึ่ง char *?
>> ฉันควรจริงๆจะตรวจสอบว่านักเรียน ชื่อวงเล็บผมจุดไม่ได้
โมฆะเท่ากับ
แล้วมันจะตกลงไปข้างหน้าและฟรี ตัวชี้นั้นและเดียวกันหรืออื่น ๆ
หนึ่งเช่นกัน
ถ้านักเรียนวงเล็บผม dot บ้านไม่ได้ เท่ากับโมฆะในตอนนี้จะให้ความคุ้มครอง
กับกรณีที่มุมที่ ผลตอบแทนที่ GetString สิ่งที่ต้องการโมฆะ
และเราได้เห็นช่วงเวลาที่ผ่านมาจะ printf ปกป้องเราขึ้นที่นี่โดยเพียงแค่บอกว่า
โมฆะซึ่งจะไปดูแปลก
แต่อย่างน้อยก็จะไม่ segfault, ในขณะที่เราได้เห็น
>> ดีให้ฉันทำสิ่งหนึ่งที่อื่น ๆ ที่นี่ structs-0 เป็นชนิดของโปรแกรมที่โง่
เพราะผมป้อนข้อมูลทั้งหมดนี้แล้ว มันหายไปทันทีที่โปรแกรมกำลังจะสิ้นสุดลง
แต่ให้ฉันไปข้างหน้าและทำเช่นนี้
ผมขอให้ขั้ว หน้าต่างบิตที่ใหญ่กว่า
ผมขอให้ structs-1 ซึ่ง รุ่นใหม่ของที่นี่คือ
>> ผมจะซูมในนิด ๆ หน่อย ๆ
และตอนนี้ให้ฉันทำงานจุด เฉือน structs-1
ชื่อของนักเรียน -
เดวิดท้องขอทำร็อบเคิร์กแลนด์, ขอทำลอเรน Leverett
มีอะไรที่น่าสนใจในขณะนี้คือการแจ้งให้ทราบ -
และฉันเพียงรู้นี้เพราะ ผมเขียนโปรแกรม -
มีไฟล์ตอนนี้เมื่อปัจจุบันของฉัน ไดเรกทอรีที่เรียกว่า students.csv
บางส่วนของคุณอาจได้เห็น เหล่านี้ในโลกจริง
>> ไฟล์ CSV คืออะไร?
ค่าที่คั่นด้วยจุลภาค
มันเป็นประเภทเช่นคนยากจน รุ่นของไฟล์ Excel
มันเป็นตารางของแถวและคอลัมน์ที่ คุณสามารถเปิดในโปรแกรมเช่น Excel,
ตัวเลขหรือบน Mac
>> และถ้าฉันเปิดแฟ้มนี้ที่นี่ใน Gedit, แจ้งให้ทราบล่วงหน้า - และตัวเลขที่ไม่ได้มี
นั่นเป็นเพียง gedit บอก ฉันหมายเลขบรรทัด
ให้สังเกตในบรรทัดแรกของเรื่องนี้ ไฟล์เดวิดและท้อง
บรรทัดถัดไปคือร็อบจุลภาคเคิร์กแลนด์
และบรรทัดที่สามคือลอเรน Leverett จุลภาค
>> ดังนั้นผมจึงมีสิ่งที่ถูกสร้างขึ้น?
ผมเคยเขียนในขณะนี้โปรแกรม C ที่ ได้อย่างมีประสิทธิภาพสามารถสร้างสเปรดชีต
ที่สามารถเปิดได้ใน โปรแกรมเช่น Excel
ไม่ใช่สิ่งที่น่าสนใจชุดข้อมูล แต่ ถ้าคุณมีชิ้นใหญ่มาก
ข้อมูลจริงที่คุณต้องการ จัดการและทำให้กราฟและ
เช่นนี้อาจจะเป็นหนึ่ง วิธีการสร้างข้อมูลที่
นอกจากนี้ CSV ทั้งหมดเป็นซุปเปอร์จริงร่วมกัน เพียงแค่สำหรับการจัดเก็บข้อมูลง่าย -
การเงิน yahoo ตัวอย่างเช่นถ้าคุณได้รับ ราคาหุ้นผ่านทางของพวกเขาที่เรียกว่า
API, บริการฟรีที่ช่วยให้คุณสามารถ ได้รับหุ้น up-to-วันที่หมุนเวียน
คำพูดสำหรับ บริษัท ที่พวกเขา ให้ข้อมูลย้อนกลับไปใน
รูปแบบ CSV ง่ายสุด
>> ดังนั้นวิธีที่เราไม่ทำอย่างนั้น?
ดีสังเกตเห็นส่วนใหญ่ของโปรแกรมนี้ เกือบเดียวกัน
แต่สังเกตเห็นลงที่นี่มากกว่าการพิมพ์ นักเรียนออกเมื่อวันที่ 35 เส้น
เป็นต้นไปผมเรียกร้องว่าฉันประหยัด นักเรียนไปยังดิสก์เพื่อบัน​​ทึกแฟ้ม
>> ดังนั้นผมสังเกตเห็นประกาศไฟล์ * -
ตอนนี้เป็นชนิดของความผิดปกติใน C. สำหรับเหตุผลใด, ไฟล์ตัวพิมพ์ใหญ่ทั้งหมด
ซึ่งไม่ชอบมากที่สุดชนิดข้อมูลอื่น ๆ ใน C. แต่นี่เป็นแบบ built-in
ชนิดข้อมูล FILE *
และฉันประกาศตัวชี้ไปยังแฟ้ม คือวิธีที่คุณสามารถคิดว่า
>> fopen หมายถึงการเปิดไฟล์
อะไรที่คุณต้องการไฟล์ที่เปิด?
ฉันต้องการเปิดแฟ้มที่ฉันจะ พลโทร students.csv
ฉันจะเรียกอะไรที่ฉันต้องการที่
>> แล้วจะคาดเดา
อาร์กิวเมนต์ที่สองคืออะไร เพื่อ fopen อาจจะหมายความว่าอย่างไร
ขวา w สำหรับการเขียนได้ เป็น r สำหรับการอ่าน
มีสำหรับการผนวกถ้าคุณ ต้องการเพิ่มแถวและไม่ได้
เขียนทับสิ่งที่ทั้ง
>> แต่ผมเพียงต้องการที่จะสร้างไฟล์นี้ ครั้งเดียวดังนั้นฉันจะใช้อ้างไม่ได้นำมาอ้าง w
และฉันรู้ว่าเพียง แต่จากที่ได้อ่าน เอกสารหรือหน้าคน
ถ้าแฟ้มไม่เป็นโมฆะ - ในคำอื่น ๆ , ถ้าไม่มีอะไรผิดพลาดไปมี -
ให้ฉันย้ำกว่า นักเรียน 0-3
>> และตอนนี้สังเกตเห็นมีอะไรบางอย่าง เคยดังนั้นเล็กน้อยที่แตกต่างกัน
เกี่ยวกับสาย 41 ที่นี่
มันไม่ printf
มัน fprintf สำหรับ printf ไฟล์
ดังนั้นมันจะเขียนไฟล์
ซึ่งไฟล์?
หนึ่งที่มีตัวชี้ที่คุณระบุ เป็นอาร์กิวเมนต์แรก
>> จากนั้นเราก็ระบุสตริงรูปแบบ
แล้วเราระบุสิ่งที่สตริงที่เราต้องการ เสียบสำหรับ s เปอร์เซ็นต์แรกและ
แล้วตัวแปรหรืออื่น ร้อยละสองของ
จากนั้นเราก็ปิดไฟล์ที่มี fclose
กว่าที่ฉันฟรีหน่วยความจำเช่นเดิมแม้ว่า ฉันควรจะกลับไปและเพิ่ม
การตรวจสอบบางอย่างสำหรับโมฆะ
>> และที่มัน
fopen, fprintf, fclose ให้ฉัน ความสามารถในการสร้างไฟล์ข้อความ
ตอนนี้คุณจะเห็นปัญหาอยู่ในชุดห้า ซึ่งเกี่ยวข้องกับภาพที่คุณจะใช้
แฟ้มไบนารีแทน
แต่โดยพื้นฐานความคิดที่เหมือนกัน แม้ฟังก์ชั่นที่คุณจะ
เห็นคือแตกต่างกันเล็กน้อย
>> ทัวร์ลมกรดดังนั้น แต่คุณจะได้รับ ทั้งหมดเกินไปคุ้นเคยกับไฟล์ I/O--
อินพุทและเอาท์พุท - มี pset ห้า
และคำถามใด ๆ เกี่ยวกับ พื้นฐานเริ่มต้นที่นี่?
อ้าง?
>> เกิดอะไรขึ้นถ้าคุณพยายามที่จะฟรีค่า null?
ผมเชื่อว่าถ้าฟรีมีอากาศ น้อยมากที่ใช้งานง่ายคุณสามารถ
ที่อาจเกิดขึ้น segfault
ผ่านมันโมฆะจะไม่ดีเพราะผมทำไม่ได้ เชื่อว่าฟรีรบกวนจิตใจในการตรวจสอบสำหรับคุณ
เพราะมันอาจจะเสีย เวลาที่จะทำตัวเองสำหรับ
ทุกคนในโลก
คำถามที่ดีแม้ว่า
>> ทั้งหมดขวาดังนั้นชนิดนี้ได้รับ เราหัวข้อที่น่าสนใจ
รูปแบบของชุดปัญหา ห้าคือนิติ
อย่างน้อยที่เป็นส่วนหนึ่ง ชุดของปัญหา
สถาบันนิติเวชโดยทั่วไปหมายถึง การกู้คืนของข้อมูลที่อาจจะหรือ
อาจจะไม่ได้ถูกลบไปแล้ว จงใจ
และดังนั้นฉันคิดว่าฉันต้องการให้คุณได้อย่างรวดเร็ว รสชาติของสิ่งที่เป็นจริงที่เกิดขึ้นทั้งหมด
ภายใต้เวลานี้ เครื่องดูดควันของเครื่องคอมพิวเตอร์ของคุณ
>> ตัวอย่างเช่นถ้าคุณมีอยู่ภายในของคุณ แล็ปท็อปหรือคอมพิวเตอร์ตั้งโต๊ะของคุณ
ฮาร์ดไดรฟ์ก็ทั้งกล อุปกรณ์ที่หมุนจริง -
มีสิ่งที่เรียกว่า platters วงกลมของ ที่มีลักษณะค่อนข้างชอบสิ่งที่ฉัน
เพิ่งมีขึ้นบนหน้าจอที่นี่ แต่ นี้เป็นโรงเรียนเก่ามากขึ้น
นี่คือสามและ-a-ครึ่งนิ้ว ฮาร์ดไดรฟ์
และสามและครึ่งนิ้วหมายของ กับสิ่งที่เมื่อคุณติดตั้ง
ในคอมพิวเตอร์
>> หลายของพวกคุณในแล็ปท็อปของคุณตอนนี้ มีไดรฟ์ของรัฐที่มั่นคงหรือ SSDs,
ที่มีชิ้นส่วนที่เคลื่อนไหว
พวกเขากำลังมากขึ้นเช่น RAM และน้อยเช่น เหล่านี้อุปกรณ์เชิงกล
แต่ความคิดยังคงเหมือนเดิม อย่างแน่นอนขณะที่พวกเขาเกี่ยวข้อง
ชุดปัญหาห้า
>> และถ้าคุณคิดเกี่ยวกับในขณะนี้ฮาร์ดไดรฟ์ แสดงให้เห็นถึงการเป็นวงกลมซึ่ง
ผมจะวาดเช่นนี้ที่นี่
เมื่อคุณสร้างไฟล์บนเครื่องคอมพิวเตอร์ของคุณ, ไม่ว่าจะเป็น SSD หรือใน
กรณีนี้ไดรฟ์ที่โรงเรียนเก่าอย่างหนัก ว่าไฟล์ประกอบด้วยบิตหลาย
ขอบอกว่ามันนี้ 0 และ 1 มัดทั้ง 0 และ 1
ดังนั้นนี้เป็นฮาร์ดไดรฟ์ของฉันทั้ง
นี้จะเห็นได้ชัดว่าไฟล์ขนาดใหญ่สวย
และจะใช้ขึ้น 0 และ 1 ที่ว่า ส่วนของแผ่นเสียงทางกายภาพ
>> ดีสิ่งที่เป็นส่วนทางกายภาพ
ดีก็ปรากฎว่าฮาร์ดไดรฟ์, อย่างน้อยชนิดนี้มี
เหล่านี้มีขนาดเล็กอนุภาคแม่เหล็กเล็ก ๆ น้อย ๆ
และพวกเขามีหลักทางเหนือและ ขั้วใต้กับพวกเขาเพื่อที่ว่าถ้าคุณ
เปิดหนึ่งของอนุภาคแม่เหล็กเหล่านั้น วิธีนี้คุณอาจจะบอกว่ามันเป็น
คิดเป็นสัดส่วน 1
และถ้ามันคว่ำลงไปทางทิศใต้ เหนือ, คุณอาจจะบอกว่ามันเป็น
แทน 0
>> ดังนั้นในโลกทางกายภาพจริงที่ว่า วิธีการที่คุณสามารถเป็นตัวแทนของสิ่งที่อยู่ใน
รัฐของไบนารี 0 และ 1
เพื่อให้ทุกไฟล์เป็นอะไร
มีทั้งกลุ่มของแม่เหล็ก อนุภาคที่เป็นวิธีการของพวกเขาหรือนี้
ด้วยวิธีนี้รูปแบบการสร้าง จาก 0 และ 1
>> แต่ปรากฎออกมาเมื่อคุณบันทึกแฟ้ม, ข้อมูลบางอย่างจะถูกบันทึกไว้แยกต่างหาก
ดังนั้นนี้เป็นตารางเล็ก ๆ น้อย ๆ ไดเรกทอรีเพื่อที่จะพูด
และฉันจะเรียกชื่อของคอลัมน์นี้และ ฉันจะเรียกสถานที่คอลัมน์นี้
>> และฉันจะบอกว่าสมมติว่า นี่คือประวัติของฉัน
resume.doc ของฉันจะถูกเก็บไว้ที่ สถานที่สมมติว่า 123
ฉันมักจะไปสำหรับหมายเลขที่
แต่พอเพียงที่จะบอกว่าเหมือน ในแรมคุณสามารถใช้ฮาร์ดไดรฟ์
ที่เป็นกิกะไบต์หรือ 200 กิกะไบต์ หรือเทราไบต์และคุณสามารถ
จำนวนทั้งหมดของไบต์
คุณสามารถนับชิ้นทั้งหมด 8 บิต
>> ดังนั้นเราจะบอกว่านี้ เป็นสถานที่ตั้ง 123
ดังนั้นในไดเรกทอรีนี้การดำเนินงานของฉัน จำได้ว่าระบบของฉัน
ประวัติอยู่ที่ 123 สถานที่ตั้ง
แต่ได้รับน่าสนใจเมื่อ คุณลบไฟล์
>> ดังนั้นเช่น -
และโชคดีที่ส่วนใหญ่ของโลกมี ติดลงบนนี้ - สิ่งที่เกิดขึ้นเมื่อ
คุณลากไฟล์ไปยังถังขยะ Mac OS ของคุณ หรือ Windows ถังรีไซเคิลของคุณ?
วัตถุประสงค์ของการทำแบบนั้นคืออะไร?
มันเห็นได้ชัดที่จะกำจัดของไฟล์, แต่การกระทำของการลากสิ่งที่ไม่และ
ทิ้งลงในถังขยะของคุณหรือของคุณ ถังรีไซเคิลทำในคอมพิวเตอร์?
>> แน่นอนไม่มีอะไรจริงๆ
มันเป็นเช่นเดียวกับโฟลเดอร์
มันเป็นโฟลเดอร์พิเศษเพื่อให้แน่ใจว่า
มันไม่ แต่จริงๆแล้วลบไฟล์หรือไม่
>> ดีไม่เพราะบางท่านอาจจะ ได้รับเช่นเดียวกับโอ้แช่งคุณไม่ได้
หมายถึงจะทำอย่างนั้น
ดังนั้นคุณดับเบิลคลิก ถังขยะหรือถังรีไซเคิล
คุณเคยโผล่ไปรอบ ๆ และคุณกู้คืน ไฟล์เพียงโดยการลากมัน
ออกจากที่นั่น
ดังนั้นเห็นได้ชัดว่ามันไม่จำเป็น ลบมัน
>> ตกลงคุณจะฉลาดกว่าที่
คุณรู้ไหมว่าเพียงแค่ลากมันเข้าไป ถังขยะหรือรีไซเคิลไม่ได้หมายความว่า
คุณกำลังทิ้งขยะ
เพื่อให้คุณไปถึงเมนูและคุณจะพูดว่า ขยะที่ว่างเปล่าถังรีไซเคิลหรือเปล่า
แล้วจะเกิดอะไรขึ้น
>> ผมจึงจะถูกลบมากขึ้นดังนั้น
แต่ทั้งหมดที่เกิดขึ้นนี้
คอมพิวเตอร์ที่ลืม resume.doc คือ
>> แต่สิ่งที่ไม่ได้เปลี่ยนแปลงเห็นได้ชัดว่า ในภาพหรือไม่
บิต, 0 และ 1 เรียกร้องที่ฉันเป็น บนเว็บไซต์ของลักษณะทางกายภาพบางส่วนของ
ฮาร์ดแวร์
พวกเขายังคงมี
มันเป็นเพียงคอมพิวเตอร์มี ลืมสิ่งที่พวกเขา
>> จึงปล่อยให้เป็นอิสระเป็นหลักของไฟล์ บิตเพื่อให้พวกเขาสามารถนำมาใช้ใหม่
แต่ไม่ได้จนกว่าคุณจะสร้างไฟล์ขึ้น และไฟล์หลายไฟล์และอื่น ๆ จะ
probabilistically ผู้ที่ 0 และ 1, ที่อนุภาคแม่เหล็กได้รับนำมาใช้ใหม่
ด้านคว่ำหรือขวาขึ้นสำหรับ ไฟล์อื่น ๆ 0 และ 1
>> เพื่อให้คุณมีหน้าต่างในเวลานี้
และก็ไม่สามารถคาดเดาได้จาก ยาวจริงๆ
มันขึ้นอยู่กับขนาดของฮาร์ดดิสก์ของคุณ ไดรฟ์และจำนวนไฟล์ที่คุณมีและ
วิธีการอย่างรวดเร็วคุณทำใหม่
แต่มีหน้าต่างในเวลานี้ในช่วง ซึ่งไฟล์ที่ยังคงสมบูรณ์
รับคืน
>> ดังนั้นถ้าคุณเคยใช้โปรแกรมเช่นแมคอาฟี หรือนอร์ตันเพื่อพยายามกู้คืน
ข้อมูลทั้งหมดที่พวกเขากำลังทำคือการพยายามที่จะ กู้คืนไดเรกทอรีนี้ที่เรียกว่า
คิดออกว่าไฟล์ของคุณเป็น
และบางครั้งนอร์ตันและจะกล่าวว่า ไฟล์เป็น 93% คืน
ดีที่หมายความว่าอย่างไร
ที่เพียงแค่หมายความว่าบางไฟล์อื่น ๆ สิ้นสุดวันที่บังเอิญขึ้นโดยใช้การพูด,
บิตเหล่านั้นออกจากไฟล์ต้นฉบับของคุณ
>> ดังนั้นสิ่งที่มีส่วนเกี่ยวข้องจริง ในการกู้คืนข้อมูล?
ดีถ้าคุณไม่ได้สิ่งที่ต้องการ นอร์ตันที่ติดตั้งในคอมพิวเตอร์ของคุณ
ที่ดีที่สุดบางครั้งคุณสามารถทำได้คือการมอง ที่ฮาร์ดไดรฟ์ทั้งหมดที่กำลังมองหา
รูปแบบของบิต
และเป็นหนึ่งในรูปแบบของชุดปัญหา ห้าคือการที่คุณจะค้นหา
เทียบเท่ากับฮาร์ดไดรฟ์, นิติวิทยาศาสตร์ ภาพของการ์ดแฟลชขนาดกะทัดรัดจาก
กล้องดิจิตอลค้นหา 0s 1s และที่มักจะมีสูง
ความน่าจะเป็นตัวแทนของ เริ่มต้นจากภาพ JPEG
>> และพวกคุณสามารถกู้คืนภาพเหล่านั้นโดย สมมติว่าถ้าผมเห็นรูปแบบนี้
บิตบนภาพทางนิติวิทยาศาสตร์ด้วย ความน่าจะเป็นสูงที่เครื่องหมาย
จุดเริ่มต้นของไฟล์ JPEG
และถ้าฉันเห็นรูปแบบเดียวกันอีกครั้ง ที่อาจเป็นจุดเริ่มต้นของ
อีก JPEG, และอื่น ๆ JPEG และไฟล์ภาพ JPEG อีก
และนี่คือวิธีการที่มักจะ การกู้คืนข้อมูลจะทำงาน
มีอะไรที่ดีเกี่ยวกับ JPEGs คือแม้ว่า รูปแบบไฟล์ที่ตัวเองจะค่อนข้าง
ที่ซับซ้อนเช่นจุดเริ่มต้นของทุก ไฟล์เป็นจริงพิสูจน์ได้อย่างเป็นธรรม
และเรียบง่ายที่สุดเท่าที่คุณจะเห็น หากคุณไม่ได้อยู่แล้ว
>> ดังนั้นขอใช้เวลามองใกล้ที่อยู่ภายใต้ เครื่องดูดควันเป็นไปได้ว่าสิ่งที่ได้รับ
ที่เกิดขึ้นและสิ่งเหล่านี้ 0 และ 1 เป็นเพื่อให้คุณอีกเล็กน้อยจาก
บริบทสำหรับความท้าทายนี้โดยเฉพาะ
>> [เล่นภาพวิดีโอ]
>> ที่ไหนจัดเก็บเครื่องคอมพิวเตอร์ของคุณมากที่สุด ของข้อมูลอย่างถาวร
ต้องการทำเช่นนั้นข้อมูลการเดินทางจาก RAM พร้อมกับสัญญาณซอฟแวร์ที่บอก
ฮาร์ดไดรฟ์วิธีการเก็บข้อมูลที่
วงจรฮาร์ดไดรฟ์แปล สัญญาณเหล่านั้นเป็นแรงดันไฟฟ้า
ความผันผวนของ
นี้ในการเปิดการควบคุมของไดรฟ์ยาก ชิ้นส่วนที่เคลื่อนไหวบางอย่างในไม่กี่คน
การย้ายชิ้นส่วนที่เหลืออยู่ใน คอมพิวเตอร์ที่ทันสมัย
>> บางส่วนของสัญญาณควบคุมมอเตอร์ ซึ่งหมุนจานโลหะเคลือบ
ข้อมูลของคุณจะถูกจัดเก็บจริง ใน platters เหล่านี้
สัญญาณอื่น ๆ ย้ายการอ่าน / เขียน หัวอ่านหรือ
เขียนข้อมูลใน platters
เครื่องจักรนี้ได้อย่างแม่นยำเพื่อให้มนุษย์ ผมไม่สามารถที่จะผ่านระหว่าง
หัวและ platters ปั่น
แต่การทำงานทั้งหมดด้วยความเร็วที่ยอดเยี่ยม
>> [เล่นวิดีโอจบ]
>> DAVID ลัน: ซูมในเล็ก ๆ น้อย ๆ ลึกลงไปในขณะที่สิ่งที่
จริงใน platters เหล่านั้น
>> [เล่นภาพวิดีโอ]
>> -ลองดูที่สิ่งที่เราเพียงแค่ เห็นในการเคลื่อนไหวช้า
เมื่อชีพจรสั้นของกระแสไฟฟ้าคือ ส่งไปยังหัวอ่าน / เขียนถ้าพลิก
เมื่อแม่เหล็กไฟฟ้าเล็ก ๆ สำหรับ เสี้ยววินาที
แม่เหล็กสร้างสนามซึ่ง การเปลี่ยนแปลงขั้วของเล็ก ๆ เล็ก ๆ
ส่วนหนึ่งของอนุภาคโลหะซึ่ง เสื้อโค้ทพื้นผิวแต่ละจาน
>> ชุดรูปแบบเล็ก ๆ น้อย ๆ เหล่านี้ พื้นที่เรียกเก็บอยู่บนดิสก์
แสดงให้เห็นถึงบิตเดียวของ ข้อมูลในเลขฐานสอง
ระบบที่ใช้โดยคอมพิวเตอร์
ตอนนี้ถ้าในปัจจุบันจะถูกส่งไปทางเดียว ผ่านการอ่าน / เขียนหัวพื้นที่
เป็นขั้วในทิศทางเดียว
ถ้าในปัจจุบันที่ถูกส่งใน ทิศทางที่ตรงข้าม,
ขั้วที่ตรงกันข้ามคือ
>> วิธีที่คุณจะได้รับข้อมูลออกจากฮาร์ดดิสก์
เพียงแค่ย้อนกลับกระบวนการ
ดังนั้นจึงเป็นอนุภาคที่อยู่บนดิสก์ ที่ได้รับในปัจจุบัน
อ่าน / เขียนหัวย้าย
ใส่กันนับล้านเหล่านี้ ส่วนแม่เหล็กและ
คุณมีไฟล์
>> ตอนนี้ชิ้นส่วนของไฟล์เดียวอาจ จะกระจัดกระจายไปทั่วทุกมุมของไดรฟ์
platters ชนิดเช่นระเบียบ ของเอกสารบนโต๊ะทำงานของคุณ
ดังนั้นไฟล์สุดพิเศษติดตาม จากที่ทุกอย่าง
คุณไม่ขอให้คุณมี สิ่งที่ต้องการที่?
>> [เล่นวิดีโอจบ]
>> DAVID ลัน: ตกลงอาจจะไม่
ดังนั้นวิธีที่หลาย ๆ ท่านครับ เติบโตขึ้นมากับเหล่านี้ได้อย่างไร
ตกลงดังนั้นจึงน้อยลงและน้อยลง มือของทุกปี
แต่ฉันดีใจที่คุณอย่างน้อยคุ้นเคย กับพวกเขาเพราะเรื่องนี้และของเราเอง
การสาธิตหนังสือเศร้ากำลังจะตายมาก ตายช้าที่นี่จากความคุ้นเคย
>> แต่นี่คือสิ่งที่ฉันอย่างน้อยย้อนกลับไปใน โรงเรียนมัธยมการใช้งานที่ใช้สำหรับการสำรองข้อมูล
และมันก็เป็นที่น่าตื่นตาตื่นใจเพราะคุณ สามารถเก็บ 1.4 เมกะไบต์บน
นี้ดิสก์โดยเฉพาะอย่างยิ่ง
และนี่ก็เป็นรุ่นที่มีความหนาแน่นสูง ตามที่ระบุโดย HD ซึ่งมี
ความหมายของวันนี้ก่อนที่จะวิดีโอ HD
>> ความหนาแน่นมาตรฐานคือ 800 กิโลไบต์
และก่อนที่จะมี ดิสก์ 400 กิโลไบต์
และก่อนที่จะมี 5 และ 1/4 เป็น ดิสก์นิ้วซึ่งเป็นฟลอปปี้อย่างแท้จริง
และเล็ก ๆ น้อย ๆ ที่กว้างขึ้นและสูง กว่าสิ่งเหล่านี้ที่นี่
แต่คุณสามารถมองเห็นสิ่งที่เรียกว่า ลักษณะของฟลอปปี้ดิสก์เหล่านี้
>> และหน้าที่ที่พวกเขากำลังจริง สวยคล้ายกับฮาร์ดไดรฟ์จากที่
ชนิดนี้อย่างน้อย
อีกครั้ง SSDs ในคอมพิวเตอร์รุ่นใหม่ ทำงานน้อยแตกต่างกัน
แต่ถ้าคุณย้ายแท็บโลหะที่เล็ก ๆ น้อย ๆ คุณสามารถเห็นจริงคุกกี้เล็ก ๆ น้อย ๆ
หรือแผ่นเสียง
>> มันไม่ใช่โลหะเช่นนี้
หนึ่งนี้เป็นจริงที่ถูกกว่าบาง วัสดุพลาสติก
และคุณสามารถชนิดของมันกระดิก
และคุณได้ trully เช็ดเพียงแค่ปิดบาง จำนวนบิตหรืออนุภาคแม่เหล็ก
จากดิสก์นี้
>> ดังนั้นโชคดีมีอะไรที่เป็นของ
ถ้าสิ่งที่อยู่ในทาง - และครอบคลุม ตาและบรรดาเพื่อนบ้านของคุณ -
คุณสามารถเพียงแค่ชนิดของดึงนี้ ออกฝักทั้งที่ชอบ
แต่มีฤดูใบไม้ผลิเล็ก ๆ น้อย ๆ เพื่อให้ รู้ว่ามีสายตาของคุณ
ดังนั้นตอนนี้คุณมีอย่างแท้จริงฟล็อปปี้ดิสก์
>> และโดดเด่นเกี่ยวกับเรื่องนี้ว่า ที่อยู่ในมากที่สุดเท่าที่เป็น
การแสดงขนาดเล็กขนาดใหญ่ ฮาร์ดไดรฟ์สิ่งเหล่านี้ซุปเปอร์
ง่ายสุด
หากคุณหยิกด้านล่างของมันตอนนี้ที่ สิ่งที่ทำด้วยโลหะที่ปิดและเปลือก
พวกเขาเปิดทั้งหมดที่มีเป็นสองชิ้น รู้สึกและฟล็อปปี้ดิสก์ที่เรียกว่า
กับชิ้นส่วนของโลหะในภายใน
>> และมีครึ่งหนึ่งของไป เนื้อหาดิสก์ของฉัน
มีครึ่งหนึ่งของพวกเขาอีกต่อไป
แต่นั่นคือทั้งหมดที่ได้รับการปั่นภายใน ของเครื่องคอมพิวเตอร์ของคุณในปีกลาย
>> และอีกครั้งเพื่อวางนี้ในมุมมองของ วิธีการใหญ่เป็นส่วนใหญ่ของคุณ
ฮาร์ดดิสก์วันนี้?
500 กิกะไบต์, เทราไบต์, อาจจะใน คอมพิวเตอร์เดสก์ทอป 2 เทราไบต์, 3
เทราไบต์, 4 เทราไบต์ขวา?
นี้เป็นหนึ่งเมกะไบต์ให้หรือใช้, ซึ่งไม่สามารถแม้แต่จะพอดีกับ MP3 ทั่วไป
อีกต่อไปวันนี้หรือบาง ไฟล์เพลงที่คล้ายกัน
>> ดังนั้นของที่ระลึกเล็ก ๆ น้อย ๆ สำหรับคุณในวันนี้และ นอกจากนี้ยังจะช่วยให้สิ่ง contextualize
เราจะได้รับการ ในขณะนี้ปัญหาตั้งห้า
ดังนั้นผู้ที่มีของคุณเพื่อให้
เพื่อให้การเปลี่ยนแปลงไปยังที่ที่ฉันจะ การใช้จ่าย pset ต่อไปเช่นกัน
ดังนั้นเราจึงได้ตั้งค่าในขณะนี้หน้านี้เพื่อ - โอ้ คู่ของประกาศได้อย่างรวดเร็ว
>> ศุกร์นี้ถ้าคุณต้องการเข้าร่วม CS50 เพื่อรับประทานอาหารกลางวันให้ไปที่สถานที่ที่ปกติ
cs50.net/rsvp
และโครงการสุดท้าย -
ดังนั้นต่อหลักสูตรที่เราได้โพสต์ สเปคโครงการสุดท้ายแล้ว
ตระหนักดีว่าไม่ได้หมายความว่า เนื่องจากมันโดยเฉพาะอย่างยิ่งในเร็ว ๆ นี้
มันโพสต์จริงๆเพียงเพื่อให้ได้ พวกคุณคิดเกี่ยวกับมัน
และแน่นอนสุดอย่างมีนัยสำคัญ ร้อยละของคุณจะได้รับการแก้ปัญหา
โครงการสุดท้ายบนวัสดุที่เรา ยังไม่ได้รับแม้จะอยู่ในชั้นเรียน,
แต่จะเป็นช่วงต้นของสัปดาห์ถัดไป
>> แจ้งให้ทราบว่าที่สเปคเรียกร้องให้ ส่วนประกอบที่แตกต่างกันไม่กี่
โครงการสุดท้าย
เป็นครั้งแรกในอีกไม่กี่สัปดาห์เป็น ก่อน-proposal, อีเมล์ลำลองสวย
TF ที่จะบอกเขาหรือของคุณสิ่งที่คุณ คิดเกี่ยวกับการสำหรับโครงการของคุณด้วย
ความมุ่งมั่นไม่มี
ข้อเสนอที่จะเป็นของคุณโดยเฉพาะ ความมุ่งมั่นว่านี่เป็นสิ่งที่
ฉันต้องการที่จะทำสำหรับโครงการของฉัน
คุณคิดอย่างไร?
มีขนาดใหญ่เกินไป?
ขนาดเล็กเกินไป?
มันเป็นเรื่องที่จัดการได้?
และคุณจะเห็นข้อมูลจำเพาะสำหรับรายละเอียดเพิ่มเติม
>> สองสามสัปดาห์หลังจากที่มีสถานะ รายงานซึ่งเป็นในทำนองเดียวกัน
อีเมล์ลำลองเพื่อ TF ของคุณที่จะพูดเพียงแค่ว่า ไกลหลังที่คุณอยู่ในขั้นสุดท้ายของคุณ
การดำเนินโครงการตามด้วย CS50 hackathon เพื่อที่ทุกคน
เป็นรับเชิญซึ่งจะเป็นเหตุการณ์จาก 20:00 เมื่อเย็นวันหนึ่งจนถึง 07:00
AM เช้าวันรุ่งขึ้น
พิซซ่าที่ผมอาจจะมีการกล่าวถึงในสัปดาห์ ศูนย์ wil ที่ได้รับการบริการที่ 09:00,
อาหารจีนที่ 01:00
และถ้าคุณยังคงตื่นตัวที่ 05:00, เราจะพาคุณไป IHOP สำหรับอาหารเช้า
>> ดังนั้น hackathon เป็นหนึ่งในมากขึ้น ประสบการณ์ที่น่าจดจำในชั้นเรียน
จากนั้นการดำเนินการครบกำหนดและ แล้วยอด CS50 พอใช้
รายละเอียดเพิ่มเติมเกี่ยวกับสิ่งเหล่านี้ ในสัปดาห์ที่จะมาถึง
>> แต่ขอกลับไปที่บางสิ่งบางอย่าง โรงเรียนเก่า -
อีกครั้งอาร์เรย์
ดังนั้นอาร์เรย์ was nice เพราะมันแก้ ปัญหาเช่นที่เราเห็นเพียงแค่
ช่วงเวลาที่ผ่านมาด้วยโครงสร้างของนักเรียน ได้รับการออกจากการควบคุมของเล็ก ๆ น้อย ๆ ถ้าเรา
ต้องการที่จะมีนักศึกษาคนหนึ่ง, สองนักศึกษา สามนักเรียนนักศึกษา dot dot dot,
บางจำนวนข้อของนักเรียน
>> ดังนั้นอาร์เรย์ไม่กี่สัปดาห์ที่ผ่านมาบินโฉบใน และแก้ไขทุกปัญหาของเราไม่ได้
รู้ล่วงหน้าว่าหลายสิ่ง บางประเภทที่เราอาจต้องการ
และเราได้เห็นว่า structs สามารถช่วยให้เรา จัดระเบียบรหัสของเราและเก็บ
ตัวแปรที่คล้ายกันแนวคิดเช่น ชื่อและที่บ้านด้วยกันเพื่อให้เรา
สามารถรักษาพวกเขาเป็นหนึ่งในกิจการภายใน ซึ่งมีชิ้นเล็ก ๆ เป็น
>> แต่อาร์เรย์มีข้อเสียบางอย่าง
สิ่งที่บางส่วนของข้อเสียคือ ที่เราได้พบ
กับอาร์เรย์ป่านนี้?
ว่าคืออะไร?
ขนาดคงที่ - ดังนั้นแม้ว่าคุณอาจจะ จะสามารถจัดสรรหน่วยความจำสำหรับ
อาร์เรย์เมื่อคุณรู้วิธีการที่นักเรียนจำนวนมาก คุณจะมีตัวอักษรหลายวิธีที่คุณมี
จากผู้ใช้เมื่อคุณได้รับการจัดสรร อาร์เรย์ที่คุณได้ทาสีชนิดของ
ตัวเองเป็นมุม
>> เนื่องจากคุณไม่สามารถแทรกองค์ประกอบใหม่ เข้ากลางของอาร์เรย์
คุณไม่สามารถแทรกองค์ประกอบอื่น ๆ ในตอนท้ายของอาร์เรย์
จริงๆคุณต้องรีสอร์ทเพื่อการสร้าง แถวใหม่ทั้งหมดที่เราได้พูดคุย
คัดลอกเก่าเป็นใหม่
และอีกครั้งที่จะปวดหัวว่า ข้อเสนอ GetString ด้วยสำหรับคุณ
>> แต่อีกครั้งคุณไม่สามารถแม้แต่จะใส่ สิ่งที่เป็นตรงกลางของแถว
ถ้าอัตราการไม่ได้รับการเติมเต็มอย่างสิ้นเชิง
ตัวอย่างเช่นถ้าแถวนี้นี่ขนาด หกมีเพียงห้าสิ่งที่อยู่ในนั้น
ดีคุณสามารถตะปูเพียง บางสิ่งบางอย่างลงบนปลาย
แต่ถ้าคุณต้องการแทรกบางสิ่งบางอย่าง ในช่วงกลางของ
อาร์เรย์แม้ว่ามันอาจจะมี ห้าหกออกมาจากสิ่งที่อยู่ในนั้น?
>> ดีเราทำอะไรเมื่อเรามีทั้งหมด ของอาสาสมัครมนุษย์ของเราในเวที
สัปดาห์ที่ผ่านมา?
ถ้าเราต้องการที่จะนำคนที่นี่อย่างใดอย่างหนึ่ง คนเหล่านี้วิธีการย้ายนี้
วิธีการที่คนเหล่านี้หรือวิธีการย้ายนี้ วิธีการและที่กลายเป็นแพง
ขยับจากคนที่อยู่ภายใน อาร์เรย์จบลงด้วยการเพิ่มขึ้นและต้นทุน
เวลาเราจึงจำนวนมาก n squared ของเรา ใช้เวลาเช่นจัดเรียงแทรกสำหรับ
ตัวอย่างเช่นในกรณีที่เลวร้ายที่สุด
ดังนั้นอาร์เรย์ที่ดี แต่คุณจะต้อง รู้ล่วงหน้าว่าใหญ่ที่คุณต้องการให้พวกเขา
>> ดังนั้นตกลงนี่คือการแก้ปัญหา
ถ้าฉันไม่ได้รู้ล่วงหน้าว่าหลาย นักเรียนผมอาจจะมีและฉันรู้ว่าครั้งหนึ่ง
ผมตัดสินใจว่าผมติดอยู่กับที่ นักเรียนหลายคนทำไม่ได้ทำไมฉันเพียงแค่เสมอ
จัดสรรพื้นที่มากที่สุดเท่าที่สอง ขณะที่ผมอาจจะคิดว่าฉันต้อง?
ที่ไม่ได้เป็นทางออกที่เหมาะสม?
>> แนบเนียนฉันไม่คิดว่าเรา จะต้องมากกว่า 50 ช่อง
ในอาร์เรย์สำหรับชั้นเรียนขนาดกลาง, เพื่อให้เพียงรอบขึ้น
ฉันจะทำให้ช่องว่าง 100 ช่องในอาร์เรย์ของฉันเพียง เพื่อที่เราจะได้รับแน่นอน
จำนวนนักเรียนที่ผมคาดหวังที่จะ จะอยู่ในบางชั้นเรียนขนาดกลาง
ดังนั้นทำไมไม่เพียงแค่รอบขึ้นและจัดสรร หน่วยความจำมากขึ้นโดยทั่วไปสำหรับอาร์เรย์
กว่าที่คุณคิดว่าคุณอาจจะต้อง?
นี้ pushback ง่ายอะไร ความคิดที่ว่า?
>> คุณเพียงแค่การสูญเสียความทรงจำ
ตัวอักษรโปรแกรมที่คุณเขียนแล้วทุก อาจจะมีการใช้หน่วยความจำมากเป็นสองเท่า
ที่คุณต้องการจริง
และนั่นก็ไม่ได้รู้สึกเหมือน ทางออกที่สวยงามโดยเฉพาะอย่างยิ่ง
นอกจากนี้มันก็ลดลง ความน่าจะเป็นของปัญหา
หากคุณเกิดขึ้นจะมีหลักสูตรที่เป็นที่นิยม หนึ่งภาคการศึกษาและคุณมี 101
นักเรียนโปรแกรมของคุณยังคงเป็น พื้นฐานเผชิญปัญหาเดียวกัน
>> ดังนั้นโชคดีที่มีวิธีการแก้อะไร โฆษณานี้ทุกปัญหาเราในรูปแบบ
ของโครงสร้างข้อมูลที่มี ที่ซับซ้อนมากขึ้นกว่าคน
ที่เราเคยเห็นป่านนี้
นี้ผมเรียกร้องเป็นรายการที่เชื่อมโยง
นี่คือรายการของตัวเลข -
9, 17, 22, 26, และ 34 -
ที่ได้รับการเชื่อมโยงกันโดยวิธีการ จากสิ่งที่ผมเคยวาดลูกศร
>> ในคำอื่น ๆ ถ้าผมต้องการที่จะเป็นตัวแทน อาร์เรย์ที่ฉันจะทำ
บางอย่างเช่นนี้
และฉันจะใส่นี้ค่าใช้จ่าย ในเวลาเพียงสักครู่
ฉันจะทำ -
สวัสดีทั้งหมดขวา
ยืนตาม
คอมพิวเตอร์เครื่องใหม่ที่นี่ชัดเจน -
สิทธิทั้งหมด
>> ดังนั้นถ้าฉันมีตัวเลขเหล่านี้ในอาร์เรย์ -
9, 17, 22, 26, 24 -
ไม่จำเป็นต้องไปที่วัด
ทั้งหมดที่เหมาะสมเพื่อให้ที่นี่เป็นอาร์เรย์ของฉัน -
พระเจ้าช่วย
ขวาทั้งหมดเพื่อให้ที่นี่เป็นอาร์เรย์ของฉัน
พระเจ้าช่วย
>> [เสียงหัวเราะ]
>> DAVID ลัน: Pretend
มันเป็นความพยายามมากเกินไปที่จะกลับไป และแก้ไขที่นั่น -
26
ดังนั้นเราจึงมีอาร์เรย์ของนี้ 9, 17, 22, 26, และ 34
สำหรับบรรดาของคุณสามารถมองเห็นได้ ความผิดพลาดที่น่าอายที่ผมเพิ่งทำ,
มีเป็น
>> ดังนั้นผมจึงเรียกร้องว่านี่คือ โซลูชันที่มีประสิทธิภาพมาก
ผมเคยจัดสรรเป็น ints มากที่สุดเท่าที่ ฉันจำเป็นต้อง - หนึ่งสองสาม
สี่ห้าหรือหก -
และฉันได้เก็บไว้แล้วตัวเลขที่ ภายในของอาร์เรย์นี้
แต่คิดว่าแล้วฉันต้องการแทรก มูลค่าเช่นหมายเลข 8?
ดีก็ไม่ไปไหน
สมมติว่าฉันต้องการแทรก จำนวนเช่น 20
ดีก็ไม่ไปไหน
ที่ไหนสักแห่งมีที่อยู่ตรงกลาง, หรือเลขที่ 35 ได้ไป
ที่ไหนสักแห่งในตอนท้าย
แต่ฉันออกจากพื้นที่ทั้งหมด
>> และนี้จึงเป็นความท้าทายขั้นพื้นฐาน ของอาร์เรย์ที่ไม่เป็นทางออก
ผมอ้างว่าช่วงเวลาที่ผ่านมา getString แก้ปัญหานี้ได้
ถ้าคุณต้องการที่จะแทรกหมายเลขหก เป็น array นี้สิ่งที่อย่างน้อยหนึ่ง
แก้ปัญหาที่คุณสามารถถอยกลับเพื่อตรวจสอบว่า เช่นเดียวกับที่เราทำกับ GetString?
ว่าคืออะไร?
>> กันทำให้มันมีขนาดใหญ่เป็น พูดง่ายกว่าทำ
เราสามารถไม่จำเป็นต้องทำให้อาร์เรย์ ที่ใหญ่กว่า แต่สิ่งที่เราจะทำอย่างไร
ทำให้แถวใหม่ที่ใหญ่กว่าขนาด 6 หรืออาจจะขนาด 10 ถ้าเราต้องการ
ได้รับล่วงหน้าของสิ่งนั้นคัดลอก อาร์เรย์เก่าเป็นใหม่และจากนั้น
ฟรีอาร์เรย์เก่า
>> แต่เวลาทำงานอะไร ตอนของกระบวนการที่?
มัน O ใหญ่ของ n เพราะการคัดลอก จะเสียค่าใช้จ่ายบางส่วนของหน่วย
เวลาดังนั้นไม่เหมาะดังนั้นหากเราจะต้อง จัดสรรแถวใหม่ซึ่งเป็นไป
ที่จะบริโภคสองเท่า หน่วยความจำชั่วคราว
คัดลอกเก่าเป็นใหม่ -
ฉันหมายความว่ามันเป็นแค่อาการปวดหัวซึ่ง เป็นอีกเหตุผลที่เราเขียน
getString สำหรับคุณ
>> ดังนั้นสิ่งที่เราอาจจะทำแทน?
ดีสิ่งที่ถ้าโครงสร้างข้อมูลของเรา จริงมีช่องว่างในการหรือไม่
สมมติว่าผมผ่อนคลายเป้าหมายของฉันของการมี ชิ้นที่อยู่ติดกันของหน่วยความจำที่ 9
ที่ถูกต้องต่อไปถึง 17 ซึ่งเป็น ที่เหมาะสมต่อไปถึงวันที่ 22 และอื่น ๆ
>> และคิดว่า 9 สามารถไปที่นี่ใน แรม 17 และสามารถไปที่นี่ใน RAM,
และ 22 สามารถไปที่นี่ใน RAM
ในคำอื่น ๆ ที่ฉันไม่ต้องการพวกเขา แม้จะกลับไปกลับอีกต่อไป
ฉันต้องอย่างใดด้ายเข็ม ผ่านแต่ละตัวเลขเหล่านี้หรือแต่ละ
ของโหนดเหล่านี้ที่เราจะเรียก สี่เหลี่ยมที่ผมเคยวาดพวกเขาไป
จำวิธีการได้รับไปยังหน้าล่​​าสุด โหนดดังกล่าวตั้งแต่แรก
>> ดังนั้นการเขียนโปรแกรมสร้างสิ่ง ที่เราเคยเห็นค่อนข้างเร็ว ๆ นี้กับที่ฉัน
สามารถใช้ด้ายที่หรือ วาดที่นี่กับที่ฉันสามารถ
ใช้ลูกศรเหล่านั้นหรือไม่
ดังนั้นตัวชี้ขวา?
ถ้าฉันไม่ได้เป็นเพียงการจัดสรร int แต่โหนด - และ
โหนดผมก็หมายถึงภาชนะ
และสายตาผมหมายถึงรูปสี่เหลี่ยมผืนผ้า
ดังนั้นโหนดที่เห็นได้ชัดว่าต้องการ จะมีสองค่า -
int ตัวเองและจากนั้นส่อให้เห็นเป็นไปตามที่ ครึ่งล่างของรูปสี่เหลี่ยมผืนผ้า,
พื้นที่เพียงพอสำหรับ int
>> ดังนั้นเพียงแค่คิดล่วงหน้าที่นี่ วิธีการใหญ่โหนดนี้คือนี้
ภาชนะในคำถาม?
กี่ไบต์สำหรับ int?
สันนิษฐาน 4 ถ้ามัน เช่นเดียวกับปกติ
แล้วกี่ไบต์ สำหรับตัวชี้?
4
ดังนั้นภาชนะบรรจุหรือโหนดนี้คือ จะเป็นโครงสร้างที่ 8 ไบต​​์
Oh, และที่บังเอิญมีความสุขที่ เราเพียงแค่นำความคิดนี้
struct หรือโครงสร้าง C
>> ดังนั้นผมจึงเรียกร้องว่าฉันต้องการที่จะใช้ขั้นตอน ไปนี้ความซับซ้อนมากขึ้น
การดำเนินงานของรายการของตัวเลข รายการที่เชื่อมโยงของตัวเลขที่ฉันต้องทำ
ความคิดเล็ก ๆ น้อย ๆ ขึ้นด้านหน้าและ ประกาศไม่เพียง แต่ int แต่ struct
ที่ฉันจะโทรตามอัตภาพ ที่นี่โหนด
เราสามารถเรียกมันว่าสิ่งที่เราต้องการ แต่ โหนดเป็นไปได้ในหลายใจ
สิ่งที่เราเริ่มมองในขณะนี้
>> ภายในของโหนดที่ int n คือ
แล้วรูปแบบนี้เล็ก ๆ น้อย ๆ แปลกได้อย่างรวดเร็วก่อน -
struct โหนดต่อไป
pictorially ดีว่าเป็นสิ่งที่?
นั่นคือครึ่งล่างของ สี่เหลี่ยมผืนผ้าที่เราเห็น
เมื่อตะกี้
>> แต่ทำไมฉันบอกว่าโหนด struct * เมื่อเทียบกับเพียงโหนด *?
เพราะถ้าตัวชี้เป็นชี้ว่า ที่โหนดอื่นก็เพียง
ที่อยู่ของโหนด
ที่สอดคล้องกับสิ่งที่เราได้ พูดคุยเกี่ยวกับตัวชี้ป่านนี้
แต่ทำไมถ้าผมเรียกร้องโครงสร้างนี้คือ ที่เรียกว่าโหนดฉันไม่ได้ที่จะบอกว่า struct
โหนดภายในที่นี่?
>> อย่างแน่นอน
มันเรียงลำดับของความเป็นจริงโง่ซี typedef เพื่อที่จะพูดมีไม่ได้
ที่เกิดขึ้นยัง
C เป็นซุปเปอร์ตัวอักษร
มันอ่านบนรหัสของคุณ ด้านล่างซ้ายไปขวา
และจนฮิตอัฒภาคว่า บรรทัดล่างคาดเดาอะไรไม่ได้
อยู่เป็นชนิดข้อมูล?
โหนดโหนดอ้างไม่ได้นำมาอ้าง
>> แต่เป็นเพราะ verbose เพิ่มเติม ประกาศผมในบรรทัดแรก -
โหนด typedef struct -
เพราะที่มาก่อนที่ วงเล็บปีกกาที่ประเภทเช่น
ก่อนการให้ความรู้-เสียงดังกราวว่าคุณ รู้ว่าสิ่งที่ให้ฉัน struct
ที่เรียกว่าโหนด struct
ตรงไปตรงมาผมไม่ชอบสิ่งที่เรียก struct โหนดโหนด struct ทั้งหมด
ตลอดรหัสของฉัน
แต่ฉันเท่านั้นที่จะใช้ครั้งเดียวเพียงแค่ภายใน เพื่อที่ฉันสามารถได้อย่างมีประสิทธิภาพ
สร้างการเรียงลำดับของการอ้างอิงแบบวงกลมไม่ ตัวชี้ไปยังตัวเองต่อ แต่
ตัวชี้ไปยังอีกคนหนึ่งของ ประเภทเหมือนกัน
>> ดังนั้นจึงปรากฎว่าเมื่อโครงสร้างข้อมูล เช่นนี้มีไม่กี่คน
การดำเนินการที่อาจจะมี ความสนใจของเรา
เราอาจต้องการแทรก ลงในรายการเช่นนี้
เราอาจต้องการลบ จากรายการเช่นนี้
เราอาจจะต้องการค้นหารายการสำหรับ มูลค่าหรือมากกว่าโดยทั่วไปการสำรวจ
และการสำรวจเป็นเพียงวิธีแฟนซีของ บอกว่าเริ่มต้นที่ด้านซ้ายและย้ายทั้งหมด
วิธีการที่เหมาะสม
>> และแจ้งให้ทราบล่วงหน้านี้แม้จะมีมากขึ้นเล็กน้อย โครงสร้างข้อมูลที่มีความซับซ้อนให้
ผมเสนอว่าเราสามารถยืมบางส่วนของ ความคิดของที่ผ่านมาสองสัปดาห์และ
ใช้ฟังก์ชันที่เรียกว่า ค้นหาเช่นนี้
มันจะกลับจริงหรือ เท็จชี้ใช่หรือ
ไม่มี n คือในรายการ
อาร์กิวเมนต์ที่สองมันเป็นตัวชี้ ไปยังรายการของตัวเองดังนั้น
ตัวชี้ไปยังโหนด
>> ทั้งหมดที่ฉันจะทำคือการแล้วประกาศ ตัวแปรชั่วคราว
เราจะเรียกว่า PTR โดยการประชุม, สำหรับตัวชี้
และฉันกำหนดให้เท่ากับ จุดเริ่มต้นของรายการ
>> และตอนนี้สังเกตเห็นห่วงขณะ
ตราบใดที่ตัวชี้ไม่เท่ากับ ให้เป็นโมฆะ, ฉันจะตรวจสอบ
คือลูกศรตัวชี้ n เท่ากับ n ที่ถูกส่งผ่านไปใน?
และรอนาที - ใหม่ ชิ้นส่วนของไวยากรณ์
อะไรคือสิ่งที่ลูกศรทั้งหมดในทันที?
อ้าง?
>> อย่างแน่นอน
ดังนั้นในขณะที่ไม่กี่นาทีที่ผ่านมาเราใช้ สัญกรณ์ในการเข้าถึงจุดบางสิ่งบางอย่าง
ภายในของ struct ถ้าตัวแปร คุณไม่ได้เป็น struct
ตัวเอง แต่ตัวชี้ไปที่ struct, ขอบคุณที่ชิ้นส่วนของไวยากรณ์ที่
ในที่สุดก็ทำให้ความรู้สึกที่ใช้งานง่าย
ลูกศรหมายถึงการปฏิบัติตามตัวชี้ เหมือนลูกศรของเรามักจะหมายถึง
pictorially และไปที่ ข้อมูลฟิลด์ภายใน
ดังนั้นลูกศรเป็นสิ่งเดียวกันเป็นจุด แต่ คุณจะใช้มันเมื่อคุณมีตัวชี้
>> ดังนั้นเพียงเพื่อปะยางรถแล้วถ้าสนาม n ภายในของโครงสร้างที่เรียกว่าตัวชี้
เท่ากับเท่ากับ n, return true
มิฉะนั้นเส้นที่นี่ - ชี้ เท่ากับตัวชี้ต่อไป
ดังนั้นสิ่งนี้จะทำแจ้งให้ทราบคือถ้าผม กำลังชี้ไปที่ struct
ที่มี 9, 9 และไม่ได้เป็นจำนวน ฉันกำลังมองหา - คิดว่าฉันกำลังมองหา
สำหรับ n เท่ากับ 50 -
ฉันจะปรับปรุงตัวชี้ชั่วคราวของฉัน ที่จะไม่ชี้ที่โหนดนี้
อีกต่อไป แต่ตัวชี้ลูกศรถัดจากที่ จะวางฉันขึ้นที่นี่
>> ตอนนี้ฉันรู้ว่าเป็นลมบ้าหมู การแนะนำ
เมื่อวันพุธที่เราจริงจะทำเช่นนี้ กับมนุษย์บางส่วนและบางส่วนที่มีมากขึ้น
รหัสอัตราที่ชะลอลง
แต่รู้ว่าเรากำลังทำข้อมูลของเรา โครงสร้างที่ซับซ้อนมากขึ้นเพื่อให้เรา
อัลกอริทึมจะได้รับมีประสิทธิภาพมากขึ้นซึ่ง เป็นไปได้ที่จำเป็นสำหรับการ
pset หกเมื่อเราโหลดในครั้งนั้น 150,000 คำ แต่จำเป็นต้องทำเช่นนั้น
ได้อย่างมีประสิทธิภาพและความนึกคิดสร้าง โปรแกรมที่ทำงานสำหรับผู้ใช้ของเราไม่ได้อยู่ใน
เชิงเส้นไม่ได้อยู่ใน n squared แต่ใน เวลาคงที่ในอุดมคติ
>> เราจะเห็นคุณในวันพุธที่
>> SPEAKER: ที่ CS50 ต่อไปเดวิด ลืมกรณีฐานของเขา
>> DAVID ลัน: และนั่นเป็นวิธีที่คุณส่ง ข้อความ c กับอะไร -
>> ข้อความ [ต่างๆ ประกาศเสียง]