>> [เล่นเพลง]
JASON Hirschhorn: OK ทุกคน
ยินดีต้อนรับสู่มาตรา
นี่คือ CS50 มากของเรา ส่วนแรกสุด
ในขณะที่คุณทุกคนรู้ว่าในสัปดาห์หน้า ส่วนที่ปกติจะเริ่มต้น
แต่ในสัปดาห์นี้เราทุกคนร่วมกัน
>> มีตัวเองเป็น
ชื่อของฉันคือเจสัน
ฉันอาจารย์ในสาขาวิทยาศาสตร์คอมพิวเตอร์
เรามี Andi ที่หัวของ TA CS50
และ Scaz ศาสตราจารย์ไบรอัน Scassellati, เขาเป็นศาสตราจารย์ในสาขาวิทยาศาสตร์คอมพิวเตอร์
>> เราเป็นหัว CS50 ที่มหาวิทยาลัยเยล
คุณสามารถส่งอีเมล เรา heads@cs50.yale.edu
เราจะอยู่ที่การบรรยาย
เราจะอยู่ที่เวลาทำงาน
ถ้ามีอะไรที่เราเคยสามารถ ทำเพื่อคุณสิ่งที่คุณต้องการ
อย่าลังเลที่จะถึงออกมาให้เรา
>> ดังนั้นสิ่งที่เราจะทำในวันนี้
หรือก่อนหน้านั้นมีอะไร ขึ้นมาในสัปดาห์นี้?
ดังนั้นเวลาทำการคือวันจันทร์, วันอังคาร วันพุธและวันพฤหัสบดีที่ 8:00-11:00
มีตารางเวลาที่อยู่บนเว็บไซต์
>> ส่วนเหมือนที่ผมกล่าวถึง จะเริ่มต้นในสัปดาห์หน้า
และคุณจะพบว่าในสัปดาห์นี้สิ่งที่ ส่วนเวลาของคุณคือสิ่งที่วันที่มันเป็น
และผู้ที่เป็น TA ของคุณ
>> ปัญหาคือชุดที่ 1 ครบกำหนดเมื่อวันพฤหัสบดีเวลา เที่ยงวันศุกร์ตอนเที่ยงวันที่มีปลาย
ใช่คุณมีเก้าวันปลาย
และมีเก้าชุดปัญหา
และสามารถใช้หนึ่ง วันต่อปัญหาที่เกิดขึ้นในช่วงปลายชุด
ใช่ในผลทุกปัญหา ชุดเนื่องจากวันศุกร์เวลาเที่ยง
นั้นคือทั้งหมด.
ทั้งหมดที่มีรายละเอียดเกี่ยวกับหลักสูตร
>> ทุกวันศุกร์เรามีอาหารกลางวัน
เราต้องการที่จะให้มีขนาดใหญ่นี้ แน่นอนรู้สึกบิตขนาดเล็ก
ดังนั้นคุณยินดีที่จะตอบรับคำเชิญ
อาหารกลางวันฟรีกับเพื่อน เพื่อนร่วมชั้นและพนักงาน
cs50.yale.edu/rsvp
>> ทุกสิ่งเหล่านี้ว่า ฉันมีบนหน้าจอ
และอื่น ๆ ที่คุณสามารถหา cs50.yale.edu หรือ cs50.harvard.edu ถ้าคุณไปที่ฮาร์วาร์
และกำลังรับชมออนไลน์นี้
>> นอกจากนี้ในเว็บไซต์เหล่านั้นมี ตันของทรัพยากรสำหรับคุณ
ทุกบรรยายไม่เพียง แต่มีวิดีโอ ของการบรรยาย แต่ยังตั้งข้อสังเกต
ใครบางคนที่จะดู บรรยายและจดบันทึกสำหรับคุณ
ดังนั้นคุณก็สามารถชำระเงิน ความสนใจในระหว่างการบรรยาย
หรือคุณสามารถใช้บันทึกของพวกเขา / ของเรา ตั้งข้อสังเกตในการเสริมบันทึกของคุณเอง
>> มีภาพนิ่งออนไลน์
แหล่งที่มา code-- ทุกอย่าง เดวิดไปมากกว่าในการบรรยาย
หรือ Scaz ไปมากกว่าการบรรยายว่า รหัสที่มาพร้อมใช้งานออนไลน์
เช่นกันเหมือนที่ผมกล่าวถึงวิดีโอ
>> ส่วนเหมือนกันทั้งหมดจะถูกถ่ายทำ
ทั้งหมดของภาพนิ่งเหล่านั้นจะสามารถใช้ได้
ทั้งหมดของรหัสที่จะ มีให้สำหรับคุณ
มีกางเกงขาสั้นในเว็บไซต์ที่มี CS50 พนักงานใช้เวลาห้าถึง 10
นาทีจะผ่านหัวข้อสำหรับคุณ
บางส่วนของคนที่คุณได้อยู่แล้ว พบในชุดปัญหา
>> สำนักงานชั่วโมงที่ผมกล่าวถึงวันจันทร์ ผ่านวันพฤหัสบดี 8:00-11:00
การศึกษา CS50 เป็นทรัพยากรที่ยอดเยี่ยม
มีปัญหาการปฏิบัติที่ สไลด์ตัวอย่างข้อบกพร่องที่รู้จักกัน
ว่านักเรียนชอบที่จะวิ่งเข้ามา, สำหรับหลักทุกครั้งที่เราหัวข้อ
จะครอบคลุมในหลักสูตรนี้
>> และสุดท้ายบนสไลด์นี้ อย่างน้อย Reference50
ซึ่งจะช่วยให้ข้อมูล ในทุกฟังก์ชั่น C
คุณอาจจะเคยหวังว่าอาจจะเป็น ที่จะใช้และหลายอื่น ๆ อีกมากมาย
>> อีกครั้งที่จุดจุดจุดที่ ด้านล่างของหน้าจอ
คือการแสดงให้เห็นว่ามีแม้กระทั่ง ทรัพยากรมากขึ้นในทั้งสองเว็บไซต์:
cs50.yale.edu, cs50.harvard.edu
>> ดังนั้นสิ่งที่เราทำในวันนี้?
ดีแรกฉันจะให้ คุณมองไปที่ทรัพยากร
แล้วไม่ว่าอย่างใดอย่างหนึ่ง
มองที่พวกเรา.
>> ตอนนี้เรากำลังจะไปมากกว่า ชนิดข้อมูลและผู้ประกอบการใน C.
จากนั้นล่ะจะมาขึ้นที่นี่และ ไปกว่าห้องสมุดในซี printf ()
ฟังก์ชั่นที่คุณมีอยู่แล้ว คุ้นเคยหรือจะกลายเป็นได้อย่างรวดเร็วมาก
คุ้นเคย
และคุณยังจะไปกว่า เงื่อนไขและลูป
>> และแล้วในที่สุด Scaz จะไปกว่า CS50 ID
หากคุณไม่ได้ในนกพิราบ แล้วในปัญหาชุดที่ 1,
เช่นเดียวกับวิธีการใช้ คำสั่งมินัลและมีประโยชน์
แล้วให้คุณสาธิตและ การเข้ารหัสการปฏิบัติใน CS50 ID
>> ก่อนที่ผมจะกระโดดในนี้ เนื้อหาในด้านนี้
ไม่มีใครมีคำถามใด ๆ เพื่อให้ห่างไกล?
ที่ดี
ตกลง.
การเปลี่ยนเกียร์
>> [การเปลี่ยนเกียร์]
>> นั่นคือผมขยับ เกียร์อยู่ในรถด้วยตนเอง
ดังนั้นชนิดข้อมูลใน C คุณไม่สามารถเพียงแค่มี ตัวแปร x และมีมันจะอยู่ในบรรทัดที่ 10
จำนวนเต็มอาจจะจำนวน 1, ในบรรทัดที่ 20 เลขทศนิยม 10.5
แล้วเส้นคู่ ภายหลังสตริงฉันรัก CS50
>> ใน C ตัวแปรจะไม่สามารถ สิ่งหนึ่งและสิ่งหนึ่งเท่านั้น
และเพื่อให้คุณต้องให้พวกเขาชนิด
และคณะกรรมการนี​​้เรา มีรายชื่อของประเภท
มีตัวอักษรซึ่ง ยืนสำหรับตัวละคร
เพื่อให้เป็นหนึ่งตัวอักษร A, B, C, ดีที่ยังสามารถเป็นช่องว่าง
หรือที่ยังสามารถ ตัวอักษรบรรทัดใหม่
>> มีจำนวนเต็มซึ่งเป็นเพียง ตัวเลขทั้งเบอร์หรือจำนวนเต็ม
rather-- แต่ไม่มีทศนิยม
>> สำหรับทศนิยมเรามี จำนวนจุดลอยตัว
เป็นตัวเลขที่มีทศนิยม
>> จากนั้นก็มี longs ซึ่งเป็น จำนวนเต็มหลักอีกต่อไป
คุณจะพบว่ายาว คือ 8 ขณะที่ int คือ 4
ฉันจะไปที่ในครั้งที่สอง
นั่นเป็นเพราะ longs สามารถเก็บแม้กระทั่ง จำนวนเต็มมากกว่า int สามารถจัดเก็บ
คู่ลอยยาว
>> และในที่สุดเรามี สตริงซึ่งเป็นชนิด
ที่คุณอาจจะได้ใช้ก่อน
หากคุณรวม hashtag # includeCS50.h ในแฟ้มแหล่งที่มาของคุณ
แล้วคุณสามารถใช้ชนิดสตริง
มันไม่ได้สร้างขึ้นจริงลงในซี
>> มีชนิดอื่น ๆ คู่เช่นกัน
แต่เหล่านี้เป็นคนที่มีหลัก ที่คุณจะใช้งานและการเผชิญหน้า
C เป็นอีกครั้งที่ผมกล่าวถึง variable-- ทุกตัว
เพียง แต่สามารถเป็นหนึ่งในชนิดและประเภทหนึ่งเท่านั้น
นั่นเป็นเพราะซีเป็นแบบคงที่ ภาษาพิมพ์เมื่อเทียบ
ภาษาพิมพ์แบบไดนามิก ซึ่งถ้าคุณสร้างตัวแปร
คุณสามารถเปลี่ยนสิ่งที่เก็บไว้ใน ได้ตามที่คุณไปในในโปรแกรมของคุณ
มากกว่าที่นี่ไปทางขวา ด้านผมมีขนาดที่แตกต่างกัน
ประเภทนี้ของข้อมูลในไบต์
ดังนั้นตัวละครที่เป็น 1 ไบต์
นั่นเป็น 8 บิต
และนั่นหมายความว่าเพราะ 8 บิตมีแปด 0s และ 1s
เราเห็นการสาธิตในครั้งแรก สัปดาห์ร่วมกับหลอดไบนารีที่
>> ด้วย 8 บิตหรือ 1 ไบต์ที่เราสามารถทำได้ แสดงตัวเลข 0-255
ขวา
หากทุกอย่างเป็น 8 บิตที่ 0 0
ถ้าบิตแรกคือ 1, ที่จำนวน หนึ่งและอื่น ๆ ตลอดทางถึง 255
และที่ว่าทำไมตัวละครที่คุณสามารถ มีหลักถึง 255 ของพวกเขา
แต่นั่นคือความอุดมสมบูรณ์เพื่อให้ครอบคลุมทั้งหมด ตัวอักษรที่เราจำเป็นต้องใช้
>> สำหรับจำนวนเต็มคุณสามารถมี 0 แล้วคุณมี 2 ถึง 32 ลบ 1
เหล่านี้เป็นวิธีการที่หลายตัวเลือก คุณมีจำนวนเต็ม
>> สำหรับระยะเวลานานคุณมี 0 2 ถึง 64 ลบ 1
เพื่อให้คุณมีจำนวนมากหลาย ตัวเลือกเพิ่มเติมสำหรับ longs
>> เงื่อนไขที่เป็นเครื่องหมายคำถาม เนื่องจากว่าเป็นที่น่าตื่นเต้นสำหรับในภายหลัง
ใช่
ผมบอกได้ทุกคน บนขอบของที่นั่งของพวกเขา
เหมือนสิ่งที่เป็นเครื่องหมายคำถามที่?
มันเป็นเรื่องน่าตื่นเต้น
ในที่สุดเราจะครอบคลุมขนาดของ สายและพูดคุยเกี่ยวกับสตริง
เพราะสตริงเป็นจริง หนึ่งในล้อการฝึกอบรม
เราใส่ในในครั้งนี้ แน่นอนที่จุดเริ่มต้น
และจากนั้นจะออกในภายหลัง ในเพราะสตริงใน C
ชี้เป็นจริง เพื่ออาร์เรย์ตัวอักษร
แต่อีกครั้งที่เป็น ที่น่าตื่นเต้นในภายหลัง
ก่อนที่ผมจะย้ายไปคำถามใด ๆ แสดงความคิดเห็นความกังวลเกี่ยวกับสไลด์นี้?
>> ตกลง.
ฉันจะต้องเป็นคนอธิบายที่ยอดเยี่ยม
นอกจากนี้เมื่อคุณกำลังเขียนโปรแกรม คุณกำลังจะใช้ประกอบการเหล่านี้
สัญญาณที่ง่ายมากที่สามารถทำง่าย การดำเนินงานที่คุณอาจ
คุ้นเคยมาก
>> ยกตัวอย่างเช่นที่อยู่ด้านขวา ด้านมือเราเห็นในการเพิ่ม
ในการเพิ่มคุณเพียงแค่ทำเครื่องหมายบวก
และอื่น ๆ ที่คุณอาจมี สองตัวแปร x และ y
คุณสามารถทำเช่น x + y ที่ในรหัสของคุณ
บางทีคุณอาจต้องการ to-- ว่าคุณ มีหมายเลข 7 และ 3
คุณต้องการในการจัดเก็บที่ ในตัวแปรที่เรียกว่าผลรวม
คุณสามารถทำเช่น int สำหรับประเภทพื้นที่ ผลรวมชื่อของตัวแปรที่ = 7 + 3;
>> สิ่งที่จะร้านค้าที่อยู่ในผลรวม?
ใคร?
ถ้าฉันมีในผลรวม = 7 + 3
สิ่งที่จะถูกเก็บไว้ในผลรวม?
คุณก็สามารถตะโกนมันออก
ผู้ชม: 10
>> JASON Hirschhorn: 10!
ที่เหมาะสมว่า
สิ่งที่เกี่ยวกับในผลรวม = 7-3, ฉันเพียงแค่ใช้เครื่องหมายขีด
สิ่งที่เกิดขึ้นจะถูกเก็บไว้?
ผู้ชม: 4
JASON Hirschhorn: 4
ผลรวมอาจจะเป็นชื่อที่ผิด ตัวแปรที่ แต่ 4 จะถูกเก็บไว้
>> การคูณใน C ใช้เล็ก ๆ น้อย ๆ ตัวละครที่สตาร์, คุณไม่ได้ใช้ x
จะแบ่งให้ใช้ไปข้างหน้า ไม่ Slash สัญลักษณ์ส่วน
และเพื่อ modulo ใช้สัญลักษณ์เปอร์เซ็นต์
>> ดังนั้นขอบอกว่าผมต้องการที่จะเห็น int ซี = 7% 3 สิ่งที่จะถูกเก็บไว้ในซี?
ดังนั้นที่เป็นหลัก ขอให้สิ่งที่ไม่โมดูโลทำอย่างไร
ไม่มีใครรู้ว่าสิ่งที่โมดูโลไม่?
ใช่
y ที่ 4
ลำโพง 1: มันเป็นส่วนที่เหลือ
JASON Hirschhorn: มันเป็น ที่เหลือเมื่อคุณแบ่ง
ดังนั้น 7 โดยแบ่งออกเป็น 3 ส่วนที่เหลือคือ 2 1
ดังนั้น 1 จะถูกเก็บไว้
>> คุณไม่ได้ลบ แต่นั่นคือวิธีการทำงาน
นั่นคือสิ่งที่ผู้ประกอบการโมดูโลไม่
มันต้องใช้เวลาเป็นจำนวนมากแบ่งออกได้โดย อีกจำนวนและผลตอบแทนให้กับคุณ
ส่วนที่เหลือ
ดังนั้นอีกครั้ง 7% 3 จะช่วยให้คุณ 1 เพราะ 7 โดยแบ่งออกเป็น 3 ส่วนที่เหลือคือ 2 1,
และผลตอบแทนที่เหลือ
>> สิ่งที่เกี่ยวกับขอกลับไปขึ้น ขั้นตอนหนึ่งที่จะเข้าสู่ระบบส่วนที่
ถ้าฉันไม่ 7 / โดยแบ่งออกเป็น 3 ไม่ ใครจะรู้ว่าสิ่งที่จะกลับมา?
>> ลำโพง 2: 2
>> JASON Hirschhorn: ทำไมที่ 2 และไม่ได้ 2.333?
>> ลำโพง 2: ฉันคิดว่ามันตัด หลังจากทั้งจำนวน
JASON Hirschhorn: ดังนั้น ที่เหมาะสมว่า
ใน C ถ้าคุณทำส่วนหนึ่งของ จำนวนเต็มสองจำนวน 7 โดยแบ่งออกเป็น 3
คำตอบที่จะได้รับที่ ในกรณีนี้ 2.3333 ตลอดไป
และพบจุดทศนิยมนั้นและ สับทุกอย่างออกหลังจุดทศนิยม
และมันก็กลับ 2
>> ดังนั้นถ้าฉันไม่ 8 โดยแบ่งออกเป็น 3
ที่จริงเรารู้ ที่จะกลับ 2.666,
แต่มันสับที่ทุกอย่างออก ทศนิยมตัดทอนมันทั้งหมด
และเพียงแค่กลับไปที่คุณ 2
ดังนั้น 6 โดยแบ่งออกเป็น 3, 7 แบ่ง โดย 3, 8 หารด้วย 3
ทั้งหมดจะกลับไปที่คุณ 2
>> ไม่มีใครรู้หรือมีการคาดเดาที่ เป็นวิธีที่จริงผมอาจจะได้รับ
คำตอบที่เต็มรูปแบบถ้าผมต้องการทศนิยมที่?
ใช่
เอาเลย
ลำโพงที่ 3: ใช้ลอยหรือไม่?
JASON Hirschhorn: คุณหมายถึงอะไร?
ลำโพงที่ 3: เพราะคุณกล่าวว่า ลอยเป็นหมายเลข [ไม่ได้ยิน]
JASON Hirschhorn: ขวา
ดังนั้นที่ตรงขวา
7 เป็นจำนวนเต็ม
แต่ถ้าผมต้องการที่จะเปิดที่ เป็นจำนวนจุดลอย
ผมจะมีการจัดเก็บที่ เป็น 7.0 เนื่องจากคอมพิวเตอร์
เป็นจริง stupid-- เราเห็นว่า กับ PB และ J example--
ก็จะทำตรง สิ่งที่คุณบอกว่า
>> ดังนั้นถ้าคุณเขียน 7 มัน คิดว่าเป็นจำนวนเต็ม
ถ้าคุณเขียน 7.0 แม้ว่าเรา รู้ว่าสิ่งเหล่านี้จะเทียบเท่า
การปฏิบัติต่อที่เหมือน จำนวนจุดลอย
ดังนั้นถ้าคุณไม่ได้แบ่ง 7.0 3 หรือหารด้วย 3.0
มันจะบอกว่าตกลงตอนนี้ เราจัดการกับลอย
ฉันจะกลับมาอยู่กับคุณตลอดไป 2.333333
แต่ไม่ได้จริงๆตลอดไปเพราะ อย่างที่เราเห็นในการบรรยาย
ตัวเลขเหล่านี้จุดลอย ไม่ได้อย่างแม่นยำว่า
>> ดังนั้นถ้าคุณต้องการทศนิยมว่า หรือเป็นส่วนหนึ่งของทศนิยมนั้น
แล้วคุณจะต้อง use-- หนึ่งของพวกเขา จะต้องมีจำนวนจุดลอย
และเครื่องคอมพิวเตอร์ที่มีการเข้าใจ ว่านี่คือจุดลอยคุณ
การจัดการกับความไม่เป็นจำนวนเต็ม
คำถามใด ๆ เกี่ยวกับตารางที่เกี่ยวกับ ด้านขวามือเพื่อให้ห่างไกล?
หรือด้านซ้ายมือของคุณของคุณ ซ้ายด้านซ้ายมือของคุณ
ใช่
ลำโพง 4: ขวา
สำหรับเหมือนปกติ จำนวนเต็มคุณจะ
write-- คุณจะต้องเขียนลอย?
>> JASON Hirschhorn: ใช่ดังนั้น
ดีถ้าคุณต้องการที่จะสร้าง ตัวแปรที่ลอยที่
คุณต้องการที่จะพูดลอย ซีเท่ากับบางสิ่งบางอย่าง
>> ลำโพง 4: ตกลง
>> JASON Hirschhorn: แต่ถ้าผมต้องการที่จะ ทำ 7 โดยแบ่งออกเป็น 3 และได้รับทศนิยมว่า
ฉันจะทำลอยซี = 7.0 / 3.0; และ ที่จะให้ฉันจุดลอย
จำนวน
>> ลำโพง 4: ตกลง
>> JASON Hirschhorn: ถ้าผมทำ สิ่งที่ต้องการ int ซี = 7/3,
ที่จะให้ฉันจำนวนเต็ม เพราะผู้เป็นจำนวนเต็มทั้งหมด
ที่ทำให้รู้สึก?
>> ลำโพง 4: ใช่
>> JASON Hirschhorn: OK
ที่ดี
คำถามใด ๆ อื่น ๆ เกี่ยวกับตารางที่?
จริงเหรอ?
ฉันตื่นเต้น.
ตกลง.
>> ดังนั้นบางสิ่งอื่น ๆ ที่คุณจะใช้ อาจเกิดในเงื่อนไขหรือลูป
เป็นประเภทนี้ operators-- ประเภทนี้ของการแสดงออกบูลีน
และการที่เราได้เรียนรู้ == คือสิ่งที่คุณ ใช้ในการตรวจสอบว่าสองสิ่งที่มีค่าเท่ากัน
>> ดังนั้นที่นี่ฉันตรวจสอบว่า x == y ที่ขอ อีกครั้งคิดว่า x คือ 7 และ y ที่ 3
ดังนั้นถ้าผมเขียน 7 == 3 สิ่งที่ ที่จะกลับมากับผมหรือเปล่า
ว่าเป็นจริงหรือเท็จ?
>> ผู้ชม: เท็จ
JASON Hirschhorn: OK
ฉันรู้สึกเหมือนทุกคนจะได้รับหนึ่งนี้
ดังนั้นทุกคนสิ่งที่จะกลับมา?
ผู้ชม: เท็จ
JASON Hirschhorn: เท็จ
ที่ดี
7 ไม่เท่ากับ 3
ดังนั้น 7 == 3 จะกลับเท็จ
คุณจะมีเครื่องหมายเท่ากับไม่ได้ดังนั้นถ้าฉัน ตรวจสอบ 7! = 3 สิ่งที่จะกลับมา?
ผู้ชม: ทรู
JASON Hirschhorn: ทรู
ที่ดีเยี่ยม
ใครบางคนเป็นสำคัญมากในการ ด้านหลังและชื่นชมว่า
แล้วคุณมีน้อยกว่าผู้ประกอบการ น้อยกว่าหรือเท่ากับผู้ประกอบการ
สูงกว่าผู้ประกอบการมากขึ้น กว่าหรือเท่ากับผู้ประกอบการ
>> ดังนั้นหนึ่งการตรวจสอบสติมากขึ้น
ถ้าผมมี 7 เป็นมากขึ้น กว่าหรือเท่ากับ 3
อะไรที่จะกลับมา?
>> ผู้ชม: ทรู
JASON Hirschhorn: ทรู
ใช่
ห้องด้านหลังที่ด้านหลัง ของห้องที่ยอดเยี่ยม
คุณสามารถรวมเหล่านี้ การแสดงออกหากคุณต้องการเช่นกัน
ด้วยตรรกะและซึ่งเป็น && หรือตรรกะหรือซึ่งเป็น ||
||
ดังนั้นตอนนี้คุณสามารถทดสอบสอง สิ่ง together-- คือตลก?
นี่คือเหตุผลที่ว่าตลก?
>> ดังนั้นถ้าผมต้องการที่ผมสามารถพูดได้คือ 7 มากกว่า 3 และ 2 เป็นน้อยกว่า 4?
ดีถ้า 7 เป็นมากขึ้น กว่า 3 ว่าเป็นความจริง
2 น้อยกว่า 4 ที่จริง
ดังนั้นเรื่องทั้งหมดนี้จะกลับมาเป็นความจริง
>> ถ้าผมทดสอบ 7 เป็นมากกว่า 3 and-- ฉันแค่เลือกตัวเลขสุ่ม here--
4 น้อยกว่า 2 ดีที่เป็นเท็จ
ดังนั้นความจริงและทำให้เท็จเท็จ
และคุณสามารถไปบนและคุณรวมเป็น เงื่อนไขจำนวนมากร่วมกันตามที่คุณต้องการ
>> ไม่มีใครมีคำถามใด ๆ ความเห็นเพื่อให้ห่างไกลกังวล?
และผมเห็นบางส่วนของคุณถ่ายภาพ ของฉันในหน้าจอซึ่งฉันขอขอบคุณ
หวังว่ามันจะไม่ Snapchat
หวังว่าจะเป็นสำหรับการบันทึกของคุณ
แต่สิ่งเหล่านี้จะไป จะสามารถใช้ได้ออนไลน์
ดังนั้นคุณจึงไม่ต้อง ถ่ายภาพนี้
เช่นเดียวกับที่ผมกล่าวถึงทุกอย่าง จะมีออนไลน์สำหรับคุณ
ตกลง.
ฉันจะได้รับ เวทีจึงไม่ใคร
ต้องการที่จะพูดอะไร ก่อนที่เกิดขึ้น?
คำถาม?
>> [interposing VOICES]
>> JASON Hirschhorn: โอ้หยุด
พวกคุณดีเกินไป
ตกลง.
ฉันจะติดแท็กออก
ไปกันเถอะ.
>> ANDI เป็ง: เรากำลังจะทำ การเปลี่ยนแปลงที่น่าอึดอัดใจไมค์ตอนนี้
>> JASON Hirschhorn: ฉัน จะใช้เวลานี้ออก
ANDI PENG: ขอบคุณการสนับสนุนพวก
คุณสามารถได้ยินฉัน?
ว่าเป็นสิ่งที่ดี?
ที่สมบูรณ์แบบ
สวย.
ผมขอเหน็บว่าใน
ตกลง.
ดังนั้นฉันจะทำเช่นเดียวกับยักษ์ ข้อมูลการถ่ายโอนข้อมูลในพวกคุณในขณะนี้
และความกังวลใด ๆ ถ้าคุณ ไม่ได้ติดตามทุกสายเล็ก ๆ น้อย ๆ ของสิ่งที่
ฉันจะแสดงให้คุณเห็น
ขณะที่เจสันกล่าวว่าทุกอย่าง เป็นแบบออนไลน์อย่างสมบูรณ์
เพียงแค่เราจะพยายามที่จะแนะนำ ทุกคนที่จะแนวคิดที่ครอบคลุม
ในบางส่วนของภาพนิ่งเหล่านี้
ดังนั้นเพียงแค่ทำตาม
ไม่ต้องกังวลถ้าคุณไม่เข้าใจ ทุกอย่าง แต่ถ้าที่จุดใด
คุณรู้สึกหายไปยกของคุณ มือเราจะหยุดไม่ต้องกังวล
เย็น
>> ดังนั้นผมจึงคิดว่าสิ่งที่มีเดวิด แล้วชนิดที่กล่าวถึงในการบรรยาย
และเจสันได้พูดพาดพิงถึงชนิดของ วันนี้คือสิ่งที่เป็นห้องสมุด
ดังนั้นในการเขียนโปรแกรมที่เรามี สิ่งเหล่านี้เรียกว่าห้องสมุด
ในกรณีที่เป็นหลักทั้งหมด พวกเขาจะเป็นเพียงชุด
ฟังก์ชั่นที่เป็น หลักเพียงรหัสที่
รับแล้วเขียนโดย คนอื่นที่เราสามารถทั้งหมด
ใช้ที่อยู่ในโปรแกรมของเรา
>> ดังนั้นวิธีการที่ไม่ปกติ ทำงานห้องสมุดใช่มั้ย?
คุณเข้าประตูห้องสมุด
คุณมีทั้งหมดเหล่านี้ หนังสือที่คุณสามารถดึงออก
และคุณสามารถเข้าถึงข้อมูล ภายในหนังสือเหล่านั้น
สิ่งที่เหมือนกันในการเขียนโปรแกรม
>> คุณมีห้องสมุดที่มีอยู่แล้ว ถูกเขียนขึ้นโดยคนอื่น
และวิธีการที่คุณสามารถที่ เป็นโปรแกรมเมอร์หรือนักเรียน
สามารถเข้าถึงห้องสมุดที่ ผ่าน hashtag # include
>> ยกตัวอย่างเช่นใน C เรา มีสาม C-- มากที่สุด
ที่ใช้กันทั่วไปสามมาตรฐาน C libraries-- ห้องสมุดอินพุต / เอาต์พุต
ห้องสมุดสตริง และห้องสมุดคณิตศาสตร์
>> ดังนั้นภายในครั้งแรกของคุณ ปัญหาสองสามชุด,
ผู้ที่จะเป็นสาม ว่าคุณกำลังใช้เป็นหลัก
ดังนั้นขณะที่เดวิดแล้ว อธิบายในการบรรยาย
มาตรฐาน I / O ห้องสมุดหรือ เข้ามาตรฐานห้องสมุด / เอาท์พุท
ไม่ตรงที่
จะช่วยให้คุณในรหัสของคุณที่จะใส่ อะไรจากผู้ใช้และการส่งออกที่
ไปที่หน้าจอหลัก พิมพ์หน้าจอ
>> ดังนั้นเวลาที่คุณใช้ฟังก์ชั่นใด ๆ ตัวอย่างเช่นฟังก์ชั่น printf () ซึ่ง
เรากำลังจะไปกว่าสไลด์ถัดไป ให้แน่ใจว่าจะรวมถึงมาตรฐาน I / O
ห้องสมุดหรืออื่น ๆ คุณจะไม่ สามารถที่จะใช้ printf () ฟังก์ชัน
เพราะคุณเป็นโปรแกรมเมอร์ ไม่เคยเขียนจริงฟังก์ชั่นที่
คุณเพียงแค่ใช้ใครสักคน รหัสอื่นภายในรหัสของคุณเอง
>> ทุกคนไม่ทำให้รู้สึก?
เย็น
>> และจากนั้นเราจะได้รับเป็นหลักบน ห้องสมุดสตริงและ math.h
ห้องสมุด .h เพียงหมายถึงห้องสมุด ห้องสมุดอื่น ๆ ที่คุณที่สุดจะ
จะใช้ที่อยู่ในรหัสของคุณ
>> อย่างไรก็ตามสำหรับวัตถุประสงค์ ของห้องสมุดนี้เรายัง
have-- ของ class-- นี้เรายังมี สิ่งที่เรียกว่าห้องสมุด CS50,
cs50.h ที่เราสำหรับ การตรวจของคุณได้สร้าง
ฟังก์ชั่นที่สำคัญและมีประโยชน์มากมาย
เพื่อให้คุณเป็นโปรแกรมเมอร์ สามารถขี่หลังออก
สิ่งที่เราได้เขียนไว้แล้วเพื่อให้ ฟังก์ชั่นนี้มีให้คุณ
สำหรับการใช้งานของคุณ
>> ฉันจะครอบคลุมคู่ของ ฟังก์ชั่นที่ใช้กันทั่วไป,
แต่รู้ว่าสิ่งเหล่านี้ ออนไลน์ทั้งหมด googleable
รู้สึกอิสระที่ดึงห้องสมุด CS50 และ แล้วคุณมีฟังก์ชั่นทั้งหมดที่มี
ใช่
>> ลำโพงที่ 5: ดังนั้นถ้าคุณไม่ได้ โดยใช้ซอฟต์แวร์ที่
ที่มีให้กับเราไว้ ชั้นไม่ว่า
หมายความว่าเราจะต้องดาวน์โหลดและหา ไฟล์ส่วนหัวนี้ตัวเองและบอก
คอมพิวเตอร์ที่มันคืออะไร?
>> ANDI PENG: คำถามที่ดี
ที่แน่นอน
ดังนั้นจึงเป็นเช่นถ้าคุณไม่ได้ ร่างกายอยู่ในห้องสมุด
มีวิธีสำหรับคุณที่จะไม่มี จริงไปและเข้าถึงได้
ดังนั้นสิ่งเดียวกันกับ การเขียนโปรแกรมใน C คุณ
ต้องให้แน่ใจว่าคุณกำลังใช้ของเรา เครื่องใช้ไฟฟ้าเพราะห้องสมุดแล้ว
รับการจดทะเบียนเป็นมัน
และจากนั้นเมื่อคุณ hashtag #include ห้องสมุดของที่นั่น
ใช่
คำถามที่ดี.
ทุกคนดีหรือไม่?
เย็น
ทั้งหมดขวา
ดังนั้นเรากำลังจะตี หลักคืออะไร
ฟังก์ชั่นแรกที่ เราในฐานะที่เป็นโปรแกรมเมอร์
จะต้องใช้ภายในรหัสของเรา
นี้เรียกว่า printf () ฟังก์ชัน
ดังนั้น printf () ฟังก์ชั่นที่ผมได้ แล้วกล่าวว่าในสไลด์ที่ผ่านมา
จะรวมอยู่ในมาตรฐาน I / O, เข้ามาตรฐาน / เอาต์พุตห้องสมุด
>> เพื่อให้แน่ใจว่าสิ่งที่คุณกำลัง using-- โอ้ให้ฉันคว้าเลเซอร์ pointer--
เมื่อใดก็ตามที่คุณกำลังใช้ printf () ฟังก์ชั่น
คุณจะต้องรวมถึงมาตรฐาน I / O ห้องสมุดหรืออื่น ๆ เมื่อคุณรวบรวม
คุณกำลังจะได้รับข้อผิดพลาด เพราะคอมพิวเตอร์จะเป็นเช่น
โอ้ผมไม่ทราบว่าที่ printf () คือ คุณไม่ได้บอกฉันที่ printf ()
คือ.
ดี printf () จะรวมอยู่ใน มาตรฐาน I / O ดังนั้นเมื่อคุณใช้ printf ()
ให้แน่ใจว่าจะมีที่ บรรทัดข้างต้นรหัสของคุณ
>> ดังนั้นตัวอย่างเช่น printf () นี่คือฟังก์ชั่น
ทั้งหมดก็จะเป็นสิ่งที่พิมพ์ ในวงเล็บให้กับผู้ใช้
ใครต้องการที่จะใช้แทง สิ่งที่บรรทัดนี้สิทธิรหัส
ที่นี่จะพิมพ์ออกมา?
ดังนั้นคำตอบที่อยู่บนหน้าจอ
ใคร?
>> VERDI: ด้านล่าง
>> ANDI PENG: แวร์ดีทำไมคุณไม่ไป ข้างหน้าและบอกว่าคำสั่งทั้งหมด?
>> VERDI: สวัสดีชื่อของฉันคือ Andi และฉันอายุ 20 ปี
ANDI PENG: อ่าน่ารัก
ดังนั้นในบรรทัดนี้เรากำลังจะไป พิมพ์ออกมาสวัสดีชื่อของฉันคือ Andi,
และผมอายุ 20 ปีซึ่ง ในความเป็นจริงเป็นคำสั่งจริง
>> ไวยากรณ์
ดังนั้นประเด็นที่คู่ของประโยคที่ว่า พวกคุณต้องการให้แน่ใจว่าคุณรู้ว่า
คำคม
คำพูดสองบอก คอมพิวเตอร์ที่ทุกอย่างภายใน
เป็นไปได้ที่จะพิมพ์
>> ทุกอย่างภายในกระป๋อง เพียงแค่เป็นว่าวิธีการ
คุณพิมพ์มันยกเว้น โดยทั่วไปในตอนท้าย
เรากำลังจะต้องการรวม hash-- โอ้ sorry-- n เส้นประ
ดังนั้น n ประ
>> ไม่มีใครต้องการที่จะคาดเดา ในสิ่งที่ไม่รหัสของเราหรือไม่
ใช่
ลำโพง 6: ทำให้มันในบรรทัดใหม่
ANDI PENG: แน่นอน
ดังนั้นสิ่งนี้จะเป็น ช่วยให้สิ่งที่เกิดขึ้น
หลังจากนี้หลังจากที่คำสั่งนี้ ที่จะพิมพ์ไปที่บรรทัดใหม่
เพื่อที่ว่าเมื่อคุณเขียนของคุณ รหัสที่คุณไม่ได้มีสิ่งที่สุ่ม
ติดอยู่ที่สิ้นสุด ที่คุณไม่ต้องการ
ทุกอย่างที่ได้รับ พิมพ์อย่างประณีตหนึ่งบรรทัด
และจากนั้นเราเริ่มต้นในบรรทัดต่อไปนี้
>> ไม่มีใครจำสิ่งที่ อัฒภาคไม่เมื่อเรากำลังเข้ารหัส?
ใช่
>> ลำโพง 7: คำชี้แจง
>> ANDI PENG: ขออภัย?
>> ลำโพง 7: มันจบคำสั่งหรือไม่
>> ANDI เป็ง: ใช่
ดังนั้นใน C หรือโปรแกรมใด ๆ ภาษาอัฒภาค
หมายถึงจุดสิ้นสุดของบรรทัดเขียนโปรแกรม
ดังนั้นตัวอย่างเช่นในภาษาอังกฤษที่เราใช้ระยะเวลา ที่จะบอกว่าโอ้นี่คือจุดจบประโยค
ในการเขียนโปรแกรมในสิ่งเดียวกันเรามี อัฒภาคเพื่อแสดงถึงการสิ้นสุดของเส้น
บ่อยครั้งเมื่อคุณอยู่ เริ่มต้นในการเขียนโปรแกรม
คุณจะตระหนักถึงคุณ ลืมที่จะเพิ่มอัฒภาค
และจากนั้นคุณพยายามที่จะทำงานของคุณ รหัสและมันไม่ทำงาน
และคุณต้องการ, อาฉันทำไม่ได้ รู้ว่าทำไมมันควรจะทำงาน
>> โอกาสที่คุณอาจจะลืม อัฒภาคหรือวงเล็บหรือบางสิ่งบางอย่าง
ที่ไหนสักแห่ง.
ดังนั้นที่สำคัญที่ต้องจำ
เย็น
สิทธิ์การแสดงของมือวิธี หลายคนที่นี่เคย
นำ AP วิทยาศาสตร์คอมพิวเตอร์หรือ โปรแกรมใน Java ก่อนเคย?
ตกลง.
น่ารัก
ที่จะไม่สามารถใช้งานได้ แล้ว แต่ใน Java คุณ
มีสิ่งที่เรียกว่า System.out.println ซึ่งไม่ได้อยู่ใน C.
>> ดังนั้นใน C เมื่อใดก็ตามที่คุณ ต้องการที่จะเพิ่มในตัวแปร
ลงไปในสิ่งที่คุณต้องการ จะพิมพ์ออกมามี
ไวยากรณ์ที่เฉพาะเจาะจงที่เรากำลังจะใช้
ที่เรียกว่า placeholding-- หลัก
เราเพิ่มตัวยึดตำแหน่งในสถานที่ ของจำนวนเต็มหรือตัวแปร
ที่เราต้องการพิมพ์
>> ดังนั้นในขณะที่พวกคุณจะได้เห็นเราได้รวม ไฟล์ส่วนหัวห้องสมุดใหม่ที่นี่
ห้องสมุด CS50
และที่มีอยู่ภายในห้องสมุด CS50 ว่า เป็นฟังก์ชั่นที่พบโดยทั่วไปเราจะใช้
ในหลักสูตรของเราที่เรียกว่า GetInt ()
>> ไม่มีใครต้องการที่จะใช้แทงที่ สิ่งที่ GetInt () อาจจะทำ
>> ผู้ชม: [ไม่ได้ยิน]
>> ANDI PENG: ขออภัย
ไม่สามารถได้ยินเสียงคุณ
Maddie ทุกคน
Maddie: โอ้มันจะแจ้งให้ สำหรับจำนวนเต็ม
ANDI PENG: แน่นอน
ดังนั้นฟังก์ชั่นนี้อีก ฟังก์ชั่นที่มีอยู่แล้ว
ถูกเขียนขึ้นโดยคนอื่น ที่เราสามารถเรียกร้องในขณะนี้
ทั้งหมดก็คือเป็นแจ้งให้คุณผู้ใช้ ที่จะใส่สิ่งที่คุณต้องการเป็นรหัส
ทำงานและจะเก็บ whatever-- ในกรณีนี้เรา GetInt () - ไอเอ็นจี
ดังนั้นนั่นหมายความว่าเรากำลัง ได้รับจำนวนเต็ม
>> และเรากำลังจะจัดเก็บ ว่าในจำนวนเต็มอีก
ที่เราได้ทำที่เรียกว่าอายุเพียง
ที่ทำให้รู้สึกกับทุกคน?
เย็น
>> ดังนั้นขณะนี้ที่เราได้เก็บไว้จำนวนเต็มนี้ ที่เราได้รับแจ้งจากผู้ใช้
ในตัวแปรนี้เราได้ สร้างชนิด int เรียกว่าอายุ
เราสามารถไปข้างหน้าและสถานที่ ว่าใน printf เรา () ฟังก์ชั่น
ดังนั้นมักจะไวยากรณ์สำหรับ printf () เป็น ว่าที่ใดก็ตามในทางกายภาพที่แท้จริงของคุณ
บรรทัดที่คุณต้องการรวมจำนวนเต็มว่า คุณทำสัญลักษณ์ที่มีสิทธิ์
สัญลักษณ์เปอร์เซ็นต์ด้วย ชนิดของตัวแปรที่คุณต้องการ
>> ดังนั้นในกรณีนี้อายุเป็นจำนวนเต็ม
ดังนั้นคุณจะรวมถึง % ฉันเพราะมันเป็นจำนวนเต็ม
และหลังจากนั้นของคุณ คำสั่งที่คุณกำลังจะ
ที่จะทำเครื่องหมายจุลภาคและ ชื่อของตัวแปร
>> ดังนั้นที่นี่เรากำลังจะพิมพ์ ออกสวัสดีชื่อของฉันคือ Andi,
และผมว่างเปล่าปีเก่า
Hashta-- หรือ sorry--, อายุกับสิ่งที่ฉันป้อนข้อมูล
ดังนั้นถ้ามีการป้อนข้อมูล 20 สำหรับ GetInt () ของฉันที่นี่
มันจะพิมพ์ออกมาสิ่งเดียวที่แน่นอน
แต่ถ้าผมต้องการที่จะป้อนข้อมูลบางสิ่งบางอย่าง อื่นเช่นอาจจะ 40 หรือ 45
แล้วคุณจะเห็นว่าสะท้อนให้เห็นถึง ตามในรหัส
>> ดังนั้นนี่คือตัวอย่าง บางสิ่งบางอย่างที่
จะพิมพ์ออกมาและมีลักษณะที่จะ คุณราวกับว่ามันเป็นสิ่งเดียวกัน
แต่อยู่ภายใต้ฝากระโปรงของ คอมพิวเตอร์มีจริง
สิ่งที่แตกต่างที่เกิดขึ้นมาก
เย็น
ทั้งหมดขวา
ดังนั้นสิ่งที่ถ้าเราต้องการตัวแปรหลาย
สวยง่าย
สิ่งเดียวกัน.
เรายังมีฟังก์ชันใหม่ นี่เรียกว่า GetString ()
นอกจากนี้ยังรวมอยู่ในห้องสมุด CS50, ว่าทั้งหมดมันไม่แจ้งให้ผู้ใช้
สตริงซึ่งเป็น เพียงแค่ชุดของตัวอักษร
เพื่อต้องการเป็นประโยคหรือชอบชื่อ
>> ดังนั้นในกรณีนี้เราจะมีสอง ตัวยึด% s% สตริงและฉัน
สำหรับจำนวนเต็ม
และเรากำลังจะทำตาม ว่าโดยตัวแปรทั้งสอง
เราต้องการรวมในการสั่งซื้อ ที่พวกเขาจะปรากฏในประโยค
ดังนั้นตัวอย่างเช่นชื่อของฉันคือ ว่างเปล่าฉันต้องการชื่อที่นั่น
ดังนั้นฉันจะมีชื่อแรก
และแล้วหลังจากนั้นผมต้องการ อายุต้องการที่จะมีคนที่สองอายุ
ดังนั้นถ้าผมต้องการที่จะใส่สวัสดี Andi ชื่อของฉันและฉันอายุ 20 ปี
ถ้าฉันป้อน Andi และ 20 สิ่งเดียวที่แน่นอนจะพิมพ์;
แต่ตอนนี้เราได้มีสองเก็บไว้ ตัวแปรที่มีชื่อเช่นเดียวกับ int
ใช่
>> ลำโพง 8: มันจะเป็น สามารถทำงานได้ถ้าคุณเปลี่ยน
ชื่อและอายุในตอนท้ายของที่?
>> ANDI เป็ง: ใช่
นั่นเป็นคำถามที่ดีจริงๆ
ดังนั้นเรื่องยาวสั้นไม่
เนื่องจากชื่อและ age-- สิ่งที่ ชนิดของตัวแปรคือชื่อ?
>> ลำโพง 8: String
>> ANDI PENG: และสิ่งที่ ชนิดของตัวแปรคืออายุ?
>> ลำโพง 8: จำนวนเต็ม
ANDI PENG: ดังนั้นที่นี่เรามีตัวยึด สตริงและจำนวนเต็มใช่มั้ย?
ดังนั้นถ้าคุณมีการสลับเหล่านี้ คอมพิวเตอร์จะไม่ทราบว่า
มันจะตรวจสอบสตริง และถ้าคุณพยายามที่จะให้มัน int,
มันจะเป็นเหมือน รอฉันสับสนคุณ
บอกฉันว่าฉันควรจะเป็น จัดสรรหน่วยความจำสำหรับเป็น int
และที่นี่เมื่อ คาดว่าจำนวนเต็ม
และคุณให้มันชื่อ และสตริงแทน,
มันยังจะทำให้เกิดความสับสนมาก จะไม่ทำงานตรงทางคุณต้องการ
ดังนั้นที่นี่ตั้งชื่อและไวยากรณ์ สิ่งที่สำคัญมากสำหรับการเรียกใช้รหัส
ทุกคนดีหรือไม่?
ใช่
Maddie
>> Maddie: ที่นี่ฉันรู้ว่าเราได้มอง ตัวอย่างในระดับที่พวกเขาถาม
สิ่งที่เป็นอายุของคุณสิ่งที่เป็นชื่อของคุณ
ที่นี่ที่จะไม่ว่าจะเป็น doesn't-- ถ้าเราจะเรียกใช้รหัสนี้
มันจะไม่ขอที่?
แต่คุณจะใส่เพียงตัวเลขสอง และจากนั้นก็จะทำงานเช่นนั้น?
>> ANDI เป็ง: ใช่ว่า
ดังนั้นถ้าคุณอยากให้มัน การแสดงผลกรุณาใส่อายุของคุณ
คุณก็สามารถเพิ่ม printf () ฟังก์ชัน ที่กล่าวว่ากรุณากรอกอายุของคุณ
ข้างต้นนั้น
นั่นเป็นคำถามที่ดี
ใช่
>> ลำโพง 9: ดังนั้นแล้วจะเป็น รวมอยู่ใน GetInt () [ไม่ได้ยิน]
ANDI PENG: ไม่มีก็จริงไม่ได้
ดังนั้นสิ่งนี้จะเป็นเพียงแค่ แจ้งให้หน้าจอที่ว่างเปล่า
ให้กับผู้ใช้บางสิ่งบางอย่างที่จะป้อนข้อมูล
ถ้าคุณต้องการมันถ้าคุณต้องการที่จะพิมพ์ บางสิ่งบางอย่างที่จะบอกผู้ใช้เช่น
โปรดให้ฉันอายุของคุณแล้วคุณ จะต้อง printf () ที่ตัวเอง
เพราะทุกคนใช้นี้ ฟังก์ชั่นสำหรับสิ่งที่แตกต่างกัน
คุณอาจจะจัดเก็บอายุ คุณอาจจะจัดเก็บอยู่
คุณอาจจะจัดเก็บหมายเลขโทรศัพท์
และเพื่อให้มันเป็นจริงขึ้นอยู่กับ พวกของใช้ของแต่ละบุคคล
สิ่งที่คุณต้องการจะพูด
ใช่
>> ลำโพง 10: ดังนั้นเพียงเพื่อชี้แจงที่ ทำคุณใส่ชื่อและอายุ
เพื่อที่จะแสดงขึ้นในสถานที่ของ% s?
>> ANDI PENG: ในขณะที่ผู้ใช้หรือไม่
>> ลำโพง 10: ใช่เช่นวิธีการทำผม ทำให้ it-- ที่ฉันจะใส่ Andi,
และสถานที่ที่ฉันจะวาง 20?
>> ANDI เป็ง: ใช่
ดังนั้นถ้าคุณจะ จริงเรียกใช้รหัสนี้
ฉันไม่ได้จริงการทำงาน รหัสนี้เป็นเพียงที่นี่ตอนนี้
ถ้าฉันจะเรียกใช้รหัสผมจะ รวบรวมรหัสให้แฟ้ม
เรียกใช้รหัสและจากนั้นจะมี เพียงแค่เป็นสองช่องว่างสำหรับผมที่จะใส่มัน
ใช่
พวกคุณจะเห็นเมื่อคุณเล่น รอบกับรหัสตัวเอง
>> สิทธิทั้งหมดที่เรากำลังจะย้าย เข้าไปในส่วนถัดไปของสิ่งที่
เราจะครอบคลุมในวันนี้
เรากำลังจะไปมากกว่าสิ่งที่ งบเงื่อนไขเป็น
ดังนั้นถ้าพวกคุณจำได้ และเรียกคืนจากการบรรยาย
งบเงื่อนไข ทั้งหมดที่พวกเขาจะเป็นชุด
คำสั่งไปยังเครื่องคอมพิวเตอร์ใน ซึ่งถ้าเงื่อนไขบางอย่างเป็นความจริง
คุณรันรหัส ภายในเงื่อนไขที่ว่า
>> ดังนั้นใน Scratch-- หลัก รูปแบบขนาดใหญ่ตั้งแต่วันนี้
คือการที่พวกคุณมีอยู่แล้วทั้งหมด เห็นตรรกะที่อยู่เบื้องหลังทุกอย่าง
ที่เรากำลังครอบคลุม
และทุกสิ่งที่เรากำลังทำคือการ แปลบางสิ่งบางอย่าง
นั่นคือใช้งานง่ายมาก รอยขีดข่วนและการเข้ารหัสมันยาก
เข้าไวยากรณ์ที่เราจะใช้ สำหรับการเรียนซึ่งเป็นซี
ดังนั้นเหตุผลทั้งหมดบล็อกนี้คือ เป็นชิ้นส่วนของรหัสที่นั่นว่า
ใช่
ตกลง.
>> นอกจากนี้เรายังได้รับในถ้า ... อื่น คำสั่งซึ่งเป็นเพียงชั้นเพิ่ม
ของความซับซ้อนที่จะถ้าคำสั่ง ที่ใช้คอมพิวเตอร์ใช้เวลาดูที่นี้
และเห็นถ้าสภาพเช่นนี้เป็นความจริงทำ สิ่งที่อยู่ภายในของทั้งสองวงเล็บ
else-- ดังนั้นชนิดเช่นถ้าเริ่มต้น มันไม่ตรงกับสภาพที่ทำเช่นนี้
มันก็เหมือนกับการแยกในถนน
หากมีฝนตกนอกผมใส่ เสื้อฝนสิ่งอื่นใด
อื่นที่ฉันไม่ได้ใส่เสื้อฝน
>> ไม่ว่าตรรกะทำให้ความรู้สึกที่ทุกคน?
เย็น
ทั้งหมดขวา
ดังนั้นเหมือนตัวอย่างหนักของ ที่เราจะได้เห็นใน C
คือถ้าผมต้องการที่จะสร้าง ตัวแปรที่เรียกว่าชั่วโมงการบ้าน
และถ้าเวลาทำการบ้านน้อย กว่าห้าผมว่าชีวิตเป็นสิ่งที่ดี
มันยอดเยี่ยม
แต่บอกว่าการต่อสู้เป็น real-- ซึ่งเป็นสิ่งที่เราทุกคนในวันจันทร์นี้
ช่วงบ่ายขึ้นฮิลล์เป็นวิทยาศาสตร์ อาจจะทำตอน now--
ผู้ชม: [หัวเราะ]
ANDI PENG: พวกเขาวิธีที่เรา จะขอขอบคุณสำหรับการที่
วิธีที่เราจะ hardcode ใน C คือ if-- สมมติ
เรามีตัวแปรประเภท int ชั​​่วโมงเรียกว่าบ้านที่นี่
ถ้าเวลาทำการบ้านน้อยกว่า ห้า printf () ชีวิตเป็นสิ่งที่ดี
โปรดจำไว้ว่าให้ / n เพราะ คุณต้องการขึ้นบรรทัดใหม่หลังจากที่
พิมพ์อื่นการต่อสู้ที่เป็นจริง
>> ไม่ทุกคนเข้าใจว่า ผมเปลี่ยนจากบล็อกนี้
ลงในบล็อกของรหัสนี้?
เย็น
ทั้งหมดขวา
>> ดังนั้นตอนนี้เรากำลังจะไปดูที่ ถ้างบหลายสิ้นเชิง
ถ้าอย่างนั้นเราถือว่า วัตถุประสงค์ของโครงการนี​​้
เราได้รับการแจ้งให้ผู้ใช้สำหรับเกรด
แจ้งให้เราใช้ GetInt () สำหรับ ชั้นประถมศึกษาปีและพวกเขาสำหรับการป้อนค่า
และคุณต้องการที่จะแสดง สิ่งที่ประเภทของชั้นประถมศึกษาปีที่พวกเขาได้
>> ดังนั้นถ้าผมจะออกแบบโปรแกรมผม มักจะหมายถึงในทุกสายตาของเรา
90-100 เป็น A, 80-90 เป็น B, และอื่น ๆ และอื่น ๆ
อะไรคือสิ่งที่ผิดปกติกับนี้ ชิ้นส่วนของรหัสว่ามันเป็นไม่ได้
ทำในสิ่งที่ฉันต้องการจะทำ
ใช่
>> ลำโพง 11: พวกเขามีข้อ จำกัด ที่ต่ำกว่า แต่พวกเขาไม่ได้มีขีด จำกัด บน
>> ANDI PENG: แน่นอน
ไม่ทุกคนได้ยินสิ่งที่เธอกล่าวว่า?
มีเป็นไปได้บน ข้อ จำกัด แต่ไม่ จำกัด ที่ต่ำกว่า
ขออภัยวิธีอื่น ๆ ข้อ จำกัด ที่ต่ำกว่าไม่มีขีด จำกัด บน
ดังนั้นคุณจึงต้องการที่จะ ใช้แทงที่บอกว่า
สิ่งที่จะได้รับการพิมพ์เกี่ยวกับเรื่องนี้ หน้าจอถ้ามีการเรียกใช้รหัสนี้
ลำโพง 11: ข้อผิดพลาด?
ANDI PENG: ข้อผิดพลาด?
ที่ดีเดาไม่ถูกต้อง
ไม่มีใครมีแทงอื่นได้หรือไม่
ใช่แอรอน
>> AARON: ถ้าคุณใส่ใน บางสิ่งบางอย่างที่ยิ่งใหญ่กว่า 90
มันจะแสดงเกรดทั้งหมดที่คุณมี
มันจะแสดงให้คุณได้ต่อ A, คุณมี B คุณมีซี
>> ANDI เป็ง: ใช่
ที่เหมาะสมว่า
เพื่อที่ต้องการจะยอดเยี่ยม
แต่พวกเขาจะร่วมกัน แต่เพียงผู้เดียวที่ผมคิดว่า
ถ้าฉันจะทำงานชิ้นส่วนของรหัสนี้
และจากนั้นก็ให้เพียงกล่าวว่าผม ป้อนชั้นประถมศึกษาปี 95
ดังนั้น 95 จะถูกเก็บไว้ในขณะนี้ ชั้นประถมศึกษาปีที่เรียกว่า int
>> และเพื่อให้ซีเป็นภาษา ที่วิ่งขึ้นบนลงล่าง
ดังนั้นจึงเป็นไปได้เสมอ วิ่งขึ้นไปที่ด้านล่าง
ดังนั้นมันจะมาที่นี่ถ้าอ่าน ชั้นประถมศึกษาปีที่มีค่ามากกว่าหรือเท่ากับ 90
printf () คุณได้กที่ยอดเยี่ยมผม มี 95 ที่มากกว่า 90
มันจะพิมพ์ ผมได้ A. มันจะ
ที่จะดูที่นี้ถ้ามันจะ พูดดี 95 นอกจากนี้ยังมีค่ามากกว่า 80
มันจะพิมพ์คุณยังได้มี เครื่องหมายอัศเจรีย์ B, และอื่น ๆ และอื่น ๆ
ออกมา
>> ดังนั้นในขณะที่เราทุกคนสามารถมองเห็น ปัญหานี้เป็นปัญหาที่พบบ่อย
ที่อาจเกิดขึ้นเมื่อเราอยู่ เขียนรหัสที่มองออก
ทุกคนคำถามใด ๆ เกี่ยวกับ เหตุผลที่เกิดขึ้น?
ที่ดี
ตกลง.
>> เราดังนั้นวิธีแก้ไขปัญหานี้จะเห็นได้ชัด ตรรกะคำถามต่อไป
ดีที่เรามีที่สวยงามเหล่านี้ สิ่งที่เรียกว่าถ้าอื่นถ้าอื่น
ถ้างบอื่น
ดังนั้นคุณจะเห็นถ้าคุณต้องการ ที่จะเปลี่ยนปัญหาที่
คุณต้องการที่จะทำให้แต่ละ เงื่อนไขพิเศษร่วมกัน
ที่คุณจะเพิ่มอื่น ... ถ้าคำสั่ง
>> และเหล่านี้ของ course-- คิดว่าพวกเขาเป็น บันไดหรือชอบในขั้น ladder--
คุณสามารถเพิ่มเป็นจำนวนมากของเหล่านี้เป็นคุณ ต้องการสำหรับเงื่อนไขมากเท่าที่คุณต้องการ
ดังนั้นที่นี่ถ้าฉันป้อนชั้นประถมศึกษาปีที่จะเป็น 95
ถ้าชั้นประถมศึกษาปีที่มีค่ามากกว่า 95 printf () ผมได้รับเอที่ดี
มันจะเห็นอื่น ... ถ้า และก็จะรู้ว่าโอ้ไม่
ฉันได้ดำเนินการครั้งแรกที่อื่น
ฉัน know-- หรือ if-- แรกที่ผมรู้ว่า ฉันไม่ต้องมองไปที่ใด ๆ เหล่านี้
เพราะหนึ่งในพวกเขา ได้รับอยู่แล้วจริง
ดังนั้นมันจะวิ่งจากบนลงล่าง
ทันทีที่คนแรกเป็นจริงแล้ว มันจะข้ามส่วนที่เหลือทั้งหมด
ของไอเอฟเออื่น ...
ที่ทำให้รู้สึก?
ดังนั้นในวิธีนี้คุณมี ระดับที่แตกต่างกันของการตรวจสอบ
และทันทีที่หนึ่งในนั้นเป็นเท็จ ส่วนที่เหลือนอกจากนี้ยังมีพวกเขาจะไม่ได้ตรวจสอบ
เย็น
ทั้งหมดขวา
>> ดังนั้นนี่คือตัวอย่างของการที่แตกต่างกัน การเรียงลำดับของคำสั่งเงื่อนไข
ที่เราเห็นมักจะน้อย แต่ เราจะได้เห็นพวกเขาและใช้พวกเขา
และพวกเขากำลังบ่อยขึ้น ที่มีประสิทธิภาพสำหรับบางกรณี
ดังนั้นเราจึงมีสิ่งที่เรียกว่า คำสั่งสวิทช์
ดังนั้นก่อนที่เราจะได้รับการคุ้มครองสิ่งที่อื่น คำสั่ง ... ถ้าคำสั่งอื่น
ที่นี่เรามีสิ่งที่เป็น ที่เรียกว่างบสวิทช์
>> ดังนั้นเมื่อเราใช้สวิทช์ งบเป็นกุญแจสำคัญ?
ดังนั้นในงบเปลี่ยนคุณ ปกติมักจะจริงคุณ
เท่านั้นที่สามารถป้อนข้อมูลจำนวนเต็มสำหรับคุณ ตัวแปรที่คุณกำลังตรวจสอบ
ดังนั้นถ้าผมต้องการที่จะตรวจสอบเพื่อดู ถ้า number-- บางอย่างเช่น
ชั้นประถมศึกษาปีถ้าผมได้ 90
ฉันต้องการให้ดูว่าเป็น A, บีหรือซีฉันจะมีกรณีที่นี่
อย่างไรก็ตามกรณีที่มี จะเป็นอีกอย่างต่อเนื่อง
>> ดังนั้นในแง่นี้ งบเปลี่ยนเท่านั้นที่สามารถ
การตรวจสอบเพื่อความเท่าเทียมกันของตัวเลขสอง
มันไม่ได้ตรวจสอบสำหรับสิ่งอื่น
นั่นคือสิ่งที่จะมาก ระวังเมื่อคุณใช้นี้
ดังนั้นที่นี่ถ้าผมต้องการที่จะตรวจสอบเพื่อดู ถ้าเกรดของฉัน 90 เท่ากับ 90 หรือ 80
หรือ 70 หรือ 60 และจากนั้นพิมพ์ ชั้นประถมศึกษาปีที่สอดคล้องกัน
ฉันจะสามารถที่จะเขียนว่า ในงบสวิทช์
>> ดังนั้นมันจะมาที่นี่คือการตรวจสอบ จำนวนเต็มนี้เท่ากับค่าคงที่นี้หรือไม่?
ถ้าไม่ได้ก็จะข้าม
มันจะมีค่าเท่ากับค่าคงที่ สองและอื่น ๆ และอื่น ๆ
จนกว่าคุณจะตีค่าเริ่มต้น ถ้าไม่มีพวกเขามีค่าเท่ากัน
เร็วที่สุดเท่าที่หนึ่งของพวกเขา จะกำหนดเท่ากัน
มันจะทำเช่นนี้ บรรทัดของรหัสและทำลาย
ซึ่งหมายความว่ามันจะตีว่า ทำงานทำลายและสมบูรณ์เพียงข้าม
ที่ด้านล่างของรหัส
ดังนั้นในแง่ที่ว่าชนิดของฟังก์ชั่น เช่นถ้าอื่นถ้าอื่นถ้าคำสั่ง
>> ดังนั้นนี่คือคอนกรีต ตัวอย่างเช่นสำหรับคุณผู้ชาย
ดังนั้นสมมติว่าผมต้องการที่จะ สร้างตัวแปรที่เรียกว่าปีที่ก่อตั้ง
และผมต้องการที่จะแจ้งให้ผู้ใช้ที่จะใส่ ปีที่โรงเรียนของพวกเขาก่อตั้งขึ้น
ดังนั้นผมจึงสามารถสร้างคำสั่งสวิทช์ที่นี่
และให้เพียงกล่าวว่าฉันป้อนข้อมูล 1636
>> รหัสนี้ที่นี่จะได้เห็นสวิทช์ ก่อตั้งขึ้นในปี 1636 ซึ่งเท่ากับ
มันจะเห็นกรณี 1636 โอ้เหล่านั้นมีค่าเท่ากัน
printf () ที่คุณไม่ควรจะเป็น ที่โรงเรียนขึ้นไปทางเหนือที่?
เพราะเราถือว่าพวกเขาทำไม่ได้ ไปที่นี่ถ้าพวกเขาไปที่ฮาร์วาร์
ทำลายและข้ามไปที่สิ้นสุด
>> ถ้าฉันจะป้อนข้อมูล 1701 ซึ่ง ผมถือว่าเราทุกคนที่จะป้อนข้อมูล
มันจะข้ามกรณีนี้มา ลงไปที่กรณีที่สองซึ่งเป็น 1701
และพิมพ์ยินดีต้อนรับสู่เยล!
ทำลายข้ามไปที่สิ้นสุด
อื่น ๆ ที่คุณอาจจะมีการใช้หลักสูตรนี้ ออนไลน์ที่ case-- ต้อนรับที่น่ากลัว
เพื่อ Yale-- ก็จะไปที่ พิมพ์ค่าเริ่มต้นสวัสดีอินเทอร์เน็ต!
และทำลาย
ใช่
>> ลำโพง 12: คุณสามารถใช้อื่น แทนการเริ่มต้นมี?
>> ANDI PENG: ไม่มีเพราะ วิธีการที่ทั้งฟังก์ชั่นนี้
สวิทช์ที่ถูกสร้างขึ้นไวยากรณ์คุณ จำเป็นต้องใช้เป็นกรณีกรณีที่เริ่มต้น
มันเหมือนถ้าอื่นถ้านี้ หนึ่งมันเป็นกรณีกรณีที่เริ่มต้น ใช่
ลำโพง 13: คุณอาจจะพูดไปแล้วนี้ แต่คุณสามารถมีมากกว่าสองกรณี?
ANDI เป็ง: ใช่คุณสามารถทำได้ มีหลายกรณีตามที่คุณต้องการ
คิดว่ามันเป็นเพียงแค่ต้องการ ในการเพิ่มเพียบ
>> ลำโพง 14: ถ้าคุณ เปลี่ยน 1701 กับ 1636,
ก็ไม่ได้ทำจริงๆ ที่เหมาะสมแตกต่าง?
มันเป็นเพียงแค่จะได้รับการตรวจสอบสำหรับมัน
>> ANDI PENG: นั่นเป็น คำถามที่ดีจริงๆ
และเราจะลามปาม นี้ในภายหลัง แต่เพียง
รู้ว่าเป็นสวิทช์ คำสั่ง infinitely-- มัน
มีประสิทธิภาพมากขึ้นกว่าที่มันและถ้า อื่นถ้าเพราะมันทำงาน
โดยใช้รูปแบบที่แตกต่างกันของการทำงานว่า ช่วยให้คุณสามารถที่จะเป็นหลักที่จะเพียงแค่
กระโดดตรงไปยัง กรณีที่คุณต้องการที่จะเป็นที่
ใช่
ลำโพง 14: เย็น
ขอบคุณ
ANDI เป็ง: ใช่
>> ลำโพง 14: และคุณไม่สามารถ ทำกรณีเช่นและมากกว่า
ANDI PENG: เลขที่
ดังนั้นนั่นคือสิ่งที่เกี่ยวกับการ จำกัด งบเปลี่ยนคือการที่คุณมี
ที่จะมีค่าคงที่เท่านั้นจำนวนเต็มเท่านั้น
ใช่
ตกลง.
>> ดังนั้นนี่คือสิ่งที่คุณ ผู้ชายมักจะพบน้อย,
แต่ผมแค่อยากจะ แนะนำในกรณีที่
ที่นี่เรามีสิ่งที่ เรียกว่าผู้ประกอบการที่ประกอบไปด้วย
ในกรณีที่เป็นหลักก็ชอบเพียง ถ้าคำสั่งเรียบเรียงหนึ่งบรรทัด
ที่นี่ผมจะไปลงในบรรทัดถัดไปที่ หน้าถัดไปเพราะมันง่ายที่จะเห็น
>> ดังนั้นเราจึงได้เห็นสิ่งที่ถูกต้องนี้หรือไม่?
นี้จะสวยง่ายต่อการปฏิบัติ
ถ้าผมต้องการที่จะทำให้ตัวแปรที่เรียกว่า สตริงชื่อ s ถ้าจำนวนหนึ่ง
ฉันให้มันเป็นน้อยกว่า 100 ผม ต้องการกำหนดให้ต่ำเพื่อสตริง
อื่นที่ฉันต้องการที่จะกำหนดสูง
>> ที่นี่จะทำสิ่งเดียวที่แน่นอน ผู้ที่แปดบรรทัดของรหัสที่กำลังทำ
ดังนั้นที่นี่ฉันต้องการที่จะสร้าง สตริงตัวแปร
และนี่คือสภาพผม การตรวจสอบหากมีจำนวนน้อยกว่า 100
แล้วคุณกำหนดค่าของต่ำ อื่นกำหนดค่าของสูง
>> ภาพนิ่งเหล่านี้จะออนไลน์ไม่ต้องกังวล ถ้าพวกคุณไม่ได้รับนี้ลง
นี่เป็นเพียงวิธีที่ง่ายมากขึ้น วิธีที่มีประสิทธิภาพของการเขียนรหัส
ตกลง.
>> ดังนั้นตอนนี้เรากำลังจะไป ใส่สิ่งที่สำหรับคนส่วนใหญ่
เป็นเหมือนมากสับสนมาก สิ่งที่จะต้องคิดเกี่ยวกับในตอนแรก
ส่วนที่ห่วง
ดังนั้นวันนี้เรากำลังจะพูดคุย เกี่ยวกับสามประเภทของลูป
เรากำลังจะเริ่มต้นด้วยในขณะที่ ห่วงแล้วพูดคุยเกี่ยวกับสิ่งที่ต้องทำในขณะที่วง
แล้วพูดคุยเกี่ยวกับลูป
>> เพื่อเป็นหลักสำหรับการมากขึ้น ผู้เรียนมองเห็นออกมี
เรามีหลักแบบกราฟิก ภาพของสิ่งที่ห่วงในขณะที่ไม่
ดังนั้นในการเขียนโปรแกรมที่คุณจะเริ่ม และใส่ห่วงที่จุดหนึ่ง
คุณสามารถตรวจสอบสภาพ
และถ้าเงื่อนไขเป็นจริง คุณรันรหัสภายใน
และคุณกลับมารอบ ๆ และคุณตรวจสอบ
ถ้ามันยังคงเป็นจริงคุณให้ทำงาน รหัสนี้ไปรอบ ๆ ในวง
>> แต่ที่สองที่ สภาพกลายเป็นเท็จ
คุณกำลังจะทำลายและสิ้นสุดห่วง
และนี่เป็นหลัก ไวยากรณ์ที่คุณกำลังจะใช้
ในขณะที่เงื่อนไขบางอย่างคือ จริงทำเช่นนี้ถ้ามันไม่เป็นความจริง
คุณกำลังจะข้ามไปที่สิ้นสุด และก้าวไปข้างหน้ากับโปรแกรมของคุณ
ตกลง.
>> ไม่มีใครมีตัวอย่าง ที่อาจเกิดขึ้นกับสิ่งที่อาจจะเกิดขึ้น
ถ้าฉันพยายามที่จะเรียกชิ้นส่วนของรหัสนี้หรือไม่?
โดยวิธีการที่ SAJ-- ที่ Scaz, Andi, Jason-- เราจะลงนามอีเมลของเรา
รัก SAJ
นั่นคือเรา
ตกลง.
>> ใครมีตัวอย่างหรือมี คิดในสิ่งนี้จะพิมพ์?
ชนิดของคำถามเคล็ดลับ
ดังนั้นที่นี่อย่าลืมเงื่อนไข เรากำลังตรวจสอบในขณะที่ความจริง
ดังนั้นในขณะนี้เป็นจริงมันเป็น จะพิมพ์ฉันรัก SAJ!
มีจุดที่เราต้องการใด ๆ เปลี่ยนอะไรอย่างอื่น?
ไม่มีใช่มั้ย?
>> ดังนั้นในที่นี่เรามี พบสิ่งที่น่าจะเป็น
จะได้รับการ bugging จำนวนมาก โปรแกรมของคุณห่วงไม่มีที่สิ้นสุด
คุณจะพบว่าถ้าคุณ ทำงานชิ้นส่วนของรหัสนี้
มันเป็นเพียงแค่ไปเพื่อให้ พิมพ์ฉันรัก SAJ!
ในขณะที่เราขอขอบคุณที่สนับสนุน เราไม่ต้องการให้คอมพิวเตอร์ของคุณ
จะผิดพลาดเพราะคุณ ให้พิมพ์ฉันรัก SAJ!
>> ดังนั้นโปรดกรุณา หลีกเลี่ยงวง จำกัด
เพราะมันไม่เคยไป ในการประเมินเป็นเท็จ
และคุณไม่เคยไป ที่จะออกจากวง
และคุณกำลังจะไป ถูกดูดในตลอดไป
เย็น
ตกลง.
ประเภทที่สองของวง เราจะพูดถึงในวันนี้
เป็นสิ่งที่ต้องทำในขณะที่ห่วงทำในขณะที่ห่วง
และก็เรียกว่าทำในขณะที่ห่วง เพราะคุณมีสิ่งที่ต้องทำและในขณะที่
ดังนั้นนี่คือสวยคล้ายกับในขณะที่ ห่วง แต่แตกต่างกันเล็กน้อย
ที่นี่คุณกำลังจะทำ สิ่งที่อยู่ภายในนี้
ในขณะที่เงื่อนไขบางอย่างเป็นความจริง
ดังนั้นถ้าผมซีและคอมพิวเตอร์ของฉัน วิ่งลงชิ้นส่วนของรหัสนี้
ผมจะดูที่ด้านบน
ฉันไปที่ C ผมว่าทำสิ่งนี้
และแล้วฉันจะตรวจสอบในขณะนี้ เป็นความจริงที่ฉันต้องทำซ้ำได้
แต่ในขณะนี้เป็นเท็จ แล้วฉันจะก้าวไปข้างหน้า
และฉันไม่เคยกลับไปที่ห่วงอีกครั้ง
>> ใครสามารถใช้แทง สิ่งที่แตกต่าง
ระหว่างวงนี้และหนึ่งที่เรา เพียงแค่มองที่เป็นจริง
ใช่
ลำโพง 15: สภาพ มาหลังจากแทนการมาก่อนหรือไม่
ANDI PENG: แน่นอน
ดังนั้นเธอจึงกล่าวว่าสภาพ มาหลังจากไม่ก่อน
ในที่สุดความแตกต่าง ระหว่างนี้และห่วงในขณะที่
คือการที่คุณกำลังจะทำ สิ่งที่อยู่ภายในนี้โดยไม่คำนึงถึง
หรือไม่ว่าสภาพของคุณคือ ความจริงแล้วตรวจสอบสภาพ
ดังนั้นในกรณีนี้คุณ always-- ในลักษณะนี้
คุณมักจะทำให้แน่ใจว่า สิ่งที่อยู่ภายในทำงานอย่างน้อย
อีกครั้งก่อนตรวจสอบเพื่อดู ถ้าคุณต้องการให้ทำงานอีกครั้ง
>> และนี่คือตัวอย่าง เมื่อเราจะใช้มัน
ดังนั้นตัวอย่างเช่นถ้าผมต้องการที่จะมี ตัวแปรชนิด int ชื่ออายุ
และฉันต้องการที่จะแจ้งให้ ผู้ใช้สำหรับอายุของพวกเขา
ฉันจะทำ printf () คุณอายุเท่าไหร่?
อายุ = GetInt () ซึ่ง จะแจ้งผู้ใช้
>> และบางคนจะน่ารำคาญจริงๆ
และคุณไม่ต้องการที่บกพร่องในของคุณ โปรแกรมของใครบางคนป้อนชอบ
โอ้ฉันเชิงลบอายุ 4 ปีหรืออะไรก็ตาม
ซึ่งในกรณีนี้หากพวกเขา ทำที่นี้ประเมิน
จริงซึ่งหมายความว่าฉันจะไป ต้องให้กลับไปและทำเช่นนี้
ดังนั้นนี้เป็นไปเพื่อให้ อีกครั้งกระตุ้นให้ผู้ใช้
เพื่อให้คุณได้เหมือนจริง จำนวนอายุและก็
จะเก็บจะกลับ redoing มันจนกว่าพวกเขาให้คุณอายุจริง
มากกว่าหนึ่งหรือไม่เป็นศูนย์
>> ดังนั้นคำใบ้คำใบ้
นี้จะเป็นมากมีประโยชน์มาก สำหรับหนึ่งในปัญหา PSet ของคุณ
ใช่
>> ลำโพง 16: ขออภัยขอโทษ
>> ANDI PENG: อ๋อ
>> ลำโพง 16: มีไม่ จะเป็นไอ้, but--
ANDI PENG: ไม่ต้องกังวล
ลำโพง 16: --are มี กฎที่แตกต่างกันที่นี่
หรือไม่คุณก็ลืม ที่จะนำคำพูดหรือไม่
>> ANDI PENG: โอ้ใช่
ขออภัยที่ไม่ดีของฉันทั้งหมด
นั่นคือแน่นอน ควรจะเป็นใบเสนอราคา
จับดี.
ที่จะไม่ได้ทำงาน
ตกลง.
>> ดังนั้นประเภทสุดท้ายของวงเราจะพูดคุย เกี่ยวกับและในที่สุดชนิดมากที่สุด
ที่ซับซ้อนเป็นห่วง
ไม่ต้องกังวลถ้าคุณทำไม่ได้ รู้ว่าสิ่งที่หมายถึง
มันสวยทำให้เกิดความสับสนในตอนแรก
เราจะไปกว่าตัวอย่าง
>> ทั้งหมดที่เกิดขึ้นในการวน คือการที่คุณมีสามงบ
ที่คุณกำลังจะรวมถึง
ดังนั้นสำหรับสิ่งบางอย่างคุณ จะเริ่มต้นตัวแปร
คุณกำลังจะเพิ่มเงื่อนไขในการ ซึ่งวงนี้จะทำให้การทำงาน
และแล้วในตอนท้ายของ ห่วงคุณกำลังจะปรับปรุงมัน
คุณสามารถปรับปรุงตัวแปร ที่คุณต้องการที่จะติดตาม
ดังนั้นเราจึงมักจะใช้ สำหรับลูปสำหรับเมื่อเรา
ต้องการเรียกใช้สำหรับวงที่ จำนวนหนึ่งครั้ง
และเรารู้อยู่แล้วว่าโอ้ฉันต้องการ วงนี้ที่จะดำเนินการเช่น 10 ครั้ง
แล้วคุณ do-- ฉันจะไปกว่า ตัวอย่างเช่นในหน้าถัดไป
>> ดังนั้นที่นี่ตัวอย่างเช่นในเกาถ้าคุณ ต้องการสิ่งที่จะทำซ้ำ 10 ครั้ง
สิ่งที่คุณจะพูดคือ ทำซ้ำ 10 ครั้งฉันรัก SAJ!
ซึ่งเป็นที่ยอมรับมากขึ้น แสดงการสนับสนุนสำหรับเรา
มากกว่าวง จำกัด
นี่คือวิธีที่คุณจะ การเปลี่ยนไปใช้ซีและเขียน
ที่มีไว้สำหรับ int-- ฉันจะสร้างหรือ ประกาศตัวแปรชนิด int ชื่อฉัน
ฉันจะเริ่มต้น มันเป็น 0 ดังนั้น i = 0;
และนี่จะเป็นสภาพของฉัน
ดังนั้นฉันน้อยกว่า 10
และแล้วที่ end-- คำสั่งสุดท้ายที่คุณอยู่
จะมีการปรับปรุงของ เกิดอะไรขึ้นกับฉันตัวแปร
ในตอนท้ายของการห่วงของคุณ
ดังนั้นมันเป็นชนิดของความสับสนเพราะ ส่วนต่าง ๆ ของสายนี้
จะเกิดขึ้นที่แตกต่างกัน ประเภทวง
แต่ฉันจะไปมากกว่า ตัวอย่างเช่น pseudocode ที่
และอาจจะอธิบายเรื่องนี้ เพียงเล็กน้อยดีกว่า
>> ดังนั้นที่นี่
นั่นเป็นห่วงเราก็เห็น
เป็นหลักใน pseudocode สิ่งที่ ที่เกิดขึ้นในโปรแกรมนี้
เป็นครั้งแรกที่ฉันสร้าง ฉันเริ่มต้นมันเป็น 0
ผมตรวจสอบเพื่อดูว่าฉันเป็น น้อยกว่า 10 ซึ่งในกรณีนี้
ครั้งแรกที่มันเป็น เพราะ 0 น้อยกว่า 10
ดังนั้นห่วงจะไปทำงาน
และแล้วฉันจะพิมพ์บรรทัดนี้
และจากนั้นในตอนท้ายของบรรทัดนี้ขวา ที่นี่ฉันจะทำเพิ่มฉันฉัน ++
ทุกสิ่งที่หมายถึงคือ การเพิ่มมันโดยหนึ่ง
>> ดังนั้นฉันอยู่ในขณะนี้ 1
เพราะมันเคยเป็น 0 ถ้าฉัน เพิ่มขึ้นมันก็ตอนนี้ 1
และแล้วฉันจะกลับไป ที่จุดเริ่มต้นของวง
และฉันจะตรวจสอบสภาพ
ยังคงสภาพที่เป็นจริงหรือไม่?
ใช่ 1 ยังคงน้อยกว่า 10
ดังนั้นมันจะพิมพ์นี้อีกครั้ง ไปแล้วฉันเพิ่มขึ้นและตรวจสอบ
เงื่อนไข อย่างต่อเนื่องอย่างต่อเนื่อง
จนกว่าคุณจะได้รับในที่สุด ไปยังจุดที่ฉันคือ 10
>> คุณกำลังจะพิมพ์นี้ 10 ครั้ง แล้วฉันจะไปเท่ากับ 10
คุณกำลังจะไปตรวจสอบสภาพ
10 น้อยกว่า 10?
ไม่มีที่เป็นเท็จ
ดังนั้นห่วงนี้จะไม่ การทำงานก็จะแตกสลาย
และคุณกำลังจะไป ต่อเมื่อมีรหัสของคุณ
>> ดังนั้นในขณะที่พวกคุณสามารถดูนี้ เป็นตัวอย่างที่ดีจริงๆ
ของวงที่คุณสามารถเขียนโปรแกรมในการที่ ทำงานสำหรับจำนวนครั้งที่กำหนดไว้
ทุกคนชัดเจน?
ใช่
>> ลำโพง 17: วิธีการเกี่ยวกับการเพิ่มขึ้น ชี้แจงก็คือการเข้ารหัสที่แตกต่างกัน?
>> ANDI PENG: คุณ can-- เราจะไป มากกว่านี้ในภาพนิ่งถัดไป
คำถามที่ดี.
เป็น anyone-- ก่อนที่ผมจะย้าย on-- ทุกคนที่สับสนทั้งหมด
เพราะนี่เป็นแนวคิดที่ยากจริงๆ
ไม่ต้องกังวลถ้าตกลง you're--
เย็น
>> ทั้งหมดขวา
เพียงแค่สไลด์ทั่วไป
ห่วงในขณะนี้จะทำ แน่นอนสิ่งเดียวกันสำหรับวงเป็น
มันเป็นเพียงแค่การเขียนที่แตกต่างกัน
พวกคุณสามารถอ่านภาพนิ่ง ที่อำนวยความสะดวกของคุณในภายหลัง
แต่เพิ่งรู้ว่ามีหลาย วิธีการเขียนในสิ่งเดียวกัน
ที่จะเกิดขึ้นกับลูปที่แตกต่างกัน
ตกลง.
>> ดังนั้นตอนนี้เราได้รับในคำถามของสิ่งที่ ถ้าเรามีห่วงด้านในของวง
เรากำลังได้รับเป็นจริง สิ่งที่จดทะเบียนกองทุนประเภทที่นี่
เมื่อคุณต้องการที่จะทำสิ่งที่หลาย ๆ ครั้งภายในของสิ่งอื่น ๆ
ที่จะทำสิ่งหลายครั้งคุณ ต้องการสิ่งที่เรียกว่าซ้อนกันสำหรับวง
สำหรับบรรดาของคุณเป็นคนแรกที่เห็นนี้และ สับสนมากทุกสิ่งที่เรากำลังทำอะไรที่นี่
จะมีการห่วงที่ เรามีตัวแปรแถว
แต่ภายในของมันเรายังมีอีก สำหรับวงของคอลัมน์ที่เรียกว่าตัวแปร
และผมขอแนะนำให้ทุกท่าน ที่กำลังสับสนแรกให้
track-- วาดออกนี้วาดออกนี้
อย่าพยายามที่จะเพียงแค่เหตุผล ผ่านมันวาดมันออกมา
>> ในหัวของคุณบนแผ่นนี้ กระดาษหรืออะไรก็ตามแถวเขียน
ติดตามสิ่งที่แถวเท่ากับ
เขียนคอลัมน์ติดตาม ของสิ่งที่มีค่าเท่ากับคอลัมน์
และติดตามสิ่งที่เป็น พิมพ์ออกมาด้วยซ้ำทุก
ย้ำทุกคนของวงนี้ทุก ทวนของวงที่มีขนาดใหญ่
เพียงแค่เก็บต่อไปตรรกะ
และผมรับประกันคุณ คุณจะรักในสิ่งที่คุณเห็น
เพราะมันยังมีมาก บังคับสำหรับชุดปัญหาของคุณได้
เย็น
ทั้งหมดขวา
ดังนั้นสิ่งที่สำคัญที่สุด ที่พวกคุณอาจจะทั้งหมด
คิดเกี่ยวกับตอนนี้ เป็นปัญหาของคุณตั้ง 1s,
ซึ่งจะครบกำหนดพฤหัสบดี / ศุกร์
>> ในโปรแกรม water.c ของคุณ คำแนะนำที่คุณกำลังจะมี
เพื่อให้ผู้ใช้สำหรับการป้อนข้อมูล
ภายในโปรแกรม mario.c ของคุณ คุณกำลังจะมี
ที่จะใช้สำหรับวงที่ซ้อนกันซึ่งเป็น สำหรับห่วงภายในสำหรับห่วง
พิมพ์บล็อกของปิรามิดเป็นหลัก เหมือนสิ่งที่มาริโอจะต้องข้ามผ่าน
และจากนั้นภายใน greedy-- ของคุณหรืออาจจะ การเปลี่ยนถ้าใด ๆ ของพวกคุณ
เคยได้ยิน that-- คุณจะต้องเป็นอย่างมาก
ระวังค่าลอยจุดแรก
จำทศนิยมลอย จำนวนเต็มไม่ได้ในสิ่งเดียวกัน
ติดตามเป็นที่หนึ่งซึ่ง
และคุณกำลังจะใช้ งบเงื่อนไขเช่นเดียวกับ
>> สิทธิทั้งหมดสิ่งสุดท้าย
ฉันมีสองสามนาทีที่เหลือ
สไตล์
ดังนั้นนี่คือบางสิ่งบางอย่างที่ไม่ได้ จริงมีผลกระทบต่อประสิทธิภาพ
หรือการทำงานที่เกิดขึ้นจริงของรหัสของคุณ
แต่ก็มีผลต่อเราในฐานะ คารมของคุณเป็นผู้อ่านของคุณ
มันมีผลต่อตัวคุณเองถ้าคุณ พยายามที่จะหาปัญหา
มันมีผลต่อการอ่านของรหัสของคุณ
>> ดังนั้นรูปแบบเช่นเมื่อคุณกำลังพยายามที่จะ รูปแบบการเขียนเรียงความภาษาอังกฤษถ้าคุณ
ไม่ได้มีย่อหน้า คุณมีทุกอย่างชนิด
jumbled ของร่วมกันในหนึ่งบรรทัดมัน ทำให้มันยากมากสำหรับทุกคน
การอ่านเรียงความของคุณแม้ว่า คะแนนของคุณจะมีเหตุผลเสียง
สิ่งที่เหมือนกันในการเขียนโปรแกรม
คุณสามารถมีความชัดเจนอย่างน่ากลัว รหัส Scaz ซึ่งจะครอบคลุม
และยังคงสามารถทำงานและการทำงาน
แต่สำหรับเราเป็นครูที่น่ารักของคุณที่จะ จะอ่านและประเมินผล PSets ของคุณ
ที่ไม่ดีมาก
>> ดังนั้นโปรดเพื่อประโยชน์ ของเราและตัวเอง
เมื่อคุณกำลังพยายามที่จะแก้ไข ปัญหาที่เกิดขึ้นในรหัสของคุณ
และคุณกำลังพยายามที่จะ อ่านรห​​ัสของคุณเองให้
แน่ใจว่าคุณไปตามธรรมเนียมปฏิบัติบาง ที่เรากำลังจะไปมากกว่า
>> ดังนั้นก่อน
ตัวแปรของคุณให้ความหมายชื่อ
ถ้าคุณต้องการที่จะเก็บจำนวนเต็ม เรียกว่าอายุกรุณาตั้งชื่ออายุ
อย่าชื่อมันสูง
เมื่อคุณกำลังพยายามที่จะ เก็บอายุสูง
มันทำให้ทุกอย่าง ทำให้เกิดความสับสนมากสำหรับเรา
เราไม่ชอบให้สับสน
คุณไม่ชอบที่จะต้องสับสน
ไม่มีใครชอบที่จะสับสน
หากคุณกำลังจะสร้างบางสิ่งบางอย่าง ชื่อที่มีความหมาย
>> อย่างไรก็ตามในสำหรับวงเดียว ตัวแปรตัวละครที่มักจะมีการปรับ
และในห่วงถ้าคุณต้องการเพียงแค่ฉัน และเจ k รู้สึกอิสระที่จะทำว่า
>> เริ่มต้นที่สอดคล้องกัน
ดังนั้นสิ่งที่หมายความว่า?
นั่นหมายความว่าในทางเทคนิคในทางทฤษฎี คุณสามารถเริ่มต้นและสร้าง
หลายตัวแปรในบรรทัดเดียวกัน
ดังนั้นสำหรับตัวอย่างเช่นผมสามารถสร้าง จำนวนเต็มเรียกว่า scaz_age ที่
และจำนวนเต็มเรียกว่า andi_age = 20 และจำนวนเต็มเรียกว่า jason_age
ในบรรทัดเดียวกัน
และผมยังสามารถกำหนดเพียงคนเดียว พวกเขาและไม่คนอื่น ๆ ไปเป็นค่า
เราขอให้คุณโปรดอย่าทำอย่างนั้น
เพราะที่นี่คุณได้สร้างหลัก สามตัวแปร แต่เพียงหนึ่งของพวกเขา
จริงมีค่า
และจากนั้นเมื่อเราอยู่ พยายามอ่านรห​​ัสของคุณ
หรือถ้าคุณกำลังพยายามที่จะแก้ไข ปัญหาที่เกิดขึ้นในรหัสของคุณ
มันสับสนมากที่จะปฏิบัติตาม
ดังนั้นเพียงแค่สำหรับการอ่านของคุณ การอ่านของเราไม่ทำอย่างนั้น
>> วงเล็บปีกกาที่สอดคล้องกัน
บางคนชอบที่จะนำพวกเขา วงเล็บปีกกาในสถานที่ที่แตกต่างกัน
มันไม่สำคัญว่าจริงๆ
เพียงให้แน่ใจว่าคุณกำลังที่สอดคล้องกันในของคุณ รหัสของตัวเองในการที่คุณชอบที่จะนำพวกเขา
>> ระยะห่างที่สอดคล้องกัน
หากคุณใส่ช่องว่างหลังหนึ่ง สำหรับวงเสมอทำอย่างนั้น
ไม่เพียงแค่ชอบชนิดของการทำมันได้ที่ บางสถานที่ไม่ได้ทำมันในคนอื่น ๆ
เพียงแค่มีความสอดคล้อง
>> ประการที่สองหากใครต้องการ การอ่านคู่มือสไตล์ CS50,
เรามีคำแนะนำอย่างเป็นทางการในรูปแบบที่ บอกคุณทั้งหมดของการประชุมเหล่านี้
บวกมากขึ้น
มันออนไลน์
มันก็เหมือนกับการ cs50.net/style หรือสิ่งที่ต้องการ
คุณสามารถ google มัน
>> สอดคล้องเป็นกุญแจสำคัญ
จึงไม่ต้องกังวลว่าสิ่งที่ คนอื่นกำลังทำ
เพียงให้แน่ใจว่าคุณเป็น สอดคล้องภายในรหัสของคุณเอง
ใครมีคำถามใด ๆ เกี่ยวกับที่?
ใช่
>> ลำโพง 18: ดังนั้นสิ่งที่เหมาะสม จะทำอย่างไรกับการเริ่มต้นเป็นเพียง
มีพวกเขาทั้งหมดในที่แยกต่างหาก บรรทัดคือว่าสิ่งที่คุณพูด?
>> ANDI PENG: ดังนั้นผมจึงมักจะมีเรื่องนี้เกิดขึ้น
แต่ถ้าคุณต้องการที่จะถ้าคุณต้องการ จะเป็นเหมือนการประหยัดพื้นที่ในรหัสของคุณ
หรืออะไรก็ตามที่คุณสามารถทำเช่นนี้
เราขอให้คุณก็ไม่ได้เริ่มต้น สิ่งหนึ่งที่ไม่ได้และคนอื่น ๆ
ดังนั้นหากคุณต้องการที่จะทำ scaz_age int, int andi_age, int jason_age ที่ดี
เพียงแค่ไม่ได้เริ่มต้นอย่างใดอย่างหนึ่ง และคนอื่น ๆ ไม่ได้เป็นสิ่งที่
>> คำถาม?
ทั้งหมดขวา
ฉันจะผ่านออก ไมโครโฟนและตัวชี้เลเซอร์
และกระบองเพื่อ Scaz ที่จุดนี้
นี้เป็นที่น่าอึดอัดใจ
นี่มันเป็น
>> ไบรอัน SCASSELLATI: ขอบคุณ
วิธีการของที่ให้พลังเสียง?
เสียงดีหรือไม่? .
ที่ดีเยี่ยม
ตกลง.
ดังนั้นทุกคนสวัสดี
>> ฉันจะพยายามที่จะทำงานผ่าน ตัวอย่างในทางปฏิบัติกับคุณ
และเรากำลังจะใช้ CS50 ของ สภาพแวดล้อมการพัฒนาสิ่งที่เรียกว่า
สภาพแวดล้อมการพัฒนาแบบบูรณาการ
และคุณได้เห็นนี้ แสดงให้เห็นในการบรรยาย
และในปัญหาชุดที่ 1 คุณ จะมีโอกาส
ที่จะใช้มันและเล่นรอบกับ มันและได้รับคุ้นเคยกับมัน
เพราะเรากำลังจะใช้มัน ผ่านส่วนที่เหลือของภาคการศึกษา
>> ดังนั้นใน IDE นี้คุณมีสิ่งที่ดู เช่นเบราเซอร์ไฟล์แบบดั้งเดิมมาก
มากกว่าในด้านหนึ่ง
คุณได้มีส่วนหนึ่งขึ้น ด้านบนที่คุณจะ
เพื่อดูรหัสต้นฉบับของคุณของคุณ CFile รหัสที่คุณเขียน
และลงด้านล่างคุณจะ มีหน้าต่าง terminal
ซึ่งคุณจะใช้ในการ ทั้งรวบรวมโปรแกรมของคุณ
และเรียกใช้หรือรันโปรแกรมของคุณ
ตกลง.
>> ดังนั้นเพียงแค่ให้เรานิด ๆ หน่อย ๆ รากฐานในหน้าต่าง terminal ที่
คุณกำลังจะได้รับ ใช้ชุดของคำสั่ง
ที่มีคำสั่งมาตรฐานตลอด ส่วนใหญ่ของระบบ Unix หรือลินุกซ์
และดังนั้นหากคุณเคยใช้ รูปแบบของ Unix, อูบุนตู
หรือใด ๆ ของรสชาติอื่น ๆ เหล่านี้จะไปดูที่คุ้นเคย
>> หากคุณไม่ได้ไม่ต้องกังวล
ไม่มีอะไรที่ซับซ้อนเกี่ยวกับพวกเขาเป็น
พวกเขาเพียงแค่ใช้ที่แตกต่างกัน ไวยากรณ์การตั้งชื่อที่แตกต่างกัน
การประชุมกว่าที่คุณเคยเห็นมาก่อน
>> เพื่อที่จะออกรายการไฟล์ ในสารบบโดยเฉพาะอย่างยิ่ง
พวกเขากำลังจะใช้ คำสั่งที่เรียกว่าคำสั่ง ls หรือรายการ
ถ้าคุณต้องการที่จะเห็นทุกอย่าง โดยมีรายละเอียดทั้งหมด
คุณจะใช้คำสั่ง อาร์กิวเมนต์บรรทัดคำสั่ง ls -l กับ
และที่จะแสดงให้คุณทุกอย่าง ในรายละเอียดมากขึ้นรวมทั้ง
สิทธิ์สำหรับไฟล์
>> ในการเปลี่ยนไดเรกทอรี คุณจะใช้คำสั่ง cd
และคุณจะสามารถที่จะเปลี่ยนไดเรกทอรี ทั้งที่จะไปไดเรกทอรีบ้านของคุณ
นั่นเป็นเพียงแผ่นซีดีโดย ตัวเองมีสองแผ่นซีดี
จุดจะกลับคุณหนึ่ง ระดับไปยังไดเรกทอรีก่อนหน้าของคุณ
และคุณยังสามารถ cd ไป ไดเรกทอรีย่อยโดยการพิมพ์แผ่นซีดี
และชื่อของไดเรกทอรีย่อยว่า
>> นอกจากนี้คุณยังสามารถสร้างไดเรกทอรีใหม่
และเรากำลังจะเดิน ผ่านทางนี้ในเวลาเพียงไม่กี่นาที
แต่ที่จะนำ ทุกอย่างบนหน้าจอ
เพื่อให้คุณสามารถเห็นพวกเขา
>> นอกจากนี้คุณยังจะมีความสามารถ ในการจัดการไฟล์ได้โดยตรง
จากบรรทัดคำสั่ง
คุณจะสามารถที่จะคัดลอกพวกเขาเพื่อ ย้ายหรือลบออก
ว่ามีที่มีประสิทธิภาพเพื่อที่จะลบ
>> IDE ที่ CS50 ช่วยให้คุณเต็ม พลังของอาร์กิวเมนต์บรรทัดคำสั่ง
และนั่นหมายความว่าคุณยังสามารถ ทำในสิ่งที่อันตรายอย่างยิ่ง
ตกลง.
ตัวอย่างเช่นคุณสามารถ เอาออกหรือที่เป็นลบ
ไฟล์โดยไม่ต้องขอ สำหรับการยืนยัน
และคุณยังสามารถลบ recursively-- ที่
อาประ flag-- ทั้ง ไดเรกทอรีย่อยและเนื้อหาทั้งหมด
ตกลง.
พวกเขากำลังแสดงอยู่ในสีแดงเพราะคุณ ควรคิดว่า "อันตราย" ทุกครั้ง
คุณเห็นสิ่งเหล่านั้น
ตกลง.
ทั้งหมดขวา
>> ตอนนี้ในที่สุดสิ่งที่มี จะเป็นจริงที่มีคุณค่าให้กับคุณ
มีเทคนิคที่ดีไม่กี่ ที่จะรู้ว่าขณะที่คุณกำลังการนำ
ผ่านหน้าต่างสถานีนี้
ครั้งแรกที่คุณสามารถล้างหน้าจอใน เวลาโดยเพียงแค่พิมพ์ชัดเจน
และคุณกำลังจะไปดู ผมทำอย่างนั้นค่อนข้างบ่อย
คุณยังสามารถแสดง ข้อความของไฟล์
โดยการพิมพ์มากขึ้นและแล้วชื่อไฟล์
แล้วคุณจะสามารถที่จะเลื่อนกลับและ ออกไปพร้อมกับที่เพียงกับสเปซบาร์
และปุ่มลูกศร
>> หากคุณมีที่เราทำในวันนี้ในการบรรยาย โปรแกรมที่กำลังทำงานอย่างต่อเนื่อง
ในวง จำกัด คุณ สามารถหยุดโปรแกรมที่
จากการดำเนินการโดยการพิมพ์ในการควบคุม ที่มีการถือครองลงควบคุม-C
และคุณอาจจะต้องทำ นี้หลายครั้ง
คอมพิวเตอร์ได้รับไกลไปข้างหน้าของคุณ
และบางครั้งคุณจำเป็นต้อง ให้มันสองสามพยายาม
ก่อนที่มันจะจริงจะมาถึง
>> นอกจากนี้คุณยังจะสามารถที่จะ จัดเรียงคำสั่ง
ที่คุณเพิ่งพิมพ์โดยใช้ขึ้นที่สำคัญ ปุ่มลูกศรแล้วปุ่มลูกศรลง
และสิ่งที่มีประโยชน์มากที่สุดแทน การพิมพ์รายชื่อไฟล์ยาว
คุณจะสามารถใช้แท็บไปที่ เติมคำแนะนำไม่กี่
ตอนนี้เรากำลังจะแสดงให้เห็นถึง ทุกคนในเวลาเพียงสอง
ดังนั้นถ้าคุณจำไม่ได้ พวกเขาไม่ต้องกังวล
เหล่านี้เป็นสิ่งที่คุณจะ รับและใช้ในขณะที่เราไปพร้อม
ตกลง.
>> ดังนั้นใน C-- แตกต่างจากใน Scratch-- C เป็นภาษาที่รวบรวม
นั่นหมายความว่าเรากำลังจะใช้แหล่งที่มา file-- ที่ข้อความที่คุณเขียน
คำสั่งที่คุณเขียน printf () งบลูป,
ทุกอย่าง else-- และเรากำลังจะ ที่จะใช้แฟ้มที่และมือมันออก
เพื่อให้โปรแกรมที่เรียกว่าคอมไพเลอร์
>> คอมไพเลอร์จะน​​ำ ข้อความที่ท่านได้เขียน
และแปลเป็​​น คำแนะนำไบนารี
ว่าคอมพิวเตอร์ของคุณ การใช้งานจริงที่เกิดขึ้น
ที่เรียกว่าวัตถุ หรือแฟ้มที่ปฏิบัติการ
ถ้าคุณดูที่ไฟล์นี้คุณจะ เพื่อดูรหัสที่คุณได้เขียน
ถ้าคุณดูที่ไฟล์นี้คุณจะ เพื่อดูการสุ่มลำดับของตัวอักษร
ที่ให้ความรู้สึกใด ๆ
นั่นเป็นเพราะเป็นไบนารี
มันไม่ได้หมายสำหรับคุณที่จะอ่าน
>> แต่เวลาที่คุณต้องการ ทำงานบางอย่างสิ่งที่คุณกำลังจะ
ที่จะมีการเรียกใช้ไฟล์วัตถุนี้
ดังนั้นเมื่อเราทำงานร่วมกับเหล่านี้ ไฟล์ที่เราจะเขียนไฟล์ในซี
จากนั้นเราจะรวบรวมมันใช้ คำสั่งเช่นทำให้ซึ่งจะก่อให้เกิด
เสียงดังกราวคอมไพเลอร์สำหรับภาษา C
และที่จะผลิตวัตถุ ยื่นเช่นออกหรือในกรณีนี้
ชื่อไฟล์ของฉันที่ฉันได้ใส่ใน
ทั้งหมดขวา
>> ดังนั้นขอจริงลองนี้
ดังนั้นผมจึงมาพร้อมกับตัวอย่าง สิ่งที่ผมอยากจะลอง
และเป็นหนึ่งในสิ่งที่ fascinates ฉันเป็นภาพเคลื่อนไหว
ดังนั้นเราจะพยายามที่จะทำ นิด ๆ หน่อย ๆ ของการเคลื่อนไหว
โดยใช้เพียงอักขระ ASCII
ตัวละครที่เราสามารถพิมพ์ได้อย่างง่ายดายในขณะนี้ออกมา
>> ดังนั้นนี่เป็นความพยายามที่ดีที่สุดของฉัน ที่สร้างสำหรับคุณ
การเคลื่อนไหวของกระต่าย วิ่งผ่านหญ้าสูง
ที่นั่นเขาได้เป็น
ตกลง.
ดังนั้นเขาจึงไม่ได้ทำงาน แต่เขา ยืนอยู่ที่นั่นในหญ้าสูง
>> ตอนนี้ถ้าฉันเป็นภาพเคลื่อนไหวที่ ในโรงเรียนเก่า
รุ่นของแอนิเมชั่สิ่งที่ฉัน จะทำคือผมจะผลิต
ภาพของกระต่ายนี้ในสนามหญ้า
แล้วฉันจะผลิต picture-- อื่น
อีกสิ่งที่พวกเขาเรียกว่า cell-- กระต่ายได้ย้ายเพียงเล็กน้อย
แล้วหนึ่งในสามที่มี กระต่ายย้ายไปนิด ๆ หน่อย ๆ ต่อไป
>> และฉันจะผลิตทั้ง ลำดับของเซลล์เหล่านี้
บางที่กระต่ายที่มีมากกว่า ลงบนด้านซ้ายมือ
และจากนั้นก็ย้ายช้าหนึ่ง โดยหนึ่งไปสู่​​ตรงกลาง
และจากตรงกลาง ไปทางด้านขวา
และถ้าผมแล้วจริงๆ โชคดีที่ฉันจะใส่มันเข้าด้วยกัน
และฉันจะมีชีวิตพวกเขา
และมีกระต่ายของฉัน วิ่งผ่านหญ้า
>> นั่นคือ PowerPoint ที่ดีของฉัน เคล็ดลับสำหรับวันที่
ตกลง.
ดังนั้นนี่เป็นสิ่งที่ดีที่จะได้รับ
ตกลง.
ดังนั้นที่นี่อีกครั้งหนึ่งที่นี่เป็นของเรา กระต่ายวิ่งผ่านหญ้า
>> ลำโพง 19: อีกครั้ง
ไบรอัน SCASSELLATI: หนึ่ง เวลามากขึ้นสิ่งที่ถูกต้อง
มีกระต่ายของคุณ
ตกลง.
>> ดังนั้นวันนี้สิ่งที่เรากำลังจะไป ทำคือการที่เรากำลังจะ
เพื่อพยายามที่จะทำให้กระบวนการ ในการผลิตเซลล์เหล่านี้
เราจะได้ค่อนข้างได้รับไปยังจุดของ ความสามารถในการทำให้พวกเขาทั้งหมดเข้าด้วยกัน
แต่เราจะพยายามที่จะทำให้การ กระบวนการของการสร้างลำดับนี้
>> และนี่คือสิ่งที่มาก การเคลื่อนไหวในวันนี้เป็นเหมือน
นั่นคือคุณไม่ได้ทำในสิ่งที่จำเป็น โดยการวาดทุกอย่างด้วยมือ
เราใช้คอมพิวเตอร์ได้โดยอัตโนมัติ ส่วนหนึ่งของกระบวนการที่
ตกลง.
>> เพื่อให้ฉันเปลี่ยนไป ในขณะนี้เพื่อ IDE CS50 ของเรา
และฉันได้สร้างขึ้นสำหรับ us-- และให้ ฉันซูมเข้าที่นี่ bit-- เล็ก ๆ น้อย ๆ ที่ฉันได้
ที่สร้างขึ้นสำหรับเราที่จุดเริ่มต้น
>> เวลาที่เราขอให้คุณนั่งทุกคน ลงและเขียนชิ้นส่วนของรหัส
สิ่งที่เรากำลังจริงๆขอให้คุณทำ คือเรากำลังขอให้การแก้ปัญหา
และวิธีการที่คุณควร คิดเกี่ยวกับการทำที่
คือโดยเริ่มต้นด้วยบางส่วน เป็นส่วนหนึ่งของการแก้ปัญหาที่ง่ายว่า
และจากนั้นก็สร้างออกจากส่วนที่
และนั่นคือสิ่งที่เรากำลังจะทำในวันนี้
>> ดังนั้นแทนที่จะพยายามทั้งหมดในครั้งเดียวที่จะ เขียนพวงทั้งหมดของรหัสที่
จะผลิต 10 เซลล์ภาพเคลื่อนไหว
เรากำลังจะเริ่มต้นแทน ที่มีชิ้นเดียวที่ทำงาน
และจากนั้นเราจะสร้าง นิด ๆ หน่อย ๆ ที่อยู่รอบ ๆ
และน้อยมากขึ้นและน้อยมาก
>> ตอนนี้สิ่งที่ดีเกี่ยวกับ การแก้ปัญหาด้วยวิธีนี้
ก็คือว่ามันจะช่วยให้คุณเริ่มต้น เสมอกับบางสิ่งบางอย่างที่คุณรู้ว่า
การทำงานและแนะนำหนึ่งในการเปลี่ยนแปลงอย่างค่อยเป็นค่อยไป
และนั่นเป็นวิธีที่ดี ที่จะเรียนรู้วิธีการรหัส,
เพราะเวลาที่คุณทำในแต่ละ การเปลี่ยนแปลงที่คุณเห็นสิ่งที่มันมีผลกระทบ
ตกลง.
>> ดังนั้นนี่คือจุดเริ่มต้นของเรา
ตกลง.
ดังนั้นที่จุดเริ่มต้นของไฟล์ของฉัน ฉันกัญชา # รวม stdio.h
นั่นคือเพื่อที่ฉันจะได้รับ printf () ฟังก์ชั่นการทำงาน
>> ฉันแล้วฉันมีฟังก์ชั่นหลักของฉัน
และนี่ยังคงมีลักษณะเล็ก ๆ น้อย ๆ ความลับหรือปิดบังบางส่วนของคุณ
มันโอเค.
ทั้งหมดก็บอกว่าเป็นที่ ฟังก์ชั่นหลักที่ใช้เวลา
ไม่มี arguments-- หมายถึงเป็นโมฆะ อะไรในซีและมัน
ผลตอบแทนโดยการประชุมจำนวนเต็ม
หลักเสมอกลับจำนวนเต็ม มักรหัสสิ่งที่บอกว่า
ไปได้ด้วยดีหรือไม่ดี
ตกลง.
แต่ที่สำคัญจะต้องมีที่ รูปแบบสำหรับเราตอนนี้
>> ฉันได้ใส่แล้วในสามบรรทัดของรหัส
และพร้อมกับสายของแต่ละคน รหัสฉันได้ใส่ความเห็น
ตอนนี้หนึ่งในสิ่งที่ เราจะยืนยันว่าคุณทำ
และมันเป็นเรื่องที่มีความสำคัญดังกล่าว การเขียนโปรแกรม,
อยู่เสมอแสดงความคิดเห็นรหัสของคุณ
เคยเขียนลงใน สิ่งที่ความคิดเห็นของภาษาอังกฤษ
ที่คุณคิดว่า รหัสควรจะทำ
ด้วยวิธีการนี​​้ในภายหลังเมื่อคุณกลับมา คุณสามารถมองไปที่มันและคุณสามารถพูดได้ว่า
โอ้ผมจำได้ว่าสิ่งที่ฉันเป็น พยายามที่จะทำอย่างไรกับเรื่องนี้
หรือเมื่อ TA นั่งลงกับคุณในการ พยายามที่จะช่วยให้คุณในเวลาทำการ
พวกเขาสามารถมองที่นี้และไปฉัน ดูสิ่งที่คุณกำลังพยายามที่จะทำ
แต่แทนที่จะนี้ สิ่งที่เกิดขึ้นจริงๆ
ตกลง.
>> ดังนั้นผมจึงได้มีสามส่วนรหัสของฉัน ฉันจะเป็นครั้งแรกของการพิมพ์ทั้งหมด
ออกบางจุดที่เริ่มต้น
จากนั้นผมก็จะพิมพ์ออกมาของฉัน กระต่ายแฟนซีมาก
และแล้วบิตบางส่วนของจุดที่สิ้นสุด
>> และทั้งสามงบพิมพ์ควร ดูคุ้นเคยกับคุณที่จุดนี้
สิ่งที่ฉันทำใน แต่ละของพวกเขาเป็นฉัน
พิมพ์ออกลำดับของตัวอักษร
มีตัวแปรที่เกี่ยวข้องกับการเป็นไม่มี
ทุกอย่างเป็นเพียงแบน
ตกลง.
>> ดังนั้นถ้าผมลงไปในขณะนี้เพื่อ terminal-- ของฉัน ขอดูว่าฉันจะได้รับกลับ out--
และฉันจะพิมพ์ที่ชัดเจนอีกครั้ง
>> ลำโพง 20: เราใช้ เฉือนคู่จะแสดงความคิดเห็น?
ไบรอัน SCASSELLATI: สามารถ ใช้ double-- ใช่
มีหลายวิธีที่จะเป็น แสดงความคิดเห็นใน C. หนึ่ง
วิธีคือการใช้เฉือนคู่
อื่น ๆ คือการใช้เฉือนและดาว แล้วปิดด้วยดาวและเฉือน
ทั้งหมดขวา
>> ครั้งแรกของทั้งหมดที่ฉันจะ เริ่มต้นการนำรอบที่นี่
ดังนั้นถ้าผมไปที่ไดเรกทอรีบ้านของฉัน ฉันได้เปลี่ยนมีไดเรกทอรี
ฉันจะมองและดูว่ามีอะไร ในไดเรกทอรีที่สั่ง ls, ออกรายการ
ฉันจะเห็นว่าฉันได้ มีสองไดเรกทอรีย่อย
ขอให้ใหญ่กว่านี้เล็กน้อย ที่นี่เพื่อให้เราทุกคนสามารถเห็นมัน
>> ฉันจะเห็นว่าฉันได้ มีสองไดเรกทอรีย่อย
ฉันจะเปลี่ยนไดเรกทอรี ที่จะเข้าไปในพื้นที่ทำงาน
และฉันจะพิมพ์ออกมาเท่านั้น ส่วนหนึ่งของมันและจากนั้นเพียงแค่กดแท็บ
และมันจะเสร็จสมบูรณ์ส่วนที่เหลือสำหรับฉัน
แฟนซี
>> ฉันจะมองและเห็นในพื้นที่ทำงาน
และตอนนี้ฉันทำงาน ใน SuperSection
ที่เรากำลังเรียนการสอนได้ในขณะนี้
ดังนั้นผมจะไปลงในไดเรกทอรีที่
และในที่สุดก็มองและดู
และผมได้มี bunny.c แฟ้มที่
>> สิ่งที่ถูกต้องเพื่อให้ฉันที่ชัดเจนอีกครั้ง
และฉันจะ now-- อีกครั้งฉัน ยังคงอยู่ในไดเรกทอรีที่
และก็บอกฉันฉันอยู่ใน ว่าไดเรกทอรี SuperSection
ฉันจะไปข้างหน้าและ ทำให้กระต่ายโปรแกรมของฉัน
และคำสั่งที่ให้กระต่าย ในขณะที่เสียงนิด ๆ หน่อย ๆ แปลก
คอมไพเลอร์ยังเรียกเสียงดังกราว
>> และจะผลิต ผลลัพธ์ที่ฉันเป็น
เป็นนักการ funny-- ปฏิบัติการ แฟ้มที่ปฏิบัติการที่เรียกว่ากระต่าย
ตกลง.
ที่ฉันสามารถทำได้แล้วและเสียงนี้ ที่เลวร้ายยิ่งรันกระต่าย
ตกลง.
และเรามาดูสิ่งที่มันไม่
ตกลง.
นั่นเป็นนิด ๆ หน่อย ๆ สิ่งที่ผมคาดหวังว่า
ฉันมีภาพกระต่ายของฉันในนั้น แต่ชนิดของฉันอยากให้มันทั้งหมดด้วยตัวเอง
อะไรที่ฉันคิดถึง?
>> ลำโพง 21: Slash ลิตรหรือเฉือน n
ไบรอัน SCASSELLATI: n Slash
ตกลง.
ดังนั้นขอกลับออกจากที่นี่
และฉันจะได้รับจากการที่
และฉันจะกลับไปเป็นคนนี้
และลองมาดูตอนนี้ จากฟังก์ชั่นหลักของฉันที่นี่
>> ดังนั้นสิ่งที่ฉันควรทำอย่างไร?
ผมต้องการที่จะจบบรรทัด
ดังนั้นผมจะใส่ในการแสดงความคิดเห็น
ฉันจะใส่ใน printf (ที่)
และสิ่งที่ฉันจะต้องใส่อะไรบ้าง?
/ n
ตกลง.
ฉันจะทำอะไรต้องจบมันด้วย?
อัฒภาค
ทั้งหมดขวา
>> ตอนนี้หนึ่งในจริงๆ สิ่งที่สำคัญคือการให้แน่ใจว่า
เวลาที่คุณทำการเปลี่ยนแปลงทุก ในรหัสของคุณที่คุณบันทึกไว้
หากคุณยังไม่ได้บันทึกรหัสของคุณคุณ จะสังเกตเห็นดาวเล็ก ๆ น้อย ๆ ไปอยู่ที่นั่น
และดาราที่บอกว่าคุณ ยังไม่ได้บันทึกรหัสนี้
>> ถ้าผมรวบรวมได้ในขณะนี้ก็ไม่ได้ จะสะท้อนให้เห็นถึงการเปลี่ยนแปลงใด ๆ ของเหล่านั้น
เพราะคอมไพเลอร์มีลักษณะที่ไฟล์ ที่อยู่บนดิสก์ที่ไม่ไฟล์ที่
เปิดในการแก้ไขของคุณ
ทั้งหมดขวา
>> ดังนั้นขอบันทึกไว้แล้วเราจะไป ขวาบนลงที่นี่กลับมาออก
ลงมาไปยังสถานีของฉัน
และให้ล้างพื้นที่อีกครั้ง
>> และเราสามารถไปข้างหน้าและอีกหนึ่ง เวลาให้โปรแกรมกระต่ายของเรา
และดำเนินกระต่าย
ที่ไม่ได้ทำงานอย่างใดอย่างหนึ่ง
เฉือนผิด
ดังนั้นถ้าคุณมองไปที่สิ่งที่ฉันเป็นที่ฉันใส่ / n ในมี แต่ฉันมีเฉือนที่ไม่ถูกต้อง
>> ทุกอย่างที่เครื่องคอมพิวเตอร์ของคุณ ไม่เป็นที่ชัดเจนมาก
ตกลง?
หนึ่งในความผิดพลาดเล็ก ๆ น้อย ๆ ของเครื่องหมายวรรคตอนและ ทันทีที่คุณไม่ได้รับสิ่งที่คุณต้องการ
ทั้งหมดขวา
ดังนั้นขอขยายกลับออกมาอีกครั้ง
เราจะกลับไป
ดีที่ทำให้การซ่อมแซมอย่างรวดเร็วมาก
เราจะใส่ทับขวา
เราจะบันทึกไว้
เราจะกลับมาอยู่ในซูม
>> ด้วยเหตุผลบางอย่างที่ไม่ได้ มีความสุข แต่ขอไปข้างหน้า
และเราจะกลับไปยังสถานีที่นี่
ชัดเจนขึ้น
เราจะซูมเข้า
และอีกครั้งหนึ่งเราจะทำให้กระต่าย
และตอนนี้นั่นเองค่ะก็ทำงาน
ไชโย
ตกลง.
>> ถ้าอย่างนั้นเราพยายามที่จะทำให้เรื่องนี้ เล็ก ๆ น้อย ๆ ทั่วไปมากขึ้น
ลองมาดูว่าแทนเพียง พิมพ์กรอบหนึ่งโดยเฉพาะอย่างยิ่ง
ลองดูว่าเราสามารถทำให้เรื่องนี้ เพื่อที่เราจะได้รับทั้งหมด 10
ของเฟรมภาพเคลื่อนไหวเหล่านั้น ว่าเราต้องการที่จะมี
ดังนั้นอีกครั้งลอง ขั้นตอนนี้ในเวลา
>> Let 's แรกคุยมันไม่ได้ เพื่อที่ฉันจะทำเฟรมทั้งหมด
แต่เพื่อให้ฉันทำอย่างใดอย่างหนึ่ง กรอบที่ฉันอาจต้องการ
ดังนั้นสิ่งที่แตกต่าง ระหว่างเฟรมหรือไม่
เป็นกระต่ายเหมือนกันหรือไม่
ผู้ชม: ใช่
ไบรอัน SCASSELLATI: ใช่
สิ่งที่แตกต่างกันคือ
>> ผู้ชม: ตำแหน่ง
ไบรอัน SCASSELLATI: ตำแหน่งใช่มั้ย?
และวิธีการที่ฉันจะควบคุมตำแหน่งของตนหรือไม่
วิธีการหลายจุดฉัน วางที่จุดเริ่มต้น
และวิธีการหลายจุดฉัน วางที่สิ้นสุด
ดังนั้นผมจึงมีห้าที่ จุดเริ่มต้นที่ห้าในตอนท้าย
>> ลองเปลี่ยนที่ห้าที่มีการห่วง
ตกลง.
และฉันจะสร้างสำหรับ ห่วงในขณะนี้ที่จะต้องพูด
ฉันจะพิมพ์ตัวเลขบางอย่าง ของจุดที่จุดเริ่มต้น
ฉันจะใช้ตัวแปร
สมมติว่าวิธีการเกี่ยวกับที่ฉันเป็น เคาน์เตอร์ในวงของฉัน
และฉันจะประกาศขึ้นด้านบน
>> และจากนั้นในการห่วง ฉันต้องทำสามสิ่ง
สิ่งแรกที่ผมต้องทำ คือผมจำเป็นที่จะต้องเริ่มต้นที่ฉัน
สิ่งที่ฉันควรเริ่มต้น มันเริ่มต้นที่จะเป็นอย่างไร
0
ตกลง.
>> จากนั้นผมจำเป็นต้องพูดอะไร เงื่อนไขการเลิกจ้างหรือไม่
เมื่อฉันควรหยุด?
ดีวิธีการหลายจุดที่คุณทำ ต้องการพิมพ์ในนี้?
>> ผู้ชม: ห้า
ไบรอัน SCASSELLATI: ห้าอีกครั้งหรือไม่
วิธีการเกี่ยวกับขอทำบางสิ่งบางอย่าง ที่แตกต่างกันที่เราทำห้า
ขอแสดงให้เห็นว่ามันแตกต่างกัน
ลำโพง 22: สอง
ไบรอัน SCASSELLATI: สอง
ตกลง.
ดังนั้นถ้าผมต้องการที่สองจุด สิ่งที่ฉันควรใส่ที่นี่?
>> ผู้ชม: สาม
>> ไบรอัน SCASSELLATI: สาม
ตกลง.
กี่ครั้งก็คือ จะไปผ่าน?
ที่จะไปผ่าน สามครั้ง, 0, 1, 2, ขวา?
สิทธิทั้งหมดให้กลับลงไปสอง
ตอนนี้เราจะได้รับจุดสองจุด
และสิ่งที่ฉันต้องการที่จะทำในแต่ละ ทุกครั้งที่ผมไปผ่านห่วง?
สิ่งที่มีการเปลี่ยนแปลง ทุกครั้งที่ผมไปผ่าน?
>> ลำโพง 23: เพิ่มจุด
>> ไบรอัน SCASSELLATI: ฉันมีให้ไป
ฉันจะเพิ่มจุด
ฉันจะพิมพ์จุด, ในแต่ละครั้งที่ผ่านห่วง
แต่วิธีการที่ฉันติดตามของวิธีการ หลายครั้งที่ฉันได้รับผ่านห่วง?
ผมใช้ผมว่า ตัวแปรที่เคาน์เตอร์
>> ดังนั้นทุกครั้งที่ผ่านฉันจะ เพื่อเพิ่มเคาน์เตอร์โดยหนึ่ง
ตอนนี้ที่เหมือนกันสำหรับ ฉันเป็นว่า i = i + 1
มันโอเค.
ฉันจะทำมัน that-- ผมชอบ ชวเลขดังนั้นฉันจะบอกว่าฉัน ++
ตกลง.
>> ลองทำสิ่งเดียวกัน ลงที่นี่ที่ด้านล่าง
เฉพาะชนิดของฉันไม่ว่าอย่างใดอย่างหนึ่ง
ฉันจะให้พวกคุณ อย่างใดอย่างหนึ่งนี้อย่างสมบูรณ์
ทั้งหมดขวา
>> ดังนั้นสิ่งที่ฉันควรจะเขียนที่นี่?
นี่ฉันเป็นห่วง
ฉันจะทำ printf () และฉันจะ ที่จะทำให้มันเพื่อที่ฉันพิมพ์เฉพาะจุดหนึ่งจุด
ที่อยู่ด้านล่าง
>> สิ่งที่ฉันควรจะเขียน ภายในวงนี้ได้ตอนนี้หรือไม่
ดีแรกของทุกสิ่ง ตัวแปรที่ฉันควรใช้?
>> ลำโพง 24: เจ
>> ไบรอัน SCASSELLATI: ฉันสามารถใช้เจ
ฉันสามารถใช้หนึ่งเดียวกันได้หรือไม่
ฉันสามารถใช้ผมอีกครั้งหรือไม่
ใช่
ที่ตกลงเพราะคือ ที่ฉันใช้ขึ้นที่นี่
ฉันไม่ต้องการพวกเขาอีกครั้งเมื่อ ฉันจะได้รับลงไปที่จุดนี้
>> ดังนั้นสิ่งที่ผมควรจะเริ่มต้น i เพื่อ?
ลำโพง 25: 10
ไบรอัน SCASSELLATI: 0
สิ่งที่ฉันควรตรวจสอบ?
วิธีการหลายจุดที่ฉันต้องการตอนนี้ในตอนท้าย ถ้าฉันมีสองจุดที่จุดเริ่มต้น?
ฉันจำเป็นต้องแปดที่สิ้นสุดดังนั้นสิ่งที่ ฉันควรจะตรวจสอบผมน้อย than--
>> ผู้ชม: เจ็ดแปดเก้า
ไบรอัน SCASSELLATI: ผมได้ยินเจ็ด
ผมได้ยินแปด
และข้าพเจ้าได้ยินเก้า
ตกลง.
ดังนั้นพวกเราทุกคนในที่เหมาะสม ball-- เจสันกล่าวว่า 10
ตกลง.
>> ถ้าผมจำเป็นต้องมีจุดสองจุดสำหรับ คนแรกที่หลายวิธีที่จะทำ
I-- และฉันต้องการแปดจุดสำหรับ ล่าสุด one-- ฉันใส่สองถึงข้างต้น
สิ่งที่ฉันควรใส่ลงมาด้านล่าง?
>> ผู้ชม: แปด
>> ไบรอัน SCASSELLATI: แปด
เพราะเห็นว่าเป็นไปได้ นับเป็นศูนย์เจ็ด
และที่แปดครั้งผ่านห่วง
ตกลง.
และสิ่งที่ฉันต้องทำในตอนท้าย?
>> ผู้ชม: ฉัน ++
>> ไบรอัน SCASSELLATI: ฉัน ++
ทั้งหมดขวา
เพื่อให้มองที่ดีงามมี
ลองมันและเรามาดูสิ่งที่มันไม่
ตกลง.
ดังนั้นเราจึงกำลังจะบันทึกไว้
ที่ดีและที่บันทึกไว้
>> เราจะขยายกลับ
เราจะพยายามที่นี่ใน terminal
เราจะซูมเข้า
โอ๊ะ
เราจะ, อีกครั้งหนึ่ง ทำให้โปรแกรมกระต่ายของเรา
และไปข้างหน้าและดำเนินกระต่าย
และมีมันเป็น
>> เพื่อให้มีกระต่ายของเรา
ที่มันมีสองจุดที่จุดเริ่มต้น แปดจุดออกมาในตอนท้าย
ทุกคนยังคงอยู่กับผมหรือเปล่า
ตกลง.
>> ดังนั้นเราสร้างมันขึ้นมา
เราสร้างหนึ่งกระต่าย กรอบหนึ่งโดยเฉพาะ
ตอนนี้เราได้รับสามารถที่จะ คุยว่าจะสร้าง
เพิ่มเติมที่แตกต่างกันของเฟรม
>> ตอนนี้ขอไปข้างหน้าและมีการ มันสร้างไม่ได้เป็นเพียงหนึ่งในกรอบ
แต่ขอสร้าง 10 เฟรมที่เราช้า
ทำให้กระต่ายย้ายทั้งหมด วิธีที่ทั่วสนาม
ทั้งหมดขวา
>> กลับกันเถอะ.
และเราจะพยายามในขณะนี้
ดังนั้นสิ่งที่ผมจำเป็นต้องเปลี่ยนที่นี่?
ฉันจะทำอะไรต้องเปลี่ยน?
>> ลำโพง 26: ก่อนอื่นคุณต้อง เปลี่ยนจำนวนสูงสุดจุด
ที่จุดเริ่มต้น
เพราะถ้าเรากำลังทำอยู่ 10 จุด ก็จะต้องขึ้นอยู่กับขนาด
ไบรอัน SCASSELLATI: ใช่
ดังนั้นตอนนี้ฉันมีมันเรียงลำดับของการเดินสาย ที่มักจะทำสองจุดที่จุดเริ่มต้น
และมักจะทำแปดจุดที่สิ้นสุด
>> ฉันต้องการที่จะสร้างห่วงอีกใช่มั้ย?
เพราะผมไม่ต้องการที่จะ สร้างเพียงหนึ่งภาพกระต่าย
ฉันต้องการที่จะสร้าง 10 ภาพกระต่าย
ดังนั้นผมจึงจำเป็นต้องสร้างห่วงอีก และในขณะที่ฉันไปถึงห่วงว่า
ฉันต้องการที่จะเปลี่ยนวิธีการหลาย ๆ จุดที่ผมพิมพ์ที่จุดเริ่มต้น
และวิธีการหลายจุดที่ผมพิมพ์ในตอนท้าย ตามที่วงจรผ่านห่วง
ผมอยู่ใน
ทั้งหมดขวา
>> จึงขอได้ที่เคาน์เตอร์อื่น
ใครบางคนก่อนที่จะกล่าวว่าเจ ดังนั้นเราจะทำให้เจอีก
และตอนนี้เรากำลังจะไป สร้างอีกสำหรับวง
>> สิ่งที่จะไปภายในวงที่?
สิ่งนี้ได้ไป ภายในวงใช่มั้ย?
กระต่ายไม่ได้ จะไปภายในวง?
ฉันจะต้องกระต่ายใน แต่ละคน 10 เฟรม?
>> ผู้ชม: เอ่อ-ฮะ
ไบรอัน SCASSELLATI: ใช่
ฉันต้องการกระต่ายในแต่ละ ใน 10 เฟรมใช่มั้ย?
วิธีการเกี่ยวกับจุดที่ ท้ายที่สุดฉันจะต้องที่?
ตกลง.
>> ดังนั้นฉันจะเยื้องทั้งหมดของพวกเขา
ฉันจะเน้นทั้งหมดของ นี้และฉันจะกด Tab
และที่จะผลักดันพวกเขาไปทั่ว นิด ๆ หน่อย ๆ เพื่อให้มันเป็นเรื่องง่ายสำหรับผม
เพื่อดูว่ามีอะไรในวง
แล้วฉันจะจบมัน
สมมติว่า
ตกลง?
>> ตอนนี้ในวงนี้ว่า ฉัน building-- ขออภัย,
ให้ที่เพื่อให้คุณสามารถ see-- ฉันมีเจเคาน์เตอร์ของฉัน
ฉันจะเริ่มต้นที่ 0
กี่ครั้งที่ฉันต้องการ ที่จะไปผ่านวงนี้หรือไม่?
ผู้ชม: 10 ครั้ง
ไบรอัน SCASSELLATI: 10 ครั้ง
ดังนั้นสิ่งที่จำนวนฉันควรใส่ที่นี่?
>> ผู้ชม: 9, 10
>> ไบรอัน SCASSELLATI: 9, 10, ใครบางคนที่มีการกล่าวว่า 11 ใช่มั้ย?
ผมอยากที่สองก่อนที่จะจุด และทำให้ฉันน้อยกว่า 2
ผมอยากแปดจุด ฉันใส่ฉันน้อยกว่า 8
ตอนนี้ผมต้องการที่จะไปผ่าน 10 ครั้งดังนั้นฉันใส่เจ than-- น้อย
>> ผู้ชม: 10
>> ไบรอัน SCASSELLATI: 10
เราจะไปที่นั่น.
และสิ่งที่ฉันจะทำในตอนท้ายจะญหรือไม่
++ เพิ่มมัน
ตกลง.
ตอนนี้ที่นี่เป็นส่วนหนึ่งหากินอะไร ที่จะเกิดขึ้นในขณะนี้ถ้าผมทำเช่นนี้?
ฉันกำลังจะพิมพ์ 10 เฟรม?
ลำโพง 27: ผมคิดว่า พวกเขาทั้งหมดจะเป็นแบบเดียวกัน
ไบรอัน SCASSELLATI: พวกเขาจะ ทั้งหมดจะเหมือนกันใช่มั้ย?
เพราะทั้งหมดของพวกเขาจะยังคง ที่จะนำจุดสองจุดที่จุดเริ่มต้น
แต่ผมไม่ต้องการให้พวกเขาทุกคน มีสองจุดเริ่มต้น
วิธีการหลายจุดฉัน ต้องการที่จุดเริ่มต้น?
>> ผู้ชม: การเปลี่ยน
>> ไบรอัน SCASSELLATI: ฉัน อยากให้มันเปลี่ยนใช่มั้ย?
ดังนั้นสิ่งที่ฉันมีที่นี่ที่เปลี่ยนแปลง ในแต่ละครั้งที่วงไปผ่าน?
>> ผู้ชม: จำนวนจุดญ
ไบรอัน SCASSELLATI: เจ จำนวนจุด
ดังนั้นผมจึงสามารถเปลี่ยนนี้จะเป็นเจ
ครั้งแรกที่ผ่าน ห่วงสิ่งที่ว่าจะเป็นอย่างไร
ฉันจะทำอะไรที่จะตั้งเจครั้งแรก?
>> ผู้ชม: 0
>> ไบรอัน SCASSELLATI: ดังนั้นวิธีที่หลาย ๆ เวลาที่ฉันจะทำเช่นนี้?
0
ครั้งที่สองผ่านห่วงเจของ จะเป็น 1 เพราะผมมันเพิ่มขึ้น
วิธีการหลายจุดที่ฉันจะพิมพ์?
1
ครั้งที่สามผ่านห่วง วิธีการหลายจุดที่ฉันจะพิมพ์?
>> ผู้ชม: สาม
ไบรอัน SCASSELLATI: เจเป็นไปได้ที่ 3
วิธีการหลายจุดที่ฉันจะพิมพ์?
โอ้ขอโทษเจจะเป็น 2
วิธีการหลายจุดที่ฉันจะพิมพ์?
>> ผู้ชม: 2
>> ไบรอัน SCASSELLATI: 2
ตกลงดังนั้นฉันจะให้ การเพิ่มว่าในขณะที่เราไปพร้อม
วิธีการเกี่ยวกับลงมาด้านล่าง?
สิ่งที่จะไปลงที่นี่?
ฉันไม่ต้องการที่ 8 เสมอ ในตอนท้ายอีกต่อไปหรือไม่
>> ลำโพง 28: 10
ไบรอัน SCASSELLATI: ฉันต้องการ 10 จุด?
ฉันต้องการที่จะเปลี่ยนแปลงมากเกินไป
ดังนั้นวิธีที่ฉันต้องการจะเปลี่ยน?
>> ผู้ชม: [ไม่ได้ยิน]
ไบรอัน SCASSELLATI: ดีถ้าฉัน มีห้าจุดที่จุดเริ่มต้น
วิธีการหลายจุดของฉันจะได้รับในตอนท้าย?
>> ผู้ชม: ห้า
>> ไบรอัน SCASSELLATI: ถ้าฉันมี หกจุดที่จุดเริ่มต้น
หลายวิธีที่ฉันจะได้รับในตอนท้าย?
ผู้ชม: สี่
ไบรอัน SCASSELLATI: ถ้าผมได้ เจ็ดจุดที่จุดเริ่มต้น
หลายวิธีที่ฉันจะได้รับในตอนท้าย?
ผู้ชม: สาม
ไบรอัน SCASSELLATI: ถ้าฉันได้ มีจุดญที่จุดเริ่มต้น
หลายวิธีที่ฉันจะได้รับในตอนท้าย?
10 เจ
ตกลง.
ดังนั้นลองออก
>> ดังนั้นฉันจะบันทึกโปรแกรมกระต่ายของเรา
อีกครั้งหนึ่งที่เราจะซูมออก
เราจะลงไปยังสถานีของเรา
เราจะล้างมัน
และซูมเข้า
เราจะทำให้โปรแกรมกระต่ายของเราอีกครั้ง
และเราจะดำเนินการได้
เอ่อโอ้.
>> ถือบนขอซูมออก
ฉันไม่ได้รับ 10 เฟรม?
ด้วยวิธีการที่หลายกระต่าย ฉันจะเห็นได้ถึงที่นั่น?
1, 2, 3, 4, 5, 6, 7, 8, 9, 10
ผมได้ 10 เฟรม
พวกเขาทั้งหมดเดียวกันได้หรือไม่
ผู้ชม: ใช่
เลขที่
>> ไบรอัน SCASSELLATI: เลขที่
นั่นเป็นครั้งแรกที่ กระต่ายอยู่ไกลด้านซ้าย
และมากกว่าที่นี่กระต่ายอยู่ไกลบน
ลำโพง 29: ขวา
ไบรอัน SCASSELLATI: ดังนั้น สิ่งที่ฉันไม่ลืมที่จะทำอย่างไร
ลำโพง 30: เริ่มต้นบรรทัดใหม่
ไบรอัน SCASSELLATI: ฉันลืม ที่จะเริ่มต้นใหม่อีกครั้ง
ผิดพลาดเหมือนที่ผมทำมาก่อน
สิทธิทั้งหมดให้เป็นไปแก้ไขปัญหาที่
ตอนนี้ฉันยังคงมีรหัส ในการมีที่จะทำให้การขึ้นบรรทัดใหม่
ไม่ได้ทำงานทำไม?
ลำโพง 31: มันไม่ได้อยู่ในวง
ไบรอัน SCASSELLATI: โอ้ มันไม่ได้อยู่ในวง
ถูกตัอง.
มันนั่งอยู่ข้างนอกนี่
และสำหรับวงคือทุกอย่าง ที่อยู่ภายในข้อความที่
>> ดังนั้นฉันจะย้าย นี้ภายในสำหรับวง
และฉันจะแท็บในด้านหน้าของมันไป แสดงให้เห็นว่ามันอยู่ในสถานที่ที่เหมาะสม
และตอนนี้เราจะบันทึกไว้อีกครั้ง
เราจะซูมออก
เราจะเปลี่ยนไปยังสถานีของเรา
ขยายเข้า.
เราจะ remake โปรแกรมกระต่ายของเรา
และตอนนี้ตอนนี้เรามี 10 เฟรมของเรา
>> [ตบมือ]
>> ไบรอัน SCASSELLATI: OK
ดังนั้น
ที่นี่มีการซ้อนกันของเราสำหรับลูป
เราสามารถที่จะสร้างใน ห่วงด้านวิธีการหลายจุดที่ฉันต้องการ
ในการพิมพ์ที่จุดเริ่มต้นในตอนท้าย
และห่วงด้านนอกควบคุม วิธีการหลายเฟรมที่ผมกำลังสร้าง
เราเริ่มต้นด้วยหนึ่งเล็ก ๆ น้อย ๆ เคอร์เนลของปัญหา
และเราสร้างขึ้นจากจากจุดนั้น
ทั้งหมดขวา
>> ให้ทำขั้นตอนเดียวมากขึ้น
คุณพร้อม?
มีสิ่งหนึ่งที่นี่ที่ เราได้จริงชนิดของได้
ความซับซ้อนเกินกว่าที่เราต้องการ
ลองมาดู
ดังนั้นในโปรแกรมกระต่ายของเรา ถ้าฉันซูมออกจากที่นี่
ที่จริงผมทำบางเดียวกัน สิ่งที่ซ้ำแล้วซ้ำอีก
ฉันจะทำอย่างไรที่การเรียงลำดับของ สิ่งเดียวกันซ้ำแล้วซ้ำอีกเป็นครั้งที่สอง?
>> ลำโพง 32: พิมพ์จุด
>> ไบรอัน SCASSELLATI: ใช่ พิมพ์ครั้งที่สองจุดเหล่านั้น
จริงๆผมควรจะมี นี้แสดงความคิดเห็นลงที่นี่
พิมพ์บางจุดที่ เริ่มต้นขึ้นที่นี่
แล้วฉันพิมพ์บางจุดที่สิ้นสุด
และผมก็ทำชนิดของสิ่งเดียวกัน
สิ่งที่เรากำลังจะเริ่มต้น ที่ทำงานเกี่ยวกับในอีกไม่กี่สัปดาห์ข้างหน้า
คือความสามารถที่จะใช้บล็อกที่ของ รหัสที่เราใช้ซ้ำแล้วซ้ำอีกครั้ง
และผ่านกระบวนการที่ เรียกว่านามธรรม
เรากำลังจะดึงพวกเขาออกและ พวกเขาเขียนครั้งเดียวเพื่อให้เราสามารถแล้ว
นำมาใช้ใหม่ซ้ำแล้วซ้ำอีก
ดังนั้นลองที่
พร้อมหรือยัง?
>> เรากำลังจะใช้บล็อกของรหัสนี้
และฉันจะเอามันออกจากที่นั่น
และฉันจะ define-- ลงที่ด้านล่าง
ฉันจะเขียนฟังก์ชันใหม่
มันจะไม่กลับอะไร
และฉันจะเรียกมันว่า printDots
>> มันจะใช้เวลาหนึ่ง อาร์กิวเมนต์จำนวนเต็มว่า
howManyDots พูดว่าฉันควรจะพิมพ์
และตอนนี้แทนการพิมพ์จุดเจฉันจะ พิมพ์บอก howManyDots ฉันควรพิมพ์
>> และมีปัญหาเล็ก ๆ น้อย ๆ ที่นี่
ใครรู้ว่ามันคืออะไร?
ฉันจะทำอะไรที่มีการระบุไว้ ที่นี่ที่ไม่ได้กำหนดไว้?
>> ผู้ชม: [ไม่ได้ยิน]
>> ไบรอัน SCASSELLATI: ดีว่า หลายจุดที่ถูกกำหนดขึ้น
ที่นี่ แต่ผมใช้ผมตัวแปรที่
ดังนั้นฉันจะใช้ตัวแปรที่ฉัน และฉันกำลังจะไปกำหนดมันลงที่นี่
แทน
>> ดังนั้นตอนนี้มันจะ stay-- โอ๊ะ ได้หมวกล็อค somehow-- ฉัน
จะให้ฉันลงที่นี่
>> ดังนั้นตอนนี้ที่นี่เป็นหน้าที่เล็ก ๆ ของฉัน หรือย่อยประจำและก็กล่าวว่า
วิธีการหลายจุดที่ฉันจะพิมพ์?
และมันจะไปถึงวงนี้และ พิมพ์ซ้ำแล้วซ้ำอีก
>> จากนั้นผมก็สามารถปรับเปลี่ยนโปรแกรมของฉันที่นี่
และสิ่งที่ผมเรียกใช้ฟังก์ชันที่?
printDots
ดังนั้นผมจึงจะเรียก printDots
วิธีการหลายจุดที่ฉันต้องการพิมพ์ เป็นครั้งแรกก่อนที่กระต่าย?
ผู้ชม: เจ
ไบรอัน SCASSELLATI: เจ
วิธีการหลายจุดที่ฉันต้องการพิมพ์ ในท้ายที่สุดหลังจากที่กระต่าย?
10 เจ
>> และมีสิ่งหนึ่งที่ฉันหายไป
ในขณะที่คุณเห็นในการบรรยายในวันนี้ เรากำลังจะประกาศ printDots
ขึ้นไปข้างบนเพื่อให้ต้นแบบ
ตกลง.
>> ดังนั้นสิ่งที่ผมทำคือผมได้พยายามที่จะ แยกที่นำกลับมาใช้เป็นส่วนหนึ่งของรหัส
ที่ฉันได้ทำซ้ำแล้วซ้ำอีก
และฉันได้พยายามที่จะดึงมันออกเพื่อให้ ทั้งหมดที่มีอยู่ในสถานที่แห่งหนึ่ง
วิธีการที่ถ้ามีความผิดพลาดบาง ฉันมีเพียงแค่ที่จะแก้ไขได้ในจุดหนึ่ง
ทั้งหมดขวา
>> ดังนั้นขอบันทึกไว้
และขอให้แน่ใจว่าการทำงาน
ดังนั้นขอให้ออกไป
เราจะไปอีกครั้งไปยังสถานีของเรา
เราจะซูมเข้า
เราจะทำให้กระบวนการกระต่ายที่
>> โอ้
และมันทำให้ฉันมีคำเตือน
มันเป็นสิ่งที่บอกฉัน?
ดีในใด ๆ เหล่านี้ บางครั้งคุณต้องการเสมอ
เพื่อเลื่อนขึ้นไป error-- แรก ตอนนี้ที่นี้ผมได้มีเพียงหนึ่ง
>> มันบอกผมใน bunny.c บนเส้น 8 คอลัมน์ 9 มีปัญหา
มันบอกว่าคุณได้ประกาศนี้ ฉันตัวแปรและคุณไม่ได้ใช้มัน
>> ตอนนี้ปกติท​​ี่ ไม่ได้เป็นข้อผิดพลาดที่เลวร้ายที่สุด
นั่นเป็นหนึ่งง่ายต่อการแก้ไข
และในความเป็นจริงเราสามารถกลับไป
เราสามารถกลับไปกระต่าย
และในกรณีนี้เราทุกคน ต้องทำคือการกำจัดของฉัน
เพราะเราไม่ได้ใช้ ฉันภายในหลักอีกต่อไป
เราเพียงแค่ใช้มัน ภายในย่อยประจำของเรา
>> ดังนั้นขอบันทึกว่า
เราจะกลับไป
และซูมเข้า
เราจะอีกครั้งหนึ่งทำให้กระต่าย
และมีอีก 10 เฟรมของเรา
ตกลง.
>> ทุกครั้งที่คุณได้รับ procedure-- ใช่
ลำโพง 33: ฉันมี a-- ฉันสับสน
คุณสามารถกลับไปที่รหัส?
ไบรอัน SCASSELLATI: อ๋อ
>> ลำโพง 33: ดังนั้นเมื่อคุณเขียน ต้นแบบของการโต้แย้งคุณ
มันมีชื่อเรียกว่า howmany?
แต่ below--
>> ไบรอัน SCASSELLATI: Oh yeah
>> ลำโพง 33: --called สิ่งที่พวกเขา ที่แตกต่างกันที่ฉันไม่เข้าใจ
>> ไบรอัน SCASSELLATI: ทำไม พวกเขามีความแตกต่างกัน
เพื่อให้เป็นคำถามที่ดี
ดังนั้นคำถามคือขึ้น ที่นี่ผมเขียน howmany,
และลงมาด้านล่างที่ผมเขียน howManyDots
>> เหตุผลก็คือว่าในต้นแบบของคุณ มันจริงไม่ได้ให้ความสนใจ
ชื่อที่คุณใส่ใน
ทั้งหมดก็จริงๆใส่ใจเกี่ยวกับ คือว่ามันเป็นจำนวนเต็ม
มันอยากจะรู้ว่ารูปแบบ สิ่งที่คุณใส่ใน
>> ตอนนี้ stylistically-- oops-- สิ่งที่ฉันควร ไม่เป็นที่ผมชอบที่จะทำให้การแข่งขันเหล่านี้
ตกลง.
เพราะที่จะให้มัน ง่ายสำหรับผมที่จะจำ
แต่นั่นก็เป็นความผิดพลาดของฉันใช่
>> ลำโพง 34: ดังนั้นสำหรับ ต้นแบบในการทำงานเพียง
เขียนเส้นนั้น เขียนต้นแบบ
ช่วยให้การทำงานที่มาว่า ด้านล่างขวามันไปที่สิ้นสุด
และเรียกสิ่งที่หมายถึง?
>> ไบรอัน SCASSELLATI: มันหมายถึงอะไร คือเมื่อคอมไพเลอร์ผ่านไป
มันจะไปจากด้านบนของ รหัสของคุณไปที่ด้านล่าง
และสิ่งที่ต้นแบบนี้เป็น มันเป็นพื้นสัญญา
>> มันบอกว่ามีเป็นไปได้ ฟังก์ชั่นที่กำหนดไว้ที่ใดที่หนึ่ง
มันจะถูกเรียกว่า printDots
และมันจะใช้เวลาหนึ่งในการโต้แย้ง ที่จะเป็นจำนวนเต็ม
และมันจะกลับมา อะไรประเภทโมฆะ
ตกลง.
ผมสัญญาว่าคุณก็เป็นไปได้ ที่กำหนดไว้ที่ใดที่หนึ่งลงที่ถนน
แต่เวลาที่คุณเห็น ที่ที่คุณไปลง
ผ่านส่วนที่เหลือของฉัน ฟังก์ชั่นหลักที่ฉันต้องการ
คุณในการรักษาที่เป็นฟังก์ชั่น ที่จะเข้าจำนวนเต็มหนึ่ง
>> และดังนั้นเมื่อคอมไพเลอร์ลงไป ผ่านทางนี้ก็เห็นสัญญาว่า
และเมื่อได้รับลง ช่วยให้ไปเก็บไป,
พบครั้งแรก printDots เป็นที่กล่าวถึง
และมันก็บอกว่าโอ้คุณให้ ฉันญนี้ เจเป็นจำนวนเต็ม
>> ดีที่คุณสัญญากับฉันที่จะ เป็นจำนวนเต็มและที่เหมาะสม
มันโอเค.
และแล้วในที่สุดก็ลดลง ที่ด้านล่างมาก
ก่อนที่ผมจะได้รับการสิ้นสุดของฉัน ไฟล์ที่ผมทำตามสัญญาของฉัน
และฉันกำหนดมัน
ตกลง?
>> ลำโพง 35: ดังนั้นจึง saves-- โปรแกรมจะช่วยให้ช่องว่าง
ว่ามันจะกลับไปและเติมที่สิ้นสุดหรือไม่
>> ไบรอัน SCASSELLATI: มันไม่ได้ เกี่ยวกับการจัดสรรหน่วยความจำ
มันเป็นจริงเพียงเกี่ยวกับสิ่งที่ ชนิดที่คุณคาดหวังว่าจะได้เห็น
สิ่งนี้ควรจะมีหนึ่ง ข้อโต้แย้งหรือข้อโต้แย้งที่ห้า?
ควรจะเป็นจำนวนเต็ม มอบให้กับมันหรือสตริง?
นั่นคือทั้งหมดที่กำลังมองหา จะทำคือการตรวจสอบ
คุณให้ฉัน ชนิดที่เหมาะสมของการโต้แย้ง
ตกลง?
ทั้งหมดขวา
>> ให้ฉันทำให้คุณมี หนึ่งบิตอื่น ๆ ที่จะมองไปที่
ศิลปะ ASCII ไม่ได้เป็นรูปแบบที่ดี ของการเคลื่อนไหวตามที่วันนี้
แต่บางคนแน่นอนใช้สิ่ง และพวกเขาผลักดันให้สุดขั้วของพวกเขา
>> นี้เป็นอย่างดาวิดแสดงให้เห็นถึง ในการบรรยาย, ชิ้นส่วนของรหัส
ที่คุณควรภายใต้สถานการณ์ที่ไม่มี พยายามที่จะทำซ้ำตัวเอง
เพราะมันเป็นสไตล์ที่น่ากลัว
ในความเป็นจริงมันถูกออกแบบมาให้เป็น ยากที่จะเป็นไปได้ที่จะอ่าน
ตกลง.
>> ดังนั้นจะทำอีกครั้งขอซูมเข้าที่นี่
ฉันจะไปตอนนี้เปลี่ยนไดเรกทอรี
ฉันจะขึ้นไปอย่างใดอย่างหนึ่ง ระดับกลับไปยังพื้นที่ทำงานของฉัน
จากนั้นผมก็จะเปลี่ยนไดเรกทอรีเป็นแบบนี้ ไดเรกทอรีอื่น ๆ ที่เราได้สร้าง
>> และนี่คือนานาชาติ obfuscated C ประกวดการเขียนโปรแกรม
obfuscated วิธีการอย่างหนัก เป็นไปได้ที่จะเข้าใจ
ดังนั้นโปรดอย่ากลัวถ้าคุณมอง ที่นี้และไปฉันไม่สามารถอ่านว่า
ที่จุดของมัน
ตกลง?
>> แต่เรามีนี้ โปรแกรมที่ยอดเยี่ยมที่ผม
จะไปดูที่โดยเพียงแค่การพิมพ์มากขึ้น
และให้ดูว่าฉันสามารถซูมออก เพียงเล็กน้อยเพื่อให้คุณสามารถมองเห็นได้
>> และนี่คือโปรแกรม
มันชื่อ endo.c.
และดูเหมือนว่าถังที่มีนี้ ชนิดของตัวอักษร F-L-U-I-D ในนั้น
>> นี้เป็นจริงโปรแกรม
มันเขียนในปิดบังมากที่สุด วิธีการที่ผู้เขียนอาจจะ
เขียนมัน
แต่มันเป็นชิ้นเล็ก ๆ ที่ยอดเยี่ยมที่ สร้างรูปแบบของการเปลี่ยนแปลงของเหลว
>> และเพื่อให้เรากำลังจะให้ ว่ารูปแบบการป้อนข้อมูลที่
ลักษณะเช่นนี้ของ staired ตั้งของภาชนะบรรจุ
ด้วยของเหลวบาง ของเหลวขึ้นที่ด้านบน
และเราจะมีมันจำลอง สิ่งที่เกิดขึ้นกับมัน
>> ดังนั้นผมจึงจะเรียกฟังก์ชั่นที่ Endo
และฉันจะให้มันว่า แฟ้มข้อมูลที่ผมเคยมี
และมีสิ่งที่ดีเลิศของเราคือศิลปะ ASCII
จำลองแบบไดนามิกเต็มรูปแบบของเหลว ทำงานในเพียงไม่กี่บรรทัดของรหัส
>> ตอนนี้สิ่งที่เป็นจริงจริงๆ ที่น่าตื่นตาตื่นใจเกี่ยวกับโปรแกรมนี้น้อย
คือว่าผมต้องการที่จะหยุดได้ในขณะนี้ ดังนั้นฉันจะใช้สิ่งที่คำสั่ง?
>> ผู้ชม: การควบคุม-C
>> ไบรอัน SCASSELLATI: การควบคุม-C ตกลง.
ดังนั้นผมจะใช้การควบคุม-C C ที่จะหยุดมันได้
ฉันจะล้างอีกครั้ง
และตอนนี้ฉันจะเรียก โปรแกรมรันโปรแกรม
โดยใช้ตัวเองเป็นอินพุท
>> และเราจะเห็นแบบไดนามิกของเหลว แบบจำลองของมันละลาย
ตกลง.
กรุณาอย่าให้โปรแกรมที่ เป็นสิ่งที่สร้างความสับสนให้กับคุณ
มันเป็นเพียงเพื่อให้เราสามารถสิ้นสุดในวันที่ สิ่งที่เย็นและน่าสนใจ
ตกลง.
>> ดีที่สุดของโชคกับชุดปัญหาของคุณได้
เราจะมีความสุขที่จะตอบ คำถามหลังเลิกเรียน
ขอบคุณมากครับ