[เสียงเพลง]
>> เดวิดเจลันสิทธิทั้งหมดนี้เป็น CS50
และนี่คือหนึ่งสัปดาห์
ดังนั้นจำได้ว่าครั้งสุดท้ายในสัปดาห์ที่ศูนย์ เรามุ่งเน้นการคิดคำนวณ
และเราเปลี่ยนจากการที่ เริ่มต้นเขียนโปรแกรมกราฟิก
ภาษาจากเพื่อนของเรา ที่ MIT Media Lab ของ
>> และมีรอยขีดข่วนเราไม่สำรวจ ความคิดเช่นฟังก์ชั่นและเงื่อนไข
และลูปและตัวแปรและแม้กระทั่ง เหตุการณ์และกระทู้, และอื่น ๆ
และวันนี้เรากำลังจะไป ยังคงใช้ความคิดเหล่านั้น
และจริงๆพวกเขาสำหรับการ รับ แต่แปลพวกเขา
ภาษาอื่นที่รู้จักในฐานะซีตอนนี้ C เป็นภาษาดั้งเดิมมากขึ้น
มันเป็นระดับที่ต่ำกว่า ภาษาถ้าคุณจะ
>> มันเป็นเรื่องเกี่ยวกับใจอย่างหมดจด
และอื่น ๆ ได้อย่างรวดเร็วก่อนมัน ทุกคนจะต้องมองที่ค่อนข้างคลุมเครือ
ถ้าคุณไม่เคยตั้งโปรแกรมก่อน
เรากำลังจะมี กึ่งทวิภาคและวงเล็บ
และวงเล็บปีกกาและอื่น ๆ
แต่ตระหนักว่าแม้ แม้ว่าไวยากรณ์คือ
เกี่ยวกับการที่จะดูเล็ก ๆ น้อย ๆ ที่ไม่คุ้นเคย ส่วนใหญ่ของคุณให้ดูที่ผ่านมาว่า
และพยายามที่จะเห็นความคิด ที่มีความจริงที่คุ้นเคย
เพราะที่นี่ในสัปดาห์หนึ่งสิ่ง เราจะเริ่มต้นที่จะทำคือการเปรียบเทียบ
แรกรอยขีดข่วนเมื่อเทียบกับซี
>> ดังนั้นสำหรับตัวอย่างเช่นจำได้ว่าเมื่อเรา การดำเนินการครั้งแรกของโปรแกรมของเรา
ครั้งสุดท้ายที่เรามีบล็อกที่มอง บางสิ่งบางอย่างเล็ก ๆ น้อย ๆ เช่น this-- เมื่อ
ธงสีเขียวคลิกแล้วเรามี หรือมากกว่าหนึ่งชิ้นส่วนปริศนาด้านล่างมัน
ในกรณีนี้การพูด, Hello World
ดังนั้นแท้จริงในเกา เมื่อฉันคลิกที่ธงสีเขียว
เพื่อเรียกใช้โปรแกรมของฉันดังนั้น ที่จะพูดเหล่านี้เป็น
บล็อกที่ได้รับการดำเนินการหรือเรียกใช้
และโดยเฉพาะรอยขีดข่วน กล่าวว่า Hello, world
>> ตอนนี้ฉันจะได้ระบุไว้ คำพูดที่แตกต่างกันที่นี่
แต่เราจะเห็นว่าจริง ๆ อีกมากมาย ของ blocks-- เหล่านี้และแน่นอน
ใน C functions-- จำนวนมากสามารถ parametrized หรือที่กำหนดเอง
ที่จะทำสิ่งที่แตกต่างกัน
ในความเป็นจริงใน C ถ้าเรา ต้องการแปลงตอนนี้
โปรแกรม Scratch นี้ ภาษาอื่น ๆ นี้
เรากำลังจะเขียน บางสิ่งบางอย่างเล็ก ๆ น้อย ๆ เช่นนี้
>> จริงอยู่ที่มีบางที่ไม่คุ้นเคย ไวยากรณ์มีแนวโน้มมากที่สุด, int,
และวงเล็บและถือเป็นโมฆะ
แต่ printf-- แม้ว่าคุณจะ คิดว่ามันก็จะพิมพ์
แต่หมายถึงการพิมพ์การพิมพ์ รูปแบบที่เราจะเห็นทันที
นี้อย่างแท้จริงจะพิมพ์ ไปที่หน้าจอใดก็ตาม
อยู่ภายในวงเล็บเหล่านั้นซึ่ง แน่นอนในกรณีนี้คือโลกสวัสดี
>> แต่คุณจะสังเกตเห็นอื่น ๆ บาง ไวยากรณ์บางราคาคู่
ที่วงเล็บที่สิ้นสุด, กึ่งลำไส้ใหญ่และชอบ
ดังนั้นจึงมีบิตของค่าใช้จ่าย เพื่อที่จะพูดทั้งรับรู้
และไวยากรณ์ที่เรากำลังจะไป ที่จะต้องจำไว้ก่อนที่จะยาว
แต่ทราบว่ามีการปฏิบัติ นี้จะเริ่มที่จะกระโดดออกจากที่คุณ
>> ในความเป็นจริงขอเน้นที่หนึ่ง ฟังก์ชั่น specifically-- ในกรณีนี้
ทักทายโลก
ดังนั้นพูดได้ก็คือฟังก์ชั่น
สวัสดีชาวโลกเป็นพารามิเตอร์ของตน หรือโต้แย้งการปรับแต่ง
>> และความเท่าเทียมกันใน C เป็นเพียง จะเป็นหนึ่งบรรทัดนี้ที่นี่
ที่ printf จะเทียบเท่ากับการพูด สตริงที่ยกมาคู่สวัสดี
โลกจะเทียบเท่าของหลักสูตร กับสิ่งที่อยู่ในกล่องสีขาวมี
และ n ทับขวาแม้เพียงเล็กน้อย ที่แปลกและขาดจากรอยขีดข่วน
ก็จะมีผลกระทบที่เราจะ เห็นในคอมพิวเตอร์เช่น Mac หรือ PC ของฉัน
เพียงย้าย เคอร์เซอร์บรรทัดถัดไป
มันก็เหมือนกับการกดปุ่ม Enter บนแป้นพิมพ์ของคุณ
>> ดังนั้นเราจะเห็นว่าอีกไม่นาน
แต่ก่อนอื่นลองมาดูที่นี้ ตัวอย่างอื่น ๆ ในกรณีของลูป
เรามีนี้ห่วงตลอดเวลาที่ผ่านมา ซึ่งเป็นชุดของชิ้นส่วนจิ๊กซอว์
ว่าทำอะไรบางอย่างแท้จริง forever-- ในกรณีนี้
บอกว่าโลกสวัสดีโลก Hello World, Hello World
ดังนั้นจึงเป็นห่วงอนันต์โดยการออกแบบ
>> ใน C ถ้าเราต้องการที่จะดำเนินการนี​​้ ความคิดเดียวกันเราก็อาจจะทำเช่นนี้
ในขณะที่ความจริง printf สวัสดี world-- ในขณะนี้ ในขณะที่เพียงความหมายชนิดของ
เสกขึ้นมาความคิดของการทำ บางสิ่งบางอย่างอีกครั้งและอีกครั้งและอีกครั้ง
และนานเท่าไหร่?
ดีเรียกคืน true-- ว่า ความจริงเป็นเพียงหนึ่งหรือ
>> และเป็นความจริงเป็นของหลักสูตรจริงเสมอ
ดังนั้นมันจึงเป็นชนิดของความหมาย คำสั่งเพียงเพื่อบอกความจริง
แต่แท้จริงนี้คือเจตนา เพราะถ้าเป็นจริงเป็นความจริงเพียงแค่เสมอ
กว่าในขณะที่ความจริงเพียงหมายถึง ถ้าเล็ก ๆ น้อย ๆ โดยอ้อม
ว่าสายของรหัสต่อไป ในระหว่างวงเล็บปีกกาเหล่านั้น
ก็ควรจะดำเนินการอีกครั้งและอีกครั้ง และอีกครั้งและไม่เคยหยุดจริง
>> แต่ถ้าคุณไม่ต้องการของคุณ ห่วงจะหยุดที่เรา
ทำครั้งสุดท้ายกับสิ่งที่ต้องการ นี้ซ้ำต่อไปนี้ 50 ครั้ง
ใน C เราสามารถทำเช่นเดียวกันกับสิ่งที่ เรียกว่าสำหรับ loop-- คำหลัก
ในขณะที่ไม่ได้ แต่สำหรับ
แล้วเรามีบางไวยากรณ์ใหม่ที่นี่ กับ int i เท่ากับ 0, ฉันน้อยกว่า 50
i ++
และเราจะกลับมาที่
แต่นี้เป็นเพียงวิธีการที่เราจะ แปลชุดของบล็อกรอยขีดข่วน
ชุดสาย C ของรหัส
>> ในขณะเดียวกันให้พิจารณาตัวแปร
และในความเป็นจริงเราเพียงแค่ เห็นชายคนหนึ่งสักครู่ที่ผ่านมา
และในกรณีของรอยขีดข่วนถ้าเรา อยากจะประกาศตัวแปรที่เรียกว่าฉัน
เพราะเราเป็นจำนวนเต็มเพียงตัวเลข และเราต้องการที่จะตั้งค่าให้ค่าบางอย่าง
เราจะใช้สีส้มนี้ กันโดยตั้ง here-- ฉัน 0
>> และเราจะเห็นในวันนี้และ ไกลออกไปเช่นเดียวกับสัปดาห์ที่ผ่านมา
โปรแกรมเมอร์ทำเกือบเสมอ เริ่มนับจากศูนย์จริงๆ
โดยการประชุม
แต่ยังเป็นเพราะการเรียกคืนจาก การสนทนาของเราของไบนารี
จำนวนที่น้อยที่สุดที่คุณสามารถ แทนด้วยจำนวนบิตใด ๆ
เป็นเพียงการไปเป็น 0 ตัวเอง
และเพื่อให้เราโดยทั่วไปจะเริ่มต้น เริ่มต้นแม้ตัวแปรของเราให้เป็น 0
>> และใน C จะทำเช่นเดียวกัน เรากำลังจะบอกว่า int
สำหรับจำนวนเต็มฉันเพียงแค่โดยการประชุม
ฉันจะได้เรียกว่าตัวแปรนี้ อะไรที่ฉันต้องการเช่นเดียวกับในรอยขีดข่วน
และแล้วเท่ากับ 0 เพียงแค่กำหนด ค่า 0 จากด้านขวา
และทำให้มันเป็นตัวแปรหรือ ภาชนะที่เก็บมีอยู่ทางซ้ายมือ
และลำไส้ใหญ่กึ่งที่สุดเท่าที่เราจะ see-- และ ที่เราเคยเห็นไม่กี่ already-- เหล่านี้
เพียงหมายถึงการสิ้นสุดของความคิด
ดำเนินการต่อไปทำอย่างอื่น บนเส้นที่เป็นไปตาม
>> ตอนนี้สิ่งที่เกี่ยวกับนิพจน์บูลีน?
จำได้ว่าในเกา เหล่านี้มีการแสดงออก
ที่มีความจริง แต่อย่างใด หรือคำถาม false--,
จริงๆที่มีทั้งจริงหรือเท็จ
ดังนั้นในกรณีของการเริ่มต้นเราอาจจะ ถามคำถามง่ายๆเช่นนี้
คือผมน้อยกว่า 50?
ดังนั้นฉันอีกครั้งเป็นจำนวนเต็ม
บางทีเรากำลังใช้มัน ในโปรแกรมรอยขีดข่วน
ในการติดตามของคะแนน หรือสิ่งที่ต้องการ
ดังนั้นรูปแบบนี้ที่นี่ในรอยขีดข่วน ก็หมายความว่าเป็นฉันน้อยกว่า 50?
ดีโชคดีที่มีอะไรบางอย่าง ที่เรียบง่ายในซีและการแปล
นี้เราก็จะบอกว่าผมน้อย กว่า 50, ใช้คีย์คุ้นเคย
บนแป้นพิมพ์
>> ในขณะเดียวกันถ้าคุณต้องการ พูดอะไรบางอย่างทั่วไปมากขึ้น
เหมือนกันคือ x น้อยกว่าปีที่แต่ละ ของ x และ y เป็นตัวตัวแปร?
เราสามารถทำในสิ่งเดียวกัน ใน C ตราบใดที่เราได้
สร้างตัวแปรเหล่านี้อยู่แล้ว
และเราจะเห็นวิธีการ ทำอย่างนั้นไม่นาน
เราก็จะบอกว่าน้อยกว่า X Y
>> ดังนั้นคุณเริ่มที่จะ ดูคล้ายคลึงกันบางอย่าง
และคนเหล่านั้นที่ทำ รอยขีดข่วนได้อย่างแน่นอน
แรงบันดาลใจจากบางส่วนของความคิดพื้นฐานเหล่านี้
และคุณจะเห็นชนิดนี้ ไวยากรณ์ในหลาย languages​​--
ไม่ได้เป็นเพียงรอยขีดข่วนไม่ เพียงแค่ C แต่งูหลาม
และ JavaScript และ ภาษาอื่น ๆ ยังคง
>> ลองพิจารณาสร้างอีก จาก C, ความคิดของเงื่อนไขที่
ทำสิ่งที่มีเงื่อนไข
หากสิ่งที่เป็นความจริงทำเช่นนี้
ถ้าอย่างอื่นเป็นความจริงทำอย่างนั้น
มันเรียงลำดับของการเขียนโปรแกรม เทียบเท่าส้อมในถนน
บางทีมันอาจจะเป็นทางแยกสองทาง ส้อมสามทางหรือมากกว่า
และในเกาเราอาจจะมี บางสิ่งบางอย่างที่เห็นเช่นนี้
>> ดังนั้นหนึ่งในนี้เป็นขนาดใหญ่
แต่พิจารณาญาติ ความเรียบง่ายของตรรกะ
ถ้า x น้อยกว่าปีแล้วบอกว่า x น้อย กว่า Y, อื่นถ้า x มากกว่า Y,
แล้วบอกว่า x มากกว่า Y
แล้วมีเหตุผลถ้า คุณคิดว่ากลับไปรอยขีดข่วน
หรือเพียงแค่สัญชาตญาณของมนุษย์ของคุณเอง ดีถ้า x ไม่เกิน Y และ X
ไม่น้อยกว่าปีแล้วแน่นอน X เป็นไปได้เท่ากับ Y
ดังนั้นในกรณีนี้โดยการทำรัง บรรดาบล็อกเกา
เราสามารถบรรลุสาม ส้อมวิธีการในถนนหรือไม่
>> ในขณะเดียวกันถ้าเราต้องการที่จะ ทำอย่างนั้นใน C มันเนื้อหา
ดู simpler-- เล็ก ๆ น้อย ๆ อย่างน้อย เมื่อคุณได้รับคุ้นเคยกับไวยากรณ์
ถ้า x น้อยกว่า Y, printf x น้อยกว่า Y
อื่นถ้า x มากกว่า Y, printf x มากกว่า Y
อื่น printf x เท่ากับ y-- และ อีกครั้งด้วย backslash ผู้ที่จบลงเพียงแค่
สำหรับสายใหม่เหล่านั้นเพื่อว่าถ้าคุณ จริงวิ่งชนิดของโปรแกรมนี้
มันก็จะย้าย เคอร์เซอร์ของคุณในท้ายที่สุด
ยังบรรทัดถัดไปของหน้าจอ
>> ตอนนี้ในขณะที่มีรอยขีดข่วนอื่น ๆ คุณสมบัติที่ซับซ้อนมากขึ้นเท่านั้น
บางอย่างที่เรากำลังจะไป แรกย้ายไปยังโลกของซี
และหนึ่งในนั้นคือ เรียกว่ารายการในรอยขีดข่วน
และเรื่องนี้เป็นพิเศษ ประเภทของตัวแปรที่
อนุญาตให้คุณสามารถเก็บสิ่งที่หลาย ๆ ในการกลับไปกลับไปกลับไปด้านหลัง
>> ใน C, มันไม่ได้มี รายการต่อ se แต่บางสิ่งบางอย่าง
ที่มีมากขึ้นโดยทั่วไป เรียกว่าอาร์เรย์แม้ว่าเราจะ
กลับมาในภายหลังภาคการศึกษานี้ เพื่อมองหาที่บางสิ่งบางอย่าง
เรียกว่ารายการหรือจริงๆรายการที่เชื่อมโยง
แต่ตอนนี้ที่อยู่ใกล้ที่สุด เทียบเท่าใน C สำหรับเรา
เป็นไปได้บางสิ่งบางอย่าง เรียกว่าอาร์เรย์
และอาร์เรย์เป็นเพียง ชนิดพิเศษของตัวแปร
ที่ช่วยให้คุณสามารถเก็บข้อมูล กลับไปกลับไปกลับไปด้านหลัง
>> และแน่นอนในเกา ถ้าเราต้องการที่จะเข้าถึง
องค์ประกอบแรกของอาร์เรย์หรือ list-- และฉันจะเรียกว่า
โดยการประชุม, argv อาร์กิวเมนต์ เวกเตอร์ แต่เพิ่มเติมว่าอีกไม่นาน
ถ้าผมต้องการที่จะได้รับองค์ประกอบแรก ของ argv ในโลกของรอยขีดข่วน
คุณมักจะทำจริง เริ่มนับตั้งแต่วันที่ 1
>> และดังนั้นผมจึงอาจได้รับข้อ 1 ของ argv
นั่นเป็นเพียงวิธีการดำเนินการที่เอ็มไอที ความคิดของรายการ
แต่ใน C, ฉันจะไป อื่น ๆ อีกมากมายเพียงแค่พูดว่า argv,
อีกครั้งซึ่งเป็นชื่อของฉัน list-- หรือเพื่อจะชัดเจนอาร์เรย์
และถ้าผมต้องการเป็นคนแรก องค์ประกอบที่ฉันจะ
การใช้วงเล็บที่คุณ อาจจะไม่ได้ใช้บ่อยภายใต้แป้นพิมพ์
>> แต่เพียง 0 หมายถึงได้รับฉันแรก
ดังนั้นในโอกาสและ เวลาผ่านไปเราจะ
ที่จะเริ่มต้นที่จะเห็นทุกอย่างเหล่านี้ ระหว่างรอยขีดข่วนและ C
โดย Scratch ใช้อย่างใดอย่างหนึ่ง
เราใช้ใน C 0 ที่นี่
แต่คุณจะเห็นได้อย่างรวดเร็ว เมื่อคุณเข้าใจ
รากฐานของแต่ละภาษาที่ สิ่งเหล่านี้เริ่มที่จะได้รับทั้งหมดเพิ่มเติม
คุ้นเคยผ่านการปฏิบัติและการปฏิบัติ
>> ดังนั้นขอให้เป็นจริงการมองในขณะนี้ที่โปรแกรม
นี่จะเป็นครั้งแรกของซีของเรา ซอร์สโค้ดของโปรแกรมที่สมบูรณ์
และโปรแกรมที่เรากำลังจะไป ที่จะนำเสนอเพื่อประกอบการพิจารณา
เป็นหนึ่งในที่เทียบเท่า เพื่อว่าชิ้นส่วนก่อนหน้านี้รอยขีดข่วน
>> ดังนั้นในที่นี่เรามีสิ่งที่เป็น เนื้อหาที่ง่ายโปรแกรม C
คุณสามารถเขียนว่า บางสิ่งบางอย่างที่ไม่จริง
ตอนนี้เราจะดูที่ผ่านมา สำหรับตอนนี้ยังรวมถึง
io.h มาตรฐานและมุมเหล่านี้ วงเล็บและ int และเป็นโมฆะ
และวงเล็บปีกกาและไม่ชอบ
>> และขอเพียงมุ่งเน้น สิ่งที่อย่างน้อยสังหรณ์ใจ
อาจจะกระโดดออกจากที่คุณมีอยู่แล้ว
ในความเป็นจริงหลักฉันทำไม่ได้ จำเป็นต้องรู้ว่าสิ่งนี้คือ
แต่เหมือนรอยขีดข่วนได้ว่าเมื่อ ธงสีเขียวคลิกชิ้นส่วนจิ๊กซอว์
เพื่อไม่ C เป็นภาษาโปรแกรม มีชิ้นส่วนหลักของรหัสที่
ได้รับการดำเนินการไปโดยปริยาย และแน่นอน มันอย่างแท้จริงจะถูกเรียกว่าหลัก
>> ดังนั้นหลักคือฟังก์ชั่น
และมันเป็นฟังก์ชั่นพิเศษที่มีอยู่ ใน C ที่ว่าเมื่อคุณรันโปรแกรม
มันเป็นหลักที่ได้รับการดำเนินการโดย ค่าเริ่มต้น. ในโลกของรอยขีดข่วน
มันเป็นปกติเมื่อธงสีเขียว คลิกที่ได้ดำเนินการโดยเริ่มต้น
>> ในขณะเดียวกันเราเคยเห็นแบบนี้มาก่อน printf หรือพิมพ์รูปแบบที่
จะเป็นฟังก์ชั่นที่มาพร้อมกับ C พร้อมกับทั้งกลุ่มของคนอื่น ๆ
จะจากเวลาและเวลาที่ อีกครั้งเพื่อที่จะทำว่า
เป็นชื่อของมันบ่งบอกอะไรบางอย่างที่พิมพ์
เราทำอะไรต้องการพิมพ์?
ดีเราจะเห็นว่า โดยตัวละครที่ล้อมรอบ
เหมือนโลกสวัสดี these--, ทับขวา n ในราคาคู่
เราสามารถบอกได้ว่า printf สิ่งที่จะพิมพ์บนหน้าจอ
>> แต่เพื่อที่จะทำ ว่าเราโชคไม่ดี
จำเป็นต้องใช้สิ่งที่เป็น แล้วความลับให้เรามนุษย์
แต่อย่างน้อยก็ค่อนข้าง readable-- คมชัดรวมถึง io.h มาตรฐาน int,
หลักโมฆะ printf ทั้งหมดของวิเศษ คาถาที่เราเพิ่งเห็นบนหน้าจอ
แต่เราจริงต้อง ไปยังความลับมากขึ้น
แรกที่เราต้องแปลรหัส ที่เราเขียนลงในรหัสเครื่อง
และเรียกคืนจากสัปดาห์ที่แล้วว่าเครื่อง อย่างน้อยคนที่เรารู้ว่าที่นี่
ในตอนท้ายของวันเท่านั้น เข้าใจศูนย์และคน
>> และพระเจ้าของข้าพเจ้าถ้าเรามีการเขียนเหล่านี้ ศูนย์และคนในการเขียนโปรแกรมจริง
มันจะมากอย่างรวดเร็ว ใช้เวลาสนุกออกจากอะไร
แต่ปรากฎต่อสัปดาห์ที่ผ่านมา ว่ารูปแบบนี้ของศูนย์และคน
เพียงแค่มีความหมายพิเศษ
ในบริบทบางอย่าง พวกเขาอาจจะหมายถึงตัวเลข
>> ในบริบทบางพวกเขาอาจหมายถึง ตัวอักษรหรือสีหรือหมายเลขใด ๆ
ของแนวคิดอื่น ๆ ที่มีอยู่บน
แต่ในขณะที่คอมพิวเตอร์ของคุณมี ซีพียู, หน่วยประมวลผลกลาง
หรือสมองภายในของเครื่องคอมพิวเตอร์ของคุณ
มันมักจะเป็น Intel ภายในเพราะนั่นคือ
หนึ่งใน บริษัท ที่ใหญ่ที่สุด ที่ทำให้ซีพียูสำหรับคอมพิวเตอร์
>> ดี CPU ของ Intel และอื่น ๆ เพียงแค่ได้ตัดสินใจล่วงหน้า
ว่ารูปแบบหนึ่งของศูนย์และ คนที่จะหมายถึงสิ่งที่เฉพาะเจาะจง
บางรูปแบบของศูนย์และคน จะหมายถึงการพิมพ์นี้เพื่อหน้าจอ
หรือเพิ่มทั้งสองตัวเลขหรือ ลบทั้งสองหมายเลข
หรือเคลื่อนย้ายชิ้นส่วนของข้อมูลนี้จาก หน่วยความจำของคอมพิวเตอร์ของฉันมากกว่าที่นี่
หรือจำนวนของระดับต่ำมาก ๆ ๆ ๆ , แต่มีประโยชน์ในท้ายที่สุดการดำเนินงาน
แต่โชคดีที่มนุษย์เราจะไม่ได้ไป จะต้องรู้รายละเอียดในระดับนี้
แท้จริงเช่นเดียวกับครั้งสุดท้ายที่เรา ใจลอยอีกครั้งและอีกครั้งและอีกครั้ง
อาคารจากระดับที่ต่ำมาก วิทยาการเช่นศูนย์และคน
กับแนวคิดระดับที่สูงขึ้น เช่นตัวเลขและตัวอักษร
และสีและอื่น ๆ เพื่อให้เราสามารถเป็นโปรแกรมเมอร์
ยืนอยู่บนไหล่ของ คนอื่น ๆ ที่มีมาก่อนเรา
และใช้ซอฟต์แวร์ที่อื่น ๆ คนได้เขียนขึ้นก่อน us--
คือโปรแกรมที่เรียกว่าคอมไพเลอร์
>> ซีเป็นภาษาที่ มักจะมีการรวบรวม
ซึ่งหมายถึงการดัดแปลงมาจาก รหัสที่มารหัสเครื่อง
โดยเฉพาะอย่างยิ่งสิ่งนี้หมายความว่า คือว่าถ้าคุณได้มีแหล่งที่มาของ
รหัสที่คุณเองเขียนในขณะที่เราเร็ว ๆ นี้ จะอยู่ในช่วงเวลาเพียงแค่บนหน้าจอ,
และคุณต้องการแปลง ในท้ายที่สุดไปยังเครื่อง code--
ศูนย์เหล่านั้นและคนที่ เพียง Mac หรือ PC ของคุณ
understands-- ที่คุณได้เป็นครั้งแรก ฟีดรหัสที่มาว่าในขณะที่
การป้อนข้อมูลให้เป็นพิเศษ โปรแกรมที่เรียกว่าคอมไพเลอร์,
การส่งออกของที่เรา จะเห็นเป็นรหัสเครื่อง
และแน่นอนครั้งสุดท้ายที่เราได้พูดคุยกัน เกี่ยวกับมันในตอนท้ายของวัน
การแก้ปัญหา.
คุณได้มีปัจจัยการผลิต
และคุณได้มีเอาท์พุท
และคุณได้มีบางชนิด ขั้นตอนวิธีการที่อยู่ตรงกลาง
>> ขั้นตอนวิธีการก็สามารถ ดำเนินการในซอฟต์แวร์
อย่างที่เราเห็นกับสัปดาห์ที่ผ่านมา pseudocode และในขณะที่เราจะเห็นด้วยรหัสที่เกิดขึ้นจริง
ในสัปดาห์นี้.
และเพื่อให้คอมไพเลอร์จริงๆเพียงแค่ มีชุดของขั้นตอนวิธีการภายใน
ของมันที่ทราบวิธีการ แปลงคำหลักพิเศษ
เช่นหลักและ printf, และอื่น ๆ ที่เราเพียงแค่
เห็นในรูปแบบของศูนย์และ คนที่อินเทลภายในและอื่น ๆ ซีพียู
จริงเข้าใจ
ดังนั้นทำอย่างไรเราทำเช่นนี้?
ที่เราจะได้รับคอมไพเลอร์หรือไม่?
>> ส่วนใหญ่ของเราที่นี่มี Mac หรือ PC
และคุณใช้ Mac OS หรือ Windows หรือลินุกซ์หรือโซลาริส
หรือจำนวนอื่น ๆ ระบบปฏิบัติการ.
และแน่นอนที่เราจะทำได้ ออกไปสู่​​เว็บ
และดาวน์โหลดคอมไพเลอร์ สำหรับ Mac หรือ PC ของคุณ
สำหรับระบบปฏิบัติการของคุณโดยเฉพาะ
แต่เราทุกคนจะอยู่บน หน้าเว็บที่แตกต่างกันเพื่อที่จะพูด
เราจะต้องออกไปเล็กน้อย การกำหนดค่าที่แตกต่างกัน
และสิ่งที่จะไม่ทำงานเหมือนกันทั้งหมด
และแน่นอนวันนี้ พวกเราหลายคนไม่ได้ใช้
ซอฟต์แวร์ที่ทำงานเฉพาะในแล็ปท็อปของเรา
แต่เราใช้สิ่งที่ เช่นเดียวกับเบราว์เซอร์ที่
ช่วยให้เราสามารถเข้าถึง Web-based การใช้งานในระบบคลาวด์
และต่อมาภาคการศึกษานี้ เราจะทำตรงนั้น
เราจะเขียนโปรแกรมหรือ ซอฟแวร์ที่ใช้ไม่ได้ code-- C,
แต่ภาษาอื่น ๆ เช่นงูหลามและ JavaScript-- ที่ทำงานในระบบคลาวด์
>> และจะทำอย่างไรที่ตัวเราเอง ช่วงปิดเทอม
จริงจะใช้เมฆตาม สภาพแวดล้อมที่รู้จักในฐานะ CS50 IDE
นี่คือการเขียนโปรแกรมบนเว็บ สภาพแวดล้อมหรือการพัฒนาแบบบูรณาการ
สิ่งแวดล้อม IDE, ที่สร้างอยู่บนบาง ซอฟแวร์โอเพนซอร์สที่เรียกว่า Cloud 9
และเราได้ทำให้การเรียนการสอนบางส่วน simplifications กับมัน
เพื่อให้เป็นไปซ่อนคุณลักษณะบางอย่างใน สัปดาห์แรกที่เราไม่ต้องการ
หลังจากที่คุณสามารถ เปิดเผยพวกเขาและทำมากที่สุด
สิ่งที่คุณต้องการกับสภาพแวดล้อม
>> และมันช่วยให้เรามากเกินไปที่จะ ก่อนติดตั้งซอฟต์แวร์บางอย่าง
สิ่งที่ต้องการสิ่งที่เรียกว่า CS50 ห้องสมุดซึ่งเราจะเห็นทันที
ให้เราใน C กับบางส่วน ฟังก์ชันการทำงานเพิ่มเติม
ดังนั้นถ้าคุณไปในที่สุด CS50.io, คุณจะได้รับแจ้งให้เข้าสู่ระบบ
และเมื่อคุณทำและสร้าง บัญชีฟรีที่
คุณจะสามารถเข้าถึง สภาพแวดล้อมที่มีลักษณะมากเช่นนี้
>> ตอนนี้อยู่ในโหมดเริ่มต้น
ทุกอย่างเป็นสิ่งที่ดีและ สว่างบนหน้าจอ
พวกเราหลายคนมีนิสัยของ ทำงานเกี่ยวกับชิ้นส่วนที่ CS50
ค่อนข้างดึก
และเพื่อให้บางส่วนของคุณอาจต้องการ ทำให้มันกลายเป็นโหมดกลางคืนเพื่อที่จะพูด
>> แต่ท้ายที่สุดสิ่งที่คุณกำลัง จะไปดูภายใน CS50 IDE
สาม areas-- ที่แตกต่างกัน ในพื้นที่ที่เหลือ
ไฟล์ของคุณจะไปได้ใน เมฆพื้นที่ด้านบนขวา
ที่รหัสของคุณเป็นไปได้ที่สามารถแก้ไขได้
คุณจะสามารถที่จะเปิด แต่ละแท็บสำหรับโปรแกรมใด ๆ
ที่คุณเขียนภายในภาคการศึกษานี้ ของมุมขวาด้านบนว่า
แล้วส่วนใหญ่ arcanely, และยังมีอำนาจ
เป็นไปได้สิ่งที่ ด้านล่างเป็นที่รู้จักกันเป็นหน้าต่าง terminal
>> นี้เป็นโรงเรียนเก่า บรรทัดคำสั่งอินเตอร์เฟซ
หรือ CLI ที่ช่วยให้ คุณสามารถรันคำสั่ง
ใน computer-- ในกรณีนี้ คอมพิวเตอร์ใน cloud--
ทำสิ่งที่ต้องการรวบรวมรหัสของคุณ จากซอร์สโค้ดรหัสเครื่อง
เพื่อเรียกใช้โปรแกรมของคุณหรือการเริ่มต้นของคุณ เว็บเซิร์ฟเวอร์หรือการเข้าถึงฐานข้อมูลของคุณ
และจำนวนของเทคนิคอื่น ๆ ที่เราจะเริ่มต้นที่จะใช้ก่อนที่จะยาว
แต่การที่จะได้รับมีเรา จะมีจริง
ไปออนไลน์และเริ่มเล่น
และจะทำอย่างไรที่ให้แรก เริ่ม tinkering กับหลัก
และเขียนส่วนหลักของโปรแกรม
และให้ใช้ฟังก์ชั่นที่ printf ซึ่งเรานำมาใช้ก่อนหน้านี้
เพียงแค่จะบอกว่าบางสิ่งบางอย่าง
>> ดังนั้นที่นี่ฉันทำไปแล้วภายในของ CS50 IDE
ผมเคยลงทะเบียนล่วงหน้า
และฉันเต็มมุ้งลวดหน้าต่าง
และเพื่อให้ในท้ายที่สุดคุณ เกินไปในปัญหาที่เกิดขึ้นมา
จะเป็นไปตามขั้นตอนที่คล้ายกันที่ จะให้เอกสารออนไลน์
ดังนั้นคุณจึงไม่ต้องกังวลเกี่ยวกับ การดูดซับทุกขั้นตอนทางเทคนิคเล็ก ๆ น้อย ๆ
ที่ผมทำที่นี่ในวันนี้
>> แต่คุณจะได้รับหน้าจอเช่นนี้
ฉันจะเกิดขึ้นในโหมดกลางคืน
และคุณสามารถปรับความสว่างทุกอย่าง โดยปิดการใช้งานโหมดกลางคืน
และในตอนท้ายของ วันคุณกำลังจะไปดู
ทั้งสามหลัก areas-- ไฟล์ เบราว์เซอร์ที่ด้านซ้าย, แท็บรหัสขึ้นด้านบน
และหน้าต่าง terminal ที่ด้านล่าง
>> ให้ฉันไปข้างหน้าและ เขียนโปรแกรมครั้งแรกของฉัน
ฉันจะ preemptively ไปที่ File, บันทึกและบันทึกแฟ้มของฉันเป็น hello.c
อันที่จริงตามแบบแผนใด ๆ ที่เราโปรแกรม เขียนว่าเขียนในภาษา C
ควรตั้งชื่อบางสิ่งบางอย่าง จุด C, โดยการประชุม
ดังนั้นฉันจะตั้งชื่อให้มัน hello.c เพราะ ผมแค่อยากจะทักทายกับโลก
ตอนนี้ผมกำลังจะไปซูม และคลิกบันทึก
และทั้งหมดที่ฉันมีที่นี่ในขณะนี้คือแท็บ ที่ฉันสามารถเริ่มต้นการเขียนโค้ด
>> นี้ไม่ได้ไปรวบรวม
นี้หมายถึงอะไร
ดังนั้นแม้ว่าผมจะแปลง นี้ศูนย์และคน,
ซีพียูเป็นไปได้ไม่มี คิดสิ่งที่เกิดขึ้นรอบ ๆ
แต่ถ้าผมเขียนเส้นที่ไม่ตรงกับ ขึ้นกับ C conventions-- C เป็นอยู่
อีกครั้งนี้ language-- มีไวยากรณ์เช่น นี้ printf สวัสดี world-- และฉันได้
อากาศสบายกับ การทำเช่นนี้เมื่อเวลาผ่านไป
ดังนั้นผมจึงไม่คิดว่าฉันทำ พิมพ์ผิดพลาดใด ๆ
>> แต่อย่างสม่ำเสมอเป็นครั้งแรกมาก เวลาที่คุณทำเช่นนี้คุณจะ
และสิ่งที่ฉันจะทำอาจจะมาก ดีไม่ทำงานให้คุณเป็นครั้งแรก
และที่ตกลงอย่างสมบูรณ์แบบ เพราะตอนนี้คุณ
ก็อาจจะดูมากทั้งความแปลก, แต่เมื่อเวลาผ่านไปเมื่อคุณได้รับคุ้นเคย
กับสภาพแวดล้อมนี้และ ภาษานี้และอื่น ๆ
คุณจะเริ่มเห็นสิ่งที่ มีทั้งที่ถูกต้องหรือไม่ถูกต้อง
>> และนี่คือสิ่งที่ ทุนเรียนการสอนและการเรียนการสอน
ผู้ช่วยได้รับดีเพื่อที่เมื่อเวลาผ่านไปเป็น จำข้อผิดพลาดหรือข้อบกพร่องในรหัสของคุณ
แต่ผมอ้างว่ามี ข้อบกพร่องในรหัสนี้
ดังนั้นตอนนี้ฉันต้องการที่จะเรียกใช้โปรแกรมนี้
>> ตอนนี้บน Mac ของตัวเองหรือ PC ฉันอยู่ใน นิสัยของไอคอนดับเบิลคลิก
เมื่อฉันต้องการที่จะเรียกใช้โปรแกรมบางอย่าง
แต่นั่นไม่ใช่รูปแบบที่นี่
ในสภาพแวดล้อมนี้ซึ่งเป็น IDE CS50
เราจะใช้ในการดำเนินงาน ระบบที่เรียกว่าลินุกซ์
ลินุกซ์เป็นที่ระลึกอีก ระบบปฏิบัติการที่รู้จักโดยทั่วไป
เป็นระบบปฏิบัติการยูนิกซ์
และลินุกซ์เป็นที่รู้จักกันโดยเฉพาะอย่างยิ่งสำหรับ มีสายสิ่งแวดล้อมสั่ง CLI
ตอนนี้เรากำลังใช้ที่เฉพาะเจาะจง รสชาติของลินุกซ์ที่เรียกว่าอูบุนตู
และ Ubuntu เป็นเพียง รุ่นหนึ่งของลินุกซ์
>> แต่ลินุกซ์เหล่านี้ทำวันนี้จริง มาพร้อมกับอินเตอร์เฟซผู้ใช้แบบกราฟิก
และคนที่เราเกิดขึ้นกับ จะใช้ที่นี่เป็น web-based
ดังนั้นนี่อาจจะดูแม้กระทั่ง ที่แตกต่างกันเล็ก ๆ น้อย ๆ จากบางสิ่งบางอย่าง
คุณเองอาจจะมี เห็นหรือทำงานในอดีตที่ผ่านมา
>> ดังนั้นฉันจะไปข้างหน้า ในขณะนี้และทำต่อไปนี้
ผมเคยบันทึกแฟ้มนี้เป็น hello.c
ฉันจะไปข้างหน้าและ ประเภท clanghello.c ดังนั้นเสียงดังกราว
สำหรับภาษา C เป็นคอมไพเลอร์
มันติดตั้งใน CS50 IDE
และคุณอย่างแน่นอนสามารถดาวน์โหลดและ ติดตั้งบน Mac ของคุณเองหรือเครื่องคอมพิวเตอร์
>> แต่อีกครั้งคุณจะไม่ได้ทั้งหมดของ ก่อนการกำหนดค่าทำเพื่อคุณ
ดังนั้นตอนนี้ฉันแค่ จะไปทำงาน clanghello.c
และตอนนี้สังเกตเห็นรูปแบบนี้ ที่นี่จะมีในที่สุด
ตระหนักถึงเพียงหมายความว่าผมอยู่ใน โฟลเดอร์หรือไดเรกทอรีที่เรียกว่าพื้นที่ทำงาน
เครื่องหมายดอลลาร์นี่เป็นเพียงการประชุม สำหรับความหมายพิมพ์คำสั่งของคุณที่นี่
>> มันเป็นสิ่งที่เรียกว่าพรอมต์เพียง โดยการประชุมเป็นเครื่องหมายดอลลาร์
และถ้าผมไปข้างหน้าในขณะนี้และคลิก ใส่ดูเหมือนจะไม่มีอะไรเกิดขึ้น
แต่ที่จริงเป็นสิ่งที่ดี
น้อยกว่าที่เกิดขึ้นใน หน้าจอของคุณมีโอกาสมากขึ้น
รหัสของคุณถูกต้อง อย่างน้อย syntactically
>> ดังนั้นถ้าผมต้องการที่จะทำงานนี้ โปรแกรมฉันจะทำอย่างไร?
ดีก็ปรากฎว่า ชื่อเริ่มต้นโดยการประชุม
สำหรับโปรแกรมเมื่อคุณไม่ได้ระบุ ชื่อสำหรับโปรแกรมของคุณเป็นเพียง a.out
และรูปแบบนี้มากเกินไปที่คุณจะ ได้คุ้นเคยกับก่อนที่จะยาว
>> Dot เฉือนก็หมายความว่าเดี๋ยวก่อน CS50 IDE เรียกใช้โปรแกรมที่เรียกว่า a.out
ที่อยู่ภายในไดเรกทอรีปัจจุบันของฉัน
จุดที่หมายถึงไดเรกทอรีปัจจุบัน
และเราจะเห็นสิ่งอื่น ๆ เช่นลำดับ ของตัวละครหมายความว่าอีกไม่นาน
>> ดังนั้นที่นี่เราไปใส่, Hello World
และคุณจะสังเกตเห็นว่าสิ่งที่เกิดขึ้น?
ไม่เพียง แต่มันพิมพ์ Hello World
นอกจากนี้ยังย้าย เคอร์เซอร์บรรทัดถัดไป
>> และทำไมเป็นเช่นนั้น?
สิ่งที่เป็นรหัสที่เราเขียนก่อน ที่ทำให้มั่นใจได้ว่าเคอร์เซอร์จะ
ไปในบรรทัดถัดไป?
สิ่งที่ตลกเกี่ยวกับ คอมพิวเตอร์คือมันเพียงจะ
ที่จะทำอย่างแท้จริงสิ่งที่คุณบอกว่าจะทำอย่างไร
>> ดังนั้นถ้าคุณบอกให้ printf สวัสดี จุลภาค, พื้นที่, โลกใกล้อ้าง
มันอย่างแท้จริงเท่านั้นจะ พิมพ์ตัวอักษรเหล่านั้น
แต่ฉันมีตัวละครพิเศษนี้ ในตอนท้ายจำทับขวาเอ็น
และนั่นคือสิ่งที่ทำให้มั่นใจได้ ว่าตัวละครไป
ยังบรรทัดถัดไปของหน้าจอ
>> ในความเป็นจริงให้ฉันไปและทำเช่นนี้
ให้ฉันไปข้างหน้าและลบ
ตอนนี้สังเกตเห็นว่า ด้านบนของหน้าจอของฉันมี
แสงสีแดงเล็ก ๆ น้อย ๆ ใน แสดงให้เห็นแท็บ
เดี๋ยวก่อนคุณไม่ได้บันทึกไฟล์ของคุณ
ดังนั้นฉันจะไปข้างหน้ากับการควบคุม S หรือคำสั่ง S บันทึกแฟ้ม
ตอนนี้มัน goes-- ไปสำหรับสีเขียว moment--
และตอนนี้ก็กลับไป เป็นเพียงไอคอนใกล้
>> ถ้าตอนนี้ผมทำงาน clanghello.c อีกครั้ง ใส่จุดเฉือน a.out, Enter,
คุณจะเห็นว่ามันจะยังคงทำงาน
แต่มันเป็นเนื้อหาที่รถม้าชนิดเล็ก ๆ น้อย ๆ
ตอนนี้พื้นที่ทำงาน prompt-- ของฉัน แล้วที่เครื่องหมายดอลลาร์
แล้ว prompt-- ที่เกิดขึ้นจริงของฉัน คือทั้งหมดในบรรทัดเดียวกัน
ดังนั้นนี้อย่างแน่นอนข้อผิดพลาดความงาม ถึงแม้ว่ามันจะไม่ได้จริงๆข้อผิดพลาดเชิงตรรกะ
>> ดังนั้นฉันจะเลิกทำสิ่งที่ผมก็ไม่ได้
ฉันจะเรียก a.out
สังเกตเห็นฉันได้เพิ่ม อักขระ newline กลับ
ผมเคยบันทึกไฟล์
>> ดังนั้นฉันจะเรียก a.out, and-- บ้า, ข้อผิดพลาด, ความผิดพลาดข้อผิดพลาดความหมาย
ดังนั้นข้อผิดพลาดคือว่าถึงแม้ ฉันเพิ่มเครื่องหมาย n มี
อีกครั้งที่บันทึกไว้อีกครั้งวิ่งโปรแกรม ลักษณะการทำงานได้เหมือนกัน
ทำไมว่าจะเป็นอย่างไร
>> ฉันหายไปขั้นตอนใช่มั้ย?
ว่าขั้นตอนสำคัญก่อนหน้านี้คือการที่คุณมี to-- เมื่อคุณเปลี่ยนรหัสที่มาของคุณ
มันจะเปิดออกก็วิ่ง มันผ่านคอมไพเลอร์
อีกครั้งเพื่อให้คุณได้รับรหัสเครื่องใหม่
และรหัสเครื่อง เลขศูนย์และคน
เป็นไปได้เหมือนกันเกือบ แต่ ไม่ได้อย่างสมบูรณ์แบบนั้นเพราะเราต้องการ
แน่นอนว่าการขึ้นบรรทัดใหม่
>> ดังนั้นการแก้ไขปัญหานี้ผมจะต้อง เพื่อเรียก clanghello.c ป้อนจุด
เฉือน a.out
และตอนนี้ Hello World จะกลับมา ไปที่ผมคาดหวังให้เป็น
ดังนั้นนี่เป็นสิ่งที่ดีและดี
แต่ a.out เป็นชื่อที่โง่สวยสำหรับ โปรแกรมแม้ว่ามันจะเกิดขึ้นจะเป็น
สำหรับเหตุผลทางประวัติศาสตร์ default-- หมายถึงผลประกอบ
>> แต่ให้ฉันไปข้างหน้านี่ และทำเช่นนี้แตกต่างกัน
ฉันต้องการให้โปรแกรม Hello World ของฉัน ที่จริงจะเรียกว่าสวัสดี
ดังนั้นถ้าเป็นไอคอนบนของฉัน สก์ท็อปก็จะไม่ได้รับการ a.out
มันจะเรียกว่าสวัสดี
>> ดังนั้นการทำเช่นนี้ก็จะเปิดออก ที่เสียงดังกราวเหมือนหลายโปรแกรม
สนับสนุนข้อโต้แย้งบรรทัดคำสั่ง หรือธงหรือสวิทช์
ซึ่งก็มีอิทธิพลต่อพฤติกรรมของมัน
โดยเฉพาะเสียงดังกราวสนับสนุนรีบ o ธงซึ่งจากนั้นจะใช้เวลาสองคำ
ในกรณีนี้ผมจะพล แต่พอสมควรเรียกว่าสวัสดี
แต่ผมสามารถเรียกมันว่าอะไร ฉันต้องการยกเว้น a.out ซึ่ง
จะค่อนข้างนอกเหนือจากจุด
>> แล้วเพียงแค่ระบุชื่อ ของไฟล์ที่ผมไม่ต้องการที่จะรวบรวม
ดังนั้นตอนนี้แม้ว่าที่จุดเริ่มต้น ของคำสั่งฉันยังคงมีเสียงดังกราว,
ในตอนท้ายของคำสั่ง ฉันยังคงมีชื่อไฟล์
ตอนนี้ผมมีบรรทัดคำสั่งเหล่านี้ ข้อโต้แย้งธงเหล่านี้ที่จะพูดว่า
โอ้โดยวิธีการที่การส่งออก-O ไฟล์ เรียกว่าสวัสดีไม่ a.out เริ่มต้น
>> ดังนั้นถ้าฉันกด Enter ตอนนี้ไม่มีอะไร ดูเหมือนจะเกิดขึ้น
และยังตอนนี้ฉันสามารถทำจุดเฉือนสวัสดี
ดังนั้นจึงเป็นโปรแกรมเดียวกัน
เลขศูนย์และคนที่มี เหมือนกันในตอนท้ายของวัน
>> แต่พวกเขากำลังอยู่ในสอง a.out files-- ที่แตกต่างกัน
ซึ่งเป็นรุ่นแรก และเพียงแค่ชื่อเขลา
และตอนนี้สวัสดีซึ่งเป็นมาก ชื่อน่าสนใจมากขึ้นสำหรับโปรแกรมที่
แต่ตรงไปตรงมาผมไม่เคย จะจำไว้ว่านี้อีกครั้ง
และอีกครั้งและอีกครั้ง
และในความเป็นจริงที่เราเขียน โปรแกรมที่ซับซ้อนมากขึ้น
คำสั่งที่คุณ จะต้องมีการเขียน
จะได้รับแม้กระทั่ง ยังคงความซับซ้อนมากขึ้น
>> จึงไม่ต้องกังวล
แต่กลับกลายเป็นว่ามนุษย์ก่อน เราได้ตระหนักว่าพวกเขามากเกินไป
มีปัญหาเดียวกันนี้แน่นอน
พวกเขาก็ไม่ได้สนุกกับต้อง พิมพ์นานพอสมควรคำสั่งลับ
นับประสาจำของพวกเขา
และเพื่อให้มนุษย์ก่อนที่เราได้ทำ โปรแกรมอื่น ๆ ที่ทำให้มันง่ายขึ้น
เพื่อรวบรวมซอฟต์แวร์ของคุณ
>> และแน่นอนหนึ่งเช่น โปรแกรมที่เรียกว่าทำให้
ดังนั้นฉันจะไปข้างหน้าและทำเช่นนี้
ฉันจะเลิกทำทุกอย่างที่ฉัน ก็ไม่ได้ในทางดังต่อไปนี้
ให้ฉันพิมพ์ LS
และคุณจะสังเกตเห็นสาม things-- a.out และดาวสวัสดี
และเป็นดาวและ hello.c
หวังว่านี้ควร จะใช้งานง่ายเพียงเล็กน้อย
ตราบเท่าที่ก่อนหน้านี้มี ไม่มีอะไรในพื้นที่นี้
ไม่มีอะไรที่ผมมีคือ สร้างจนกว่าเราจะเริ่มต้นระดับ
>> และฉันสร้าง hello.c
จากนั้นผมก็รวบรวมมันและเรียกมันว่า a.out
และจากนั้นผมรวบรวมอีกครั้งเล็กน้อย ที่แตกต่างกันและเรียกมันว่าสวัสดี
ดังนั้นผมจึงมีสามไฟล์ในไดเรกทอรีนี้ ในโฟลเดอร์ที่เรียกว่าพื้นที่ทำงานนี้
ตอนนี้ผมสามารถมองเห็นเช่นกันว่า ถ้าฉันซูมออกจริง
>> ถ้าฉันซูมออกที่นี่และ มองไปที่มือข้างขวาที่ด้านบน
มุมเป็นสัญญาทางด้านซ้าย ด้านซ้ายมือของหน้าจอ
มักจะแสดงให้คุณ สิ่งที่อยู่ในบัญชีของคุณคืออะไร
ภายในของ CS50 IDE
และมีสามไฟล์มี
>> ดังนั้นผมจึงต้องการที่จะกำจัดของ a.out และสวัสดี
และในขณะที่คุณอาจ นึกสังหรณ์ใจคุณ
สามารถเรียงลำดับของการควบคุมการคลิก หรือคลิกขวาบนนี้
และเมนูเล็ก ๆ นี้ปรากฏขึ้น
คุณสามารถดาวน์โหลดไฟล์เรียกใช้ มันดูตัวอย่างรีเฟรช, เปลี่ยนชื่อ
หรือสิ่งที่ไม่
>> และฉันก็สามารถลบ และมันก็จะหายไป
แต่ขอทำสิ่งที่มีคำสั่ง สายสำหรับตอนนี้เพื่อให้ได้รับความสะดวกสบาย
กับเรื่องนี้และทำต่อไปนี้
ฉันจะไปข้างหน้าและลบ a.out โดยการพิมพ์ตัวอักษร rma.out
มันจะเปิดออกคำสั่งสำหรับ การลบหรือลบบางสิ่งบางอย่าง
ไม่ได้ลบหรือลบ
>> มันขึ้นชัดถ้อยชัดคำ RM, เพียงเพื่อประหยัด คุณกดแป้นพิมพ์บางส่วนและกด Enter
ตอนนี้เรากำลังจะได้รับบ้าง ความลับเอา a.out แฟ้มปกติ
ผมไม่ทราบจริงๆสิ่งที่เป็น ไฟล์ที่ผิดปกติจะยัง
แต่ฉันไม่ต้องการที่จะเอามันออกไป
>> ดังนั้นฉันจะพิมพ์ Y สำหรับใช่
หรือฉันสามารถพิมพ์ออกมาและกด Enter
และอีกครั้งดูเหมือนจะไม่มีอะไรเกิดขึ้น
แต่นั่นคือโดยทั่วไปเป็นสิ่งที่ดี
>> ถ้าฉันพิมพ์ LS เวลานี้ สิ่งที่ฉันควรจะเห็น?
หวังเพียงแค่สวัสดีและ hello.c
ตอนนี้เช่นกันคุณจะ แจ้งให้ทราบล่วงหน้าแห่งนี้เครื่องหมายดอกจัน
ที่ในตอนท้ายของโปรแกรมของฉัน
และพวกเขายังแสดงในสีเขียว
นั่นเป็นเพียงวิธี CS50 IDE ของ ของ cluing คุณเข้าสู่ความเป็นจริง
ว่าที่ไม่ได้รหัสที่มา
นั่นคือปฏิบัติการเป็นที่ทำงาน โปรแกรมที่คุณสามารถทำงานได้จริง
โดยทำจุดเฉือนและจากนั้นชื่อของมัน
>> ตอนนี้ให้ฉันไปข้างหน้าและลบ นี้ RM สวัสดีป้อนลบปกติ
ยื่นสวัสดีใช่
และตอนนี้ถ้าผมพิมพ์ LS, เรากลับไป hello.c
พยายามที่จะไม่ลบ รหัสที่มาที่เกิดขึ้นจริง
ถึงแม้ว่าจะมีคุณสมบัติ ที่สร้างขึ้นใน CS50 IDE ที่
คุณสามารถไปถึงประวัติการแก้ไขของคุณ และย้อนกลับในเวลาที่ถ้าคุณตั้งใจ
ลบสิ่งที่ทำจะมีสติ ตามที่ระบบแจ้งเหล่านี้ใช่หรือไม่
สิ่งที่คุณต้องการจะทำจริง
และถ้าเราไปขึ้นไปด้านบน มุมซ้ายมือนี่
ทั้งหมดที่ยังคงเป็น hello.c
เพื่อให้มีที่อัดแน่นของ คำสั่งอื่น ๆ ที่คุณ
สามารถดำเนินการในโลกของลินุกซ์ ซึ่งหนึ่งในนั้นคืออีกครั้งให้
และเรากำลังจะทำให้ โปรแกรมของฉันตอนนี้ดังต่อไปนี้
>> แทนการทำเสียงดังกราว, แทนการทำเสียงดังกราว-O,
ฉันจะเพียงแค่ ตัวอักษรพิมพ์ให้สวัสดี
และตอนนี้สังเกตเห็นผม ไม่ได้ทำให้การพิมพ์ hello.c
ฉันพิมพ์ให้สวัสดี
>> และโปรแกรมนี้ทำให้ มาพร้อมกับ IDE CS50 และอื่น ๆ
โดยทั่วไปกับลินุกซ์ เป็นโปรแกรมที่เป็น
จะทำให้โปรแกรมที่เรียกว่าสวัสดี
และก็จะถือว่าโดยการประชุม ว่าถ้าโปรแกรมนี้สามารถทำ
มันจะทำจากแหล่งที่มา ไฟล์โค้ดสิ้นสุดในจุด C, hello.c
>> ดังนั้นถ้าฉันกด Enter ตอนนี้ขอให้สังเกตว่า คำสั่งที่ได้รับการดำเนินการ
เป็นจริงได้อีกต่อไป ก่อนที่จะขึ้นกว่า แต่ก่อน
และนั่นเป็นเพราะเราได้ ที่กำหนดไว้ล่วงหน้า CS50 IDE ที่จะมี
คุณสมบัติเพิ่มเติมบางอย่างในตัวว่า เราไม่จำเป็นต้องเพียง แต่เร็ว ๆ นี้จะ
แต่สิ่งที่สำคัญที่จะตระหนักถึง คือตอนนี้ผมมีโปรแกรมสวัสดี
>> ถ้าฉันพิมพ์ LS อีกครั้งฉัน มีโปรแกรมทักทาย
และฉันสามารถเรียกใช้มันด้วย จุดเฉือน a.out ไม่มี
เพราะจุดทั้งนี้ การออกกำลังกายเป็นจุดเฉือนสวัสดี
และตอนนี้ฉันมีโปรแกรม Hello World ของฉัน
ดังนั้นก้าวไปข้างหน้า เราเกือบเสมอเพียง
จะรวบรวมโปรแกรมของเรา โดยใช้คำสั่งทำให้เป็น
และจากนั้นเราจะเรียกพวกเขาโดย จุดเฉือนและชื่อของโปรแกรม
แต่ตระหนักถึงสิ่งที่ทำคือทำ คุณคือมันไม่ได้เป็นตัวคอมไพเลอร์
มันเป็นเพียงโปรแกรมอำนวยความสะดวก ที่รู้วิธีที่จะเรียกคอมไพเลอร์
ที่จะทำงานเพื่อที่คุณเองสามารถใช้งานได้
>> สิ่งที่คำสั่งอื่น ๆ ที่มีอยู่ใน ลินุกซ์และในการเปิด CS50 IDE?
อีกไม่นานเราจะเห็นว่ามี คำสั่งซีดี, เปลี่ยนไดเรกทอรี
นี้ช่วยให้คุณภายใน อินเตอร์เฟซบรรทัดคำสั่งของคุณ
ก้าวไปข้างหน้าและด้านหลัง และเปิดโฟลเดอร์ที่แตกต่างกัน
โดยไม่ต้องใช้เมาส์ของคุณ
>> LS เราเห็นซึ่งย่อมาจากรายการ ไฟล์ในไดเรกทอรีปัจจุบัน
ทำให้ผบ. คุณสามารถ อาจจะเริ่มต้นที่จะสรุป
สิ่งเหล่านี้หมายถึง now-- ทำให้ไดเรกทอรี ถ้าคุณต้องการสร้างโฟลเดอร์
RM สำหรับลบ, RM Dir สำหรับ ลบ directory-- และเหล่านี้
อีกครั้งเป็นบรรทัดคำสั่ง เทียบเท่าของสิ่งที่คุณ
สามารถทำใน CS50 IDE ด้วยเมาส์ของคุณ
แต่เร็ว ๆ นี้จะได้พบกับ ว่าบางครั้งมันก็เป็นเพียง
เร็วมากที่จะทำ สิ่งที่มีแป้นพิมพ์
และท้ายที่สุดเป็นจำนวนมากมีประสิทธิภาพมากขึ้น
>> แต่มันก็ยากที่จะยืนยันว่า สิ่งที่เราได้รับการทำเพื่อให้ห่างไกล
เป็นสิ่งที่มีประสิทธิภาพเมื่อทุก เราได้รับการบอกว่ามีที่ Hello World
และในความเป็นจริงผม hardcoded คำ Hello World ลงในโปรแกรมของฉัน
ไม่มีชีวิตชีวายัง
รอยขีดข่วนเป็นลำดับความสำคัญ สัปดาห์ที่ผ่านมาน่าสนใจมากขึ้น
>> และเพื่อให้ได้รับมี
ลองมาขั้นตอนต่อว่าโดย วิธีการบางส่วนของฟังก์ชั่นเหล่านี้
ดังนั้นไม่เพียง แต่ C มาพร้อมกับพริทฟ์ และอัดแน่นของฟังก์ชั่นอื่น ๆ
บางอย่างที่เราจะเห็น เมื่อเวลาผ่านไปก็ไม่ได้
ทำให้มันง่ายที่ออกทางด้านขวา ประตูในการได้รับการป้อนข้อมูลของผู้ใช้
>> ในความเป็นจริงหนึ่งในจุดอ่อน ของภาษาเช่น C,
และแม้กระทั่ง Java และยัง คนอื่น ๆ ก็คือว่ามันไม่ได้
ทำให้ง่ายต่อการเพียงแค่ได้รับสิ่งที่ต้องการ จำนวนเต็มจากผู้ใช้หรือสตริงคำ
และวลีปล่อยให้สิ่งที่อยู่คนเดียวเช่น ค่าจุดหรือตัวเลขจริงลอย
ที่มีจุดทศนิยมและจริงๆ หมายเลขนานที่สุดเท่าที่เราจะเห็นทันที
ดังนั้นรายชื่อของฟังก์ชั่นนี้ได้ที่นี่เหล่านี้ เป็นเหมือนชิ้นส่วนปริศนา Scratch อื่น ๆ
ที่เราได้ติดตั้งใน CS50 IDE ที่เราจะใช้เพียงไม่กี่สัปดาห์
เป็นล้อการฝึกอบรมของแปลกและ ในที่สุดก็จะนำพวกเขาออกและมอง
ใต้ฝากระโปรงบางทีที่ ว่าสิ่งเหล่านี้จะถูกนำมาใช้
>> แต่การที่จะทำเช่นนี้ขอ จริงเขียนโปรแกรม
ผมขอไปข้างหน้าในขณะนี้
และฉันจะสร้างใหม่ โดยการคลิกที่ไฟล์นี้บวกเล็กน้อย
และคลิกแฟ้มใหม่
>> ฉันจะบันทึกต่อไปนี้ อย่างใดอย่างหนึ่งเช่นสมมติว่า string.c,
เพราะผมต้องการที่จะเล่นกับสตริง
และสตริงใน C เป็นเพียง ลำดับของตัวอักษร
ดังนั้นตอนนี้เราไปข้างหน้า และทำต่อไปนี้
>> รวมถึงมาตรฐานและ IO.h-- มันจะเปิดออกมาตรฐานการ IO
IO ก็หมายความเข้าและส่งออก
ดังนั้นมันกลับกลายเป็นว่า บรรทัดนี้นี่คือสิ่งที่
เป็นเพื่อนบ้านเราใช้ printf
printf ของหลักสูตรผลิตออก
ดังนั้นเพื่อที่จะใช้ printf ก็จะเปิด ออกคุณต้องมีบรรทัดของรหัสนี้
ที่ด้านบนของไฟล์ของคุณ
>> และเราจะกลับมากับสิ่งที่ ที่จริงหมายความว่าอีกไม่นาน
ปรากฎว่าใน โปรแกรม C ใด ๆ ที่ฉันเขียน
ฉันจะเริ่มต้นด้วย รหัสที่มีลักษณะเช่นนี้
และคุณจะสังเกตเห็น CS50 IDE และ พัฒนาแบบบูรณาอื่น ๆ
สภาพแวดล้อมเช่นนั้น จะพยายามอย่างดีที่สุด
พวกเขาสามารถที่จะจบความคิดของคุณ
ในความเป็นจริงสักครู่ที่ผ่านมาถ้าผมเลิกทำ สิ่งที่ฉันก็ไม่ได้ผมกด Enter
>> จากนั้นผมก็ตีเปิดหยิก รั้งกด Enter อีกครั้ง
และจะเสร็จสิ้นการคิดของผม
มันทำให้ผมเส้นใหม่เยื้องไม่น้อย ด้วยเหตุผลโวหารดีเราจะเห็น
และแล้วมันจะให้ฉัน ที่วงเล็บปีกกาที่จะจบความคิดของฉัน
ตอนนี้ก็ไม่เคย คาดเดาสิ่งที่คุณต้องการจะทำ
แต่ส่วนใหญ่ก็ไม่ได้ ช่วยให้คุณประหยัดการกดแป้นพิมพ์บาง
ดังนั้นช่วงเวลาที่ผ่านมาเราวิ่ง program-- นี้ สวัสดีโลกและเรียบเรียงแล้วมัน
และจากนั้นก็วิ่งมัน
แต่ไม่มีชีวิตชีวาที่นี่
เกิดอะไรขึ้นถ้าเราต้องการที่จะ ทำสิ่งที่แตกต่างกันอย่างไร
ดีสิ่งที่ถ้าฉันต้องการจริง ได้รับสตริงจากผู้ใช้หรือไม่?
ฉันจะใช้ชิ้นส่วนจิ๊กซอว์ เรียกว่าในปัจจุบันผู้ได้รับสตริง
>> ปรากฎใน C ที่ว่าเมื่อคุณไม่ต้องการ เพื่อให้เข้ากับชิ้นส่วนจิ๊กซอว์
หรือมากกว่าฟังก์ชั่นอย่างถูกต้องเพื่อคุณ แท้จริงเพียงแค่ทำเปิดวงเล็บ
ใกล้วงเล็บ
ดังนั้นจึงเป็นประหนึ่งว่ามี ไม่มีกล่องสีขาวที่จะพิมพ์ลงใน
กล่าวว่าก่อนที่จะบล็อก มีกล่องสีขาวเล็ก ๆ น้อย ๆ
เราไม่ได้ว่ากล่องสีขาวตอนนี้
>> แต่เมื่อผมเรียกสตริงผม ต้องการที่จะนำผลที่ได้จากที่ไหนสักแห่ง
ดังนั้นกระบวนทัศน์ที่พบบ่อยมากใน C คือการ เรียกฟังก์ชันเช่นสตริงได้รับที่นี่
แล้วเก็บค่าตอบแทนของ
มันเป็นผลมาจากมัน ความพยายามในการบางสิ่งบางอย่าง
>> และสิ่งที่เป็น สร้างในการเขียนโปรแกรม
ไม่ว่าจะเป็นรอยขีดข่วนหรือตอนนี้ซีว่าเรา สามารถใช้ในการจัดเก็บจริงอะไร?
เรียกมันว่าตัวแปรใช่มั้ย?
และรอยขีดข่วนที่เราทำไม่ได้จริงๆ สนใจสิ่งที่เกิดขึ้นในตัวแปร
>> แต่ในกรณีนี้เราทำจริง
ฉันจะบอกว่าสตริง
แล้วฉันจะเรียก สิ่งที่ฉันต้องการ
ฉันจะเรียกมันว่า ชื่อที่ได้รับได้รับสตริง
>> และตอนนี้แม้ว่าคุณ ใหม่เล็ก ๆ น้อย ๆ นี้
แจ้งให้ทราบว่าผมขาดรายละเอียดบาง
ฉันลืม semi-colon
ฉันต้องการที่จะจบความคิดนี้
ดังนั้นฉันจะเลื่อนเคอร์เซอร์ของฉัน และกดกึ่งลำไส้ใหญ่มี
และสิ่งที่ฉันได้เพียงแค่ทำ?
ในสายของรหัสนี้ หมายเลข 5 ในขณะนี้
ฉันโทรสตริงไม่มีปัจจัยการผลิต
จึงไม่มีสีขาวเล็ก ๆ น้อย ๆ กล่องเช่นบันทึกบล็อกมี
>> ฉันแค่บอกเดี๋ยวก่อน คอมพิวเตอร์ได้รับฉันสตริง
เครื่องหมายเท่ากับไม่ได้จริงๆ เครื่องหมายเท่ากับต่อ se
มันเป็นเรื่องที่ได้รับมอบหมาย ผู้ประกอบการซึ่งหมายถึง
Hey, คอมพิวเตอร์, ย้ายค่า จากขวาไปซ้าย
และซ้ายที่ฉันมีดังต่อไปนี้
>> Hey, คอมพิวเตอร์, ให้ฉัน string-- ลำดับของตัวอักษร
และเรียกว่าสตริงชื่อ
และผมก็ไม่ได้มีการเรียกชื่อ
>> ฉันจะเรียกว่าอัตภาพ บางอย่างเช่น S,
เหมือนเราใช้ i เพื่อ เรียกฉันตัวแปร
แต่ตอนนี้ผมต้องทำอะไรกับมัน
มันจะสวยโง่ พยายามรวบรวมรหัสนี้ทำงาน
โปรแกรมนี้แม้ว่า ฉันได้รับสตริง
เพราะมันยังคงเป็นเพียง จะบอกว่า Hello World
>> แต่สิ่งที่ถ้าฉันไม่ต้องการที่จะเปลี่ยนแปลงนี้
ทำไมถึงไม่ทำเช่นนี้?
ร้อยละ S, s จุลภาค
และนี่คือความลับเล็ก ๆ น้อย ๆ ยังคง
>> ดังนั้นให้ฉันให้ฉันตัวแปรชัดเจนมากขึ้น
ผมขอชื่อนี้ชื่อตัวแปร
และขอให้ดูว่าเราไม่สามารถหยอกล้อ นอกเหนือสิ่งที่เกิดขึ้นที่นี่
>> ดังนั้นในบรรทัดห้าฉันได้รับสตริง
และฉันเก็บสตริงที่ สิ่งที่ผู้ใช้มีการพิมพ์ใน
ที่แป้นพิมพ์ของเขาหรือเธอ ในตัวแปรเรียกชื่อ
และปรากฎว่า printf ไม่เพียง แต่
ใช้เวลาหนึ่งในการโต้แย้งคู่ คำพูดหนึ่งในการป้อนข้อมูลคำพูดคู่
>> มันสามารถใช้เวลาสองหรือสามหรือมากกว่าเช่น ว่าที่สองหรือที่สามหรือสี่
มีชื่อทั้งหมดของตัวแปร หรือเฉพาะค่า
ที่คุณต้องการที่จะเสียบเข้า แบบไดนามิกที่สตริงในเครื่องหมายคำพูด
ในคำอื่น ๆ สิ่งที่ จะมีความผิดกับเรื่องนี้?
ถ้าฉันเพียงแค่กล่าวว่าสวัสดีชื่อทับขวา N, บันทึกไฟล์ของฉันรวบรวมรหัสของฉัน
และวิ่งไปนี้สิ่งที่จะเกิดขึ้น?
>> มันเป็นเพียงแค่จะบอกว่าสวัสดี ชื่ออักษร N-A-M-E
ซึ่งเป็นชนิดของโง่เพราะ ก็ไม่แตกต่างจากโลก
ดังนั้นอะไรในคำพูดเป็น สิ่งที่ได้รับการพิมพ์ตัวอักษร
ดังนั้นถ้าฉันต้องการที่จะมี ตัวยึดที่นั่น
ที่จริงผมจำเป็นต้องใช้ บางไวยากรณ์พิเศษ
และปรากฎถ้าคุณอ่าน เอกสารสำหรับฟังก์ชั่น printf ที่
มันจะบอกคุณว่า ถ้าคุณใช้ร้อยละ S,
คุณสามารถใช้แทนค่าดังต่อไปนี้
>> หลังจากจุลภาคหลังจากที่ ราคาคู่คุณก็
เขียนชื่อของ ตัวแปรที่คุณต้องการ
ในการเชื่อมต่อเป็นรูปแบบที่ รหัสหรือรูปแบบระบุ,
ร้อยละ s สำหรับสตริง
และตอนนี้ถ้าเราได้บันทึกไฟล์ของฉัน ผมจะกลับไปลงไปยังสถานีของฉัน
และฉันพิมพ์สตริง, เพราะอีกชื่อนี้
แฟ้มที่ผมเลือกก่อนที่จะเป็น string.c
>> ดังนั้นฉันจะพูดสตริงป้อน
โอ้ความดีให้ดูที่ทั้งหมดของ ผิดพลาดที่เราได้ทำแล้ว
และนี่ is-- สิ่งนี้เป็นจริง เหมือนหกโปรแกรมบรรทัดเจ็ด?
ดังนั้นนี่เป็นที่ที่มันสามารถมาก ได้อย่างรวดเร็วอย่างท่วมท้น
>> หน้าต่าง terminal นี้มี ขณะนี้เป็นเพียงซาก
เป็นจำนวนมากของข้อความผิดพลาด
แน่นอนผมไม่ได้มีข้อผิดพลาดมากขึ้น ข้อความกว่าที่ฉันมีสายรหัส
ดังนั้นสิ่งที่เกิดขึ้น?
>> ดีกลยุทธ์ที่ดีที่สุด ที่จะทำทุกเวลาที่คุณ
ไม่พบการครอบงำ รายการข้อผิดพลาดเช่นนั้น
จะเลื่อนกลับมองหาคำสั่ง คุณเพียงแค่ขับรถซึ่งในกรณีของฉัน
จะทำให้สตริง
มองไปที่สิ่งที่ทำให้เขาและที่ว่า คำสั่งเสียงดังกราวยาวไม่มีเรื่องใหญ่มี
>> แต่สีแดงจะไม่ดี
สีเขียวจะพยายามที่จะเป็น อ่อนโยนและเป็นประโยชน์
แต่ก็ยังคงไม่ดีในกรณีนี้
แต่ที่มันไม่ดี?
>> String.c สายห้าห้าตัวอักษร
ดังนั้นนี้เป็นเพียงการประชุมร่วมกัน
บางสิ่งบางอย่างบางสิ่งบางอย่างลำไส้ใหญ่หมายความว่า หมายเลขบรรทัดและจำนวนตัวอักษร
ข้อผิดพลาดที่ไม่ได้ประกาศใช้ สตริงระบุ
คุณหมายถึงมาตรฐานมีอะไรบ้าง?
>> ดังนั้นน่าเสียดายที่เสียงดังกราว พยายามที่จะเป็นประโยชน์
แต่มันเป็นเรื่องที่ไม่ถูกต้องในกรณีนี้
ไม่มีเสียงดังกราวผมไม่ได้หมายความว่ามาตรฐาน IO
ฉันหมายความว่าในบรรทัดเดียวใช่
>> แต่บรรทัดห้าเป็นหนึ่งในที่นี่
และเสียงดังกราวไม่ เข้าใจ S-T-R-I-N-G
มันเป็นตัวระบุที่ไม่ได้ประกาศเป็น คำมันก็ไม่เคยเห็นมาก่อน
และนั่นเป็นเพราะ C, ภาษา เรากำลังเขียนโค้ดในตอนนี้
ไม่ได้เรียกว่าตัวแปรสตริง
>> มันไม่ได้โดยเริ่มต้นการสนับสนุน สิ่งที่เรียกว่าสตริง
นั่นเป็นชิ้นส่วนของ CS50 ศัพท์แสง แต่เดิมมาก
แต่ฉันสามารถแก้ไขปัญหานี้ดังต่อไปนี้
>> ถ้าผมเพิ่มหนึ่งบรรทัดของรหัส ไปด้านบนของโปรแกรมนี้
รวม CS50.h ซึ่งเป็นไฟล์อื่น ที่ไหนสักแห่งภายในของ CS50 IDE ที่ไหนสักแห่ง
บนฮาร์ดไดรฟ์เพื่อที่จะพูด ของระบบปฏิบัติการอูบุนตู
ที่ผมทำงานที่ คือแฟ้มที่
จะสอนปฏิบัติการ ระบบสิ่งสตริงเป็นเพียงแค่
เช่น io.h มาตรฐานคือไฟล์ ในระบบปฏิบัติการที่
จะสอนว่าสิ่งที่เป็น printf
>> แท้จริงเราจะได้รับ ข้อความที่คล้ายกันมาก
ถ้า IO ได้เข้ารับการรักษามาตรฐาน IO.h และพยายามที่จะใช้ printf
ดังนั้นฉันจะไปข้างหน้าและเพียงแค่ ใช้การควบคุม L เพื่อล้างหน้าจอของฉัน
หรือคุณสามารถพิมพ์ชัดเจนและมันจะ เพียงแค่ล้างหน้าต่าง terminal
แต่คุณก็ยังสามารถเลื่อนกลับในเวลา
>> และฉันจะเรียกสตริง
ข้ามมือของฉันเวลานี้ใส่
โอ้พระเจ้าของฉันมันทำงาน
มันแสดงให้เห็นฉันคำสั่งลับยาว นั่นคือสิ่งที่ทำให้สร้างผ่านเสียงดังกราว,
แต่ไม่มีข้อผิดพลาด
ดังนั้นตระหนักถึงแม้ว่า คุณอาจได้รับสมบูรณ์
จมกับ จำนวนข้อความผิดพลาด
มันก็อาจจะน่ารำคาญนี้ซ้อน ผลกระทบที่เสียงดังกราวไม่เข้าใจ
สิ่งหนึ่งซึ่งหมายความว่ามันแล้ว ไม่เข้าใจคำถัดไป
หรือบรรทัดถัดไป
และดังนั้นจึงเพียงฉายาในรหัสของคุณ
แต่การแก้ไขอาจจะง่าย
และอื่น ๆ มักจะมุ่งเน้นไปที่ บรรทัดแรกของการส่งออกมาก
และถ้าคุณทำไม่ได้ เข้าใจว่ามันเพียงแค่มอง
สำหรับคำหลักที่อาจจะมี เบาะแสและหมายเลขบรรทัด
และตัวอักษรที่ ความผิดพลาดที่อาจจะ
>> ตอนนี้ให้ฉันไปข้างหน้าและพิมพ์ จุดเฉือนสตริงป้อน
อืมก็ไม่ได้พูดอะไรสวัสดี
ทำไม?
ดีจำได้ว่ามันเป็นที่ที่ทำงานอยู่หรือไม่
>> มันอาจจะติดอยู่ในขณะนี้ ในวง, ถ้าคุณจะอยู่บนเส้นหก
เพราะได้รับ String โดยการออกแบบ เขียนโดยพนักงาน CS50,
มีความหมายที่แท้จริงเพียงแค่นั่ง มีรอและรอ
และรอให้สตริง
ทั้งหมดที่เราหมายถึงโดยสตริงคือการใส่มนุษย์
เพื่อให้คุณรู้อะไรไหม
ผมขอไปข้างหน้า
และเพียงแค่ในราชประสงค์ให้ฉัน พิมพ์ชื่อของฉันเดวิดป้อน
ตอนนี้ผมมีโปรแกรมแบบไดนามิกมากขึ้น
มันบอกว่าสวัสดีเดวิด
>> ถ้าฉันไปข้างหน้าและทำงานนี้อีกครั้ง ให้ฉันลองพูดชื่อ Zamila ป้อน
และตอนนี้เรามีโปรแกรมแบบไดนามิก
ฉันยังไม่ได้เขียนยากโลก
ฉันยังไม่ได้เขียนยาก ชื่อหรือเดวิดหรือ Zamila
>> ตอนนี้ก็มากขึ้นเช่นโปรแกรม เรารู้ว่าถ้ามันที่ใช้การป้อนข้อมูล
มันผลิตออกแตกต่างกันเล็กน้อย
ตอนนี้จะไม่ดีที่สุด ประสบการณ์การใช้งานหรือ UX
ฉันเรียกใช้โปรแกรม
>> ผมไม่ทราบว่าสิ่งที่ฉันควร ที่จะทำจริงเว้นแต่ฉันมองไปที่
หรือจำรหัสที่มา
ดังนั้นขอให้ผู้ใช้ ประสบการณ์ที่ดีขึ้นเล็กน้อย
กับสิ่งที่ง่ายที่สุดของ
ผมขอกลับไปเป็นแบบนี้ โปรแกรมและเพียงแค่พูด printf
>> และแจ้งให้เราไปข้างหน้าและพูดชื่อของลำไส้ใหญ่ และพื้นที่แล้วเซมิโคลอน
และเพียงเพื่อลูกไม่มีฟันเฟือง n
และนั่นคือเจตนา เพราะฉันไม่ต้องการ
พรอมต์ที่จะย้ายไปบรรทัดถัดไป
>> ฉันต้องการที่จะแทนการทำเช่นนี้ทำให้สตริง คอมไพล์รหัสของฉันลงในเครื่องใหม่
รหัส dot เฉือนสตริง
Ah นี้เป็นสวยมาก
ตอนนี้ที่จริงผมรู้ว่าสิ่งที่คอมพิวเตอร์ อยากให้ผมทำให้มันชื่อ
>> ดังนั้นฉันจะไปข้างหน้าและพิมพ์ ในร็อบป้อนและสวัสดีร็อบ
ดังนั้นตระหนักถึงนี้ยังคงเป็นที่สิ้นสุด ในวันนี้เพียงโปรแกรมเก้าเส้น
แต่เราได้ดำเนินการขั้นตอนทารกเหล่านี้
>> เราเขียนบรรทัดเดียวกับที่เรา เป็นที่คุ้นเคย printf, Hello World
จากนั้นเราก็ undid เล็กน้อยว่า
และเราใช้จริงสตริง
และเราโยนค่านั้นในตัวแปร
และจากนั้นเราเดินไปข้างหน้าและการปรับปรุง มันต่อกับสายที่สาม
และนี้กระบวนการซ้ำของ การเขียนซอฟแวร์เป็นกุญแจสำคัญอย่างแท้จริง
ใน CS50 และในชีวิตโดยทั่วไป คุณควรทั่วไปไม่นั่งลง
มีโปรแกรมในใจและลองเขียน สิ่งแช่งทั้งทั้งหมดในครั้งเดียว
>> มันจะย่อมส่งผลในทาง ข้อผิดพลาดมากกว่าที่เราเห็นตัวเองที่นี่
แม้ฉันไปในวันนี้อย่างต่อเนื่อง ทำผิดพลาดโง่อื่น ๆ
มีความผิดพลาดจริงยาก ที่มีความยากที่จะคิดออก
แต่คุณจะทำผิดพลาดมากขึ้นมากขึ้น บรรทัดของรหัสที่คุณเขียนทั้งหมดในครั้งเดียว
และเพื่อให้การปฏิบัตินี้ เขียนเล็กน้อยของรหัส
ที่คุณสะดวกสบายกับการรวบรวม มันเรียกใช้ทดสอบมากกว่าปกติ
แล้วย้าย on-- เพื่อให้เหมือนกับที่เราเก็บไว้ layering และ layering สัปดาห์ที่ผ่านมา
สร้างจากบางสิ่งบางอย่างมาก ง่ายต่อการบางสิ่งบางอย่างที่ซับซ้อนมากขึ้น
ทำเช่นเดียวกันที่นี่
อย่านั่งลงและพยายามที่จะ เขียนปัญหาทั้งหมด
จริงใช้ขั้นตอนทารกเหล่านี้
>> ตอนนี้สายจะไม่ทั้งหมด ที่เป็นประโยชน์แก่ตนเอง
เราต้องการจริงนึกคิดเหมือน มีอย่างอื่นในชุดเครื่องมือของเรา
ดังนั้นขอจริงทำตรงนั้น
>> ผมขอไปข้างหน้าในขณะนี้และชักขึ้น โปรแกรมที่แตกต่างกันเล็กน้อย
และเราจะเรียก int.c นี้สำหรับจำนวนเต็ม
ฉันกำลังจะไปเหมือนกัน รวม CS550.h
ฉันจะรวมถึงมาตรฐาน IO
และที่เป็นไปได้รักกัน ในอีกไม่กี่วันแรกเหล่านี้ของชั้นเรียน
>> และฉันจะพร้อม ตัวเองด้วยฟังก์ชั่นหลัก
และตอนนี้แทนการรับสตริง ให้เป็นไปข้างหน้าและได้รับ int
ขอเรียกว่า i และเรียกมันว่าจะได้รับ int ใกล้ parens กึ่งลำไส้ใหญ่
และตอนนี้ขอทำ บางสิ่งบางอย่างกับมัน printf
>> สมมติว่าสิ่งที่ต้องการ สวัสดีทับขวา N, จุลภาคฉัน
ดังนั้นผมสวยมากลอกเลียนแบบ สิ่งที่ฉันได้เพียงแค่ช่วงเวลาที่ผ่านมา
ฉันมีตัวยึดที่นี่
ฉันได้จุลภาคฉันที่นี่เพราะผมต้องการ ฉันจะเสียบเข้าไปในตัวยึดที่
>> ดังนั้นขอไปข้างหน้าและลอง รวบรวมโปรแกรมนี้
ไฟล์จะถูกเรียกว่า int.c.
ดังนั้นฉันจะพูดให้ int ป้อน
โอ้พระเจ้าของฉัน แต่ไม่มีเรื่องใหญ่ใช่ไหม?
มีความผิดพลาดคือ
>> มีความผิดพลาดเป็นประโยค ที่นี่เช่นว่าโปรแกรมไม่สามารถ
จะรวบรวมภายใน int.c สาย เจ็ดตัวอักษร 27 รูปแบบข้อผิดพลาด
ระบุชนิดถ่าน ดาว, สิ่งที่เป็น
แต่ประเภทอาร์กิวเมนต์เป็น int
>> ดังนั้นที่นี่ก็เช่นกันเราจะไม่ to-- แม้ว่าในวันนี้เป็นจำนวนมากของวัสดุ
เรากำลังจะครอบงำคุณด้วย อย่างคุณลักษณะของ C ทุก
และการเขียนโปรแกรมมากขึ้นโดยทั่วไป ในเวลาเพียงไม่กี่สัปดาห์แรกเหล่านี้
ดังนั้นจึงมีมักจะเป็นศัพท์แสง ที่คุณไม่คุ้นเคย
และในความเป็นจริงถ่านดาวเป็นสิ่งที่ เรากำลังจะกลับมา
ในช่วงเวลาหนึ่งหรือสองสัปดาห์ของ
>> แต่ตอนนี้ขอดูว่าเราสามารถทำได้ แยกคำที่มีความคุ้นเคย
Formats-- ดังนั้นเราจึงได้ยินเสียงรูปแบบ ระบุรหัสรูปแบบก่อน
นั่นเป็นที่คุ้นเคย
Type-- แต่อาร์กิวเมนต์มีชนิด int
รอสักครู่ผมเป็น int
>> บางทีร้อยละจริง มีความหมายบางอย่างที่กำหนดไว้
และแน่นอนมันไม่
จำนวนเต็มถ้าคุณต้องการ printf เพื่อทดแทนมัน
คุณจริงต้องใช้ ระบุรูปแบบที่แตกต่างกัน
และคุณจะไม่ทราบเรื่องนี้ ยกเว้นในกรณีที่มีคนบอกคุณ
ท่านได้ทำไว้ก่อน
แต่ร้อยละคือสิ่งที่ฉัน สามารถนำมาใช้กันทั่วไป
ใน printf สำหรับเสียบจำนวนเต็ม
นอกจากนี้คุณยังสามารถใช้ร้อยละ D สำหรับจำนวนเต็มทศนิยม
แต่ฉันเป็นสิ่งที่ดีและง่ายที่นี่
ดังนั้นเราจะไปกับที่
>> ตอนนี้ให้ฉันไปข้างหน้าและ วิ่งให้ int ใส่
ที่ดีไม่มีข้อผิดพลาด
Dot เฉือนตกลง int-- ประสบการณ์การใช้งานที่ไม่ดี เพราะผมยังไม่ได้บอกกับตัวเอง
สิ่งที่ต้องทำ
แต่ที่ดี
ฉันจับได้อย่างรวดเร็ว
>> และตอนนี้ให้ฉันไปข้างหน้าและ พิมพ์ในเดวิด, OK, Zamila ร็อบ
ตกลงดังนั้นนี้เป็นสิ่งที่ดี
เวลานี้ผมใช้ฟังก์ชั่น ชิ้นส่วนจิ๊กซอว์ที่เรียกว่าได้รับ int
และมันจะเปิด out-- และเราจะ ได้เห็นต่อไปนี้ใน term--
พนักงาน CS50 ได้ดำเนินการ ได้รับสตริงในลักษณะดังกล่าว
ว่ามันจะมีเพียงร่างกาย ได้รับสตริงสำหรับคุณ
>> จะได้ดำเนินการรับ int ใน ลักษณะที่ว่าก็จะ
ได้รับจำนวนเต็มสำหรับคุณ
และถ้าคุณมนุษย์ ไม่ให้ความร่วมมือก็
แท้จริงแค่ไป บอกว่าลองใหม่ลองใหม่ลองใหม่
แท้จริงนั่งอยู่ที่นั่นวนลูปจนกว่า คุณต้องมีภาระหน้าที่ที่มีจำนวนบางขลัง,
เช่น 50, 50 และสวัสดี
>> หรือถ้าเราทำงานนี้อีกครั้ง และพิมพ์ 42, 42 สวัสดี
และเพื่อให้ได้รับฟังก์ชั่น int ภายในของชิ้นส่วนปริศนาที่
ตรรกะพอคิดพอ ที่จะคิดออกว่าอะไรคือคำ?
และสิ่งที่เป็นจำนวน?
เพียงยอมรับในที่สุดตัวเลข
>> ดังนั้นจึงปรากฎว่านี้ ไม่ได้ทั้งหมดที่แสดงออก
ป่านฉะนี้
ดังนั้นยายครั้งสุดท้ายที่เรา ไปสวยได้อย่างรวดเร็ว
เข้าสู่เกมการดำเนินการและภาพเคลื่อนไหว และผลงานศิลปะในรอยขีดข่วน
และที่นี่เราจะเป็นเนื้อหา กับโลกสวัสดีและทักทาย 50
>> มันไม่ได้เป็นสิ่งที่สร้างแรงบันดาลใจ
และแน่นอนไม่กี่เหล่านี้ก่อน ตัวอย่างจะใช้เวลา
ทางลาดขึ้นในความตื่นเต้น
แต่เราก็มีมากขึ้น ควบคุมตอนนี้ในความเป็นจริง
และเรากำลังจะไปมาก ได้อย่างรวดเร็วเริ่มต้น layering
ด้านบนของวิทยาการพื้นฐานเหล่านี้
>> แต่ก่อนอื่นเรามาทำความเข้าใจ สิ่งที่เป็นข้อ จำกัด
ในความเป็นจริงหนึ่งในสิ่งที่ รอยขีดข่วนไม่ได้อย่างง่ายดาย
ให้เราทำคือจริงๆมอง ใต้ฝากระโปรง
และทำความเข้าใจกับสิ่งที่ คอมพิวเตอร์เป็นสิ่งที่มันสามารถทำ
และสิ่งที่เป็นข้อ จำกัด ของมัน
และแน่นอนที่ขาด ความเข้าใจที่อาจเกิดขึ้นในระยะยาว
สามารถนำไปสู่​​การเขียน mistakes-- ของเราเอง ข้อบกพร่องการเขียนซอฟแวร์ที่ไม่ปลอดภัย
ได้รับการแฮ็กในบางวิธี
>> ดังนั้นลองมาขั้นตอนบางอย่างที่มีต่อ ความเข้าใจนี้ดีขึ้นเล็กน้อยโดย
วิธีการพูด, ตัวอย่างต่อไปนี้
ฉันจะไปข้างหน้าและการดำเนินการ จริงอย่างรวดเร็วโปรแกรมที่เรียกว่า Adder
เช่นขอเพิ่มตัวเลขร่วมกัน
และฉันจะให้รหัสบางมุม ที่นี่และเพียงแค่คัดลอกและวาง
ที่ผมมาก่อนเพียง เพื่อให้เราสามารถได้รับไปไม่ช้าก็เร็ว
ดังนั้นตอนนี้ฉันได้มีจุดเริ่มต้นพื้นฐาน ของโปรแกรมที่เรียกว่า Adder
>> และให้ไปข้างหน้าและทำเช่นนี้
ฉันจะไปข้างหน้าและ พูด INTX ได้รับได้รับ int
และคุณรู้อะไรไหม
ขอให้ประสบการณ์การใช้งานที่ดีขึ้น
>> ดังนั้นขอเพียงบอกว่าเป็น X และมีประสิทธิภาพ แจ้งให้ผู้ใช้ที่จะให้เรา X
แล้วปล่อยให้ฉันไปข้างหน้าและพูดว่า printf วิธีการเกี่ยวกับ Y คือครั้งนี้คาดหวังว่า
สองค่าจากผู้ใช้
แล้วให้เพียงไปข้างหน้าและ พูด printf ผลรวมของ x และ y คือ
และตอนนี้ฉันไม่ต้องการที่จะทำร้อยละ s
ฉันต้องการจะทำผมร้อยละทับขวา n แล้​​วเสียบในมูลค่ารวม
>> ดังนั้นฉันจะไปเกี่ยวกับการทำเช่นนี้?
คุณรู้ไหมว่า?
ฉันรู้วิธีการใช้ตัวแปร
ผมขอประกาศใหม่ int Z
>> และฉันจะใช้การคาดเดาที่นี่
หากมีสัญญาณที่เท่าเทียมกันในเรื่องนี้ ภาษาบางทีฉันก็สามารถทำ x บวก Y,
ตราบใดที่ฉันท้ายของฉัน คิดกับลำไส้ใหญ่กึ่ง?
ตอนนี้ผมสามารถกลับไปลงที่นี่เสียบ Z, จบความคิดนี้กับลำไส้ใหญ่กึ่ง
และเรามาดูตอนนี้ถ้าเหล่านี้ ลำดับของ lines-- X คือการได้รับ int
Y คือการได้รับ int
>> เพิ่ม x และ y เก็บค่าใน z-- ดังนั้นอีกครั้งจำเครื่องหมายเท่ากับ
ไม่เท่ากับ
มันเป็นเรื่องที่ได้รับมอบหมายจากขวาไปซ้าย
และให้พิมพ์ออกมาว่าผลรวม ของ x และ y ไม่ได้เป็นตัวอักษร Z,
แต่สิ่งที่อยู่ภายในของ Z
ดังนั้นขอให้ Adder - ดีไม่มีข้อผิดพลาดในครั้งนี้
Dot เฉือน Adder ป้อน, X เป็นไปได้ที่ 1
>> Y เป็นไปได้ 2
และผลรวมของ x และ y คือ 3
ดังนั้นนั่นคือทั้งหมดที่ดีและดี
>> ดังนั้นคุณจะคิดว่าคณิตศาสตร์ ควรจะทำงานในโปรแกรมเช่นนี้
แต่คุณรู้อะไรไหม
คือตัวแปรนี้สาย 12 แม้จำเป็น?
คุณไม่จำเป็นต้องได้รับในนิสัย เพียงการจัดเก็บสิ่งที่อยู่ในตัวแปร
เพียงเพราะคุณสามารถ
และในความเป็นจริงมันโดยทั่วไป การออกแบบที่ไม่ดีการพิจารณา
ถ้าคุณกำลังสร้างตัวแปรที่เรียกว่า Z ในกรณีนี้การจัดเก็บบางสิ่งบางอย่างในนั้น
และจากนั้นทันที ใช้มัน แต่ไม่เคยอีกครั้ง
ให้สิ่งที่ทำไมชื่อ เช่น Z ถ้าคุณอย่างแท้จริง
จะใช้ว่า สิ่งที่ได้เพียงครั้งเดียวและอื่น ๆ
ใกล้เคียงกับตำแหน่งที่คุณสร้างขึ้น ในสถานที่แรก
เพื่อให้ใกล้เคียงในแง่ของสายรหัส?
เพื่อให้คุณรู้อะไรไหม
แต่กลับกลายเป็นว่า C มีความยืดหยุ่นสวย
ถ้าจริงผมต้องการที่จะ plug-in ค่าที่นี่
ผมไม่จำเป็นต้องประกาศตัวแปรใหม่
ฉันสามารถ plug-in x บวก Y เพราะ C เข้าใจ
การคำนวณทางคณิตศาสตร์และผู้ประกอบการ
>> ดังนั้นฉันก็สามารถพูดได้ว่าทำคณิตศาสตร์นี้ X Y บวกสิ่งที่ค่าเหล่านั้น
เสียบที่เกิด จำนวนเต็มเป็นสตริงที่
ดังนั้นนี้อาจจะมี แต่ เพียงหนึ่งเส้นที่สั้นกว่า
การออกแบบที่ดีขึ้นซึ่งเป็นโปรแกรมที่ดีกว่า เพราะมีโค้ดน้อยลงดังนั้น
น้อยกว่าสำหรับผมที่จะเข้าใจ
และมันก็เป็นเพียงแค่ทำความสะอาด ตราบเท่าที่เราไม่ได้
แนะนำคำศัพท์ใหม่ สัญลักษณ์ใหม่เช่น Z,
ถึงแม้ว่าพวกเขาไม่ได้จริงๆ ให้บริการมากของวัตถุประสงค์
>> แต่น่าเสียดายที่ไม่ได้เป็นคณิตศาสตร์ ทุกสิ่งที่บางครั้งมีความน่าเชื่อถือ
Let 's ไปข้างหน้าและทำเช่นนี้
ฉันจะไปข้างหน้า ในขณะนี้และทำต่อไปนี้
>> ขอทำ printf ผมเปอร์เซ็นต์บวกร้อยละ ฉันจะเป็นร้อยละ i, n ทับขวา
และฉันจะทำ xyx this-- บวก Y
ดังนั้นฉันแค่ไปที่จะเขียน นี้แตกต่างกันเล็กน้อยที่นี่
ให้ฉันเพียงแค่จะตรวจสอบสติได้อย่างรวดเร็ว
อีกครั้งให้ไม่ได้รับล่วงหน้าของตัวเอง
ทำให้ Adder จุดเฉือน Adder
X คือ 1, Y คือ 2, 1 บวก 2 คือ 3
ดังนั้นที่ดี
แต่ขอให้มีความซับซ้อนในตอนนี้ บิตและสร้างไฟล์ใหม่
>> ฉันจะโทรห​​าคนนี้ พูด ints พหูพจน์สำหรับจำนวนเต็ม
ผมขอเริ่มต้นที่ฉันเป็นช่วงเวลาที่ผ่านมา
แต่ตอนนี้ขอทำสายอื่น ๆ ไม่กี่
ให้ฉันไปข้างหน้าและทำต่อไปนี้ printf ผมเปอร์เซ็นต์ลบร้อยละ i,
คือผมร้อยละจุลภาค x, y จุลภาค YX ลบ
ดังนั้นฉันทำเล็กน้อย คณิตศาสตร์ที่แตกต่างกันมี
ขอทำอีกคนหนึ่ง
ดังนั้นร้อยละร้อยละฉันครั้ง ฉันเป็นฉันเปอร์เซ็นต์ทับขวา n
Let 's plug-in x และ y, x ครั้ง Y
เราจะใช้เครื่องหมายดอกจันบน คอมพิวเตอร์ของคุณสำหรับครั้ง
>> คุณไม่ได้ใช้ X x คือ ชื่อตัวแปรที่นี่
คุณสามารถใช้ดาวคูณ
ให้ทำอย่างใดอย่างหนึ่งมากขึ้น
ผมร้อยละ printf แบ่ง โดย I ร้อยละร้อยละ i,
ทับขวา n XY หารด้วย y-- เพื่อให้คุณใช้ทับใน C
ส่วนจะทำอย่างไร
และขอทำคนอื่น ๆ
ที่เหลือของผมร้อยละหาร โดยร้อยละฉันเป็นฉันร้อยละ
xy-- และตอนนี้ที่เหลือ เป็นสิ่งที่เหลือกว่า
เมื่อคุณพยายามแบ่ง หารลงในเศษที่
วิธีการมากที่เหลือว่า คุณไม่สามารถแบ่งออก?
>> จึงมีไม่ได้จริงๆ จำเป็นสัญลักษณ์
เราได้นำมาใช้ในโรงเรียนประถมศึกษาสำหรับเรื่องนี้
แต่มีใน C. คุณสามารถ พูดแบบโมดูโล X Y ที่
เครื่องหมายเปอร์เซ็นต์ใน context-- นี้ ทำให้เกิดความสับสนเมื่อคุณอยู่ภายใน
ของราคาคู่ ภายในของ printf ร้อยละ
จะถูกใช้เป็นตัวระบุรูปแบบ
>> เมื่อคุณใช้ร้อยละนอก ว่าในการแสดงออกทางคณิตศาสตร์
มันเป็นผู้ประกอบการโมดูโลสำหรับโมดูลาร์ arithmetic-- สำหรับวัตถุประสงค์ของเรา
นี่ก็หมายความว่าสิ่งที่เป็น ที่เหลือของ x หารด้วย Y?
ดังนั้น x หารด้วย Y คือ X เฉือน Y
มีอะไรที่เหลือของ x หารด้วย Y?
มัน X Y MOD, เป็นโปรแกรมเมอร์จะบอกว่า
>> ดังนั้นถ้าฉันทำผิดพลาดที่นี่ไม่มีให้ฉัน ไปข้างหน้าและทำให้ ints, พหูพจน์ดี
และ ints เฉือนจุด
และให้ไปข้างหน้าและ ไม่ขอบอก, 1, 10
สิทธิทั้งหมด 1 บวก 10 เป็น 11 ตรวจสอบ
1 ลบ 10 เป็นลบ 9 ตรวจสอบ
>> 1 ครั้งที่ 10 คือ 10 การตรวจสอบ
1 หารด้วย 10 is-- ตกลงเราจะข้ามที่หนึ่ง
ที่เหลือของ 1 หารด้วย 10 คือ 1
ถูกต้อง.
แต่มีข้อผิดพลาดในที่นี่
>> ดังนั้นหนึ่งฉันใส่ของฉัน มอบไม่ถูกต้อง
ฉันหมายความว่ามันใกล้เคียงกับ 0
1 หารด้วย 10 คุณรู้ว่าถ้าเรา ตัดมุมบางแน่ใจว่ามันเป็นศูนย์
แต่จริงๆมันควรจะเป็น 1/10 0.1 หรือ 0.10 0.1000 หรืออื่น ๆ
>> มันไม่ควรจะเป็นศูนย์จริงๆ
ดีก็ปรากฎว่าคอมพิวเตอร์คือ ทำอย่างแท้จริงสิ่งที่เราบอกว่ามันจะทำ
เรากำลังทำทางคณิตศาสตร์เช่น x หารด้วย Y
และทั้งสอง x และ y ต่อเส้น รหัสก่อนหน้านี้เป็นจำนวนเต็ม
>> นอกจากนี้ในบรรทัดที่ 15 เรามี บอก printf เดี๋ยวก่อน printf Plug-in
จำนวนเต็ม plug-in จำนวนเต็ม plug-ใน integer-- เฉพาะ
x แล้ว Y และ X หารด้วย Y x และ y เป็น ints
เรามีดี
>> แต่สิ่งที่เป็น x หารด้วย X?
x หารด้วย Y ควรจะเป็น คณิตศาสตร์ 1/10 หรือ 0.1,
ซึ่งเป็นจำนวนจริงจำนวนจริง มีอาจเป็นจุดทศนิยม
มันไม่ได้เป็นจำนวนเต็ม
>> แต่สิ่งที่อยู่ใกล้ที่สุด จำนวนเต็ม 1/10 หรือ 0.1?
ใช่มันชนิดของการเป็นศูนย์
0.1 เป็นเหมือนมากขนาดนี้
1 และเป็นมากขนาดนี้
ดังนั้น 1/10 จะอยู่ใกล้กับ 0 กว่าก็คือการอย่างใดอย่างหนึ่ง
>> และเพื่อให้สิ่งที่ C จะทำสำหรับ us-- ชนิดของเพราะเราบอกว่ามัน to--
จะถูกตัดทอนจำนวนเต็มที่
ก็สละค่าอีกครั้งซึ่งเป็น ควรจะเป็นสิ่งที่ชอบ 0.1000,
0 และอื่น ๆ
และจะตัดทอนทุกอย่าง หลังจุดทศนิยม
ดังนั้นสิ่งที่นี้ สิ่งเพราะมันไม่ได้
พอดีกับความคิดของจำนวนเต็มซึ่ง เป็นเพียงตัวเลขเช่นติดลบ 1 0, 1,
ขึ้นและลงมันจะพ่นไปทุกอย่าง หลังจุดทศนิยมเพราะคุณ
ไม่สามารถใส่จุดทศนิยม ในจำนวนเต็มโดยความหมาย
>> ดังนั้นคำตอบที่นี่เป็นศูนย์
ดังนั้นวิธีที่เราจะแก้ไขปัญหานี้หรือไม่?
เราต้องแก้ไขปัญหาอื่นทั้งหมดเข้าด้วยกัน
และเราสามารถทำเช่นนี้ดังต่อไปนี้
>> ให้ฉันไปข้างหน้าและสร้างใหม่ ไฟล์หนึ่งนี้เรียกว่า floats.c
และบันทึกไว้ที่นี่ใน ไดเรกทอรีเดียวกัน float.c
และแจ้งให้เราไปข้างหน้าและคัดลอก บางส่วนของรหัสที่มาจากก่อนหน้านี้
>> แต่แทนที่จะได้รับ เป็น int ขอทำเช่นนี้
ให้ฉันค่าจุดลอย เรียกว่า x ที่จุดลอย
คุ้มค่าเป็นเพียงตัวอักษร บางสิ่งบางอย่างที่มีจุดลอย
มันสามารถย้ายไปทางซ้ายไปทางขวา
มันเป็นจำนวนจริง
>> และแจ้งให้เราโทรหาไม่ได้ ได้รับ int แต่ได้รับลอย
ซึ่งยังเป็นหนึ่งในเมนู ตัวเลือกในห้องสมุด C250
ลองเปลี่ยน Y เพื่อลอย
ดังนั้นนี้จะกลายเป็นได้รับลอย
>> และตอนนี้เราไม่ต้องการที่จะเสียบ ints
มันจะเปิดออกเราจะต้องใช้ร้อยละ F สำหรับลอย F ร้อยละลอย
และตอนนี้บันทึกไว้
และตอนนี้นิ้วข้ามให้ ลอยดีลอยเฉือนจุด
X เป็นไปได้หนึ่ง 1. Y เป็นไปได้ 10 อีกครั้ง
>> และมีความสุข, OK นอกจากของฉันถูกต้อง
ผมก็หวังว่าสำหรับข้อมูลเพิ่มเติม แต่ฉันลืมที่จะเขียนมัน
ดังนั้นขอไปและแก้ไขข้อผิดพลาดตรรกะนี้
>> Let 's ไปข้างหน้าและคว้าดังต่อไปนี้
เราก็จะทำสำเนาเล็ก ๆ น้อย ๆ และวาง
และฉันจะบอกว่าลบ
>> และฉันจะบอกว่าครั้ง
และฉันจะบอกว่าแบ่ง
และฉันจะไม่ทำแบบโมดูโล, ซึ่งไม่เป็นที่ใกล้ชิดที่นี่
หารด้วย F และเวลา plus-- ตกลงให้ทำเช่นนี้อีกครั้ง
>> ลอยให้ลอยเฉือนจุด และวันที่ 1, 10, and-- ดีไม่ตกลง
ดังนั้นฉันงี่เง่า
ดังนั้นนี่เป็นเรื่องธรรมดามาก วิทยาการคอมพิวเตอร์
จะทำผิดพลาดโง่เช่นนี้
>> เพื่อวัตถุประสงค์ในการสอน สิ่งที่ผมอยากจะทำ
ถูกเปลี่ยนวิทยาศาสตร์ที่นี่ จะบวกไปลบเพื่อครั้ง
และจะแบ่งตามที่คุณหวังว่า สังเกตเห็นระหว่างการออกกำลังกายนี้
ดังนั้นตอนนี้ขอรวบรวมอีกครั้งนี้ โปรแกรมทำลอยเฉือนจุด
>> และเป็นครั้งที่สามขอ ดูว่ามันตรงกับความคาดหวังของฉัน
1, 10, ใส่ใช่, OK, 1.000, โดยแบ่งออกเป็น 10.000 เป็น 0.100000
และปรากฎว่าเราสามารถควบคุมจำนวน ตัวเลขหลังจุดทศนิยมเหล่านั้น
เราจริงจะ
เราจะกลับมาที่
>> แต่ตอนนี้ในความเป็นจริงทางคณิตศาสตร์ที่ถูกต้อง
ดังนั้นอีกครั้งสิ่งที่ Takeaway ที่นี่?
ปรากฎว่าใน C มี ไม่เพียงเท่านั้น strings-- และในความเป็นจริง
มีไม่ได้จริงๆเพราะเรา เพิ่มผู้ที่มีห้องสมุด CS50
แต่มีไม่ได้เป็นเพียง ints
>> นอกจากนี้ยังมีลอย
และมันจะเปิดออกพวงของข้อมูลอื่น ๆ ประเภทเกินไปที่เราจะใช้ก่อนที่จะยาว
เปิดออกถ้าคุณต้องการเป็นหนึ่งเดียว ตัวอักษรไม่ใช่สตริงของตัวอักษร
คุณสามารถใช้เพียงถ่าน
>> ปรากฎว่าถ้าคุณต้องการบูลที่ ค่าบูลีน, จริงหรือเท็จเท่านั้น
ขอบคุณไปยังห้องสมุด CS50 เราได้ เพิ่มไปที่ C บูลชนิดข้อมูลได้เป็นอย่างดี
แต่มันก็ยังนำเสนอใน ภาษาอื่น ๆ จำนวนมากเช่นกัน
และปรากฎว่าบางครั้งคุณ ต้องตัวเลขใหญ่แล้วมาโดยค่าเริ่มต้น
กับ ints และลอย
>> และในความเป็นจริงคู่เป็นจำนวน ที่ใช้ไม่ได้ 32 บิต แต่ 64 บิต
และนานเป็นตัวเลขที่ ใช้ไม่ได้ 32 บิต แต่ 64 บิต
ตามลำดับสำหรับจุดลอย ค่านิยมและจำนวนเต็มตามลำดับ
ดังนั้นขอจริงในขณะนี้ เห็นนี้ในการดำเนินการ
>> ฉันจะไปข้างหน้านี่ และชักขึ้นโปรแกรมอื่นอย่างใดอย่างหนึ่ง
ที่นี่ฉันจะไปข้างหน้า และไม่รวมถึง CS50.h.
และแจ้งให้เราไปรวมถึงมาตรฐาน IO.h.
>> และคุณจะสังเกตเห็นบางสิ่งบางอย่าง ขี้ขลาดที่เกิดขึ้นที่นี่
มันไม่ได้เป็นรหัสสีสิ่งที่อยู่ใน เช่นเดียวกับมันก่อน
และปรากฎว่าเป็นเพราะฉัน ยังไม่ได้ให้สิ่งที่ชื่อไฟล์
>> ฉันจะโทรห​​าคนนี้ sizeof.c และกดบันทึก
และสังเกตเห็นสิ่งที่เกิดขึ้นกับฉันมาก รหัสสีขาวกับสีดำที่ฉากหลัง
ตอนนี้อย่างน้อยมี บางม่วงในการมี
และมันก็เป็นไวยากรณ์ที่ไฮไลต์
>> นั่นเป็นเพราะค่อนข้างเพียงฉันได้ IDE บอกสิ่งที่ชนิดของไฟล์
มันเป็นโดยให้มันชื่อและ เฉพาะไฟล์นามสกุล
ตอนนี้ขอไปข้างหน้าและทำเช่นนี้
ฉันจะไปข้างหน้าและมาก เพียงแค่พิมพ์บูล following--
คิดเป็นร้อยละ LU
>> เราจะกลับมา ว่าในสักครู่
แล้วฉันจะไป ขนาดการพิมพ์ของบูล
และตอนนี้เพียงเพื่อประหยัด ตัวเองบางครั้งฉัน
จะทำทั้งหมด พวงของเหล่านี้ได้ในครั้งเดียว
และโดยเฉพาะอย่างฉันจะไป เปลี่ยนเป็นถ่านและถ่าน
หนึ่งนี้ผมจะมีการเปลี่ยนแปลง ไปเป็นคู่และคู่
>> หนึ่งนี้ผมจะมีการเปลี่ยนแปลง จะลอยและลอย
หนึ่งนี้ผมกำลังจะไป เปลี่ยนไปเป็น int และ int
และหนึ่งนี้ฉันจะ จะเปลี่ยนไปนานนาน
และก็ยังคงได้รับ เป็นเวลานานนาน
>> และแล้วในที่สุดผมให้ ตัวเองหนึ่งมากเกินไปสตริง
ปรากฎว่าใน C มี ผู้ประกอบการพิเศษที่เรียกว่า
ขนาดของตัวอักษรที่ จะเรียกใช้เมื่อ
บอกให้เราทราบขนาดของ แต่ละตัวแปรเหล่านี้
และนี่คือวิธีการในขณะนี้ เราสามารถเชื่อมต่อกลับ
เพื่อการสนทนาสัปดาห์สุดท้ายของ ของข้อมูลและการเป็นตัวแทน
>> ให้ฉันไปข้างหน้าและรวบรวม ขนาดของขนาดเฉือนจุดของ
และขอดู
ปรากฎว่าใน C, เฉพาะใน CS50 IDE,
โดยเฉพาะใน ระบบปฏิบัติการอูบุนตู
ซึ่งเป็นปฏิบัติการ 64 บิต ระบบในกรณีนี้
บูลเป็นไป ใช้หนึ่งไบต์ของพื้นที่
นั่นเป็นวิธีที่ขนาดเป็นวัด ไม่ได้อยู่ในบิต แต่ในไบต์
และจำได้ว่าเป็นหนึ่งไบต์แปดบิต
ดังนั้นบูลแม้ว่าคุณ ในทางเทคนิคจะต้อง 0 หรือ 1
มันสิ้นเปลืองน้อย วิธีการที่เราได้ใช้มัน
จริง ๆ แล้วมันจะใช้ทั้ง byte-- ดังนั้นศูนย์ทั้งหมดเป็นบางที
ทุกคนหรือสิ่งที่ต้องการที่ หรือเพียงหนึ่งในหมู่ 1 แปดบิต
>> ถ่านขณะที่ใช้สำหรับตัวละคร เหมือนอักขระ ASCII ต่อสัปดาห์ที่ผ่านมา
เป็นไปได้ที่ตัวละครตัวหนึ่ง
และที่ synchs ขึ้นด้วยความคิดของเรา มันเป็นไม่เกิน 256 bits-- ค่อนข้าง
ซิงค์กับมันไม่ถูก นานกว่า 8 บิตซึ่ง
จะช่วยให้เราเป็นจำนวนมากถึง 256 ค่า
คู่เป็นไป 8 ไบต​​์หรือ 64 บิต
>> ลอยคือ 4
เป็น int คือ 4
ยาวยาว 8
และสตริงคือ 8
แต่ไม่ต้องกังวลเกี่ยวกับว่า
เรากำลังจะไปลอกกลับชั้นที่
มันจะเปิดออกสตริงสามารถ จะนานกว่า 8 ไบต​​์
>> และแน่นอนเราได้เขียน สตริงแล้ว Hello World,
นานกว่า 8 ไบต​​์
แต่เราจะกลับมา ว่าในสักครู่
แต่ใช้ไปนี่คือต่อไปนี้
>> คอมพิวเตอร์ใด ๆ เพียง แต่มี จำกัด จำนวนหน่วยความจำและพื้นที่
คุณสามารถจัดเก็บจำนวนมาก ไฟล์บน Mac หรือ PC
คุณสามารถเก็บโปรแกรมจำนวนมากดังนั้นใน RAM ทำงานในครั้งเดียวจำเป็นต้องแม้
มีหน่วยความจำเสมือนเพราะ คุณมีจำนวน จำกัด ของแรม
>> และเพียงเพื่อ picture-- ถ้า ที่คุณไม่เคยเปิดแล็ปท็อป
หรือสั่งหน่วยความจำเสริม สำหรับคอมพิวเตอร์ของคุณ
อาจจะไม่ทราบว่า ภายในเครื่องคอมพิวเตอร์ของคุณ
เป็นสิ่งที่มีลักษณะ เล็ก ๆ น้อย ๆ เช่นนี้
ดังนั้นนี้เป็นเพียง บริษัท ที่ร่วมกันตั้งชื่อ สิ่งสำคัญที่ทำให้ RAM สำหรับคอมพิวเตอร์
และแกะเป็นที่ที่โปรแกรม มีชีวิตอยู่ในขณะที่พวกเขากำลังทำงาน
>> ดังนั้นในทุก Mac หรือ PC เมื่อคุณเป็นสองเท่า คลิกโปรแกรมและจะเปิดขึ้น
และจะเปิดบางเอกสาร Word หรือสิ่งที่ต้องการที่
มันเก็บไว้ชั่วคราว RAM, RAM เพราะจะเร็ว
กว่าฮาร์ดดิสก์ของคุณหรือ ดิสก์ของรัฐที่มั่นคงของคุณ
จึงเป็นเพียงที่โปรแกรมไป จะมีชีวิตอยู่เมื่อพวกเขากำลังทำงาน
หรือเมื่อไฟล์ที่มีการใช้
>> เพื่อให้คุณมีสิ่งที่มีลักษณะ เช่นภายในของแล็ปท็อปของคุณนี้
หรือสิ่งที่ใหญ่กว่าเล็กน้อย ภายในของเดสก์ทอปของคุณ
แต่ที่สำคัญคือคุณมีเพียง จำนวน จำกัด ของสิ่งเหล่านี้
และมีเพียงจำนวน จำกัด ฮาร์ดแวร์นั่งอยู่บนโต๊ะทำงานนี้ได้
ที่นี่
>> ดังนั้นแน่นอนเราไม่สามารถจัดเก็บ ตัวเลขยาวเพียบ
และยังถ้าคุณคิดว่ากลับไป โรงเรียนประถมศึกษาวิธีการหลายตัวเลขสามารถ
คุณต้องไปทางขวา ของจุดทศนิยม?
สำหรับเรื่องที่ว่าหลายตัวเลขสามารถ คุณมีทางด้านซ้ายของจุดทศนิยม?
จริงๆหลายอย่างมากมาย
>> ตอนนี้มนุษย์เราอาจเพียง ทราบวิธีการออกเสียงล้าน
และพันล้านล้านล้านและ quadrillion และ Quintillion
และฉันผลักดันขีด จำกัด ของฉัน understanding-- หรือ my-- ฉันเข้าใจ
ตัวเลข แต่ของฉัน การออกเสียงของตัวเลข
แต่พวกเขาจะได้รับการขนาดใหญ่ที่มีเพียบ ตัวเลขหลายอย่างมากมายไปทางซ้าย
หรือไปทางขวาของจุดทศนิยม
>> แต่คอมพิวเตอร์มีเพียง จำนวน จำกัด ของหน่วยความจำ
จำนวน จำกัด ของทรานซิสเตอร์เป็น จำนวน จำกัด ของหลอดไฟภายใน
ดังนั้นสิ่งที่เกิดขึ้นเมื่อ คุณทำงานออกจากพื้นที่?
ในคำอื่น ๆ ถ้าคุณ คิดว่ากลับไปเมื่อสัปดาห์ที่แล้ว
เมื่อเราได้พูดคุยเกี่ยวกับตัวเลข ตัวเองเป็นตัวแทนในไบนารี
สมมติว่าเรามี นี้มูลค่า 8 บิตที่นี่
>> และเรามีเจ็ด 1 และ 0
และสมมติว่าเราต้องการ เพื่อเพิ่ม 1 ค่านี้
นี้เป็นจำนวนมากจริงๆตอนนี้
>> นี่คือ 254 ถ้าผมจำได้ว่า คณิตศาสตร์จากสัปดาห์ที่ผ่านมาทางด้านขวา
แต่สิ่งที่ถ้าฉันจะเปลี่ยน ที่ขวาสุด 0 ถึง 1?
จำนวนทั้งหมดของ แน่นอนจะกลายเป็นแปด 1
ดังนั้นเรายังคงดี
>> และนั่นอาจจะหมายถึง 255 แต่ขึ้นอยู่กับบริบท
จริง ๆ แล้วมันจะเป็นตัวแทน จำนวนลบ
แต่เพิ่มเติมว่าเวลาอื่น
นี้รู้สึกเหมือนว่ามันจะเป็นเรื่องของ สูงที่สุดเท่าที่ผมสามารถนับ
>> ตอนนี้ก็เป็นเพียง 8 บิต
และ Mac ของฉันก็มีวิธี มากกว่า 8 บิตของหน่วยความจำ
แต่จะมี จำกัด
ดังนั้นอาร์กิวเมนต์เดียวกันแม้ว่าเรา มีมากขึ้นของคนเหล่านี้บนหน้าจอ
>> แต่สิ่งที่เกิดขึ้นถ้าคุณ การจัดเก็บจำนวนนี้ 255
และคุณต้องการที่จะนับ 1 บิตที่สูงขึ้น?
คุณต้องการที่จะไป 255-256
ปัญหาของหลักสูตรคือว่าถ้าคุณ เริ่มนับที่ศูนย์เช่นสัปดาห์ที่ผ่านมา
คุณไม่สามารถนับสูงถึง 256 ให้อยู่คนเดียว 257
นับประสา 258 เมตรเพราะสิ่งที่ ที่เกิดขึ้นเมื่อคุณเพิ่ม 1?
ถ้าคุณทำโรงเรียนชั้นประถมศึกษาปีเก่า วิธีการที่คุณใส่ 1 ที่นี่
และจากนั้น 1 บวก 1 คือ 2 แต่ที่ จริงๆศูนย์คุณดำเนินการ 1
ดำเนินการ 1 ดำเนินการ 1
ทุกสิ่งเหล่านี้ เหล่านี้ 1 ให้ไปที่ศูนย์
และคุณลมขึ้นใช่เป็นคน ชี้ให้เห็นเป็นที่ 1 ด้านซ้ายมือ
แต่ทุกอย่างที่คุณสามารถ เห็นจริงและเหมาะสมในหน่วยความจำ
เป็นเพียงแปด 0 ซึ่งคือการพูด ในบางจุดถ้าคุณคอมพิวเตอร์
พยายามนับสูงพอขึ้นคุณ จะห่อรอบมันจะดูเหมือน
ให้เป็นศูนย์หรืออาจจะติดลบ ตัวเลขที่ต่ำกว่าศูนย์
>> และเราชนิดของสามารถดูนี้
ให้ฉันไปข้างหน้าและเขียน โปรแกรมอย่างรวดเร็วจริงที่นี่
ให้ฉันไปข้างหน้าและเขียน โปรแกรมที่เรียกว่ามากเกิน
รวม CS50.h รวม มาตรฐาน IO.h-- โอ้
ผมพลาดการเน้นไวยากรณ์ของฉัน
จึงขอบันทึกเป็น overflow.c
>> และตอนนี้ int void-- หลัก และอีกไม่นานเราจะ
กลับมาอธิบายว่าทำไม เราให้เขียน int เป็นโมฆะหลัก
แต่สำหรับตอนนี้ขอเพียงแค่ทำ มันเอามันให้ได้รับ
ขอให้ตัวเองเป็น int, และเริ่มต้นมันเป็น 0
>> ลองมาแล้วทำเพื่อฉันได้รับ int zero-- จริงให้ทำวง จำกัด
และดูสิ่งที่เกิดขึ้น
ในขณะที่ความจริงแล้วลองพิมพ์ n คิดเป็นร้อยละ i, ทับขวา N, plug-in n
แต่ตอนนี้ขอทำ n n ได้รับบวก 1
>> ดังนั้นในคำอื่น ๆ ในแต่ละ ทวนของวง จำกัด นี้
ขอใช้เวลาคุ้มค่า n ของ และเพิ่ม 1 ถึงมันแล้ว
เก็บผลที่ได้กลับมาอยู่ใน n ด้านซ้าย
และในความเป็นจริงที่เราเคยเห็นไวยากรณ์ เล็กน้อยเช่นนี้ในเวลาสั้น ๆ
เคล็ดลับเด็ดแทน การเขียนออกมาทั้งหมดนี้
คุณจริงสามารถพูด n บวกเท่ากับ 1
>> หรือถ้าคุณอยากจะเป็นแฟนซี ที่คุณสามารถพูด n บวกบวกกึ่งลำไส้ใหญ่
แต่สองคนหลังนี้เป็นเพียง สิ่งที่เราต้องการโทรน้ำตาลประโยค
สำหรับสิ่งแรก
>> สิ่งแรกคืออย่างชัดเจนมากขึ้น ปรับทั้งหมดที่ถูกต้องทั้งหมด
แต่นี่เป็นเรื่องธรรมดามากขึ้นผมจะบอกว่า
ดังนั้นเราจะทำเช่นนี้เพื่อรอสักครู่
>> ตอนนี้ขอให้ล้นซึ่งเสียง ค่อนข้างเป็นลางไม่ดีล้นเฉือนจุด
ลองมาดู, N ได้รับใหญ่สวย
แต่ให้คิดว่าวิธีการใหญ่ n จะได้รับ?
>> n เป็น int
เราเห็นช่วงเวลาที่ผ่านมากับขนาดของ ตัวอย่างที่เป็น int สี่ไบต์
เรารู้จากสัปดาห์ที่ผ่านมาสี่ไบต์ 32 บิตเพราะ 8 ครั้งที่ 4 ที่ 32
ว่าจะเป็น 4 พันล้าน
>> และเรามีถึง 800,000
นี้จะใช้ตลอดไป นับให้สูงที่สุดเท่าที่จะทำได้
ดังนั้นฉันจะไปข้างหน้า ที่คุณอาจไม่นาน
และกดปุ่มควบคุม C-- ตรงไปตรงมา, การควบคุม C, มากที่ C ควบคุมทั่วไป
หมายถึงการยกเลิก
แต่น่าเสียดายเพราะนี้ ทำงานในระบบคลาวด์
บางครั้งเมฆเป็น สิ่งที่คายออกมาก
การส่งออกมากก็จะ ใช้เวลาสักครู่สำหรับการป้อนข้อมูลของฉัน
ที่จะได้รับไปยังเมฆ
ดังนั้นแม้ว่าฉันตี C ควบคุมไม่กี่วินาทีที่ผ่านมา
นี้แน่นอนด้านข้าง ผลกระทบของวง จำกัด
>> และเพื่อให้ในกรณีดังกล่าวเรา จะออกจากที่เป็น
และเรากำลังจะเพิ่มอีก หน้าต่าง terminal มากกว่าที่นี่
กับบวกซึ่งแน่นอนไม่ได้ เช่นนั้นเพราะมันยังคงคิด
และให้ไปข้างหน้าและจะ เล็ก ๆ น้อย ๆ ที่เหมาะสม
>> ฉันจะไปข้างหน้าและทำ นี้เฉพาะขอบเขตหลายครั้ง
ลองใช้สำหรับห่วง ซึ่งผมพูดพาดพิงถึงก่อนหน้านี้
ลงมือทำกันเถอะ.
ให้ฉัน int อีกตัวแปรหนึ่งที่ผมได้รับ 0
ฉันมีค่าน้อยกว่าสมมติว่า 64 ผม ++
และตอนนี้ให้ฉันไปข้างหน้าและการพิมพ์ ออก n เป็นร้อยละฉันจุลภาค n
แล้ว n-- นี้ยังคงเป็น จะใช้เวลาตลอด
ลงมือทำกันเถอะ.
>> n n ได้รับครั้งที่ 2
หรือเราอาจจะแฟนซี และทำครั้งเท่ากับ 2
แต่ขอเพียงแค่พูดว่า n เท่ากับตัวเองครั้งที่ 2
ในคำอื่น ๆ ในเรื่องนี้ รุ่นใหม่ของโปรแกรม
ฉันไม่ต้องการที่จะรอตลอดไป จาก 800,000 เช่น 4 พันล้าน
ขอเพียงได้รับนี้ไปด้วย
>> Let 's จริงคู่ n ในแต่ละครั้ง
ซึ่งการเรียกคืนเป็นสองเท่า ตรงข้ามของการมีของหลักสูตร
และในขณะที่สัปดาห์ที่ผ่านมาเรามี บางสิ่งบางอย่างอีกครั้งและอีกครั้ง
และอีกครั้งเร็วสุด, ก็จะเพิ่มขึ้น
ได้รับเราจาก 1 ถึงที่ใหญ่ที่สุดที่เป็นไปได้ ค่าที่เราสามารถนับถึงกับ int
>> เพื่อขอทำตรงนี้
และเราจะกลับไปที่นี้มาก่อนที่จะยาว
แต่นี้อีกครั้งเป็นเช่นเดียวกับ บล็อกซ้ำรอยขีดข่วน
และคุณจะใช้นี้ก่อนที่จะยาว
>> เพียงแค่นี้ก็หมายความว่านับจากศูนย์ ขึ้นไป แต่ไม่เท่ากันถึง 64
และทวนของแต่ละ ห่วงเพียงให้การเพิ่มฉัน
ดังนั้น i ++ - และนี่สร้างทั่วไป ในบรรทัดที่ 7 เป็นเพียงวิธีที่พบบ่อยสุด
ของการทำซ้ำเส้นบาง รหัสจำนวนครั้งบาง
ซึ่งสายรหัส?
เหล่านี้วงเล็บปีกกาเป็นคุณ อาจจะมีการรวบรวมได้จากตอนนี้
หมายถึงการทำต่อไปนี้
>> มันอยู่ในรอยขีดข่วนเช่นเมื่อ มันมีบล็อกสีเหลือง
และสีอื่น ๆ ที่ชนิดของ โอบกอดหรือกอดบล็อกอื่น ๆ
นั่นคือสิ่งที่หยิก การจัดฟันจะทำอะไรที่นี่
ดังนั้นถ้าผมได้ไวยากรณ์ของฉัน right-- คุณ สามารถมองเห็นสัญลักษณ์แครอทใน C หมายถึง
ว่าเป็นวิธีที่หลายครั้งที่ฉันเป็น พยายามที่จะแก้ปัญหานี้
จึงขอกำจัดที่หนึ่ง ทั้งหมดและปิดหน้าต่างที่
และเราจะใช้ใหม่
ทำให้ล้นเฉือนจุด ล้นใส่ขวาทั้งหมด
มันดูไม่ดีในตอนแรก
แต่ขอเลื่อนกลับในเวลา เพราะผมทำอย่างนี้ 64 ครั้ง
>> และแจ้งให้ทราบเป็นครั้งแรกที่ n คือ 1
ครั้งที่สอง, N คือ 2 แล้ว 4 แล้ว 8 แล้ว 16
และดูเหมือนว่าเร็วที่สุดเท่าที่ ฉันได้รับการประมาณ 1 พันล้าน,
ถ้าฉันเป็นสองเท่าอีกครั้งว่า ควรให้ฉัน 2 พันล้าน
แต่มันจะเปิดออกก็ ขวาบนยอด
>> และเพื่อให้มันจริงล้น เป็น int จาก 1 พันล้าน
ลบประมาณ 2 พันล้านเพราะจำนวนเต็ม
ซึ่งแตกต่างจากตัวเลขเรา ถูกสมมติว่าสัปดาห์ที่ผ่านมา
สามารถเป็นได้ทั้งบวกและลบ ในความเป็นจริงและในเครื่องคอมพิวเตอร์
และเพื่อให้อย่างน้อยหนึ่งในบรรดา บิตถูกขโมยได้อย่างมีประสิทธิภาพ
ดังนั้นเราจริงๆมีเพียง 31 บิต หรือ 2 พันล้านค่าที่เป็นไป
>> แต่ตอนนี้ Takeaway ที่ค่อนข้าง เพียงแค่ตัวเลขเหล่านี้เป็นสิ่งที่
คณิตศาสตร์และสิ่งที่เป็น สิ่งที่ไม่ดีที่เกิดขึ้นในที่สุด
เพราะในที่สุดคุณกำลังพยายามที่จะ เปลี่ยนรูปบิตหนึ่งหลายครั้งเกินไป
และคุณได้อย่างมีประสิทธิภาพไปจากทั้งหมด 1 ที่จะอาจจะทั้งหมด 0 หรืออาจจะ
เพียงบางรูปแบบอื่น ๆ ที่ อย่างชัดเจนขึ้นอยู่กับบริบท
สามารถตีความได้ว่าเป็นจำนวนลบ
และอื่น ๆ ก็จะดูเหมือนฉันสูงสุด สามารถนับในโปรแกรมนี้โดยเฉพาะอย่างยิ่ง
เป็นเพียงประมาณ 1 พันล้าน
แต่มีวิธีการแก้ปัญหาบางส่วนที่นี่
คุณรู้ไหมว่า?
>> ผมขอเปลี่ยนจาก int ไปนาน
และแจ้งให้เราไปข้างหน้านี่ และ say-- ฉันจะมี
การเปลี่ยนแปลงนี้จะไม่ได้ลงนามยาว
หรือขอดูผมไม่เคยจำได้ว่าตัวเอง
>> Let 's ไปข้างหน้าและทำให้น้ำล้น
ไม่มีที่ไม่ได้แนวหน้าขอขอบคุณ
ดังนั้นบางครั้งเสียงดังกราวจะมีประโยชน์
ผมจำไม่ได้ว่าสิ่งที่รูปแบบ ระบุเป็นสำหรับระยะยาว
>> แต่ที่จริงแล้วเสียงดังกราวบอกฉัน
สีเขียวเป็นชนิดของดีบางอย่าง ยังหมายความว่าคุณทำผิดพลาด
มันคาดเดาว่าฉันหมายถึงแนวหน้า
>> เพื่อให้ฉันใช้มันเป็นคำแนะนำที่มีความยาว เลขทศนิยมยาวประหยัด
และแจ้งให้เราเรียกมันดอท เฉือนล้นใส่
และตอนนี้สิ่งที่เย็นนี้
>> ถ้าผมเลื่อนกลับในเวลาที่เรายังคงเริ่มต้น นับในเวลาเดียวกันกิจกรรมดังนั้นเล็กน้อย 1, 2, 4,
8, 16
แจ้งให้ทราบว่าเราได้รับทั้งหมด ทางขึ้นไป 1 พันล้าน
แต่แล้วเราได้อย่างปลอดภัยได้รับไป 2 พันล้าน
>> จากนั้นเราจะได้ 4 พันล้าน แล้ว 8 พันล้าน, 17 พันล้าน
และเราไปที่สูงขึ้นและ สูงขึ้นและสูงขึ้น.
ในที่สุดนี้มากเกินไปแบ่ง
>> ในที่สุดด้วยความยาวยาว ซึ่งเป็นมูลค่า 64 บิตไม่
ค่า 32 บิตถ้าคุณนับ สูงเกินไปคุณห่อรอบ 0
และในกรณีนี้เราเกิดขึ้นกับ จบลงด้วยจำนวนลบ
>> ดังนั้นปัญหานี้เป็นปัญหา
และปรากฎว่านี้ ปัญหาไม่ได้ทั้งหมดที่เป็นความลับ
แม้ว่าฉันจะได้จงใจ เหนี่ยวนำด้วยความผิดพลาดเหล่านี้
มันจะเปิดออกที่เราเห็นมันทุกชนิด รอบตัวเราหรืออย่างน้อยบางส่วนของเราทำ
>> ดังนั้นในเลโก้สตาร์วอถ้า คุณเคยเล่นเกม
มันจะเปิดออกคุณสามารถไปรอบ ๆ ทำลายสิ่งขึ้นในโลกเลโก้
และเก็บเหรียญเป็นหลัก
และถ้าคุณเคยเล่น เกมนี้ทางเวลามากเกินไป
เป็นบุคคลที่ไม่มีชื่อนี้ ที่นี่ได้จำนวนทั้งหมด
ของเหรียญที่คุณสามารถเก็บ คือมันจะดูเหมือน 4 พันล้าน
>> ขณะนี้มีมันกลมจริง
ดังนั้น LEGO ได้พยายามที่จะ ให้ผู้ใช้สิ่งที่เป็นมิตร
พวกเขาไม่ได้ทำมันตรง 2 32 อำนาจต่อสัปดาห์ที่ผ่านมา
แต่ 4 พันล้านเหตุผล
ดูเหมือนว่าบนพื้นฐานของข้อมูลนี้ ที่เลโก้และ บริษัท ดังกล่าว
ทำซอฟต์แวร์ที่เกิดขึ้นจริงนี้ตัดสินใจ ว่าจำนวนสูงสุดของเหรียญ
ผู้ใช้สามารถสะสม เป็นแท้จริง 4 พันล้าน
เพราะพวกเขาเลือกในรหัสของพวกเขา จะใช้เวลานานไม่นานเห็นได้ชัด
แต่เพียงจำนวนเต็มไม่ได้ลงนาม จำนวนเต็มเท่านั้นที่เป็นจำนวนเต็มบวกที่มี
ค่าสูงสุดคือประมาณว่า
ดีที่นี่เป็นอีกหนึ่งตลก
ดังนั้นในเกมอารยธรรมซึ่ง บางท่านอาจจะคุ้นเคยกับ
ปรากฎว่าปีที่ผ่านมามี เป็นข้อผิดพลาดในเกมนี้โดย
ถ้าคุณเล่นบทบาท ของคานธีในเกม
แทนของเขาเป็นความสงบมาก แทนที่จะเป็นอย่างไม่น่าเชื่ออย่างไม่น่าเชื่อ
ก้าวร้าวในบางสถานการณ์
โดยเฉพาะอย่างยิ่งวิธีการที่อารยธรรม ผลงานก็คือว่าถ้าคุณเล่นการพนัน
นำมาใช้ในการปกครองระบอบประชาธิปไตยของคุณ คะแนนที่ได้รับความแข็งขัน
decremented สองเพื่อลบ ลบแล้วลบลบ
>> ดังนั้นคุณลบ 2 จาก iterating ที่แท้จริงของคุณ
แต่ถ้าคุณเป็น iterating ในขั้นต้นที่ 1 และ 2 คุณลบจากมัน
หลังจากการนำประชาธิปไตย เป็นคานธีที่นี่อาจจะ
ได้ทำเพราะเขาเป็น passive-- มาก 1 โยแข็งขัน
แต่ถ้าเขาทำผิดกฎหมายการปกครองระบอบประชาธิปไตยแล้ว เขาจะไปจาก 1 ถึง 1 ในแง่ลบ
>> แต่น่าเสียดายที่พวกเขา โดยใช้ตัวเลขที่ไม่ได้ลงชื่อ
ซึ่งหมายความว่าพวกเขาได้รับการรักษาในเชิงลบแม้กระทั่ง หมายเลขราวกับว่าพวกเขาเป็นบวก
และปรากฎว่า เทียบเท่าในเชิงบวกของติดลบ 1
ในโปรแกรมคอมพิวเตอร์ทั่วไปคือ 255
ดังนั้นถ้าคานธี adopts ประชาธิปไตยและดังนั้นจึงมี
คะแนนความก้าวร้าวของเขาลดลง มันจริงม้วนรอบ 255
และทำให้เขามากที่สุด ตัวละครในเชิงรุกในเกม
เพื่อให้คุณสามารถ Google ขึ้นเกี่ยวกับเรื่องนี้
และมันก็เป็นจริงนัก ข้อผิดพลาดในการเขียนโปรแกรมโดยไม่ได้ตั้งใจ
แต่ที่เข้ามาค่อนข้าง ตำนานนับตั้งแต่
>> นั่นคือทั้งหมดที่สนุกและน่ารัก
น่ากลัวมากขึ้นคือเมื่อเกิดขึ้นจริง อุปกรณ์โลกแห่งความจริงและไม่เกม
มีข้อบกพร่องเหล่านี้เหมือนกัน
ในความเป็นจริงเพียงหนึ่งปีที่ผ่านมาบทความมา เกี่ยวกับโบอิ้ง 787
>> และบทความในตอนแรก ได้อย่างรวดเร็วอ่านความลับเล็ก ๆ น้อย ๆ
แต่ก็กล่าวว่านี้ซอฟแวร์ ช่องโหว่ในของโบอิ้ง
ใหม่ 787 เจ็ทมี มีศักยภาพที่จะทำให้เกิดนักบิน
การสูญเสียการควบคุม เครื่องบินอาจจะเป็น
ในช่วงกลางเดือนเที่ยวบิน, เจ้าหน้าที่จอห์นฟา สายการบินเตือนเมื่อเร็ว ๆ นี้
มันเป็นความมุ่งมั่น ว่ารุ่น 787
เครื่องบินที่ได้รับการขับเคลื่อน ต่อเนื่องเป็นเวลา 248 วัน
จะสูญเสียทุกกระแสสลับ AC, พลังงานไฟฟ้าเนื่องจากเครื่องกำเนิดไฟฟ้า
หน่วยควบคุม GCUs พร้อมกัน ที่จะเข้าสู่โหมด Fail Safe
มันเป็นชนิดของการสูญเสียผม
แต่บันทึกกล่าวว่าตกลงตอนนี้ผมได้ที่ สภาพที่เกิดจากซอฟแวร์
ตอบโต้ภายใน การควบคุมเครื่องกำเนิดไฟฟ้า
หน่วยงานที่จะล้นหลัง 248 วันของการใช้พลังงานอย่างต่อเนื่อง
เราจะออกนี้ ทราบเพื่อป้องกันการสูญหาย
ทุก AC ไฟฟ้า พลังงานซึ่งอาจส่งผล
สูญเสียการควบคุมเครื่องบิน
>> ดังนั้นตัวอักษรมีจำนวนเต็มบาง หรือเทียบเท่าชนิดข้อมูล
ถูกนำมาใช้ในซอฟแวร์ ในเครื่องบินที่เกิดขึ้นจริง
ว่าถ้าคุณเก็บเครื่องบินของคุณ ในนานพอซึ่งเห็นได้ชัด
สามารถเป็นกรณีที่หากคุณกำลังใช้งานเพียงแค่ พวกเขาอย่างต่อเนื่องและไม่เคยถอด
เครื่องบินของคุณดูเหมือนว่าหรือ ปล่อยให้แบตเตอรี่ตาย
ในที่สุดก็จะนับขึ้นและขึ้น และขึ้นและขึ้นและขึ้นและขึ้น
>> และโดยธรรมชาติเป็น จำนวน จำกัด ของหน่วยความจำ
จะล้นกลิ้งกลับไป ศูนย์หรือบางค่าลบ
ผลข้างเคียงของซึ่งเป็น ความเป็นจริงที่แท้จริงตระหนก
ว่าเครื่องบินอาจต้อง จะได้รับการรีบูตมีประสิทธิภาพ
หรืออาจจะตกแย่ลงในขณะที่มันบิน
ดังนั้นเหล่านี้ชนิดของปัญหา ยังคงอยู่กับเรา
even-- นี้เป็นบทความปี 2015 ทั้งหมดน่ากลัวมากขึ้น
เมื่อคุณไม่จำเป็นต้อง เข้าใจชื่นชมหรือคาดหวัง
ผู้ที่ชนิดของข้อผิดพลาด
>> ดังนั้นจึงปรากฎว่ามีคนอื่น ๆ สิ่งที่ไม่ดีเกี่ยวกับการแสดงข้อมูล
แต่กลับกลายเป็นว่าแม้จะลอยอยู่ ชนิดของข้อบกพร่องเพราะลอยเกินไป
ผมเสนอ 32 บิตหรือ อาจจะ 64 ถ้าคุณใช้คู่
แต่ที่ยังคง จำกัด
>> และจับคือว่าถ้าคุณสามารถ ใส่จำนวนอนันต์ของตัวเลข
หลังจากจุดทศนิยม มีวิธีที่คุณไม่มี
สามารถเป็นตัวแทนเป็นไปได้ทั้งหมด ตัวเลขที่เราได้รับการสอน
ในชั้นประถมศึกษาโรงเรียนสามารถอยู่ในโลก
คอมพิวเตอร์เป็นหลักมีการ เลือกกลุ่มย่อยของตัวเลขเหล่านั้น
เพื่อเป็นตัวแทนอย่างถูกต้อง
>> ตอนนี้คอมพิวเตอร์สามารถ รอบอาจจะนิด ๆ หน่อย ๆ
และช่วยให้คุณสามารถจัดเก็บประมาณ จำนวนใด ๆ ที่คุณอาจต้องการ
แต่เพียงอย่างสังหรณ์ใจถ้าคุณ มีจำนวน จำกัด ของบิต
คุณสามารถเปลี่ยนรูปพวกเขา ในรูปแบบที่แน่นอนจำนวนมากดังนั้น
ดังนั้นคุณจึงไม่อาจ ใช้จำนวน จำกัด
ของการเปลี่ยนแปลงของบิต รูปแบบของศูนย์และคน,
เพื่อเป็นตัวแทนของอนันต์ จำนวนของตัวเลข
ซึ่งแสดงให้เห็นว่าคอมพิวเตอร์อาจ เป็นอย่างดีจะโกหกเราบางครั้ง
>> ในความเป็นจริงเรามาทำเช่นนี้
ผมขอกลับไปเป็น IDE CS50
ให้ฉันไปข้างหน้าและ สร้างโปรแกรมเล็ก ๆ น้อย ๆ
เรียกว่าไม่แน่ชัดเพื่อแสดงให้เห็นว่า คอมพิวเตอร์เป็นจริงไม่แน่ชัด
>> และแจ้งให้เราไปข้างหน้าและเริ่มต้นด้วย บางส่วนของรหัสที่ก่อนหน้านี้เท่านั้น
และตอนนี้ก็ทำต่อไปนี้
ให้ฉันไปข้างหน้าและทำ printf ร้อยละ F, ทับขวา N, 1 หารด้วย 10
ในคำอื่น ๆ ลองดำน้ำลึก 1/10 เช่น 1 และหารด้วย 10
แท้จริงคอมพิวเตอร์สามารถเป็นตัวแทน 1/10
>> ดังนั้นขอให้ไปข้างหน้าและทำให้ไม่แน่ชัด
มาดูกัน.
รูปแบบระบุประเภทคู่
แต่ข้อโต้แย้งที่มีชนิด int
เกิดอะไรขึ้น?
>> โอ้น่าสนใจจึงเป็น บทเรียนที่ได้เรียนรู้จากก่อน
ฉันพูดเดี๋ยวก่อนโชว์คอมพิวเตอร์ ฉันลอยกับร้อยละ F
แต่ฉันให้มัน 2 ints
ดังนั้นมันจะเปิดออกผมสามารถแก้ไข ในสองวิธี
>> ฉันเพียงแค่อาจจะเปลี่ยนหนึ่งไป 1.0 และ 10 เข้า 10.0 ซึ่งจะแน่นอน
มีผลของการแปลง พวกเขาเข้าไปใน floats-- ยังคงหวังว่า
หมายเลขเดียวกัน
หรือมันจะเปิดออกมีบางสิ่งบางอย่าง เราจะได้เห็นอีกครั้งก่อนที่จะยาว
คุณสามารถโยนตัวเลข
>> คุณสามารถใช้สอดนี้ การแสดงออกของคุณสามารถพูดได้ว่า
Hey, คอมพิวเตอร์, ใช้เวลานี้ 10 ซึ่งฉันรู้ว่าเป็น int
แต่รักษามันโปรด ราวกับว่ามันเป็นลอย
แต่ตอนนี้ความรู้สึกที่ซับซ้อนโดยไม่จำเป็น
>> สำหรับวัตถุประสงค์ของเราในวันนี้ ขอเพียงแค่ตัวอักษร
ทำให้พวกเขาลอยค่าจุด มีจุดทศนิยมเช่นนี้
ให้ฉันไปข้างหน้าและวิ่งให้ ไม่แน่ชัดดีเฉือนจุด
ไม่แน่ชัดป้อน
ตกลงเรากำลังมองหาที่ดี
>> 1 หารด้วย 10 ตามที่ของฉัน Mac ที่นี่เป็นแท้จริง 0.100000
ตอนนี้ผมได้รับการสอนในโรงเรียนประถมศึกษามี ควรจะเป็นจำนวนอนันต์ของ 0
ดังนั้นขออย่างน้อยพยายาม จะเห็นบางส่วนของคนเหล่านั้น
แต่กลับกลายเป็นว่า printf เป็นเพียงเล็กน้อย ยังคงเป็นนักเล่นกว่าที่เราได้รับใช้
แต่กลับกลายเป็นคุณไม่ได้มีการระบุ เพียงแค่ร้อยละ F หรือเพียงแค่ร้อยละฉัน
จริงๆคุณสามารถระบุ บางตัวเลือกการควบคุมที่นี่
>> โดยเฉพาะผมจะ ที่จะบอกว่าเดี๋ยวก่อน printf,
แสดงให้ฉันจริง 10 คะแนนทศนิยม
ดังนั้นมันจึงดูแปลกเล็กน้อย
แต่คุณบอกว่าร้อยละ จุดตัวเลขหลายวิธี
คุณต้องการที่จะเห็นหลังจากที่ จุดทศนิยมแล้ว F
สำหรับแบนเพียงเพราะนั่นคือ สิ่งที่เอกสารกล่าวว่า
ให้ฉันไปข้างหน้าและประหยัด
>> และแจ้งให้ทราบเกินไปฉันได้รับ เหนื่อยกับการพิมพ์ดีดครั้งใหม่สิ่ง
ดังนั้นฉันแค่การตั้งค่าและ ลูกศรชี้ลงบนแป้นของฉันที่นี่
และถ้าผมให้กดปุ่มขึ้นคุณ สามารถดูคำสั่ง
ที่ฉันทำหรือทำไม่ถูกต้อง
>> และฉันจะไปข้างหน้าในขณะนี้และ ไม่ได้ใช้งานจริงที่เห็นได้ชัด
ทำให้ไม่แน่ชัดจุด เฉือน imprecision-- ดังนั้น
สิ่งที่ฉันได้รับการสอนใน ตรวจสอบโรงเรียนเกรดออก
แม้ว่าผมจะพิมพ์ได้ถึง 10 ทศนิยม สถานที่ที่มันแน่นอนคือ 0.10000
แต่คุณรู้อะไรไหม
>> ให้ของได้รับโลภน้อย
สมมติว่าเหมือนแสดงให้ฉัน 55 ชี้หลังจุดทศนิยม
ลองใช้เวลานี้จริงๆ โปรแกรมออกสำหรับสปิน
ผมขอรีเมคมันด้วยการแต่งหน้า ไม่แน่ชัดจุดเฉือนไม่แน่ชัด
>> และที่นี่เราไป
วัยเด็กของคุณเป็นเรื่องโกหก
เห็นได้ชัดว่า 1 หารด้วย 10 เป็นที่แน่นอน 0.100000000000000005551115123--
>> เกิดอะไรขึ้น?
ดีก็จะเปิดออกถ้าคุณชนิดของ มองไกลพอออกมาในพื้นฐาน
เป็นตัวแทนของนี้ จำนวนก็จริง
ไม่ว่า 1/10 หรือ 0.1 และ จำนวนอนันต์ของศูนย์
ตอนนี้ทำไมเป็นเช่นนั้น?
>> ดีแม้ว่านี้เป็นที่เรียบง่าย จำนวนมนุษย์เรา 1 หารด้วย 10
ก็ยังคงเป็นหนึ่งในหลาย ๆ เพียบ ตัวเลขที่เราจะได้คิดขึ้น
แต่คอมพิวเตอร์เท่านั้นที่สามารถเป็นตัวแทนของ ขีดดังนั้นหลายหมายเลข
และเพื่อให้มีประสิทธิภาพว่า คอมพิวเตอร์แสดงให้เราเป็นที่ใกล้เคียงที่สุด
ประมาณไปยังหมายเลขที่ เราต้องการที่จะเชื่อว่าเป็น 1/10
หรือจริงๆไม่มีที่สิ้นสุด 0.10000
>> แต่แม้ว่านี้เป็น ใกล้ที่สุดเท่าที่จะได้รับ
และแน่นอนถ้าคุณดู ใต้ฝากระโปรง
ในขณะที่เราอยู่ที่นี่โดยการมอง 55 หลักหลังทศนิยม
เราจริงเห็นความจริงว่า
ตอนนี้เช่นกันถ้าคุณได้ เคยเห็น movie--
ส่วนใหญ่ของคุณอาจจะ haven't-- แต่ซูเปอร์แมน 3 บางปีที่ผ่านมา
ริชาร์ดไพรเออร์หลัก leveraged นี้ ความเป็นจริงใน บริษัท ของเขาจะขโมยมาก
เศษส่วนและเศษส่วนของเพนนี, เพราะ company-- เท่าที่ผมจำได้
จะได้รับ while-- เป็นหลัก ทิ้งสิ่งที่ไม่เหมาะสม
เข้ามาในความคิดของเซ็นต์
>> แต่ถ้าคุณเพิ่มขึ้นทั้งหมดเหล่านี้ เล็ก ๆ เล็ก ๆ จำนวนเล็ก ๆ อีกครั้ง
และอีกครั้งและอีกครั้งที่คุณสามารถเป็นใน กรณีของเขาทำให้จำนวนเงินที่ดี
>> ที่ความคิดเดียวกันก็ถูกฉีกออกโดย ขึ้นเมื่อเร็ว ๆ นี้ แต่ยังคงตอนที่มีอายุมากกว่า
ภาพยนตร์ที่เรียกว่าพื้นที่สำนักงาน ที่คนในหนังเรื่องนั้น
ทำสิ่งเดียวกันเมาขึ้น สมบูรณ์จบลงด้วยวิธีที่มากเกินไป
เงินในบัญชีธนาคารของพวกเขา
มันเป็นที่น่าสงสัยมาก
แต่ในตอนท้ายของวัน ไม่แน่ชัดเป็นสิ่งที่อยู่รอบตัวเรา
>> และที่มากเกินไปสามารถ ใจหายกรณี
แต่กลับกลายเป็นว่าซูเปอร์แมน 3 และพื้นที่สำนักงานกันมี
สามารถเป็นจริงบางอย่างมาก มีเครือข่ายทั่วโลก
ของความเป็นจริงของแน่ชัด เป็นตัวแทนของข้อมูล
ว่าแม้เรามนุษย์ ในวันนี้ไม่จำเป็นต้อง
เข้าใจเช่นเดียวกับที่เราควร หรือจำได้บ่อยเท่าที่เราควร
และจริงคลิปต่อไปนี้ จากการมองโลกจริงมากบาง
เครือข่ายของสิ่งที่เกิดขึ้นถ้าคุณ ไม่ได้ชื่นชมไม่แน่ชัดว่า
สามารถเกิดขึ้นได้ในการเป็นตัวแทนตัวเลข
>> [เล่นวีดีโอ]
>> -Computers เราได้มาทั้งหมดจะยอมรับ ปัญหาที่มักจะทำลาย
ไปกับข้อบกพร่อง them-- ไวรัส และบกพร่องซอฟต์แวร์
สำหรับราคาขนาดเล็กจ่าย เพื่อความสะดวก
แต่ในเทคโนโลยีชั้นสูงและความเร็วสูง ทหารและโครงการอวกาศของการใช้งาน
ปัญหาที่เกิดขึ้นมีขนาดเล็กที่สุดสามารถ จะขยายเข้าไปในภัยพิบัติ
>> เมื่อวันที่ 4 มิถุนายน 1996 นักวิทยาศาสตร์เตรียม ที่จะเปิดตัวกำลังใจ Ariane 5 จรวด
มันได้รับการดำเนินการทางวิทยาศาสตร์ ดาวเทียมได้รับการออกแบบ
ที่จะสร้างได้อย่างแม่นยำว่า ปฏิสัมพันธ์ของโลกสนามแม่เหล็ก
กับลมพลังงานแสงอาทิตย์
จรวดถูกสร้างขึ้นสำหรับ องค์การอวกาศยุโรป
และยกออกจากโรงงาน บนชายฝั่งของฝรั่งเศสกิอานา
>> -At ประมาณ 37 วินาทีใน เที่ยวบินที่พวกเขาเป็นครั้งแรก
สิ่งที่สังเกตเห็นก็จะไม่ถูกต้อง
หัวถูกหมุนใน วิธีการที่พวกเขาไม่ควร
ประมาณ 40 วินาทีในการบิน เห็นได้ชัดว่ารถอยู่ในฐานะลำบาก
>> และที่ว่าเมื่อพวกเขาทำ การตัดสินใจที่จะทำลายมัน
เจ้าหน้าที่ความปลอดภัยในช่วงที่มี ความกล้าอย่างมากกดปุ่ม
พัดขึ้นจรวดก่อนที่มันจะ กลายเป็นอันตรายต่อความปลอดภัยของประชาชน
>> -This เป็นหญิงสาว การเดินทางของ Ariane 5
และการทำลายล้างของมันเอา วางเพราะข้อบกพร่อง
ที่ฝังอยู่ในซอฟท์แวจรวด
-The ปัญหาในอาริอานคือ ว่ามีตัวเลขที่
จำเป็นต้องใช้ 64 บิตในการแสดง
และพวกเขาต้องการที่จะแปลง มันเป็นจำนวน 16 บิต
พวกเขาสันนิษฐานได้ว่า จำนวนก็ไม่เคยไป
จะต้องมีขนาดใหญ่มากว่าส่วนใหญ่ของผู้ที่ ตัวเลขในจำนวน 64 บิตเป็นศูนย์
พวกเขาผิด
>> -The ไร้ความสามารถของหนึ่ง โปรแกรมซอฟแวร์ที่จะยอมรับ
ชนิดของหมายเลขที่สร้างขึ้นโดย อีกคนหนึ่งคือที่รากของความล้มเหลว
การพัฒนาซอฟต์แวร์ได้กลายเป็น ส่วนค่าใช้จ่ายสูงมากของเทคโนโลยีใหม่
จรวดอาริอานได้รับมาก ที่ประสบความสำเร็จมากของซอฟต์แวร์
ที่สร้างขึ้นสำหรับมันก็ยัง ใช้ใน Ariane 5
>> -The ปัญหาพื้นฐานคือการที่อาริอาน 5 เร็วเร่งได้เร็วขึ้น
และซอฟต์แวร์ที่ไม่ได้ คิดว่า
>> -The ทำลายจรวด เป็นภัยพิบัติทางการเงินขนาดใหญ่
อันเนื่องมาจากความผิดพลาดของซอฟต์แวร์นาที
แต่ตอนนี้ไม่ได้เป็นครั้งแรก ปัญหาเวลาแปลงข้อมูล
ได้ plagued เทคโนโลยีจรวดที่ทันสมัย
>> -in ปี 1991 ด้วยการเริ่มต้น ของสงครามอ่าวครั้งแรก,
รักชาติขีปนาวุธ ประสบการณ์ชนิดที่คล้ายกัน
ของปัญหาการแปลงจำนวน
และเป็นผลให้ 28 คน 28 ทหารอเมริกัน
ถูกฆ่าตายและประมาณ 100 คนอื่น ๆ ได้รับบาดเจ็บ
เมื่อรักชาติซึ่งควร เพื่อป้องกัน scuds เข้ามา
ล้มเหลวในการยิงขีปนาวุธ
>> เมื่อมีอิรักบุกคูเวตและอเมริกา เปิดตัวพายุทะเลทรายในช่วงต้นปี 1991
แบตเตอรี่รักชาติขีปนาวุธถูกนำไปใช้ เพื่อปกป้องซาอุดีอาระเบียและอิสราเอล
จากอิรักสกั๊ดขีปนาวุธโจมตี
ต่อต้านการก่อการร้ายเป็นสหรัฐช่วงกลาง พื้นผิวที่อากาศระบบการผลิต
โดย บริษัท Raytheon
>> -The ขนาดของ Interceptor ต่อต้านการก่อการร้าย ตัวเองเป็นเรื่องเกี่ยวกับประมาณ 20 ฟุตยาว
และน้ำหนักประมาณ 2,000 ปอนด์
และจะดำเนินการรบประมาณ, ฉันคิดว่ามันประมาณ 150 ปอนด์
และหัวรบที่ตัวเองเป็น ระเบิดสูงซึ่ง
มีชิ้นส่วนที่อยู่รอบ ๆ
ปลอกของจรวดคือ ออกแบบมาเพื่อทำหน้าที่เหมือน Buckshot
>> -The ขีปนาวุธจะดำเนินการ ต่อภาชนะสี่
และมีการขนส่งโดยรถพ่วงเทลเลอร์
>> -The Patriot ระบบป้องกันขีปนาวุธ กลับไปอย่างน้อย 20 ปีในขณะนี้
มันถูกออกแบบมา เป็นป้องกันขีปนาวุธอากาศ
จะยิงลงเครื่องบินศัตรู
ในสงครามอ่าวครั้งแรก, เมื่อสงครามที่มาพร้อม
กองทัพอยากจะใช้มันเพื่อ ยิงลง scuds ไม่เครื่องบิน
>> อิรักกองทัพอากาศ ไม่มากของปัญหา
แต่กองทัพเป็นห่วงเกี่ยวกับ scuds
ดังนั้นพวกเขาจึงพยายามที่จะ อัพเกรดต่อต้านการก่อการร้าย
>> -Intercepting ศัตรู วิถีการเดินทางที่ Mach 5
กำลังจะถูกท้าทายพอ
แต่เมื่อรักชาติ ก็รีบวิ่งเข้าไปในบริการ
กองทัพไม่ได้ตระหนักถึงของ การปรับเปลี่ยนที่ทำให้อิรัก
scuds ของพวกเขาไปไม่ได้เกือบจะตี
>> อะไรเกิดขึ้นก็คือ scuds ที่ ที่กำลังจะมาในก็ไม่เสถียร
พวกเขาถูกโยกเยก
เหตุผลของเรื่องนี้ก็คือ ชาวอิรักในการสั่งซื้อ
ที่จะได้รับ 600 กิโลเมตร ออกจาก 300 กิโลเมตร
ขีปนาวุธพิสัยเอาน้ำหนัก ออกจากจรวดด้านหน้า
พวกเขาทำให้จรวดเบา
>> ดังนั้นตอนนี้รักชาติ พยายามที่จะมาที่สกั๊ด
และส่วนใหญ่เวลาที่ ส่วนใหญ่ที่ครอบงำของเวลา
มันก็จะบินจากสกั๊ด
เมื่อผู้ประกอบการระบบต่อต้านการก่อการร้าย ตระหนักถึงความรักชาติพลาดเป้าหมายของตน
พวกเขาระเบิดจรวดต่อต้านการก่อการร้ายของ เพื่อหลีกเลี่ยงการบาดเจ็บล้มตายไปได้ถ้ามัน
ได้รับอนุญาตให้ตกอยู่กับพื้นดิน
>> ใช่หรือไม่เพราะเป็นสิ่งที่คนส่วนใหญ่เห็น ผู้บั้งไฟขนาดใหญ่ในท้องฟ้า
และเข้าใจผิดว่าเป็น ดักขีปนาวุธสกั๊ดของ
>> -Although ในเวลากลางคืน ท้องฟ้าปรากฏรักชาติ
ที่จะประสบความสำเร็จ ทำลาย Scuds ที่ Dhahran,
อาจจะมีผิดพลาดไม่ เกี่ยวกับผลการปฏิบัติงาน
มีระบบเรดาร์ต่อต้านการก่อการร้ายของ สูญหายติดตามของสกั๊ดที่เข้ามา
และไม่เคยเปิดตัวเนื่องจาก ข้อบกพร่องซอฟต์แวร์
มันเป็นอิสราเอลที่ค้นพบครั้งแรก ว่าอีกต่อไปเป็นระบบบน
ยิ่งเวลาที่แตกต่าง กลายเนื่องจากนาฬิกาฝังตัว
ในเครื่องคอมพิวเตอร์ของระบบ
>> -About สองสัปดาห์ก่อน โศกนาฏกรรมใน Dhahran,
อิสราเอลรายงานไปยัง กระทรวงกลาโหม
ว่าระบบที่ได้รับการสูญเสียเวลา
หลังจากนั้นประมาณแปดชั่วโมงหรือทำงาน พวกเขาสังเกตเห็นว่าระบบ
ได้กลายเป็นที่เห็นได้ชัดแม่นยำน้อยลง
กระทรวงกลาโหมตอบสนองโดยการ บอกทั้งหมดของแบตเตอรี่ต่อต้านการก่อการร้าย
จะไม่ปล่อยให้ระบบ มาเป็นเวลานาน
พวกเขาไม่เคยกล่าวว่าสิ่งที่เป็นเวลานาน was-- แปดชั่วโมง 10 ชั่วโมง 1,000 ชั่วโมง
ไม่มีใครรู้ว่า
>> -The แบตเตอรี่ต่อต้านการก่อการร้าย ประจำการอยู่ที่ค่ายทหาร
ที่ Dhahran และข้อบกพร่องภายใน นาฬิกาที่ได้รับมากกว่า 100 ชั่วโมง
เมื่อคืนวันที่ 25 กุมภาพันธ์
>> -IT เวลาที่จะติดตามความถูกต้อง ประมาณสิบวินาที
ตอนนี้หนึ่งในสิบของวินาที เป็นตัวเลขที่น่าสนใจ
เพราะมันไม่สามารถจะแสดงออก ในไบนารีตรงที่
หมายความว่ามันไม่สามารถแสดงได้ว่า ในเครื่องคอมพิวเตอร์ดิจิตอลใด ๆ ที่ทันสมัย
มันยากที่จะเชื่อ.
>> แต่ใช้สิ่งนี้เป็นตัวอย่าง
ลองมาจำนวนหนึ่งในสาม
หนึ่งในสามไม่สามารถ แสดงในทศนิยมตรง
หนึ่งในสามเป็น 0.333 ไปในอินฟินิตี้
>> ไม่มีทางที่จะทำด้วยความไม่เป็น ความถูกต้องสมบูรณ์ในทศนิยม
นั่นคือสิ่งที่ชนิดของปัญหาที่เกิดขึ้น ที่เกิดขึ้นในผู้รักชาติ
อีกต่อไประบบวิ่งที่ ที่เลวร้ายยิ่งผิดพลาดเวลากลาย
>> หลังการ 100 ชั่วโมงของการดำเนินงาน ข้อผิดพลาดในเวลาที่เป็นเพียงประมาณหนึ่งในสาม
วินาที
แต่ในแง่ของการกำหนดเป้​​าหมาย วิถีการเดินทางที่ Mach 5
มันมีผลในการติดตาม ข้อผิดพลาดกว่า 600 เมตร
มันจะเป็นความผิดพลาดร้ายแรง สำหรับทหารในสิ่งที่เป็น
เกิดขึ้นก็คือการเปิดตัวสกั๊ดเป็น ตรวจพบโดยดาวเทียมเตือนภัยล่วงหน้า
และพวกเขารู้ว่าสกั๊ดเป็น มาในทิศทางทั่วไปของพวกเขา
พวกเขาไม่รู้ว่ามันอยู่ที่ไหนมา
>> -IT ตอนนี้ถึงเรดาร์ ส่วนประกอบของระบบต่อต้านการก่อการร้าย
ปกป้อง Dhahran เพื่อค้นหาและเก็บ ติดตามขีปนาวุธของศัตรูที่เข้ามา
>> -The เรดาร์เป็นสมาร์ทมาก
มันจริงจะติดตาม ตำแหน่งของสกั๊ดที่
และจากนั้นคาดการณ์ที่มันอาจจะ จะเป็นครั้งต่อไปเรดาร์ส่ง
ชีพจรออก
ที่ถูกเรียกว่าประตูช่วง
>> -Then เมื่อรักชาติ ตัดสินใจที่มีเวลามากพอ
ผ่านที่จะกลับไปและตรวจสอบต่อไป สถานที่สำหรับวัตถุที่ตรวจพบนี้
มันจะไปกลับ
ดังนั้นเมื่อมันเดินกลับไปทางที่ผิด สถานที่มันก็เห็นไม่มีวัตถุ
และตัดสินใจว่าไม่มี วัตถุก็คือการตรวจจับเท็จ
และลดลงติดตาม
>> -The สกั๊ดที่เข้ามาหายไป จากหน้าจอเรดาร์
และวินาทีต่อมามัน กระแทกเข้าค่ายทหาร
สกั๊ดถูกฆ่าตาย 28 และเป็นคนสุดท้าย หนึ่งยิงในช่วงสงครามอ่าวครั้งแรก
>> น่าเศร้าที่การปรับปรุงซอฟต์แวร์ มาถึงที่ Dhahran ในวันรุ่งขึ้น
ข้อบกพร่องที่มีซอฟแวร์ รับการแก้ไขปิด
บทหนึ่งในทุกข์ ประวัติศาสตร์ของขีปนาวุธต่อต้านการก่อการร้าย
>> [เล่นวีดีโอ]
เดวิดเจลัน: ดังนั้นนี่คือทุกคนที่จะ บอกว่าปัญหาเหล​​่านี้ของล้น
และไม่แน่ชัดเป็นจริงทั้งหมดเกินไป
ดังนั้นวิธีการที่เราได้รับที่นี่?
เราเริ่มต้นด้วยเพียงการพูดคุยเกี่ยวกับ printf
อีกครั้งที่ฟังก์ชั่นนี้ สิ่งที่จะพิมพ์หน้าจอ
และเราแนะนำหลังจากนั้น ฟังก์ชั่นอื่น ๆ ไม่กี่
จากสิ่งที่เรียกว่าห้องสมุดของ CS50
และเราจะดำเนินการต่อไป เห็นเหล่านี้ในเวลาที่กำหนด
และเราโดยเฉพาะอย่างยิ่งใช้สตริงได้รับ และได้รับ int และตอนนี้ยังได้รับการลอย
และยังคนอื่น ๆ เรายังจะได้พบกับ และใช้ตัวเองก่อนที่จะยาว
>> แต่ในบางโอกาสมี เราเห็นแล้วต้อง
ในการจัดเก็บสิ่งที่มือของฟังก์ชั่นเหล่านั้นกลับมา?
มือพวกเขาเรากลับสตริง หรือ int หรือลอย
และบางครั้งเราจำเป็นต้องใส่ว่า สตริงหรือ int หรือลอยอยู่ที่ไหนสักแห่ง
>> และการจัดเก็บสิ่งเหล่านั้นจำได้เพียงแค่ เช่นเดียวกับใน Scratch เรามีตัวแปร
แต่แตกต่างจากในเกา ใน C เรามีประเภทที่เกิดขึ้นจริง
ข้อมูล variables-- ประเภท generally-- เพิ่มเติม
ในหมู่พวกเขาสตริงเป็น int เป็น ลอยและอื่น ๆ เหล่านี้ยังคง
>> และดังนั้นเมื่อเราประกาศตัวแปรใน C, เราจะมีการประกาศประเภทข้อมูลของเรา
นี่ไม่ใช่สิ่งที่เราจะ ต้องทำต่อไปในภาคการศึกษา
ในขณะที่เราเปลี่ยนไปใช้ภาษาอื่น ๆ
แต่ตอนนี้เราจะต้อง การนิรนัยล่วงหน้า
อธิบายให้คอมพิวเตอร์สิ่งที่ประเภท ของตัวแปรที่เราต้องการที่จะให้เรา
>> ตอนนี้ในขณะเดียวกันในการพิมพ์ ผู้ที่ชนิดของชนิดข้อมูล
เราจะต้องบอก printf สิ่งที่คาดหวัง
และเราเห็น s ร้อยละสตริง และร้อยละ I สำหรับจำนวนเต็ม
และอีกสองสามคนแล้ว
และผู้ที่มีเพียงความต้องการ สำหรับการนำเสนอภาพ
ของข้อมูลที่
>> และแต่ละเหล่านี้สามารถจริงจะ parametrized หรือเอ็นดูในบางวิธี
ถ้าคุณต้องการที่จะส่งเสริมการควบคุม ประเภทของการส่งออกที่คุณได้รับ
และในความเป็นจริงก็ปรากฎว่าไม่เพียง แต่ จะมีทับขวา n สำหรับบรรทัดใหม่
มีอย่างอื่นที่เรียกว่าทับขวาเป็น R สำหรับกลับรถซึ่ง
เป็นมากขึ้นคล้ายกับผู้ เครื่องพิมพ์ดีดโรงเรียนเก่า
และยังใช้ Windows ใช้เวลาหลายปี
>> มีเสื้อทับขวาสำหรับแท็บ
ปรากฎว่าถ้าคุณต้องการที่จะ ราคาคู่ภายในของสตริง
จำได้ว่าเราได้ใช้ คู่ราคาคู่
อ้างด้านซ้ายและด้านขวา ปลายสายของเราป่านนี้
ที่ดูเหมือนจะสร้างความสับสนให้สิ่ง
>> หากคุณต้องการที่จะนำคำพูดคู่ใน ตรงกลางของ string-- และแน่นอนที่
มันจะทำให้เกิดความสับสนที่จะเห็น
และเพื่อให้คุณจะต้องหลบหนีเพื่อที่จะ พูดอ้างคู่กับบางสิ่งบางอย่าง
เช่นตัวอักษรราคาคู่ทับขวา
และมีไม่กี่อื่น ๆ ยังคง
และเราจะเห็นมากขึ้นของคนเหล่านั้น ในการใช้งานจริงก่อนที่จะยาว
>> ดังนั้นตอนนี้ขอเปลี่ยนจาก ข้อมูลและการแสดง
และผู้ประกอบการทางคณิตศาสตร์ทั้งหมด ซึ่งทำให้เรามีอาคารบางส่วน
บล็อกด้วยซึ่งในการเล่น
แต่ตอนนี้ขอให้จริง เราส่วนที่เหลือของคำศัพท์
ที่เรามีอยู่แล้ว สัปดาห์ที่ผ่านมาที่มีรอยขีดข่วน
โดยการดูที่บางส่วนอื่น ๆ สร้างใน C-- ไม่ทั้งหมดของพวกเขา
แต่ความคิดเรา เกี่ยวกับการดูจริงๆเพียงแค่
จะเน้นการแปลจาก หนึ่งภาษาเกาไปยังอีกซี
>> และช่วงเวลาที่เราจะรับ เครื่องมือเพิ่มเติมสำหรับชุดเครื่องมือของเรา
เพื่อที่จะพูดไวยากรณ์
และแน่นอนคุณจะเห็นว่าความคิด ตอนนี้ค่อนข้างคุ้นเคยจากสัปดาห์ที่ผ่านมา
ดังนั้นขอให้ทำเช่นนี้
>> Let 's ไปข้างหน้าและชักขึ้นโปรแกรม ที่จริงใช้การแสดงออกบางอย่าง
นิพจน์บูลีน
ผมขอไปข้างหน้านี่ และสร้างไฟล์ใหม่
ฉันจะเรียก condition.c นี้
>> ให้ฉันไปข้างหน้าและ รวมถึงห้องสมุด CS50
และแจ้งให้เราไปข้างหน้าและรวมถึง มาตรฐาน IO.h สำหรับการทำงานของเรา
และ printf และอื่น ๆ ตามลำดับ
ผมขอให้ตัวเองสำเร็จรูปที่ เป็นโมฆะหลัก int ซึ่งมีคำอธิบายที่เราจะ
กลับมาในอนาคต
>> ตอนนี้ให้ฉันไปข้างหน้าและให้ ตัวเองเป็น int ผ่านได้รับ int
ก็ขอให้ข้าไปข้างหน้าและทำเช่นนี้
ผมอยากจะบอกว่าถ้าผมเป็น less-- ขอ ความแตกต่างระหว่างบวกลบ
หรือค่าเป็นศูนย์
>> ดังนั้นถ้าฉันมีค่าน้อยกว่าศูนย์ให้ฉัน เพียงแค่มีโปรแกรมนี้เพียงแค่พูดว่า
ลบทับขวา N, อื่น ๆ ถ้าฉันมีค่ามากกว่าศูนย์
ตอนนี้ฉันกำลังของหลักสูตรจะพูด printf บวก n ทับขวา
แล้วอื่น if-- ฉันสามารถทำเช่นนี้
>> ฉันจะทำอย่างไรถ้าฉันมีค่าเท่ากับ 0
แต่ผมต้องการจะทำที่ อย่างน้อยหนึ่งข้อผิดพลาดอยู่แล้ว
จำได้ว่าเป็นเครื่องหมายเท่ากับ ไม่เท่ากับเป็นมนุษย์เรารู้ว่ามัน
>> แต่มันเป็นผู้ประกอบการที่ได้รับมอบหมาย
และเราไม่ต้องการที่จะใช้ 0 บน ที่เหมาะสมและใส่ไว้ในผมด้านซ้าย
ดังนั้นเพื่อหลีกเลี่ยงความสับสนนี้หรือ บางทีอาจจะผิดวัตถุประสงค์ของเครื่องหมายเท่ากับ,
มนุษย์ตัดสินใจบางปีที่ผ่านมา ว่าในหลายภาษาโปรแกรม
เมื่อคุณต้องการที่จะตรวจสอบเพื่อความเท่าเทียมกัน ระหว่างด้านซ้ายและด้านขวา
คุณใช้จริงเท่ากับเท่ากับ
ดังนั้นคุณจะตีเท่ากับสองเท่า
เมื่อคุณต้องการที่จะกำหนดจากขวา ไปทางซ้ายคุณใช้เครื่องหมายเท่ากับเดียว
ดังนั้นเราจึงสามารถทำ this-- อื่น ถ้าฉันเท่ากับเท่ากับศูนย์
>> จากนั้นผมก็จะไป เปิดวงเล็บปีกกาของฉัน
และพูดว่า printf 0, n ทับขวาทำ
แต่จำไว้ว่าวิธีการเหล่านี้ ส้อมในถนนสามารถทำงานได้
และจริงๆเพียงแค่คิดว่าเกี่ยวกับตรรกะ
ฉันเป็นตัวเลข
มันเป็นจำนวนเต็มโดยเฉพาะ
และนั่นหมายความว่ามันเป็นไปได้น้อย กว่า 0 หรือมากกว่า 0 หรือ 0
จึงมีชนิดของนี้ กรณีที่เริ่มต้นโดยนัย
>> และเพื่อให้เราสามารถเช่นเดียวกับ รอยขีดข่วนแจกจ่ายกับอื่นถ้า
และเพียงแค่พูดอื่น
เหตุผลถ้าคุณ โปรแกรมเมอร์รู้ว่ามีเพียง
สามถังเข้าไปที่ สถานการณ์สามารถ fall-- แรก
ที่สองหรือที่สาม ในเรื่องนี้ case-- ไม่
ต้องเพิ่มความแม่นยำเพิ่มเติม และตรรกะเพิ่มเติมมี
เพียงแค่ไปข้างหน้ากับ กรณีที่เริ่มต้นที่นี่อื่น
>> ตอนนี้ขอไปข้างหน้า หลังจากบันทึกนี้ให้
เงื่อนไขดอทเฉือน conditions-- ไม่ได้เป็นส่วนติดต่อผู้ใช้ที่ดี
เพราะฉันไม่ได้กระตุ้น ผู้ใช้ที่ผมกล่าวถึงก่อนหน้านี้
แต่ที่ดี
เราจะให้มันง่าย
ลองหมายเลข 42
และที่เป็นบวก
ลองจำนวน เชิงลบ 42 ลบ
>> ลองค่า 0
และแน่นอนว่าการทำงาน
ตอนนี้คุณจะเห็นมีปัญหาก่อน ยาวทดสอบสิ่งสามครั้ง
อาจจะไม่เพียงพอ
คุณอาจต้องการที่จะทดสอบบางอย่าง ตัวเลขขนาดใหญ่บางส่วนที่มีขนาดเล็ก
ตัวเลขบางกรณีมุมเช่น เราจะมาอธิบายให้พวกเขา
>> แต่สำหรับตอนนี้เป็น โปรแกรมใช้งานง่ายสวย
และผมค่อนข้างมั่นใจว่าเหตุผล ว่ามันตกอยู่ในสามกรณี
และแน่นอนแม้ว่าเราเพียง มุ่งเน้นไปที่ข้อเสียที่อาจเกิดขึ้น
ของไม่แน่ชัดและไหลท่วมใน ความเป็นจริงที่หลายปัญหา CS50 ของ
เราจะไม่ต้องกังวล เกี่ยวกับตลอดเวลา
ปัญหาเหล​​่านั้นล้นและ ไม่แน่ชัดเพราะในความเป็นจริงใน C,
จริง ๆ แล้วมันไม่ได้ทั้งหมดที่ ง่ายต่อการหลีกเลี่ยงสิ่งเหล่านั้น
หากคุณต้องการที่จะนับขึ้น ขนาดใหญ่และขนาดใหญ่และขนาดใหญ่
มันจะเปิดออกมีเทคนิคคุณ สามารถใช้มักเกี่ยวข้องกับสิ่งที่เรียกว่า
ห้องสมุดคอลเลกชันของรหัสที่ คนอื่น ๆ ที่เขียนว่าคุณสามารถใช้
และภาษาอื่น ๆ เช่น Java และอื่น ๆ จริง
ทำให้มันง่ายขึ้นมาก จะนับที่สูงยิ่งขึ้น
ดังนั้นมันคือเรื่องจริงบางส่วนของอันตรายเหล่านี้ ฟังก์ชั่นของภาษาที่คุณใช้
และในสัปดาห์ที่ผ่านมาเราจะ ดูวิธีการที่อันตรายจริงๆ C
สามารถหากคุณไม่ได้ใช้มันอย่างถูกต้อง
แต่จากที่นั่นและมี งูหลามและ JavaScript จะ
เราชั้นบนคุ้มครองเพิ่มเติมบางอย่าง และเรียกใช้น้อยลงของความเสี่ยงเหล่านั้น
>> ดังนั้นขอให้เล็ก ๆ น้อย ๆ ตรรกะที่น่าสนใจในโปรแกรมของเรา
เพื่อให้ฉันไปข้างหน้าและสร้าง โปรแกรมที่เรียกว่าตรรกะ
เพียงเพื่อให้ฉันสามารถเล่นกับบางส่วน ตรรกะที่เกิดขึ้นจริง logical.c
ฉันเพิ่งจะคัดลอกและวางบาง รหัสจากก่อนหน้านี้ดังนั้นฉันได้รับกลับมา
ไปยังจุดเริ่มต้นที่ดีนี้
>> ผมขอเวลานี้ทำซีถ่านฉัน จะให้ชื่อของซี
เพียงเพราะมันเป็นธรรมดา ได้รับตัวอักษรจากผู้ใช้
และให้แสร้งว่า ผมดำเนินการส่วนหนึ่ง
ของโปรแกรม Rm นั้นลบ โปรแกรมก่อนที่ได้รับแจ้งผู้ใช้
จะลบไฟล์
วิธีการที่เราสามารถทำเช่นนี้?
>> ผมอยากจะบอกว่าถ้า C เท่ากับ เท่ากับอ้างนำมาอ้าง,
Y แล้วฉันจะถือว่า ที่ผู้ใช้เลือกที่ใช่
ฉันแค่จะพิมพ์ใช่
ถ้ามันถูกเขียนจริง โปรแกรมกำจ​​ัด
เราสามารถลบไฟล์ มีเส้นมากขึ้นของรหัส
แต่เราจะให้มันง่าย
>> อื่นถ้า C เท่ากับเท่ากับ n-- และตอนนี้ที่นี่ฉันจะบอกว่า
ผู้ใช้จะต้องมีความหมายไม่มี
และจากนั้นก็ได้ที่คุณรู้อะไรไหม
ผมไม่ทราบว่าสิ่งที่คนอื่น ผู้ใช้จะไปพิมพ์
ดังนั้นฉันเพียงแค่จะบอกว่า ที่เป็นข้อผิดพลาดใด ๆ ก็ตาม
เขาหรือเธอพิมพ์จริง
>> ดังนั้นสิ่งที่เกิดขึ้นที่นี่?
มีความแตกต่างพื้นฐานคือ เมื่อเทียบกับสิ่งที่ผมเคยทำมาในอดีต
ราคาคู่ราคาคู่สองครั้ง คำพูดและยังราคาเดียว
ราคาเดียว
มันจะเปิดออกใน C ว่าเมื่อ คุณต้องการเขียนสตริง
คุณใช้คำพูดสองเช่นเดียวกับเราได้ ได้ใช้ตลอดเวลานี้กับ printf
>> แต่ถ้าคุณต้องการที่จะจัดการกับเพียง ตัวเดียวที่เรียกว่าถ่าน
แล้วคุณจริงใช้ราคาเดียว
บรรดาผู้ที่ได้ตั้งโปรแกรม ก่อนที่คุณอาจไม่ได้
จะต้องกังวลเกี่ยวกับเรื่องนี้ ความแตกต่างในบางภาษา
ใน C มันไม่สำคัญ
และอื่น ๆ เมื่อฉันได้รับถ่านและฉันต้องการ เพื่อเปรียบเทียบถ่านที่ใช้เท่ากับ
เท่ากับตัวอักษรบางอย่างเช่น Y หรือ N, ที่ฉันทำ แน่นอนจะต้องมีราคาเดียว
>> ตอนนี้ขอไปข้างหน้าและทำเช่นนี้
Let 's ไปข้างหน้าและจะทำให้ จุดตรรกะเฉือนตรรกะ
และตอนนี้ฉันถาม
ดังนั้นน่าจะเป็นประสบการณ์ใช้งานที่ดี จริงจะบอกฉันว่าจะทำที่นี่
แต่ฉันจะเพียงสุ่มสี่สุ่มห้า พูด Y สำหรับใช่ตกลงที่ดี
>> ลองเรียกใช้อีกครั้ง, N ไม่ดี
สมมติว่าเหมือนคนบางคนที่ผมรู้ หมวกล็อคกุญแจของฉันอยู่บนทั้งหมดบ่อยเกินไป
ดังนั้นผมจึงทำทุน Y ป้อนข้อผิดพลาด
ตกลงมันไม่ได้เป็นสิ่งที่ฉันคาดหวัง
แท้จริงคอมพิวเตอร์ จะทำในสิ่งที่ตัวอักษร
ผมบอกว่ามัน do-- ตรวจสอบ ตัวพิมพ์เล็กและตัวพิมพ์เล็ก Y n
นี้ไม่ได้รู้สึกเหมือนดี ประสบการณ์ของผู้ใช้ แต่
ให้ฉันถามหาและยอมรับ ทั้งกรณีที่ต่ำกว่าหรือกรณีบน
ดังนั้นมันจะเปิดออกคุณอาจต้องการ จะพูดอะไรเหมือนในเกา
เช่นตัวอักษรหรือ C เท่ากับ เท่ากับทุน Y ยกมาเพียงครั้งเดียว
เปิดออก, C ไม่ได้ คำหลักที่แท้จริงนี้หรือ
>> แต่มันจะมีแถบแนวตั้งสอง
คุณจะต้องกด Shift ค้างไว้มักจะ ถ้าคุณกำลังใช้แป้นพิมพ์ของสหรัฐ
และกดแถบแนวตั้ง ที่สำคัญดังกล่าวข้างต้นที่สำคัญผลตอบแทน
แต่แถบแนวตั้งนี้ แถบแนวตั้งหรือหมายความว่า
>> หากตร​​งกันข้ามเราต้องการ ที่จะพูดและเหมือนในเกา
เราสามารถทำเครื่องหมายสัญลักษณ์
ที่ทำให้ไม่รู้สึกตรรกะที่นี่ เพราะมนุษย์ไม่อาจ
พิมพ์ทั้ง Y และ Y ตัวพิมพ์เล็ก เงินทุนและ Y เป็นตัวละครเดียวกัน
ดังนั้นหรือเป็นสิ่งที่เราตั้งใจที่นี่
>> ดังนั้นถ้าฉันทำเช่นนี้ในสถานที่ทั้งสองหรือ C เท่ากับเท่ากับทุน N, วิ่งตอนนี้
ทำให้ตรรกะตรรกะรันใหม่อีกครั้ง
ตอนนี้ผมสามารถพิมพ์ Y
และผมสามารถทำมันได้อีกครั้งกับ ทุน Y หรือเอ็นทุน
และฉันจะเพิ่มในการเพิ่มเติม ยังคงอยู่รวมกัน
>> ดังนั้นนี่คือตรรกะ โปรแกรมเท่าตอนนี้
ผมตรวจสอบเหตุผลสำหรับ ค่านี้หรือค่านี้
และฉันไม่จำเป็นต้องจำเ​​ป็น เกิดขึ้นกับอีกสองไอเอฟเอหรืออื่น ๆ ที่ไอเอฟเอ
ที่จริงผมสามารถรวมบางส่วนของ ตรรกะที่เกี่ยวข้องร่วมกันในลักษณะนี้
ดังนั้นนี้จะดีกว่า มากกว่าเพียงแค่การออกแบบ
ว่าถ้า C เท่ากับ Y กรณีที่ต่ำกว่า พิมพ์ใช่อื่นถ้า C เท่ากับทุน Y,
พิมพ์ใช่อื่นถ้า C เท่ากับ lower-- ในคำอื่น ๆ
คุณไม่จำเป็นต้องมี สาขามากขึ้น
คุณสามารถรวมบางส่วนของเทียบเท่า สาขาเหตุผลเป็นในลักษณะนี้
>> ดังนั้นลองมาดูที่เพียงหนึ่ง ส่วนผสมสุดท้ายหนึ่งสร้างสุดท้าย
ที่ C ช่วยให้
และเราจะกลับมาใน ในอนาคตอื่น ๆ ยังคง
และจากนั้นเราจะสรุปโดยการมอง ที่ไม่ถูกต้องของ code--
ได้รับรหัส work-- แต่การออกแบบ ของรหัสและเมล็ดพืชเหล่านั้นในช่วงต้น
>> เพื่อให้ฉันไปข้างหน้าและ เปิดไฟล์ใหม่ที่นี่
คุณรู้ไหมว่า?
ฉันจะใช้อีกครั้ง ว่าโปรแกรมเดียวกัน
แต่ใช้สร้างที่แตกต่างกัน
>> เพื่อให้ฉันได้อย่างรวดเร็วให้ตัวเอง รวมถึงการเข้าถึง CS50.h
สำหรับห้องสมุด CS50, มาตรฐาน Io.h สำหรับ printf
ให้ฉันเป็นโมฆะหลักของฉัน int
แล้วที่นี่ให้ ฉันไปข้างหน้าและทำเช่นนี้
>> ถ่านที่ได้รับได้รับถ่านเหมือนเมื่อก่อน
และฉันจะใช้โครงสร้างใหม่ now-- สลับในสิ่งที่ตัวละคร?
ดังนั้นสวิทช์เป็นชนิดเช่น สลับรางรถไฟ
หรือจริงๆมันเป็นชนิดของ ถ้ามิฉะนั้นถ้าอื่นถ้า,
แต่เขียนค่อนข้างแตกต่าง
>> สวิทช์มีลักษณะเช่นนี้
คุณมีสวิทช์และแล้วสิ่งที่ ตัวอักษรหรือหมายเลขที่คุณต้องการที่จะมอง
แล้วบางส่วนวงเล็บปีกกาชอบใน เริ่มต้นเพียงแค่พูดว่าทำสิ่งนี้
แล้วคุณมีกรณีที่แตกต่าง
>> คุณไม่ได้ใช้ถ้าและอื่น ๆ
คุณอักษรใช้กรณีที่คำว่า
และคุณจะพูดอะไรเช่นนี้
>> ดังนั้นในกรณีของ Y ตัวพิมพ์เล็ก, หรือในกรณีของเงินทุน Y ที่
ไปข้างหน้าและพิมพ์ออกมาใช่
และจากนั้นแยกออกจากสวิทช์
แค่นั้นแหละ.
เรากำลังทำ
>> อื่นถ้า, เพื่อที่จะพูด กรณีที่ต่ำกว่า n หรือร่วมทุน N,
แล้วไปข้างหน้าและพิมพ์ ไม่ออกแล้วทำลาย
Else-- และชนิดของนี้เป็น กรณีที่เริ่มต้น indeed-- printf error--
และเพียงแค่การวัดที่ดีแม้ว่า เหตุผลพักนี้ไม่จำเป็น
เพราะเราในตอนท้าย สวิทช์อยู่แล้ว
ตอนนี้ผมกำลังจะหมดจากสวิทช์
ดังนั้นนี้มีลักษณะแตกต่างกันเล็กน้อย
>> แต่เหตุผลมัน เทียบเท่าจริง
และเหตุผลที่คุณจะใช้ หนึ่งในช่วงอื่น ๆ ?
บางครั้งเพียงแค่ความชอบส่วนบุคคล บางครั้งความงาม,
ถ้าผมเหลือบนี้ ตอนนี้มีบางสิ่งบางอย่าง
ที่จะกล่าวว่าสำหรับ การอ่านรห​​ัสนี้
ผมหมายถึงไม่เคยคิดจริงที่ว่านี้ รหัสใหม่ให้พวกเราหลายคนในห้องพัก
>> แต่เพียงแค่ชนิดของมันสวย
คุณจะเห็นตัวพิมพ์เล็ก Y เมืองหลวง Y, n กรณีที่ต่ำกว่าค่าเริ่มต้นทุน N,
มันเป็นเพียงแค่ชนิดของการกระโดด ออกจากที่คุณในทางที่
ว่าเนื้อหาอาจจะ ตัวอย่างก่อนหน้านี้
กับไอเอฟเอและแถบแนวตั้ง และอื่น ๆ ที่ไอเอฟเอที่ไม่อาจมี
ดังนั้นนี้เป็นจริงเรื่องของส่วนบุคคล ทางเลือกจริงๆหรืออ่าน
ของรหัส
>> แต่ในแง่ของการทำงานให้ฉัน ไปข้างหน้าและทำให้สวิทช์เฉือนจุด
สวิทช์และตอนนี้พิมพ์ Y พิมพ์เล็ก ทุน Y พิมพ์เล็ก N, ทุน N,
เดวิดลองใหม่อีกครั้งเพราะนั่นคือ ไม่ได้เป็นตัวเดียว
ขอทำ X ข้อผิดพลาดเป็นไปตามคาด
และ logically-- และนี่คือสิ่งที่ ฉันอยากจะแนะนำใน general-- แม้กระทั่ง
แม้ว่าเราจะมีเพียงรอยขีดข่วน พื้นผิวของบางส่วนของคุณสมบัติเหล่านี้
>> และมันอาจจะไม่ชัดเจนเมื่อคุณ ตัวเองนั่งลงที่แป้นพิมพ์
วิธีการทำงานนี้หรือไม่?
สิ่งนี้จะทำอย่างไร?
สิ่งที่สวยงามเกี่ยวกับการมี แล็ปท็อปหรือคอมพิวเตอร์ตั้งโต๊ะหรือการเข้าถึง
กับคอมพิวเตอร์คอมไพเลอร์, และมีการแก้ไขรหัสเช่นนี้
คือคุณมักจะสามารถตอบเหล่านี้ คำถามสำหรับตัวคุณเองเพียงแค่พยายาม
>> ตัวอย่างเช่นถ้าวาทศิลป์ คำถามที่อยู่ในมือเขา
เกิดอะไรขึ้นถ้าคุณลืม งบแบ่งของคุณหรือไม่
ที่เป็นจริง สิ่งที่พบมากที่จะทำ
เพราะมันไม่ได้ดู เหมือนที่คุณต้องการพวกเขาจริงๆ
พวกเขาไม่ได้จริงๆเสร็จสมบูรณ์ของคุณ คิดเหมือนวงเล็บหรือหยิก
รั้งไม่
Let 's ไปข้างหน้าและ คอมไพล์รหัสและดู
เพื่อให้สวิทช์, สวิทช์ดอทเฉือน
ลองพิมพ์ในกรณีที่ต่ำกว่า Y กรณีด้านบนใส่
ดังนั้นผมจึงพิมพ์ Y
>> โปรแกรมที่กล่าวว่าใช่ไม่มีข้อผิดพลาด ราวกับว่ามันก็เปลี่ยนความคิดของตน
แต่ชนิดของมันเป็นเพราะสิ่งที่เกิดขึ้น มีสวิทช์เป็นกรณีแรกที่
การแข่งขันเป็นหลักหมายถึงเฮ้คอมพิวเตอร์ การดำเนินการทั้งหมดของรหัสที่อยู่ข้างใต้
และถ้าคุณไม่ได้บอกว่าการแบ่งหรือ ไม่ได้บอกว่าการแบ่งหรือไม่พูดทำลาย
คอมพิวเตอร์เป็นไปเป่า ผ่านทุกเส้นที่
และดำเนินการทั้งหมดของพวกเขาจนกว่า ได้รับไปที่วงเล็บปีกกา
ดังนั้นเบรกเป็นจริงที่จำเป็น
แต่ Takeaway นี่คือเมื่อ มีข้อสงสัยลองอะไร
บางทีบันทึกรหัสแรกของคุณ หรือบันทึกไว้ในแฟ้มพิเศษ
ถ้าคุณกังวลมากเกี่ยวกับ ล้อขึ้นและมีการกู้คืน
งานที่คุณรู้ว่าเป็นคนที่ทำงาน
>> แต่ลองสิ่ง
และไม่กลัวที่จะเป็นบางที ของสิ่งที่คอมพิวเตอร์อาจทำ
หรือว่าคุณอาจทำลายบางสิ่งบางอย่าง
คุณสามารถเปลี่ยนกลับ บางรุ่นก่อนหน้านี้
>> ดังนั้นขอจบด้วยการมอง ที่การออกแบบของรหัส
เรามีความสามารถนี้ในขณะนี้ที่จะเขียน เงื่อนไขและเขียนลูป
และตัวแปรและฟังก์ชั่นการโทร
ดังนั้นตรงไปตรงมาเราชนิดของการกลับมาที่ ว่าเราอยู่ที่ไหนสัปดาห์ที่ผ่านมากับการเกา
แม้ว่ามีต้นฉบับเดิมที่น่าสนใจน้อย สภาพแวดล้อมกว่า Scratch ช่วยให้
>> แต่สังเกตเห็นวิธีการอย่างรวดเร็วเราได้ที่ได้มา คำศัพท์ที่แม้ว่าจะเป็น
จะใช้เวลาสักครู่จะจมลงไปใน เพื่อที่ว่าตอนนี้เราสามารถใช้คำศัพท์นี้
การเขียนโปรแกรมที่น่าสนใจมากขึ้น
และให้ใช้ขั้นตอนทารก ไปยังที่ดังต่อไปนี้
ให้ฉันไปข้างหน้าและ สร้างไฟล์ใหม่ที่นี่
>> ฉันจะเรียกสิ่งนี้ว่า prototype.c และแนะนำ
เป็นครั้งแรกที่ความสามารถในการ ที่จะทำให้การทำงานของคุณเอง
บางท่านอาจจะมี การกระทำเช่นนี้มีรอยขีดข่วน
โดยคุณสามารถสร้างของคุณ บล็อกกำหนดเองในเกา
แล้วลากเข้าไปในสถานที่ ทุกที่ที่คุณต้องการใน C.
และในการเขียนโปรแกรมมากที่สุด ภาษาคุณสามารถทำตรง
ในปัจจุบันผู้ให้ฟังก์ชั่นของคุณเอง ถ้าพวกเขาไม่ได้อยู่แล้ว
>> ดังนั้นสำหรับตัวอย่างให้ฉันไปข้างหน้า และรวมถึง CS50.h และรวมถึง
มาตรฐาน IO.h โมฆะหลัก int
และตอนนี้เรามี ตัวยึดพร้อมที่จะไป
ผมให้สิ่งที่พิมพ์ เช่นชื่อของผู้คนในวันนี้
และที่รู้สึก like-- จะไม่ดีถ้ามี
มีฟังก์ชั่นที่เรียกว่าพิมพ์ชื่อ?
ฉันไม่ได้มีการใช้ printf
ฉันไม่ต้องจำ ทุกรหัสรูปแบบ
ทำไมฉันจึงไม่หรือทำไม ไม่ได้มีใครบางคนก่อนที่ฉัน
สร้างฟังก์ชั่นที่เรียกว่าพิมพ์ ชื่อที่ได้รับชื่อบาง
เพียงแค่พิมพ์ออก?
>> ในคำอื่น ๆ ถ้าผมบอกว่าเดี๋ยวก่อน คอมพิวเตอร์ให้ฉันสตริง
โดยขอให้ผู้ใช้สำหรับการดังกล่าว ผ่านฟังก์ชั่นสตริง CS50 ของ
Hey, คอมพิวเตอร์, ใส่สตริงที่ใน ตัวแปรในด้านซ้ายมือ
และเรียกมัน
แล้วเฮ้คอมพิวเตอร์ไปข้างหน้า และพิมพ์ว่าชื่อของคนทำ
>> ตอนนี้มันจะดีเพราะ โปรแกรมนี้ชื่อเหมาะเจาะ
บอกฉันสิ่งที่มันควรจะทำอย่างไร โดยวิธีการที่ชื่อของฟังก์ชั่นเหล่านั้น
ผมขอไปและทำให้ต้นแบบใส่
และโชคไม่ดี นี้จะไม่บิน
>> Prototype.c สาย 7 ตัวอักษร 5 ข้อผิดพลาดการประกาศโดยปริยาย
ชื่อฟังก์ชั่นการพิมพ์ ไม่ถูกต้องใน C99, C99
หมายถึงรุ่นของซี ที่ออกมาในปี 1999
นั่นคือทั้งหมดที่
>> ดังนั้นผมจึงไม่ทราบว่า ทั้งหมดนี้หมายความว่ายัง
แต่ฉันจะตระหนักถึงความผิดพลาดในสีแดง
ที่เห็นได้ชัดสวย
>> และดูเหมือนว่ามี ตัวอักษรสีเขียวที่นี่
ปัญหาคือมีชื่อพิมพ์เปิด วงเล็บ S, วงเล็บใกล้กึ่งลำไส้ใหญ่
แต่การประกาศโดยนัยของ ฟังก์ชั่นที่เราไม่เห็นในเวลาสั้น ๆ ก่อนหน้านี้
ซึ่งหมายความเพียงว่าเสียงดังกราว ไม่ทราบว่าผมหมายถึง
>> ผมเคยใช้คำศัพท์ว่ามันเป็น ไม่เคยเห็นหรือได้รับการสอนมาก่อน
และดังนั้นผมจึงจำเป็นต้องสอน สิ่งที่ฟังก์ชั่นนี้หมายถึง
ดังนั้นฉันจะไปข้างหน้าและทำอย่างนั้น
>> ฉันจะไปข้างหน้าและการดำเนินการ ฟังก์ชั่นที่เรียกว่าตัวเองชื่อพิมพ์ของฉัน
และผมจะต้องพูดดังนี้ว่า มันไม่นี้ printf สวัสดีร้อยละ
S, ทับขวา n ชื่อกึ่งลำไส้ใหญ่
ดังนั้นสิ่งที่ฉันไม่เพียงแค่ทำอย่างไร
>> ดังนั้นมันจะเปิดออกไป ใช้ฟังก์ชั่นของคุณเอง
ชนิดที่เรายืมบางส่วนของ โครงสร้างเดียวกันเป็นหลัก
ที่เราได้รับเพียง สำหรับรับและฉัน
รู้เพียงคัดลอกและ วางสิ่งที่สวยมาก
ฉันได้รับการเขียนในอดีตที่ผ่านมา
แต่สังเกตเห็นรูปแบบที่นี่
int หลักเป็นโมฆะเราจะหยอกล้อออกจากกัน อีกไม่นานสิ่งที่จริงหมายถึง
>> แต่สำหรับวันนี้เพียงแค่ ทราบขนาน
โมฆะชื่อพิมพ์ ชื่อสตริงเพื่อให้มี
คำหลักสีม่วงซึ่ง เรากำลังจะเริ่มต้น
โทรชนิดกลับเป็นชื่อของ ฟังก์ชั่นและจากนั้นการป้อนข้อมูล
ดังนั้นในความเป็นจริงเราสามารถกลั่น ชนิดของสัปดาห์ที่ผ่านมาเช่นนี้
เป็นนี้เป็นชื่อหรือที่ อัลกอริทึมของรหัสเรา
จะ write-- อัลกอริทึมพื้นฐาน
รหัสที่เรากำลังจะเขียน
>> นี่คือปัจจัยการผลิต
นี่คือผลลัพธ์ของมัน
ฟังก์ชั่นนี้ชื่อพิมพ์คือ ออกแบบมาเพื่อใช้สตริงเรียกชื่อ
หรือสิ่งที่เป็น input และจากนั้นเป็นโมฆะ
มันไม่กลับอะไร เหมือนได้รับสตริงหรือได้รับ int ไม่
ดังนั้นมันจะมอบอะไรบางอย่างกลับมา
มันเป็นเพียงแค่จะมี ผลข้างเคียงเพื่อที่จะพูด
ในการพิมพ์ชื่อของบุคคล
ดังนั้นสังเกตเห็นสาย 7 ผม สามารถเรียกชื่อพิมพ์
สาย 10 ผมสามารถกำหนด หรือใช้ชื่อพิมพ์
แต่โชคไม่ดีที่ไม่เพียงพอ
>> ให้ฉันไปข้างหน้าและ คอมไพล์นี้หลังจากบันทึก
โอ้โฮตอนนี้ผมได้ทำมัน เลวก็จะดูเหมือน
ประกาศดังนั้นโดยนัยของ พิมพ์ชื่อฟังก์ชั่นไม่ถูกต้อง
และอีกครั้งมีข้อผิดพลาดขึ้น
แต่ที่ผมเตือนก่อนหน้านี้แม้ ถ้าคุณได้รับจมกับ
หรือเศร้าเล็ก ๆ น้อย ๆ ที่จะเห็นจำนวนมากดังนั้น ข้อผิดพลาดมุ่งเน้นเฉพาะในวันแรก
ในตอนแรกเพราะมันอาจเป็นเพียงแค่ มีผลซ้อน
ดังนั้น C หรือเสียงดังกราวมากขึ้นโดยเฉพาะ ยังไม่รู้จักชื่อพิมพ์
>> และนั่นเป็นเพราะเสียงดังกราว, โดยการออกแบบเป็นชนิดของใบ้
มันเพียง แต่สิ่งที่คุณบอกว่าจะทำอย่างไร
และมันไม่ให้ในการสั่งซื้อ ในที่ที่คุณบอกว่าจะทำอย่างไร
>> ดังนั้นผมจึงได้กำหนดหลักในสายสี่ เหมือนที่เราได้รับการทำมักจะสวย
ฉันได้กำหนดชื่อพิมพ์บนเส้น 10
แต่ฉันพยายามที่จะใช้ พิมพ์ชื่อในบรรทัดเจ็ด
>> มันเร็วเกินไปยังไม่มี
ดังนั้นผมอาจจะฉลาดและเป็นเช่น ตกลงดังนั้นขอเพียงแค่เล่นไปตาม
และย้ายชื่อพิมพ์ขึ้น ที่นี่และรวบรวมอีกครั้ง
โอ้พระเจ้า.
มันทำงาน
มันเป็นง่ายๆเป็นว่า
>> แต่ตรรกะเป็นว่าที่
คุณจะต้องสอนสิ่งที่มันเสียงดังกราว โดยกำหนดฟังก์ชั่นเป็นครั้งแรก
จากนั้นคุณสามารถใช้มัน
แต่ตรงไปตรงมานี้รู้สึก เหมือนลื่นลาด
>> ดังนั้นทุกครั้งที่ผมทำงาน เป็นปัญหาผมเพียง
จะเน้นและคัดลอกโค้ด ผมเขียนตัดและวางขึ้นที่นี่
และแน่นอนเราสามารถ ประดิษฐ์บางสถานการณ์
ฟังก์ชั่นที่หนึ่งอาจจะ ต้องเรียกอีก
และคุณก็ไม่สามารถใส่ทุก ฟังก์ชั่นข้างต้นอื่น ๆ ทุกคน
>> ดังนั้นมันจะเปิดออกมีของ เป็นทางออกที่ดี
เราสามารถออกจากนี้จะเป็น
และตรงไปตรงมาโดยทั่วไปดี และความสะดวกสบายและการออกแบบที่ดี
ที่จะนำหลักแรกเพราะอีกครั้ง หลักเช่นเดียวกับเมื่อธงสีเขียวคลิก
ที่มีฟังก์ชั่นที่ ได้รับการดำเนินการไปโดยปริยาย
ดังนั้นคุณอาจจะเป็นดีใส่ ไว้ที่ด้านบนของไฟล์
เพื่อที่ว่าเมื่อคุณหรือ อื่น ๆ ของมนุษย์มีลักษณะที่ไฟล์
คุณรู้ว่าสิ่งที่เกิดขึ้น เพียงแค่อ่านหลักแรก
ดังนั้นมันจะเปิดออกเราสามารถบอกเสียงดังกราว เชิงรุก, Hey, เสียงดังกราวบนสายสี่
ฉันสัญญาว่าจะดำเนินการ ฟังก์ชั่นที่เรียกว่าพิมพ์
ชื่อที่ใช้เรียกชื่อสตริง เป็น input และผลตอบแทนที่ไม่มีอะไรเป็นโมฆะ
และฉันจะได้รับรอบเพื่อ การดำเนินการได้ในภายหลัง
>> ที่นี่มาหลัก
ที่สำคัญตอนนี้ในบรรทัด 9 สามารถใช้ พิมพ์ชื่อเพราะเสียงดังกราว
เป็นที่ไว้วางใจที่สุด ก็จะพบความหมาย
การดำเนินงานของชื่อพิมพ์
ดังนั้นหลังจากการบันทึกไฟล์ของฉันให้ ฉันไปข้างหน้าและทำให้ต้นแบบ
ดูดีในเวลานี้
Dot เฉือนต้นแบบให้ฉัน ไปข้างหน้าและพิมพ์ในชื่อ
ดาวิดสวัสดีเดวิด Zamila สวัสดี Zamila และแน่นอนตอนนี้ก็ทำงาน
>> ดังนั้นส่วนผสมที่นี่คือที่เราได้ ทำให้ฟังก์ชั่นที่กำหนดเองเช่นเดียวกับที่กำหนดเอง
รอยขีดข่วนบล็อกเราจะเรียกมันว่า
แต่แตกต่างจากรอยขีดข่วนที่คุณสามารถ เพียงแค่สร้างมันและเริ่มใช้มัน
ตอนนี้เราจำเป็นต้องเป็น เล็ก ๆ น้อย ๆ อวดความรู้มากขึ้น
และจริงในการฝึกอบรมดังกราว ที่จะใช้หรือคาดหวังว่ามัน
ตอนนี้เช่นกันว่าทำไมทุกเวลานี้มี เรารับเพียงสุ่มสี่สุ่มห้าบนความเชื่อรวมทั้ง
CS50.h และรวมทั้งมาตรฐาน IO.h?
>> ดีก็จะเปิดออก ในหมู่สิ่งอื่น ๆ เพียงไม่กี่
ทุกสิ่งที่อยู่ในบรรดา dot H ไฟล์ที่เกิดขึ้นจะเป็นไฟล์
พวกเขากำลังไฟล์ส่วนหัวเพื่อที่จะพูด
พวกเขากำลังเขียนยังคงอยู่ในซี แต่ พวกเขากำลังเป็นประเภทที่แตกต่างกันของไฟล์
>> สำหรับตอนนี้คุณสวยมากสามารถสันนิษฐานได้ว่า ว่าสิ่งที่อยู่ภายในของ CS50.h
บางหนึ่งสมุทรเช่นนี้ไม่ได้ สำหรับฟังก์ชั่นที่เรียกว่าพิมพ์ชื่อ
แต่สำหรับรับ String, Get Float, และอื่น ๆ น้อย
และมีต้นแบบที่คล้ายกัน หนึ่งสมุทรภายในของ IO.h มาตรฐาน
สำหรับ printf ซึ่งขณะนี้อยู่ใน ฟังก์ชั่นของตัวเองพิมพ์ชื่อของฉัน
ดังนั้นในคำอื่น ๆ ตลอดเวลานี้เราได้ รับเพียงแค่สุ่มสี่สุ่มห้าคัดลอกและวาง
รวมถึงนี้ ได้แก่ ว่าสิ่งที่เกิดขึ้น?
เหล่านี้เป็นเพียงชนิดของเบาะแส จะเสียงดังกราวเป็นสิ่งที่ฟังก์ชั่น
จะจริงดำเนินการเพียง อื่น ๆ ในไฟล์ที่แตกต่างกัน
ที่อื่น ๆ บนระบบ
>> พิมพ์ชื่อดังนั้นเราจึงได้ดำเนินการ
มันจะมีผลข้างเคียงนี้ พิมพ์บางสิ่งบางอย่างบนหน้าจอ
แต่มันไม่จริง มือฉันบางสิ่งบางอย่างกลับมา
ทำอย่างไรเราจะไปเกี่ยวกับ การใช้โปรแกรมที่
ไม่มือฉันบางสิ่งบางอย่างกลับมา?
>> ดีขอลองนี้
ให้ฉันไปข้างหน้าและการดำเนินการ ไฟล์ที่เรียกว่า return.c
เพื่อให้เราสามารถแสดงให้เห็นถึงวิธีการบางอย่าง เช่นรับสตริงหรือรับ Int,
เป็นจริงกลับมา บางสิ่งบางอย่างกลับไปยังผู้ใช้
Let 's ไปข้างหน้าและกำหนด int เป็นโมฆะหลัก
>> และอีกครั้งในอนาคตเราจะ อธิบายสิ่งที่ int และถือเป็นโมฆะว่า
คือทำจริง
แต่สำหรับวันนี้เราจะ ใช้มันเพื่อรับ
ฉันจะไปข้างหน้าและ printf, เพื่อประสบการณ์การใช้งานที่ดี, X คือ
แล้วฉันจะรอ ผู้ใช้ที่จะให้ฉันได้รับ X กับ int
>> แล้วฉันจะไปข้างหน้า และพิมพ์ x เพื่อตาราง
ดังนั้นเมื่อคุณมีเพียง แป้นพิมพ์คนทั่วไป
ใช้แครอทเล็ก ๆ น้อย ๆ สัญลักษณ์บนแป้นพิมพ์
เพื่อเป็นตัวแทนของอำนาจ ของหรือตัวแทนของ
ดังนั้น x ยกกำลังสองเป็นปัจจุบันฉัน
>> และตอนนี้ฉันจะทำเช่นนี้
ฉันสามารถ do-- สิ่งที่ X ยกกำลังสอง? X Squared เป็น X X ครั้ง
>> และเราทำอย่างนี้บาง เวลาที่ผ่านมาแล้วในวันนี้
นี้ไม่ได้รู้สึกเหมือน ทุกสิ่งที่คืบหน้ามาก
คุณรู้ไหมว่า?
ลองใช้ประโยชน์จากบางส่วนของความคิดที่ว่า จากครั้งสุดท้ายของนามธรรม
>> มันจะไม่ดีถ้า มีฟังก์ชั่นที่เรียกว่า
ตารางที่ไม่ตรงกับที่?
มันก็ยังคงที่ส่วนท้ายของ วันไม่คณิตศาสตร์เดียวกัน
แต่ขอเป็นนามธรรม ออกไปความคิดของการ
จำนวนหนึ่งคูณด้วย อื่นและเพียงแค่ให้มันชื่อ
เช่นตารางค่านี้
>> และในคำอื่น ๆ C, ขอสร้างฟังก์ชั่น
เรียกว่าตารางที่ไม่ตรงกับที่
มันจะถูกเรียกว่าตาราง
มันเป็นไปได้ที่จะใช้เป็น int
และเราจะจะเพียง เรียกว่า n โดยค่าเริ่มต้น
>> แต่เราสามารถเรียกมันว่าอะไรที่เราต้องการ
และสิ่งที่มันเป็นไป ทำอย่างแท้จริงคือการกลับไป
ผลครั้งที่ n n
แต่เพราะมันเป็น บางสิ่งบางอย่างกลับมาซึ่ง
คำหลักคือสีม่วงเราได้ ไม่เคยเห็นมาก่อนผมในบรรทัดที่ 11
ไม่สามารถเพียงแค่บอกว่าเวลานี้เป็นโมฆะ
>> เป็นโมฆะในตัวอย่างที่เราเพิ่งเห็น แทนการพิมพ์ชื่อเพียงหมายความว่า
ทำอะไรสักอย่าง.
แต่ไม่ได้มือฉันบางสิ่งบางอย่างกลับมา
ในกรณีนี้ผมไม่ต้องการ เพื่อกลับ n N ครั้ง
หรืออะไรก็ตามที่เป็นตัวเลขที่
>> ดังนั้นผมจึงไม่สามารถพูดได้, Hey, คอมพิวเตอร์, เราจะกลับมาไม่มีอะไรเป็นโมฆะ
มันจะกลับมาโดยธรรมชาติเป็น int
และเพื่อให้เป็นสิ่งที่เกิดขึ้นที่นี่
>> การป้อนข้อมูลตาราง เป็นไปได้เป็น int
และเพื่อให้เราสามารถใช้มันก็มีการ มีชื่อเอ็นมันจะเอาท์พุท
เป็น int ที่ไม่จำเป็นต้องชื่อ
เราสามารถที่จะปล่อยให้มันเป็นหลักหรือใครก็ตามที่อยู่ ใช้ผมจะจำค่านี้ถ้าเรา
ต้องการกับตัวแปรของตัวเอง
>> และอีกครั้งใหม่เท่านั้น คำหลักที่นี่คือการกลับไป
และฉันแค่ทำคณิตศาสตร์บาง
ถ้าผมอยากจะเป็นที่ไม่จำเป็น ผมอาจจะบอกว่าสินค้าที่ได้รับครั้ง int n n
>> และจากนั้นผมอาจจะบอกว่าผลิตภัณฑ์กลับ
แต่อีกครั้งไปยังจุดของฉันก่อนหน้านี้ เพียงแค่นี้ไม่เป็น design-- ดี
เช่นทำไมแนะนำชื่อ สัญลักษณ์เช่นผลิตภัณฑ์
เพียงเพื่อให้ทันทีกลับได้หรือไม่
มันทำความสะอาดเล็ก ๆ น้อย ๆ เล็ก ๆ น้อย ๆ ที่เข้มงวดมากขึ้นเพื่อให้
จะพูดเพียงเพื่อบอกว่าการกลับมาครั้ง n N, ได้รับการกำจัดของสายนี้โดยสิ้นเชิง
>> และมันก็เป็นรหัสเพียงน้อยที่จะอ่าน โอกาสน้อยสำหรับความผิดพลาด
และขอให้ดูว่านี้ ตอนนี้ทำงานจริง
ตอนนี้ฉันจะไป ข้างหน้าและให้ผลตอบแทน
>> อ๊ะประกาศโดยนัยของฟังก์ชั่น
ฉันทำผิดพลาดนี้ก่อนที่จะไม่มีเรื่องใหญ่
ผมขอเพียงแค่พิมพ์หรือเน้นและ คัดลอกแน่นอนฟังก์ชั่นต้นแบบเดียวกัน
หรือลายเซ็นของฟังก์ชั่นได้ที่นี่
หรือฉันจะย้ายทั้งฟังก์ชั่น
>> แต่ที่ขี้เกียจเล็กน้อย
ดังนั้นเราจะไม่ทำอย่างนั้น
ตอนนี้ให้ฉันทำให้ผลตอบแทน อีกครั้งกลับมาเฉือนจุด
>> X คือ 2 x ยกกำลัง 4 X คือ 3 x ยกกำลัง 9
และฟังก์ชั่นที่ดูเหมือนว่า ตอนนี้ที่จะได้ทำงาน
ดังนั้นสิ่งที่แตกต่างกันที่นี่?
ฉันมีฟังก์ชั่นที่เรียกว่าสี่เหลี่ยม ในกรณีนี้ซึ่งผมใส่ในการป้อนข้อมูล
และผมได้รับกลับมาส่งออก
และยังก่อนหน้านี้ถ้า ฉันเปิดตัวอย่างอื่น ๆ
จากก่อนหน้านี้ที่ ถูกเรียก prototype.c,
ผมมีชื่อพิมพ์ซึ่ง กลับเป็นโมฆะเพื่อที่จะพูด
หรือมันกลับไม่มีอะไรและ ก็มีผลข้างเคียง
>> ดังนั้นสิ่งที่เกิดขึ้นที่นี่?
ดีพิจารณาฟังก์ชัน ได้รับสตริงเพื่อรอสักครู่
เราได้ใช้ฟังก์ชั่น ได้รับสตริงในลักษณะดังต่อไปนี้
>> ที่เราเคยมีฟังก์ชั่นได้รับ สตริงเช่น ได้แก่ CS50.h,
รวมถึงมาตรฐาน IO.h, int หลักเป็นโมฆะ
แล้วทุกครั้งที่ผมได้ เรียกว่าสตริงป่านนี้
ฉันได้กล่าวว่าสิ่งที่ต้องการสตริง ได้รับได้รับสายเพราะได้รับ string--
ขอเรียกสตริงได้รับนี้ get.c-- ตัวเองกลับสตริงที่ฉันสามารถแล้ว
การใช้งานและพูดว่าสวัสดีจุลภาค ร้อยละ S, ทับขวา n, s
>> ดังนั้นนี่คือตัวอย่างเช่นเดียวกัน จริงๆที่เรามีก่อนหน้านี้
เพื่อให้ได้รับสตริงส่งกลับค่า
แต่ช่วงเวลาที่ผ่านมาสายการพิมพ์ ไม่คืนค่า
มันก็มีผลข้างเคียง
ดังนั้นนี่คือความแตกต่างพื้นฐาน
เราได้เห็นที่แตกต่างกัน ประเภทฟังก์ชั่นในขณะนี้
ซึ่งบางส่วนได้กลับมา ค่านิยมบางอย่างที่ทำไม่ได้
ดังนั้นอาจจะเป็นสตริงหรือ int หรือลอย
หรืออาจจะเป็นเพียงความว่างเปล่า
>> และความแตกต่างคือ ที่ฟังก์ชั่นเหล่านี้ที่
ได้รับข้อมูลและคืนค่าเป็นจริง นำบางสิ่งบางอย่างกลับไปที่โต๊ะ
เพื่อที่จะพูด
ดังนั้นขอให้ไปข้างหน้าและ มองไปที่ชุดสุดท้ายหนึ่ง
ตัวอย่างที่ให้ความรู้สึกตอนนี้ วิธีที่เราอาจแน่นอนนามธรรมที่ดีกว่า
และดีกว่าและดีกว่าหรือมากกว่า และมากขึ้นและมากขึ้นในการสั่งซื้อ
ที่จะเขียนในที่สุดรหัสที่ดีกว่า
Let 's ไปข้างหน้าและในจิตวิญญาณ รอยขีดข่วนทำต่อไปนี้
>> ให้ฉันไปข้างหน้าและรวมถึง CS50.h และมาตรฐาน IO.h.
ให้ฉันไปข้างหน้าและให้ ตัวเองเป็น int หลักเป็นโมฆะ
และแจ้งให้เราไปข้างหน้าโทร cough.c นี้
>> และแจ้งให้เราไปข้างหน้าและเพียง เช่นรอยขีดข่วนพิมพ์ออกไอ / n
และฉันต้องการที่จะทำเช่นนี้สามครั้ง
ดังนั้นฉันแน่นอนแค่ไป คัดลอกและวางสามครั้ง
ตอนนี้ผมกำลังจะทำ ไอดอทเฉือนไอ
ขอให้ตัวเองเป็นห้องเล็ก ๆ น้อย ๆ นี่ใส่ไอไอ, ไอ
>> นอกจากนี้เห็นได้ชัดแล้ว โอกาสในการปรับปรุง
ผมได้คัดลอกและวาง ไม่กี่ครั้งในวันนี้
แต่นั่นก็เป็นเพียงดังนั้นฉันไม่ได้ ต้องพิมพ์ตัวอักษรเป็นจำนวนมาก
ฉันยังคงมีการเปลี่ยนแปลงสิ่งที่ เส้นที่มีรหัส
>> ทั้งสามเส้นเหมือนกัน ที่รู้สึกขี้เกียจและแน่นอนมี
และอาจจะไม่ได้เป็นวิธีการที่เหมาะสม
ดังนั้นกับสิ่งที่ส่วนผสม เราสามารถปรับปรุงรหัสนี้หรือไม่?
เราไม่ได้มีการคัดลอกและวางโค้ด
>> และแน่นอนทุกครั้งที่คุณรู้สึก ด้วยตัวคุณเองคัดลอกและวาง,
และไม่ได้เปลี่ยนรหัส อัตราต่อรองจะมีวิธีที่ดีกว่า
และแน่นอนมี
ให้ฉันไปข้างหน้าและทำห่วง แม้ว่าไวยากรณ์อาจจะไม่
มาตามธรรมชาติเลย
>> ทำเช่นนี้สามครั้งเพียงแค่ โดยการทำ following--
และผมก็เพิ่งรู้เรื่องนี้จากการปฏิบัติ
แต่เรามีจำนวนตัวอย่างในขณะนี้
และคุณจะเห็นออนไลน์ ยังคงอ้างอิงเพิ่มเติม
>> นี่คือไวยากรณ์ในบรรทัดที่ 6 ที่ เหมือนรอยขีดข่วนที่ซ้ำ
บล็อกทำซ้ำสามครั้งต่อไป
มันมีมนต์ขลังเล็ก ๆ น้อย ๆ สำหรับตอนนี้
แต่นี้จะได้รับมากขึ้น และมีความคุ้นเคยมากขึ้น
>> และก็จะต้องทำซ้ำ สายแปดสามครั้ง
เพื่อที่ว่าถ้าผมรวบรวมอีกครั้งทำให้ไอ จุดเฉือนไอ, ไอ, ไอ, ไอ
มันก็ยังคงทำงานในลักษณะเดียวกัน
ดังนั้นนั่นคือทั้งหมดที่ดีและดี
แต่ที่ไม่ใจลอยมาก
>> มันเป็นเรื่องที่ถูกต้องได้อย่างสมบูรณ์แบบ
แต่มันให้ความรู้สึกเหมือนมี อาจจะมีโอกาส
เช่นเดียวกับในโลกของ รอยขีดข่วนกับชนิดของการเริ่มต้น
เพื่อเพิ่มความหมายบางอย่างที่นี่เพื่อให้ ผมไม่เพียงแค่มีบางอย่างสำหรับห่วง
และฟังก์ชั่นที่บอกว่า ไอหรือไม่ไอ
คุณรู้ไหมว่า?
ให้ฉันพยายามที่จะเป็น เย็นน้อยกว่านั้น
และที่จริงเขียนฟังก์ชั่นที่ มีผลข้างเคียงบางอย่างเรียกว่าไอ
>> และจะใช้เวลาไม่มีการป้อนข้อมูลและ ไม่มีการคืนค่าเป็นผลผลิต
แต่คุณรู้ว่าสิ่งที่มันไม่?
มันไม่ printf this--, อ้างนำมาอ้างไอ
>> และตอนนี้ขึ้นที่นี่ฉันจะ ไปข้างหน้าและสำหรับ int,
ฉันได้รับเป็นศูนย์ผมน้อยกว่า 3 ผมบวกบวก
ฉันจะไม่ทำ printf ซึ่งเป็น เนื้อหาการดำเนินงานในระดับต่ำ
รายละเอียด
ฉันไม่สนใจวิธีการไอ
ผมแค่อยากจะใช้ฟังก์ชั่นไอ
และฉันแค่จะเรียกอาการไอ
>> ตอนนี้ทราบขั้ว
เมื่อคุณเรียกใช้ฟังก์ชันถ้าคุณทำไม่ได้ ต้องการที่จะให้มันปัจจัยการผลิตทั้งหมดที่ดี
เพียงแค่ทำวงเล็บเปิดปิด วงเล็บและคุณทำเสร็จแล้ว
>> เมื่อคุณกำหนดฟังก์ชั่นหรือ ประกาศต้นแบบฟังก์ชั่นของการ
ถ้าคุณรู้ล่วงหน้าก็ไม่ได้ จะใช้ข้อโต้แย้งใด ๆ
บอกว่าเป็นโมฆะในวงเล็บนั้นไม่มี
และที่ทำให้แน่ใจว่าคุณ จะไม่ได้ตั้งใจมันในทางที่ผิด
ให้ฉันไปข้างหน้าและทำให้ไอ
และแน่นอนผมเคยทำผิดพลาด
>> บ้ามีว่า ประกาศโดยปริยาย
แต่ที่ดี
มันแก้ไขได้ง่าย
ฉันเพียงแค่ต้องต้นแบบที่สูงขึ้น ในแฟ้มของฉันกว่าฉันจริงใช้มัน
>> ดังนั้นตอนนี้ให้ฉันให้ไออีกครั้งดี
ตอนนี้ก็ทำงาน
ทำให้ไอ, ไอ, ไอ, ไอ
ดังนั้นคุณอาจจะคิดว่าเรากำลังจริงๆ เพียงวิศวกรรมปัญหานี้
และแน่นอนเรามี
นี้ไม่ได้เป็นสิ่งที่ดี ผู้สมัครของโปรแกรม
ในขณะที่สำหรับ refactoring และทำในสิ่งที่เป็น
เรียกว่าการสลายตัวตามลำดับชั้น ที่คุณใช้โค้ดบางส่วนแล้ว
คุณชนิดของปัจจัยสิ่งที่ออกเพื่อให้เป็น ให้เหตุผลความหมายมากขึ้นกับพวกเขา
และนำมาใช้มันในระยะท้ายที่สุดอีกต่อไป
แต่มันเป็นกลุ่มอาคารที่มีต่อ โปรแกรมที่มีความซับซ้อนมากขึ้น
ว่าเราจะเริ่มต้น เขียนก่อนนานแล้วว่า
ช่วยให้เรามีคำศัพท์ ด้วยซึ่งในการเขียนโค้ดที่ดีกว่า
และแน่นอนเราจะมาดูว่าเรา ไม่สามารถพูดคุยต่อไปนี้
>> ดูเหมือนว่าง่อยเล็ก ๆ น้อย ๆ ที่ผมหลัก จำเป็นต้องกังวลเกี่ยวสาปนี้ได้ห่วง
และเรียกไออีกครั้งและอีกครั้ง
ทำไมฉันไม่สามารถเพียงแค่บอกไอ กรุณาไอสามครั้ง
ในคำอื่น ๆ ทำไมฉันไม่สามารถเพียงแค่ ให้เข้ากับไอและทำเช่นนี้?
>> ทำไมฉันไม่สามารถเพียงแค่พูดใน ไอหลักสามครั้ง
และตอนนี้เป็นชนิดที่มีมนต์ขลังของ
มันซ้ำแล้วซ้ำอีกมากที่นี่
และมันก็เป็นจริงขั้นตอนทารก
>> แต่ความสามารถในการพูด สายแปดไอสามครั้ง
มันเป็นเพียงเพื่อให้สามารถอ่านได้มากขึ้น
และบวกกับผมไม่ต้องรู้ว่า หรือวิธีการดูแลที่ไอจะดำเนินการ
และแน่นอนในภายหลัง ระยะและโครงการสุดท้าย
ถ้าคุณรับมือกับโครงการที่มี เพื่อนร่วมชั้นหรือสองเพื่อนร่วมชั้น
คุณจะรู้ว่าคุณกำลังจะไป ต้องหรือต้องการที่จะแบ่งการทำงาน
>> และคุณจะต้องการที่จะตัดสินใจ ล่วงหน้าว่าใครจะทำอะไร
และในชิ้น?
และมันจะไม่ดี ถ้าคุณตัวอย่างเช่น
ใช้ค่าใช้จ่ายของการเขียนหลักทำ
และเพื่อนร่วมห้องของคุณหรือของคุณ พันธมิตรมากกว่าปกติ
ดูแลการดำเนินการไอ
>> และกองนี้เหล่านี้ ผนังของนามธรรม
หรือชั้นของนามธรรมถ้า คุณจะมีพลังซุปเปอร์
เพราะโดยเฉพาะอย่างยิ่งที่มีขนาดใหญ่ โปรแกรมที่ซับซ้อนมากขึ้นและระบบ
มันจะช่วยให้คนหลายคนที่จะสร้าง สิ่งที่ร่วมกันและในที่สุด
ตะเข็บทำงานของพวกเขาร่วมกันในลักษณะนี้
แต่แน่นอนเรา จำเป็นที่จะต้องแก้ไขในขณะนี้ไอ
เราจำเป็นต้องบอกไอ ว่าเดี๋ยวก่อนคุณรู้อะไรไหม
คุณจะต้องใช้เวลา input-- จึงไม่เป็นโมฆะ แต่ int และตอนนี้
Let 's ไปข้างหน้าและใส่ลงไปใน ไอนั้น int ฉันได้รับเป็นศูนย์
>> ฉันมีค่าน้อยกว่ากี่ครั้ง
ผมบอกว่าสามก่อน
แต่นั่นไม่ใช่สิ่งที่ฉันต้องการ
ฉันต้องการที่จะได้รับไอทั่วไปเพื่อ สนับสนุนจำนวนซ้ำใด ๆ
>> ดังนั้นแน่นอนมันเป็น n ที่ฉันต้องการ สิ่งที่ผู้ใช้บอกฉัน
ตอนนี้ผมสามารถไปข้างหน้าและพูดว่าไอพิมพ์
และไม่ว่าสิ่งจำนวน ผู้ใช้ผ่านใน
ผมจะย้ำว่าหลายครั้ง
>> ดังนั้นในตอนท้ายของวัน โปรแกรมเป็นเหมือนกัน
แต่สังเกตเห็นทั้งหมดของสิ่งนี้ แม้อาจจะอยู่ในแฟ้มอื่น
อันที่จริงผมไม่ทราบว่าที่ ขณะที่วิธีการที่จะดำเนินการ printf
>> ผมไม่ทราบว่าในขณะที่วิธีการที่จะได้รับ สตริงหรือได้รับ int หรือได้รับลอย
จะดำเนินการ
และผมไม่ต้องการที่จะ เห็นพวกเขาในหน้าจอของฉัน
มันเป็นฉันเริ่มที่จะมุ่งเน้นไปที่ โปรแกรมของฉันไม่ได้ฟังก์ชั่นเหล่านั้น
>> ดังนั้นแน่นอนทันทีที่คุณ เริ่มต้นรหัสเช่นนี้แฟออก
เรายังสามารถย้ายไอ เป็นไฟล์แยกกันได้อย่างไร
คนอื่นอาจจะใช้มัน
และคุณและโปรแกรมของคุณกลายเป็น สวยงามมากและสามารถอ่านได้มาก
เนื้อหาจริงๆสี่ โปรแกรมบรรทัดที่นั่น
>> ดังนั้นขอให้ไปข้างหน้าในขณะนี้ และทำให้หนึ่งในการเปลี่ยนแปลงมากขึ้น
ขอให้สังเกตว่าต้นแบบของฉัน มีการเปลี่ยนแปลงขึ้นด้านบน
ดังนั้นขอให้ฉันแก้ไขปัญหาที่ทำให้ ฉันไม่ได้รับการตะโกนใส่
>> ทำให้ไอให้ฉันทำงานไอครั้งเดียว อื่น ๆ อีกมากมายที่ยังคงทำในสิ่งเดียวกัน
แต่ตอนนี้ทราบเรามี ส่วนผสมสำหรับรุ่นสุดท้าย
คุณรู้ไหมว่า?
ฉันไม่ได้ต้องการเพียงแค่ไอจำเป็นต้อง
ฉันต้องการจะมีบางสิ่งบางอย่างที่กว้างขึ้น
เพื่อให้คุณรู้อะไรไหม
ผมต้องการที่จะทำเช่นนี้
ฉันต้องการจะมีมากเช่นรอยขีดข่วน ไม่บล็อกพูด แต่ไม่ได้เป็นเพียง
พูดอะไรบางอย่างจำนวนครั้งบาง
ฉันต้องการที่จะพูดสตริงที่เฉพาะเจาะจงมาก
และดังนั้นฉันทำไม่ได้ ต้องการให้เพียงแค่พูดว่าไอ
ฉันต้องการที่จะพูดอะไรก็ตาม สตริงจะถูกส่งใน
>> ดังนั้นสังเกตเห็นฉันได้ทั่วไป นี้เพื่อให้ในขณะนี้
พูดความรู้สึกเหมือนเป็นชื่อที่ดี สำหรับเรื่องนี้เหมือนเกา
ใช้เวลาสองขัดแย้งแตกต่างจากรอยขีดข่วน
หนึ่งคือสตริง
หนึ่งคือเป็น int
>> และฉันจะเปลี่ยนพวกเขา
ฉันเพียงแค่ชนิดเช่นความคิดของ พูดสตริงแรกแล้ว
กี่ครั้งในภายหลัง
เป็นโมฆะหมายความว่ามันยังคง ไม่เกิดสิ่งใด
เหล่านี้เป็นเพียงภาพด้านข้าง ผลกระทบเช่นเดียวกับ [? จอร์แดน?]
ผลข้างเคียงทางวาจาตะโกน
ก็ยังไม่เท่าสิ่งที่ N, 0 ถึง แต่ไม่เท่ากับ n
ซึ่งหมายความ N ครั้งรวม
แล้วก็พิมพ์ออกมา สิ่งที่เป็นสตริง
ดังนั้นผมจึงได้ทั่วไปจริงๆ บรรทัดของรหัสนี้
ดังนั้นตอนนี้ฉันจะดำเนินการ ฟังก์ชั่นไอ?
>> ฉันจะทำไอโมฆะ
และฉันยังคงสามารถใช้ในวิธีการ หลายครั้งคุณต้องการที่จะมีอาการไอ
แต่คุณรู้อะไรไหม
ตอนนี้ผมสามารถที่จะพูดถ่อ
>> ฉันจะโทรบอกด้วย ไอคำผ่านใน n
และถ้าผมต้องการที่จะยังใช้ เพียงเพื่อความสนุกสนานฟังก์ชั่นจาม
ฉันสามารถจามจำนวนครั้งบาง
และฉันสามารถให้การนำ n เพราะ ทราบเมตรในบริบทนี้หรือขอบเขตที่
มีอยู่เพียงภายในฟังก์ชั่นนี้
>> n และในบริบทนี้เท่านั้น มีอยู่ในฟังก์ชั่นนี้ได้ที่นี่
ดังนั้นเราจะกลับไปมา ปัญหาเหล​​่านี้ของขอบเขต
และที่นี่ฉันแค่ไปที่จะพูดว่า Achoo แล้วครั้ง N กึ่งลำไส้ใหญ่
>> และตอนนี้ผมก็ต้องไปขอยืม ฟังก์ชั่นเหล่านี้ลายเซ็นขึ้นที่นี่
ดังนั้นไอถูกต้อง
จามโมฆะถูกต้องในขณะนี้
>> และฉันยังคงเพียงแค่ต้องบอกว่า
ดังนั้นฉันจะบอกว่าการพูด สตริง S, int n กึ่งลำไส้ใหญ่
ดังนั้นผมจึงได้มากกว่าวิศวกรรม ห่าออกจากโปรแกรมนี้
>> และนี้ไม่ได้ หมายความว่านี้ก็คือ
สิ่งที่คุณควรทำเมื่อเขียน แม้ที่ง่ายที่สุดของโปรแกรม
นำสิ่งที่เห็นได้ชัด ง่ายจริงๆสั้นจริงๆ
และอีกครั้งที่จะใช้มัน ใช้รหัสวิธีที่มากเกินไป
แต่คุณจะเห็นจริงและใน เวลามองย้อนกลับไปในตัวอย่างเหล่านี้
และตระหนักถึงโอ้เหล่านี้เป็นขั้นตอน เราเอาไปคุยจริง
เพื่อสะท้อนอะไรบางอย่างออกมา จนกระทั่งในตอนท้ายของวัน
รหัสของฉันเป็นจริงเหมาะสมสวย
เพราะถ้าผมต้องการที่จะไอสาม ครั้งแล้วจามสามครั้ง
ฉันก็จะไปวิ่งนี้ โปรแกรมทำให้ไอและเรียกใช้ไอ
และฉันมีสามอาการไอ และสามจาม
>> และเพื่อให้เป็นพื้นฐาน กระบวนทัศน์ถ้าคุณจะ
สำหรับวิธีการที่เราอาจจะไปเกี่ยวกับ การดำเนินการจริงโปรแกรม
แต่ขอเพียงแค่เห็นในขณะนี้ว่ามันคืออะไร เราได้รับการทำทั้งหมดเวลานี้
และสิ่งที่บางชิ้นสุดท้าย อยู่เบื้องหลังคำสั่งง่ายๆนี้
ในตอนท้ายของวันที่เราได้ รับการใช้เสียงดังกราวเป็นคอมไพเลอร์ของเรา
เราได้รับการเขียนแหล่งที่มา รหัสแปลง
ผ่านเสียงดังกราวเป็นรหัสเครื่อง
>> และเราได้รับใช้ให้เพียง เพื่ออำนวยความสะดวกการกดแป้นพิมพ์ของเราเพื่อให้
ที่เราไม่ต้องจำ คาถาเหล่านั้นของตัวเองเสียงดังกราว
แต่สิ่งที่ทำให้ทำจริง?
และในทางกลับกันสิ่งที่เป็น เสียงดังกราวทำจริง?
>> มันจะเปิดออกแม้ว่าเราได้ง่าย การอภิปรายในวันนี้โดยกล่าวว่า
คุณใช้รหัสที่มาผ่านเป็น เข้ากับคอมไพเลอร์ที่ช่วยให้คุณ
การส่งออกของเครื่อง รหัสเปิดออกมีของ
ขั้นตอนที่แตกต่างกันไม่กี่ภายในมี
และรวบรวมเกิดขึ้นเป็นร่ม ระยะสำหรับทั้งกลุ่มของขั้นตอน
แต่ขอเพียงแค่หยอกล้อ นี้ออกมาได้อย่างรวดเร็วจริงๆ
>> แต่กลับกลายเป็นว่าเราได้รับการทำ สิ่งที่มากขึ้นทุกครั้งที่ผมรันโปรแกรม
หรือทุกครั้งที่ผมรวบรวมโปรแกรมวันนี้
ดังนั้น preprocessing หมายถึง this-- อะไรในโปรแกรม C,
ในขณะที่เราจะเห็นอีกครั้งและอีกครั้ง ที่เริ่มต้นด้วยสัญลักษณ์กัญชานี้
หรือสัญลักษณ์ hashtag ที่นี่หมายถึง มันเป็นคำสั่ง preprocessor
นั่นหมายความว่าในกรณีนี้เดี๋ยวก่อน คอมพิวเตอร์ทำอะไรกับไฟล์นี้
ก่อนที่จะรวบรวมรหัสของตัวเอง
>> ในกรณีนี้รวมถึงกัญชามี หลักวิธีการของซีว่า
เฮ้คอมพิวเตอร์ไปได้รับเนื้อหา ของ CS50.h และวางพวกเขาที่นี่
เฮ้คอมพิวเตอร์ให้ไปรับ เนื้อหาของมาตรฐาน IO.h,
ที่ใดก็ตามที่อยู่บน ฮาร์ดไดรฟ์วางไว้ที่นี่
ดังนั้นสิ่งเหล่านั้นเกิดขึ้น ครั้งแรกในช่วง preprocessing
>> และเสียงดังกราวไม่ทั้งหมดนี้สำหรับเรา
และมันไม่ได้ดังนั้นยี้ ได้อย่างรวดเร็วคุณทำไม่ได้
เห็นสี่สิ่งที่แตกต่างที่เกิดขึ้น
แต่นั่นเป็นขั้นตอนดังกล่าวครั้งแรก
>> สิ่งที่เกิดขึ้นจริงต่อไปหรือไม่
ดีอย่างเป็นทางการต่อไป ขั้นตอนการรวบรวม
และปรากฎว่า คอมไพล์โปรแกรม
ในทางเทคนิคหมายถึงไปจาก รหัสที่มาของสิ่งที่เราได้
รับการเขียนวันนี้เพื่ออะไร เรียกว่ารหัสการชุมนุมบางสิ่งบางอย่าง
ที่มีลักษณะแตกต่างกันเล็กน้อย
>> และในความเป็นจริงเราสามารถมองเห็นได้อย่างรวดเร็วจริง
ให้ฉันจริงไปเป็น IDE ของฉัน
ให้ฉันไปข้างหน้าและเปิด hello.c ซึ่ง เป็นโปรแกรมแรกมากกับการที่เรา
เริ่มวันนี้
และแจ้งให้เราไปข้างหน้าและเรียกเสียงดังกราว แตกต่างกันเล็กน้อยเสียงดังกราว-S hello.c,
ซึ่งเป็นจริงไป ให้ฉัน hello.s ไฟล์อื่น
>> และเราอาจจะไม่เคย อีกครั้งดูชนิดของรหัสนี้
ถ้าคุณใช้เวลาในระดับที่ต่ำ ระดับระบบเช่น CS61,
คุณจะเห็นมากขึ้น ของชนิดของรหัสนี้
แต่นี้เป็นภาษาประกอบ
นี่คือ X86 ภาษาประกอบ ว่าซีพียูที่มีพื้นฐาน
IDE CS50 จริงเข้าใจ
>> และความลับมันไม่ ดูมันเป็นบางสิ่งบางอย่าง
คอมพิวเตอร์เข้าใจสวยดี
Sub Q นี้เป็นลบ
มีการเคลื่อนไหวเป็น
>> มีการเรียกฟังก์ชั่นที่นี่ X oring, การเคลื่อนไหว, การเพิ่ม, ป๊อป,
ผลตอบแทน
ดังนั้นจึงมีบางมาก คำแนะนำในระดับต่ำ
ที่ซีพียูเข้าใจว่า ฉันพูดพาดพิงถึงก่อนหน้านี้
นั่นคือสิ่งที่ Intel Inside
>> มีรูปแบบของการเป็น ศูนย์และคนที่
แผนที่เหล่านี้คำ arcanely แต่ ค่อนข้างดีชื่อคำแนะนำ
เพื่อที่จะพูด
นั่นคือสิ่งที่เกิดขึ้นเมื่อ คุณรวบรวมรหัสของคุณ
คุณจะได้รับการชุมนุม ภาษาออกมาจากมันซึ่ง
หมายถึงขั้นตอนที่สามคือการรวบรวม รหัสการชุมนุมที่เป็นที่สุด
เครื่องศูนย์ code-- และคนที่ไม่ได้ ข้อความที่เราเพิ่งเห็นสักครู่ที่ผ่านมา
>> ดังนั้นก่อนการประมวลผลที่ไม่พบ และแทนที่และสิ่งอื่น ๆ น้อย
รวบรวมใช้เวลาแหล่งที่มาของ รหัส C จากซอร์สโค้ด
ที่เราเขียนในการชุมนุม รหัสที่เราเพียงแค่เหลือบมองไปที่
ประกอบใช้เวลาการชุมนุมว่า รหัสเลขศูนย์และคน
ที่ซีพียูจริงๆจะ เข้าใจในตอนท้ายของวัน
และการเชื่อมโยงเป็นขั้นตอนสุดท้าย ที่เกิดขึ้นสำหรับ us-- อีกครั้ง
ได้อย่างรวดเร็วเพื่อให้เราไม่ได้ notice-- ที่บอกว่า
เฮ้คอมพิวเตอร์ใช้เวลาทั้งหมดของ เลขศูนย์และคนที่
เป็นผลมาจากการรวบรวมรหัสของดาวิด และฟังก์ชั่นหลักของเขาในกรณีนี้
>> และ hey คอมพิวเตอร์ไปได้รับ ทั้งหมดของศูนย์และคน
ว่าพนักงาน CS50 เขียน ภายในห้องสมุด CS50
ผสมกับผู้ที่อยู่ในของดาวิด
และ hey คอมพิวเตอร์ไปได้รับศูนย์ทั้งหมด และคนที่คนอื่นเขียนปี
ที่ผ่านมาสำหรับ printf
และเพิ่มผู้เข้ามา สิ่งที่ทั้งเพื่อให้เราได้
มีศูนย์และคนของฉัน ศูนย์พนักงาน CS50 และคน
เลขศูนย์ printf และคน และสิ่งอื่น ๆ ที่เรากำลังใช้
>> พวกเขาทั้งหมดได้รับการรวมกันเป็นหนึ่ง โปรแกรมที่เรียกว่าในกรณีนี้สวัสดี
ดังนั้นต่อจากนี้ไปเราจะเป็นเพียงแค่ ใช้คำว่าการรวบรวม
และเราจะใช้สำหรับการรับว่าเมื่อ เราบอกว่ารวบรวมโปรแกรมของคุณมันหมายถึง
เฮ้ทำก่อนการประมวลผล การประกอบและการเชื่อมโยง
แต่มีบางสิ่งที่จริงฉ่ำ ที่เกิดขึ้นมีอยู่ภายใต้ฝากระโปรง
และโดยเฉพาะอย่างยิ่งถ้าคุณ ได้รับความอยากรู้อยากเห็นบางครั้ง
คุณสามารถเริ่มต้นการพูดล้อ รอบในระดับที่ต่ำกว่านี้
แต่ตอนนี้ทราบว่า ในหมู่คบสำหรับวันนี้
ค่อนข้างเพียง จุดเริ่มต้นของกระบวนการ
ในการได้รับความสะดวกสบายด้วย บางสิ่งบางอย่างเหมือนโลกสวัสดี
อันที่จริงส่วนใหญ่ของสิ่งที่เราทำในวันนี้ แน่นอนจะไม่จมอยู่ใน Super Fast
และมันจะใช้เวลาบางส่วน เวลาและการปฏิบัติบาง
และราคาที่คุณจะเรียงลำดับ ของต้องการที่จะตีแป้นพิมพ์ของคุณ
หรือตะโกนใส่หน้าจอ
และทั้งหมดที่ตกลง
แม้ว่าอาจจะพยายามที่จะไม่ ทำมันในห้องสมุดมาก
>> และในที่สุดคุณจะ สามารถแม้ว่าจะเริ่มต้น
เห็นรูปแบบทั้งในรหัสที่ดี ที่คุณเขียนและในความผิดพลาด
ที่คุณทำ
และเหมือนกระบวนการของ กลายเป็น TF หรือ CA เป็นเหมือน
คุณจะเริ่มต้นที่จะได้รับที่ดีขึ้นและ ดีกว่าที่เห็นรูปเหล่านั้น
และเพียงแค่การแก้ของคุณ ปัญหาของตัวเองในที่สุด
ในขณะเดียวกันจะมีปริมาณมาก ของเราที่จะให้ยืมคุณสนับสนุนและให้คุณได้รับ
ผ่านทางนี้
และในการเขียนอัพ สำหรับทุกปัญหาที่เกิดขึ้น
คุณจะได้รับคำแนะนำผ่าน ทุกคำสั่ง
ที่แน่นอนฉันรู้จาก จำนวนมากของการปฏิบัติโดยขณะนี้
แต่อาจจะมีการบิน เหนือหัวของคนสำหรับในตอนนี้
และที่ดีทั้งหมด
>> แต่ในท้ายที่สุดคุณจะ เริ่มต้นที่จะเห็นรูปแบบโผล่ออกมา
และเมื่อคุณได้รับในอดีตทั้งหมดของ รายละเอียดโง่เหมือนวงเล็บ
และวงเล็บปีกกาและกึ่งทวิภาค, และสิ่งที่ตรงไปตรงมา
ที่ไม่ได้เลย ที่น่าสนใจทางสติปัญญา
และมันก็ไม่ใช่วัตถุประสงค์ของ การเรียนเบื้องต้นใด ๆ
มันเป็นความคิดที่จะไปสำคัญ
>> มันเป็นลูปและ เงื่อนไขและฟังก์ชั่นที่
และอื่น ๆ ที่มีประสิทธิภาพนามธรรม, และแฟของรหัส
และการออกแบบที่ดีและคนดี รูปแบบและในที่สุดความถูกต้อง
ของรหัสของคุณที่ในท้ายที่สุด จะสำคัญที่สุด
ดังนั้นในสัปดาห์หน้าเราจะนำเหล่านี้ ความคิดที่เราเห็นครั้งแรกในรอยขีดข่วน
และในขณะนี้มีการแปล ซีและเราจะเริ่มต้น
ที่จะแนะนำเป็นครั้งแรกของ หลักสูตรโดเมนโลกแห่งความจริง
>> เราจะมุ่งเน้นไปที่โลกของการรักษาความปลอดภัย และมากขึ้นโดยเฉพาะการเข้ารหัส
ศิลปะของข้อมูล scrambling
และในหมู่คนแรก ปัญหาคุณเอง
จะได้รับการเขียนเกิน เล่นกับบางส่วนของไวยากรณ์
และการแก้ตรรกะ ปัญหาที่เกิดขึ้นในท้ายที่สุดก่อนที่จะนาน
คือการช่วงชิงจริงหรือเข้ารหัส และท้ายที่สุดการถอดรหัสข้อมูล
และทุกอย่างที่เราเคยทำ วันนี้ค่อนข้างจะต่ำ
ระดับเป็นเพียงการไปเพื่อให้ เราจะใช้เวลาหนึ่งและหนึ่ง
และเป็นหนึ่งในขั้นตอนอื่น ๆ ดังกล่าวข้างต้นที่มีต่อ การเขียนโค้ดที่น่าสนใจที่สุดเลย
>> เพื่อให้มากขึ้นในสัปดาห์หน้าว่า
>> [เล่นวีดีโอ]
>> อะไรที่คุณสามารถบอกฉันเกี่ยวกับ ครั้งสุดท้ายที่คุณเห็นเขา?
อะไรที่ฉันสามารถพูดจริงเหรอ?
ฉันหมายความว่ามันเป็นเหมือนคนอื่น ๆ การฝึกซ้อมก่อนการผลิต
ยกเว้นมีบางอย่างที่เขากล่าวว่า ที่ปลายมากที่ติดอยู่กับฉัน
>> -This เป็น CS50
>> ใช่หรือไม่เพราะเป็นทุกคนตัด งานที่ดีในการฝึกซ้อม
>> อาหารกลางวันใช่หรือไม่เพราะหรือไม่?
>> -Yeah คุณและฉันสามารถ คว้าแซนวิชในบิต
ให้ฉันเพียงแค่สอบถามกับ เดวิดได้อย่างรวดเร็วจริงๆ
ดาวิด
>> [จบ PLAYBACK]