>> [เล่นเพลง]
DAVID ลัน: สิทธิทั้งหมด
นี่คือ CS50 และนี้ เป็นจุดสิ้นสุดของสัปดาห์ที่ 2
ฉันขอโทษฉันไม่สามารถมี มีกับทุกท่านในวันนี้
แต่คุณอยู่ในมือที่ดีมาก
ให้ผมแนะนำ CS50 ของตัวเองร็อบโบว์
ROB BOWDEN: และแน่นอนแล้ว เราจะต้องทำให้ความสนุกของความเป็นจริง
ที่เขาส่งมาให้เราแนวตั้ง วิดีโอและแสดงให้เห็นนี้
>> [วิดีโอเล่นภาพ]
>> [เล่นเพลง]
>> [รอยเท้า]
>> วิดีโอ -This ไม่ได้ ต้องดูทางนี้
มันอาจจะได้รับการป้องกัน
บอกว่าไม่มีการวิดีโอในแนวตั้ง
>> วิดีโอแนวตั้งเกิดขึ้นเมื่อคุณ ถือกล้องของคุณทางที่ผิด
วิดีโอของคุณจะจบ มองเหมือนอึ
>> - [ฮึดฮัด]
>> -There เป็นคนมากขึ้นและติดยาเสพติด เพื่อการทำวิดีโอในแนวตั้งทุกวัน
มันไม่ได้แตกหรืออะไร แต่ก็ยังคงไม่ดีจริงๆ
มีสองชนิดที่แตกต่างกันอยู่ คนที่มีความทุกข์กับ VVS
กลุ่มแรกถือว่า วิดีโอที่พวกเขาถ่ายภาพเหมือนภาพ
พวกเขาไม่ได้หมายถึงอันตรายใด ๆ
พวกเขาก็ไม่เข้าใจว่า ในขณะที่คุณสามารถเปิดภาพ
คุณไม่สามารถจริงๆเปิดวิดีโอ
>> [CRASH]
>> - [ลิงเสียง]
>> -The กลุ่มอื่น ๆ ที่เป็นคน ที่ไม่ได้ให้ [แหลม]
>> วิดีโอซินโดรมแนวตั้งเป็นอันตราย
ภาพเคลื่อนไหวที่มี ได้เสมอในแนวนอน
โทรทัศน์เป็นแนวนอน
หน้าจอคอมพิวเตอร์เป็นแนวนอน
สายตาของผู้คนที่มีแนวนอน
เราไม่ได้สร้างขึ้นเพื่อ ดูวิดีโอในแนวตั้ง
>> -I รักวิดีโอในแนวตั้ง
>> ใส่ใจ -Nobody เกี่ยวกับคุณ
>> ถ้าปัญหานี้ ซ้ายไม่ จำกัด , คุณมากเกินไป
จะเริ่มต้นการแสดงสี่วิดีโอ ในครั้งเดียวเพียงเพื่อประหยัดแบนด์วิดธ์
>> วิดีโอแนวตั้งจะ -Letterboxed มีขนาดของแสตมป์
>> และอื่นมันจะแพร่กระจายไปทุกที่
มีหน้าจอภาพยนตร์ ได้เสมอในแนวนอน
หากวิดีโอกลายเป็นแนวตั้ง ได้รับการยอมรับโรงภาพยนตร์
จะต้องสูงและผอม
>> และอื่นทั้งหมดของโรงภาพยนตร์จะ ได้จะได้รับการฉีกขาดลงและสร้างขึ้นมาใหม่
และเมื่อถึงเวลาที่พวกเขาสร้างขึ้นมาใหม่ Mila Kunis จะเก่าและน่าเกลียด
>> -Birds จะผิดพลาดในพวกเขาและตาย
>> ทุกคนได้รับ -We'll แข็ง คอจากการมองขึ้น
>> และอื่นไม่มีใครจะนั่งอยู่ใน แถวหน้าที่เคยอีกครั้ง
>> จอร์จลูคัสจะกลับปล่อยดาว สงคราม again-- รุ่นผอม
>> -I จริงๆก็ไม่เคยสามารถที่จะบอก เรื่องที่ผมอยากจะบอก
นี่เป็นโอกาสที่ดีสำหรับผมที่จะ การทดสอบด้วยเทคโนโลยีใหม่
>> มั้กระตุก
>> ทาเวลาโทรศัพท์มือถือที่ใช้ในการ วิดีโอบันทึกสิ่งล่อใจที่มี
เพียงแค่บอกว่าไม่มี
บอกว่าไม่มีการจอร์จลูคัส
บอกว่าไม่มีการเก่า Mila Kunis
บอกว่าไม่มีการวิดีโอในแนวตั้ง
>> และอื่นถ้าคุณเห็นคนที่ทำมันพูดว่า "คุณไม่ได้ยิงหุ่นที่ถูกต้อง!"
>> [เล่นเพลง]
>> [จบเล่นภาพ]
>> [APPLAUSE]
>> [OUT AUDIO]
ROB BOWDEN: --simple รูปแบบของการเข้ารหัส
ซึ่งเป็นพื้นการเข้ารหัส และถอดรหัสข้อความลับ
ดังนั้นที่นี่เรามีของเล่นที่ง่ายมาก
และความคิดที่เป็นวงแหวนรอบนอก หมุนรอบแหวน
และคุณสามารถเห็นบางทีถ้าผมซูม ใน that-- มันยากที่จะเห็น
แต่เหมือนจำนวน 1- ดีที่ย้าย
>> จำนวน 1 แผนที่ไปยังตัวอักษร X จำนวน 2 แผนที่ไปยังตัวอักษร
เจยากอย่างไม่น่าเชื่อ ไม่ได้ที่จะข้ามไปข้างหน้า
ตัวอักษร 2 แผนที่เจ จำนวน 3 แผนที่จะดีดังนั้น
กับแหวนวงนี้คุณสามารถให้ คนข้อความที่ 1, 2, 3
ด้วยเหตุผลบางอย่าง ต้องการที่จะบอกพวกเขา XJD
แต่คุณสามารถให้พวกเขา ข้อความบางส่วนของตัวเลข
และตราบใดที่พวกเขามีแหวนวงนี้พวกเขา สามารถถอดรหัสสิ่งที่คุณกำลังพยายามที่จะพูด
>> ดังนั้นคุณอาจจะได้เห็นนี้ ตัวอย่างเช่นโดยเฉพาะอย่างยิ่งของการเข้ารหัส
ก่อนถ้าไปรอบ ๆ ในช่วงเทศกาลคริสต์มาส คุณได้ดูเรื่องคริสต์มาส
ถ้าคุณไม่เคยเห็น มาก่อนแล้วก็
เปิด TBS ที่แท้จริง เวลาในวันคริสต์มาสอีฟใด ๆ
เพราะพวกเขาก็แสดงให้เห็นว่ามันกลับไปกลับ การสำรองการสำรองการสำรองตลอดทั้งวัน
และวิดีโอที่เกี่ยวข้องคือ
[วิดีโอเล่นภาพ]
-Be มันที่รู้จักกันทั้งเพ ที่ราล์ฟปาร์กเกอร์เป็นขอ
ได้รับการแต่งตั้งเป็นสมาชิกของเล็ก ๆ น้อย ๆ เด็กกำพร้าแอนนี่วงกลมลับ
และมีสิทธิที่จะได้รับเกียรตินิยมทั้งหมด และผลประโยชน์ที่เกิดขึ้นดังกล่าว
ลงนามกำพร้าแอนนี่
ปิแอร์อังเดรราชโองการหมึก!
เกียรติประวัติและผลประโยชน์ แล้วที่อายุสิบเก้า!
>> [ตะโกนจาก RADIO]
-เข้ามา.
ให้ของได้รับกับมัน
ฉันไม่จำเป็นต้องทุกสิ่งที่แจ๊ส เกี่ยวกับการลักลอบและโจรสลัด
คืนพรุ่งนี้ -Listen กับ การผจญภัยสรุป
ของเรือโจรสลัดสีดำ
ตอนนี้ก็ถึงเวลาสำหรับ ข้อความลับของแอนนี่
สำหรับคุณสมาชิกของวงกลมลับ
โปรดจำไว้ว่าเด็กเฉพาะสมาชิก ของแอนนี่ความลับของวงกลม
สามารถถอดรหัสข้อความลับของแอนนี่
โปรดจำไว้ว่าแอนนี่ขึ้นอยู่กับคุณ
ตั้งขาของคุณเพื่อ B2
นี่คือข้อความนั้น
12
11
2
-I am ในการประชุมลับครั้งแรกของฉัน
>> -25
14
11
18
16
>> โอ้ปิแอร์อยู่ในเสียงที่ดีในคืนนี้
ผมบอกได้เลยว่าคืนนี้ เป็นข้อความที่สำคัญจริงๆ
-3
25
นั่นคือข้อความจากแอนนี่ตัวเอง
โปรดจำไว้ว่าอย่าบอกใคร
>> -Five วินาทีต่อมาผมอยู่ในเฉพาะ ห้องพักในบ้านที่เป็นเด็กเก้า
จะนั่งในความเป็นส่วนตัวและถอดรหัส
Aha!
B!
ผมไปต่อไป
อีคำแรกคือ "เป็น."
เอสมันได้มาง่ายขึ้นในขณะนี้
ยู 25
นั่นคืออาร์
-Come บนฟี่!
ฉันต้องไป!
ผมจะไปมีสิทธิลงแม่!
Gee หวือ
ทีโอ "ให้แน่ใจว่าได้" - ให้แน่ใจว่าสิ่งที่?
อะไรคือสิ่งเล็ก ๆ น้อย ๆ เด็กกำพร้า แอนนี่พยายามที่จะพูด?
ให้แน่ใจว่าได้อะไร?
>> -Randy ได้มีที่จะไป!
คุณจะกรุณ​​าออกมา?
>> สิทธิพักแม่!
ฉันจะออกขวา!
ผมได้รับในขณะนี้อย่างใกล้ชิด
ความตึงเครียดเป็นที่น่ากลัว
มันคืออะไร?
ชะตากรรมของโลก อาจแขวนอยู่ในสมดุล!
>> -Ralphie, แรนดี้ได้ที่จะไป!
>> ผมจะไปมีสิทธิออกสำหรับร้องไห้ออกมาดัง ๆ !
เกือบจะมี!
นิ้วมือข​​องฉันบิน
ใจของฉันเป็นกับดักเหล็ก
ทุกขุมขนสั่นสะเทือน
มันเป็นที่ชัดเจนเกือบ!
ใช่
ให้แน่ใจว่าได้ดื่มโอวัลติของคุณ
โอวัลติ?
พาณิชย์ crummy?
ไอ้บ้า
>> [จบเล่นภาพ]
>> ROB BOWDEN: เพื่อให้เป็นวิธี โอวัลติที่เกี่ยวข้องกับการเข้ารหัส
โดยทั่วไป CS50 โฆษณาเพียง โอวัลติเพื่อที่เราจะทำได้
จะเป็นเชิงพาณิชย์ crummy สำหรับโอวัลติ
ทั้งหมดขวา
ดังนั้นตอนนี้วิทยาการคอมพิวเตอร์ที่เกิดขึ้นจริง
โปรดจำไว้ว่าในวันจันทร์ที่เราออกมา การดำน้ำลึกลงไปในสาย
ดังนั้นเราจึงได้รับการจัดการกับ สตริง "Zamyla."
และเราก็ตระหนักถึง ความจริงที่ว่าเราสามารถรักษา
"Zamyla" เป็นลำดับของตัวอักษร
และจำไว้ว่าเราได้เรียนรู้ สัญกรณ์วงเล็บ
ดังนั้นหากนี้ถูกเก็บไว้ ในสตริง "s" แล้ว
ถ้าเราบอกว่ายึด s 0 ที่จะ บ่งบอกถึงตัวอักษรซี
และถ้าเรากล่าวว่าวงเล็บ s 1 ที่ จะบ่งบอกถึงตัวพิมพ์เล็กครั้งแรก
และอื่น ๆ ขึ้นไปยึด s 5 ซึ่งจะบ่งบอกถึงสุดท้าย
>> ตอนนี้จำไว้ว่า ความยาวของสายนี้คือ 6,
แต่ดัชนีเป็นสตริงที่มี 0 ถึง 5 Z ผ่านที่ผ่านมา
ดังนั้นในตอนนี้ควรเป็นภาพใหญ่ ของหน่วยความจำของคอมพิวเตอร์ของคุณ RAM ของคุณ
ดังนั้นที่ใดที่หนึ่งโปรแกรมที่ คุณกำลังใช้งานเครื่องคอมพิวเตอร์ของคุณ
ความต้องการที่จะจำ Zamyla ที่ใดที่หนึ่งในความทรงจำ
ดังนั้นผมจึงสามารถมีอาสาสมัครหรือไม่?
ใช่โปรด
และสิ่งที่เป็นชื่อของคุณ?
>> คณบดีคณบดี
>> ROB BOWDEN: คณบดี?
ยินดีที่ได้รู้จักคุณดีน
ดังนั้นมาที่นี่และ เรากำลังจะมีคุณวาด
ในรูปแบบที่ดีของเราที่ดีของหน่วยความจำ
ตอนนี้ผมชอบที่จะคิดของหน่วยความจำ เป็นหนึ่งในแถบยาวของไบต์
แต่สำหรับการแสดงผลเราจะ เพียงแค่ซ้ายไปขวาบนลงล่าง
ตกลง?
>> ดังนั้นฉันจะแสดง program-- Getstrings.c
และเพื่อให้ทุกโปรแกรมนี้ จะขอทำสี่สาย
จากผู้ใช้ที่มี GetString แล้วพิมพ์
สิ่งที่สายแรกเข้ามาเป็น
เราไม่สนใจสองผ่านสี่
ตกลง.
ดังนั้นกว่าที่นี่ now-- เมื่อ ผมคำขอ s1 แรก
เพื่อให้คุณมีเครื่องคอมพิวเตอร์
และคุณมีการดำเนินการ GetString
ดังนั้นคุณจึงขอสตริงจาก ฉันและฉันพูดว่าตกลงคณบดี
ให้สตริง "คณบดี".
>> ดังนั้นในบางส่วนของหน่วยความจำที่คุณ ต้องจำไว้ "คณบดี".
เพื่อเขียนลงในหน่วยความจำที่ใดที่หนึ่ง
ที่สมบูรณ์แบบ
ตกลง.
ดังนั้นตอนนี้เรามี s2
และ s2 เป็นไปได้ ขอให้ GetString
ดังนั้นฉันจะใส่สตริง
ฉันจะใส่ "ฮันนาห์."
ดังนั้นใส่ "ฮันนาห์" อยู่ที่ไหนสักแห่งในหน่วยความจำ
ใช่
A-H
>> ตกลงดังนั้นตอนนี้ s3
และมันก็เป็นไปได้อีก ขอให้ GetString
และดังนั้นตอนนี้ใส่ "มาเรีย".
ทั้งหมดขวา
แล้วมีคนสุดท้าย ขอให้ GetString, s4
ดังนั้นผมไม่ทราบว่า
วิธีการเกี่ยวกับที่เราจะไปด้วย antidisestablishmentarianism
ดังนั้นที่ใส่ในหน่วยความจำ
ใช่
ดังนั้นเพียงแค่ทำ "ร็อบ".
>> ตกลง.
ดังนั้นตอนนี้ explain-- ทำไม คุณออกจากช่องว่างเหล่านี้หรือไม่
ทำไมคุณต้องว่างเปล่านี้ พื้นที่ที่นี่ที่นี่และที่นี่?
ใช่
สังเกตเห็นดังนั้นเมื่อผมไป พิมพ์ s1-- ดังนั้นหากเรา
มี "ฮันนาห์" ทำงาน ขวาขึ้นถัดจาก "คณบดี"
ทำอย่างไรเรารู้ว่าเมื่อ สตริง "คณบดี" จบลง?
ดังนั้นการพิมพ์ s1 สตริงอาจจะมี เพียงแค่พิมพ์ "DeanHannahMariaRob"
ถ้ามันไม่ได้มีเงื่อนงำใด ๆ เมื่อ "คณบดี" จริง ๆ แล้วจบลง
>> ทั้งหมดขวา
ดังนั้นในความทรงจำวิธีที่เราจริง เป็นตัวแทนของจุดสิ้นสุดของสตริงนี้
เป็นศูนย์ที่มีเครื่องหมาย
ดังนั้นพื้นที่ตรงนี้เป็นสิ่งที่เราต้องการ
มันควรจะเป็นศูนย์เครื่องหมาย
นี้จะเป็นเครื่องหมายศูนย์, และนี่จะเป็นศูนย์เครื่องหมาย
และคุณสามารถมีได้รับรางวัลยอดเยี่ยม สำหรับการเป็นอาสาสมัครที่สมบูรณ์แบบ
ใช้ลูกความเครียด!
>> ตกลง.
ดังนั้นเครื่องหมายตัวละครตัวนี้เป็นศูนย์ วิธีการที่เราแสดงให้เห็นจุดสิ้นสุดของสตริง
มันเป็นวิธีที่เมื่อโปรแกรมใดก็ตาม ต้องการที่จะพิมพ์สตริง
ก็จำได้ว่าเราได้เรียนรู้ how-- ฟังก์ชัน strlen สัปดาห์ที่ผ่านมา?
ความยาวของสตริง?
มันเป็นวิธีที่มีความยาวสตริงสามารถที่จะ กำหนดระยะเวลาที่เป็นสตริง
มันก็ช่วยให้การทำซ้ำ มากกว่าตัวละคร
จนกว่าจะพบ ศูนย์เครื่องหมายตัวอักษร
ดังนั้นสิ่งสำคัญที่ต้องตระหนัก เกี่ยวกับศูนย์เครื่องหมายตัวอักษร
คือมันเป็นตัวแทนของ โดยศูนย์ทั้งหมดในบิต
ดังนั้นสังเกตเห็นว่านี่คือที่แตกต่างกัน จากตัวละครที่เป็นศูนย์
ดังนั้นตัวละครศูนย์ถ้าคุณจำ ในตัวอย่างที่เขาให้ในตอนท้าย
ของการบรรยายที่แผนที่ตัวอักษร to-- เช่นแผนที่ทุนถึง 65
แผนที่ที่จะเป็นตัวพิมพ์เล็ก 97
ขพิมพ์เล็กจะเป็น 98
ดังนั้นจำนวน 0 แผนที่ to-- ฉันทำไม่ได้ รู้ว่าปิดด้านบนของหัวของฉัน
44 หรือ 45
ที่ไหนสักแห่งในพื้นที่ที่
>> ดังนั้นตัวละคร 0 เป็นจำนวนจริง
แต่ศูนย์เครื่องหมาย แผนที่ทุกศูนย์บิต
เพื่อให้มีความแตกต่าง ระหว่างเครื่องหมายศูนย์
ซึ่งเราจะเรียกว่าเทอร์มิ null
มีความแตกต่างระหว่างเป็น เครื่องหมายศูนย์และศูนย์ตัวละคร
>> ทั้งหมดขวา
ดังนั้นการพูดคุยอีกเล็กน้อยเกี่ยวกับสตริง
ดังนั้นแล้วเราดูที่นี่นี้เป็นวิธีที่ มันจะออกมาวางในหน่วยความจำ
ดังนั้นความคิดของสตริงนี้เป็นลำดับ ของ characters-- เพื่อให้คอมพิวเตอร์อย่างเป็นทางการ
ระยะ sciency ลำดับเป็นอาร์เรย์
ดังนั้นเราจึงจะเรียกสตริง อาร์เรย์ของตัวอักษร
และมีข้อมูลอื่น ๆ จริง ชนิดที่ทำให้เราสามารถสร้างอาร์เรย์จาก
>> ดังนั้นการกระตุ้นนี้ดูตัวอย่าง
เราจะเรียกมันว่าฉันจะ ages0.c คัดลอกและวางแม่แบบของเรา
ตกลง.
ดังนั้นในโปรแกรมนี้สิ่งที่เรา ต้องการจะทำคือคว้าอายุ
ในสามของนักเรียนในการเรียนการสอน
ดังนั้นเราจึงรู้ว่า int age-- และตอนนี้ฉันจะพูด 0
ดังนั้นคุณอาจต้องการที่จะพูด age1 แต่ เพื่อวัตถุประสงค์ในการที่เราจะเห็นมากในไม่ช้า
ฉันจะบอก int age0 เท่ากับ GetInt
ดังนั้นสายเดียวกันกับ GetInt ที่เราได้รับใช้ฉัน
ไม่ได้เกิดขึ้นจะได้รับการกระตุ้น พูดว่า "ให้ฉันอายุ."
เพียง แต่ขอให้มัน
>> และ age1 เท่ากับ GetInt
และ int age2 เท่ากับ GetInt
ดังนั้นอีกครั้งสามนักเรียน แต่ ในที่สุดดัชนีตัวแปร
มี age0 ผ่าน age2
ตกลง.
ดังนั้นโปรแกรมนี้จะทำอะไรก็ตาม เราต้องการด้วย age0, age1 และ age2,
แต่โปรแกรมนี้ในท้ายที่สุด ทำงานให้กับนักศึกษาสาม
>> ตกลง.
ดังนั้นตอนนี้สิ่งที่ถ้าผมต้องการที่สี่นักเรียน?
ดีฉันจะต้องกลับไป เป็นรหัสของฉันเปลี่ยนความคิดเห็นที่
และตอนนี้เรามีอยู่ int age3 เท่ากับ GetInt
ตกลง.
ดังนั้นผู้ที่เห็นปัญหาที่เกิดขึ้นที่นี่?
ปัญหาคืออะไร มีการจัดเรียงของการติดตั้งนี้หรือไม่?
ใช่
ดังนั้นเราจึงกำลังสร้าง ตัวแปรสำหรับนักเรียนแต่ละคน
ตอนนี้ที่ทำงาน แต่ ในที่สุดสิ่งที่ถ้าตอนนี้ผม
พูดว่า "ผมต้องการที่จะคว้าอายุ แปดหรือ 16 นักเรียนนักศึกษา
หรือ แต่นักเรียนจำนวนมากของ ร้อยของนักเรียนในการ CS50
หรือหลายพันคนในมหาวิทยาลัย หรือพันล้านคนในโลก?
ดังนั้นในท้ายที่สุดนี้ไม่ยั่งยืน
เวลาที่คุณเห็นตัวเองการคัดลอก และวางรหัสเช่นนี้
คุณมักจะรู้สึก ว่ามีวิธีที่ดีกว่า
>> ดังนั้นนี่คือที่เราแนะนำ การประกาศอาร์เรย์
ดังนั้นเมื่อคุณประกาศอาร์เรย์ นี่คือสิ่งที่รูปแบบทั่วไป
เป็นไปได้ที่มีลักษณะเหมือน
เรากำลังจะพูดประเภท
และจากนั้นเรากำลังจะไป ให้ชื่อของอาร์เรย์ที่
เช่นเดียวกับที่เรากำหนดตัวแปรใดก็ตาม
และแล้วในที่สุดเราจะใช้ สัญกรณ์วงเล็บนี้อีกครั้ง
แต่ในบริบทที่แตกต่างจาก วิธีการที่เราได้ใช้มันก่อนหน้านี้
>> ดังนั้นที่นี่ดูเหมือนจะเป็นปกติ การประกาศตัวแปรที่เราได้เห็น
ดังนั้นเราจึงได้เห็น int x ลำไส้ใหญ่กึ่งก่อน
ดีตอนนี้เราอาจจะเห็นบางสิ่งบางอย่าง เช่น int x วงเล็บ 5
และวางความคิดเข้ามาในนี้ โปรแกรม GetInt ที่เรา have--
เพื่อให้เราสามารถดำเนินการ นี้ในทางเดียวกัน
>> สมมติว่าในซีเรามีแนวโน้มที่จะใช้ n เป็นจำนวนของบางสิ่งบางอย่าง
ดังนั้นที่นี่เรากำลังจะไป เก็บสี่นักเรียน
และตอนนี้เราสามารถพูดได้อายุ int วงเล็บ n-- ได้ค่อนข้างได้รับมัน yet--
ที่จะประกาศอาร์เรย์ของสี่นักเรียน
ดังนั้นวิธีนี้จะมองใน หน่วยความจำจะคล้ายกับนี้
ล้างนี้
และเรากำลังจะมีที่ใดที่หนึ่ง ใน memory-- ฉันจะใส่นี้มีขึ้น
>> ดังนั้นที่ใดที่หนึ่งในความทรงจำ
หนึ่งสองสามสี่.
เรามีสี่จำนวนเต็มในแถว สำหรับอาร์เรย์ของจำนวนเต็มสี่นี้
ดังนั้นในขณะนี้สิ่งที่เป็น ขนาดของหนึ่งในกล่องเหล่านี้หรือไม่
ใช่
มันเป็นสี่ไบต์
มันเป็น 32 บิต
ดังนั้นตอนนี้จะแตกต่าง จากแถวที่เรา
เห็นก่อนหน้านี้อาเรย์ของตัวละคร
ในสตริงแต่ละกล่องเพียงหนึ่งไบต์ เพราะเป็นตัวละครที่เป็นเพียงหนึ่งไบต์
แต่กับอาร์เรย์ของจำนวนเต็มแต่ละ กล่องจะต้องมีสี่ไบต์ในการสั่งซื้อ
เพื่อให้พอดีกับจำนวนเต็มทั้งหมด
ดังนั้นนี่คือสิ่งที่อาเรย์ของ สี่ ints จะมีลักษณะ
>> และจากนั้นก็กลับไปที่รหัส
ตอนนี้เราต้องการในการจัดเก็บจริง จำนวนเต็มเป็น array ที่
ดังนั้นตอนนี้เป็นอย่างมากมาก รูปแบบทั่วไปที่จะในบางจุด
กลายเป็นหน่วยความจำของกล้ามเนื้อ
ดังนั้นฉัน int เท่ากับ 0
ฉันน้อยกว่า n
ฉันบวกบวก
วงเล็บอายุเท่ากับฉัน GetInt
>> ดังนั้นนี้ห่วงรูปแบบนี้ คุณควรจะได้รับใช้มากในการ
ดังนั้นนี่คือโดยทั่วไปวิธีการที่เราจะ ย้ำกว่าเกือบอาร์เรย์ใด ๆ
ตอนนี้สังเกตเห็นการจัดเรียงของนี้ อธิบายว่าทำไมจากจุดเริ่มต้น
เราไม่ได้มีวงที่จะให้ int ฉันมีค่าเท่ากับ 1, ฉันน้อยกว่าหรือเท่ากับ 10
เหตุผลที่ถูกที่เริ่มต้นจาก ศูนย์ทำให้การทำงานนี้ได้ดีกับอาร์เรย์
ดังนั้นอาร์เรย์จะเป็นศูนย์การจัดทำดัชนี
ถ้าอาร์เรย์นี้เป็นระยะเวลา 4 ดัชนีอยู่ที่ 0 ถึง 3
>> ดังนั้นผ่านครั้งแรก ทวนของวงนี้
เรากำลังจะได้รับการตั้งค่าอายุ วงเล็บ 0 เท่ากับการเรียกร้องให้ GetInt
ดังนั้นสิ่งที่ฉันเกิดขึ้น ที่จะเข้าสู่ที่แป้นพิมพ์
ในการส่งผ่านที่สองเรา การตั้งค่า age1 เท่ากับ GetInt
ผ่านสาม age2
รอบชิงชนะเลิศผ่าน age3
ดังนั้นหากในครั้งแรกผ่านของวง ฉันใส่หมายเลข 4 ที่แป้นพิมพ์
แล้วเราจะใส่ 4 ที่นี่
ถ้าในการส่งผ่านที่สองผมใส่ 50 เราจะใส่ 50 ที่นี่
เมื่อวันที่ผ่านสามฉันอาจ เข้าสู่เชิงลบ 1 ลบ 1,
และแล้วในที่สุดถ้าเราเข้าไป 0-- และ ตอนนี้จำได้ว่านี่คือดัชนีสาม
>> หลังจากที่เรากลับมาห่วงฉันเป็น จะได้รับการเพิ่มขึ้นถึง 4
ฉันจะไม่น้อยกว่า n ซึ่งเป็น 4
และเราแยกออกจากวง
ดังนั้นสิ่งที่จะผิดกับเรื่องนี้?
[ไม่ได้ยิน]
ผู้ชม: [ไม่ได้ยิน]
>> ใช่
ดังนั้นอาร์เรย์มีเพียงสี่สถานที่ ซึ่งหมายความว่าในขณะที่ดัชนี 0 ถึง 3
ดังนั้นถ้าเป็นกรณีนี้ผมจะ ใช้เวลาในการมูลค่า 4 ในบางจุด
วงเล็บอายุ 4 จะได้รับการตั้งค่า สิ่งที่เกิดขึ้นเป็นมากกว่าที่นี่
กับสิ่งที่ฉันต้องบอกว่าใส่ 6
ที่จะได้รับการตั้งค่านี้ถึง 6
>> แต่เราไม่ทราบว่ามีอะไรมากกว่าที่นี่
นี้ไม่ได้เป็นหน่วยความจำ ที่เรามีการเข้าถึง
ดังนั้นถ้าคุณจำได้จาก การบรรยายก่อนหน้านี้
เขาได้รับการพิมพ์ออกค่า Zamyla และ บางจุดที่เขาตีการแบ่งส่วนนี้
ความผิด ดังนั้นคุณอาจจะได้เห็น ความผิดพลาดของการแบ่งส่วนมากเท่าที่คุณ
การดำเนินการบางส่วนของปัญหาชุด
แต่นี้เป็นหนึ่งในวิธีการที่ คุณสามารถพบการแบ่งส่วน
ความผิดพลาดเมื่อคุณเริ่มต้นการเข้าถึง หน่วยความจำในรูปแบบที่คุณไม่ควรจะ
ดังนั้นเราจึงไม่ได้มีการเข้าถึง สถานที่นี้และนี่คือข้อผิดพลาด
>> ดังนั้นนี่จะดีกว่า
ตอนนี้ยังคงมีขนาดเล็ก ปัญหากับรหัสนี้
และที่พื้นว่าเรา ยังคงติดอยู่ที่สี่นักเรียน
ตอนนี้ถ้าฉันต้องการใช้แปดนักเรียนตกลง
มันไม่ได้ว่าข้อตกลงที่มีขนาดใหญ่
ฉันสามารถไปในการเปลี่ยนแปลง แสดงความคิดเห็นและการเปลี่ยนแปลง n
ตอนนี้จะทำงานร่วมกับแปดนักเรียน
ถ้าฉันรวบรวมนี้และเรียกใช้ นี้ก็จะแสดง me--
ก็จะขอเลขแปด นักเรียนและมันก็จะทำงาน
แต่ก็น้อยกว่าที่เหมาะที่จะต้อง คอมไพล์โปรแกรมทุกครั้งเดียว
ฉันต้องการที่จะเปลี่ยนจำนวนของนักเรียน ที่ฉันต้องการที่จะเข้าสู่วัยสำหรับ
>> ดังนั้นการปรับปรุงขั้นสุดท้ายเกี่ยวกับ นี้ในขณะที่เราจะเห็น here-- เรา
จะขอหมายเลขของผู้คน
ที่นี่เรามีจำนวนมาก ของผู้คนในห้องพัก
หรือวัยใด ๆ ของคนที่อยู่ในห้องพัก
แต่เรากำลังจะขอหมายเลข ของผู้คนในห้องพักจากผู้ใช้
ดังนั้นนี่คือสิ่งที่ต้องทำเหมือนกันในขณะที่ ห่วงที่เราเคยเห็นมาก่อน
ก็เหมือนกันแน่นอน ทำในขณะที่ห่วงว่าคุณ
อาจจะมีการดำเนินการเกี่ยวกับปัญหาการตั้งค่า
ดังนั้นตราบใดที่พวกเขากำลัง ป้อน n น้อยกว่า 1,
จึงมีได้เป็นที่ อย่างน้อยหนึ่งคนในห้องพัก
ตราบใดที่พวกเขากำลัง ป้อน n น้อยกว่า 1,
แล้วเรากำลังจะขอให้อีกครั้ง
กรุณาใส่ตัวเลข ของผู้คนในห้องพัก
ตอนนี้เมื่อเรามีจำนวน ของผู้คนใน room--
ดังนั้นผมอาจจะใส่ว่ามี 200 คนในห้องนี้
จากนั้นก็ลงที่นี่เรากำลังจะมา และประกาศอาร์เรย์ขนาด 200
เรากำลังประกาศอาร์เรย์ที่ ใหญ่พอที่จะถือ 200 ทุกเพศทุกวัย
ลงมาก็เป็นห่วง ที่คุณจะได้รับใช้มากในการ
ดังนั้น iterating มากกว่าอาร์เรย์นี้ มอบหมายให้แต่ละสถานที่
ในอาร์เรย์ที่เป็นจำนวนเต็มและ ท้ายที่สุดแล้วนี่เรา
แค่ตัวอย่างของการทำซ้ำ มากกว่าอาร์เรย์ที่ไม่ได้ที่จะกำหนดค่า
แต่การเข้าถึงค่า
>> ดังนั้นที่นี่เราจะเห็นว่าเรา จะพูดว่าปีต่อจากนี้
คน% ฉันจะเป็นฉัน% ปีเก่า ที่ฉัน% แรกคือผมบวก 1
ดังนั้นฉันเป็นตัวแปรดัชนีนี้
และฉัน% ที่สองคือจะเป็น ค่าที่เก็บไว้ในอาร์เรย์บวก 1 ทุกเพศทุกวัย
ดังนั้นบวก 1 นี้เป็นเพียงเพราะเรา saying-- บวก 1 นี้อายุผมบวก 1
บวก 1 นี้เป็นเพียงเพราะเรา ว่าปีนับจากนี้คนที่
จะเก่า
>> ดังนั้นทำไมฉันนี้บวก 1?
ทำไมเรามีบวก 1 มี?
ใช่
ดังนั้นจำอาร์เรย์จะเป็นศูนย์การจัดทำดัชนี
ดังนั้นหากเรากำลังพิมพ์นี้ออกมา คนที่เพียงแค่อ่านออก
แล้วอาจจะเป็นพวกเขาต้องการที่จะเห็นบางสิ่งบางอย่าง เหมือนคนหนึ่งจำนวนหนึ่งคน
จะอายุ 20 ปี
จำนวนคนที่สองจะอายุ 15 ปี
พวกเขาไม่ต้องการเห็นคน จำนวนศูนย์คือ 15 ปี
>> ดังนั้นการรวบรวมนี้และเพียงแค่เห็นสิ่งที่ มันดู like-- สร้างพื้นที่บางส่วน
ทำให้ทุกเพศทุกวัย compiles
วิ่งทุกเพศทุกวัย
เราเห็นผู้คนจำนวนมากในห้องพัก
ดังนั้นผมจะบอกว่ามี คนสามคนในห้องพัก
อายุจำนวนหนึ่งคน สมมติว่า 15, 20, 25
และตอนนี้ฉันจะบอกว่าปีจาก ตอนนี้พวกเขาจะเป็น 16, 21, 26
ลองมาดูกันว่างานนี้ด้วย n ที่ไม่เท่ากับ 3
ดังนั้นถ้าผมบอกว่าผู้คนจำนวนมากคือ 5, หนึ่ง สองสามสองหนึ่งปีนับจากนี้
พวกเขาจะมีสองสาม สี่สามสองปี
ดังนั้นผมจึงอาจเป็นเพียงแค่ ได้อย่างง่ายดาย n เป็น 10,000
ตอนนี้ผมจะนั่งอยู่ที่นี่สำหรับค่อนข้าง ในขณะที่ทุกเพศทุกวัยเข้ามา แต่งานนี้
>> ดังนั้นตอนนี้ในความทรงจำที่เราอยู่ที่ไหนสักแห่ง มีอาร์เรย์ของขนาด 10,000 ที่
ในที่สุดจึง 40,000 ไบต์เนื่องจากมี
สี่ไบต์สำหรับแต่ละจำนวนเต็มเหล่านั้น
ดังนั้นจึงมีอาร์เรย์ของ ขนาด 10,000 ที่เราสามารถทำได้
เก็บทุกเพศทุกวัยของผู้ที่ 10,000 คน
ทั้งหมดขวา
คำถามใด ๆ เกี่ยวกับเรื่องนี้?
ใช่
เกิดอะไรขึ้นถ้าคุณให้จำนวนลบ?
ลองมาดูสิ่งที่เกิดขึ้น
ดังนั้นในจำนวน case-- นี้โดยเฉพาะ ของผู้คนในห้องพัก, เชิงลบอย่างใดอย่างหนึ่ง
มันปฏิเสธว่า เพราะที่นี่เราเกิดขึ้น
ที่จะจัดการกับความจริงที่ว่าถ้า n เป็น น้อยกว่าหนึ่งที่เรากำลังจะไปถามอีก
ถ้าคุณพยายามที่จะประกาศ อาร์เรย์ขนาดลบ
โดยทั่วไปจะไม่ทำงาน
>> ดังนั้นลอง
ลองไม่สนใจสิ่งที่ ค่าที่พวกเขาสำหรับการป้อนข้อมูล n
และเพียงแค่บอกว่าทุกเพศทุกวัย int เชิงลบอย่างใดอย่างหนึ่ง
ลองมาดูว่ามันยัง compiles
ฉันไม่แน่ใจ.
เลขที่
ทุกเพศทุกวัยดังนั้นการประกาศเป็น อาร์เรย์ที่มีขนาดเชิงลบ
ล่วงหน้าดังนั้นจึงตระหนักถึงอาร์เรย์ไม่สามารถ จะมีขนาดเชิงลบและปฏิเสธมัน
ตอนนี้ถ้าเราไม่ได้จัดการ นี้วงในขณะที่ทำอย่างถูกต้อง
ถ้าเราไม่ได้ตรวจสอบ ถ้า n มีค่าน้อยกว่า 1-
สมมติว่าเราเพียงแค่ ไม่ได้มีที่ทั้งหมดนี้
และแทนที่จะเราก็คว้าจำนวนเต็ม
ไม่ว่าสิ่งที่เป็นจำนวนเต็มไม่มี เราประกาศอาร์เรย์ของขนาดที่
>> ดังนั้นคอมไพเลอร์ไม่สามารถ อาจจะบ่นในขณะนี้
ถ้าผมรวบรวม this-- ดังนั้นจึงไม่สามารถบ่น
เพราะมันไม่สามารถรู้ว่าฉัน จะป้อนหมายเลขลบ
ซึ่งอาจจะไม่ถูกต้อง
สำหรับทั้งหมดก็รู้ฉันอาจ ป้อนหมายเลขบวก
ซึ่งเป็นที่ถูกต้องสมบูรณ์
ดังนั้นผมจึงคิดว่าฉันใส่ในเชิงลบ 1 คนในห้องพัก, ความผิดส่วน
>> ดังนั้นตกลง
ดังนั้นขอเพิ่มกลับเพียงแค่นี้ ให้มันสิ่งที่มันเดิม
เพื่อให้ทุกเพศทุกวัย
ตอนนี้ถ้าผมต้องการที่จะลอง เชิงลบ age-- จึงขอ
บอกว่ามีคนห้าคนในห้องพัก
อายุจำนวนหนึ่งคน เป็นลบ 4 คนสาม
เป็นศูนย์คน three-- ตกลง
ดังนั้นที่นี่ปีนับจากนี้จำนวนคน หนึ่งจะเป็นค่าลบ 3 ปี
ดังนั้นอาจจะไม่ได้ทำให้รู้สึก
แต่นั่นเป็นเพียงเพราะมอง รหัสทั้งหมดที่เรากำลังทำ
ขอ GetInt
>> ตอนนี้ถ้าเราได้มี ฟังก์ชั่น GetPositiveInt
หรือเราเพิ่งทำเพียงแค่นี้ การเรียงลำดับของวงในขณะเดียวกันลงที่นั่น
แล้วนี้จะทำงานได้ดีอย่างสมบูรณ์
แต่ในการนี​​้โดยเฉพาะ กรณีที่เราก็ไม่ได้ทำ
เกิดขึ้นที่จะจัดการค่าลบ
คำถามใด ๆ อื่น ๆ เกี่ยวกับอาร์เรย์?
ตกลง.
>> ดังนั้นเราจึงได้เห็นตอนนี้อาร์เรย์
และเรากำลังจะต้องใช้ นี้อาร์กิวเมนต์บรรทัดคำสั่ง
ดังนั้นในการกำหนดปัญหา two-- ผมรู้ว่าหลายท่าน
อาจจะยังคงทำงานในชุดปัญหา หนึ่ง แต่ปัญหาที่เกิดขึ้นตั้งสองกำลังจะมาถึง
ในปัญหาที่เกิดขึ้นตั้งสองคุณกำลังจะไป จะต้องมีการจัดการกับสตริงอาร์เรย์
และการขัดแย้งบรรทัดคำสั่ง
>> ดังนั้นสิ่งที่เป็นอาร์กิวเมนต์บรรทัดคำสั่ง?
ตอนนี้คุณสามารถดูลงที่นี่ ทีเซอร์เล็ก ๆ น้อย ๆ ว่าสิ่งที่
จะเกิดขึ้น
เราเห็น int หลัก argc อิงค์, วงเล็บ argv สตริง
ดังนั้นก่อนลองที่จะตีความ สิ่งที่พยายามที่จะพูด
ตอนนี้ตกลง
>> ดังนั้นที่บรรทัดคำสั่งที่คุณควรจะ รับใช้บางส่วนของคำสั่งเหล่านี้
ในขณะนี้และคุณอาจจะได้ทำงาน ซีดีใน terminal ก่อน
ดังนั้นถ้าเราบอกว่าซีดี pset1, คุณรู้ไหมว่าที่ควร
จะมีการเปลี่ยนแปลงลงในไดเรกทอรี pset1
>> ตอนนี้สังเกตเห็นว่าคุณไม่เคย เขียนโปรแกรมเช่นนี้มาก่อน
แต่ละโปรแกรมที่คุณเขียน ที่คุณจะเรียกใช้การพูด, เฉือนดอทมาริโอ
จุดเฉือนโลภแล้ว อาจจะแจ้งให้คุณสำหรับการป้อนข้อมูล
ตอนนี้นั่นไม่ใช่สิ่งที่ เปลี่ยนไดเรกทอรีไม่
เมื่อคุณเรียกใช้แผ่นซีดีก็ไม่ได้แล้วพูดว่า ไดเรกทอรีที่คุณต้องการลงในแผ่นซีดี?
แต่คุณเพียงแค่พูดว่า pset1 ซีดีและ มันก็จะเข้าสู่ไดเรกทอรี pset1
>> ดังนั้นในทำนองเดียวกันเรามีตัวอย่างอื่น ๆ
ทำให้สวัสดี
เมื่อคุณเรียกใช้ให้มันไม่ได้แล้วพูดว่า โปรแกรมที่คุณต้องการจะทำ?
คุณเพียงแค่บอกว่าที่ บรรทัดคำสั่งให้สวัสดี
>> ย้ายเป็นอีกตัวอย่างหนึ่ง
หนึ่งนี้เราจะย้าย mario.c ยื่นขึ้นหนึ่งไดเรกทอรี
ดังนั้นตอนนี้เรารู้ว่ามีตัวอย่างนี้ เรากำลังผ่านจริงๆสองขัดแย้ง
มี mario.c เป็นอาร์กิวเมนต์แรก และ dot dot เป็นอาร์กิวเมนต์ที่สอง
และจากนั้นเมื่อคุณทำงานให้คุณ เห็นว่าคำสั่งนานจริงๆ line--
คำสั่งที่นานจริงๆ พิมพ์ที่บรรทัดคำสั่ง
เพื่อให้ยาว command-- นี้ เป็นเพียงส่วนหนึ่งที่สั้นของมัน
แต่ตอนนี้เรามีสาม อาร์กิวเมนต์บรรทัดคำสั่ง
รีบจุดศูนย์ทักทายและ hello.c
>> ดังนั้นเหล่านี้เป็นบรรทัดคำสั่ง ข้อโต้แย้งข้อโต้แย้ง
ที่คุณผ่านที่ บรรทัดคำสั่งเพื่อที่จะ
ไม่จำเป็นต้องได้รับแจ้ง เมื่อคุณเรียกใช้โปรแกรม
มันจะทำลายหากเมื่อ คุณวิ่งเสียงดังกราวก็กล่าวว่า "ต​​กลง
ซึ่ง program-- ที่ ไฟล์ที่คุณรวบรวม?
hello.c
สิ่งที่คุณจะธง ชอบที่จะใส่? รีบ o
สิ่งที่คุณต้องการ ไฟล์ที่จะเรียกว่า?
สวัสดี.
ไม่มีคุณเพียงแค่ใช้เสียงดังกราว รีบ o สวัสดี hello.c
>> ดังนั้นมองกลับไปที่นี้
ตอนนี้ argc-- argc นับเป็นอาร์กิวเมนต์
มันเป็นจำนวนบรรทัดคำสั่ง ข้อโต้แย้งที่เข้ามาที่บรรทัดคำสั่ง
ดี argv-- ทางเทคนิค โวย่อมาจากเวกเตอร์
ซึ่งโดยทั่วไปหมายถึงอาร์เรย์
แต่คุณสามารถที่จะไม่สนใจ
Argv-- เรามี argv สตริง เพื่อให้วงเล็บ argv สตริง
ดังนั้นนี่คือรูปแบบของผู้อื่น วงเล็บคุณยังไม่ได้เห็นมาก่อน
ดังนั้นเราจึงได้เห็นวงเล็บ สัญกรณ์เมื่อเราได้กล่าวว่า
เหมือนสตริง s เท่ากับ Zamyla
วงเล็บ s 0 เข้าถึงตัวละครซี
>> เราได้เห็นวงเล็บเมื่อ เรากล่าวว่าทุกเพศทุกวัย int วงเล็บ 5
ที่ประกาศอาร์เรย์ของขนาด 5
ดังนั้นนี่คือรุ่นที่ วงเล็บเรายังไม่ได้เห็นมาก่อน
ดังนั้นการจัดเรียงของ argv สายนี้ว่า จะคุ้นเคยอย่างสมบูรณ์
ว่ามันก็จะเป็นสตริง
ตอนนี้วงเล็บระบุ ว่านี่คืออาร์เรย์
สตริงดังนั้น argv วงเล็บหมายถึง ที่ argv เป็นอาร์เรย์ของสาย
ตอนนี้ในทางเทคนิคสตริง เป็นอาร์เรย์ของตัวอักษร
ดังนั้นนี่คือตอนนี้อาร์เรย์ ของอาเรย์ของตัวอักษร
แต่มันเป็นเรื่องง่ายมากที่จะคิดเกี่ยวกับ นี้เป็นเพียงอาร์เรย์ของสตริง
>> เหตุใดจึงต้องวงเล็บอาจจะว่างเปล่า
เช่นทำไมไม่สามารถเราพูดว่า วงเล็บ 5 วงเล็บ n?
ใช่
เราไม่ทราบจำนวน ปัจจัยการผลิตที่มีกำลังจะเป็น
ดังนั้นถ้าเราดูที่ตัวอย่างเช่นเสียงดังกราว, เราพูดเสียงดังกราวรีบ o สวัสดี hello.c
โดยเฉพาะในกรณีนี้มีเกิดขึ้น จะเป็นสามอาร์กิวเมนต์บรรทัดคำสั่ง
และเพื่อ brackets-- ที่เราจะเห็น ในครั้งที่สองก็จะไม่สาม
ในทางเทคนิคมันจะเป็นสี่
แต่วงเล็บเราจะ กล่าวว่ามีสาม
แต่ตอนนี้ถ้าเรามองไปที่ย้าย mario.c จุดจุดวงเล็บ
เราต้องการที่จะใส่สองในพวกเขา
>> และมีจำนวนมากของคำสั่งที่ มีจำนวนตัวแปรของบรรทัดคำสั่ง
ข้อโต้แย้ง
ดังนั้นสิ่งที่รุ่นนี้ สัญกรณ์วงเล็บบ่งชี้
คือว่า argv เป็นอาร์เรย์ของสาย
แต่เราไม่ทราบจำนวน สตริงในอาร์เรย์ที่
และวิธีที่เราทำแล้วรู้วิธี สายจำนวนมากอยู่ในแถว?
นั่นเป็นจุดรวม argc
argc บอกเราว่า argv ยาว
>> ดังนั้นสิ่งสุดท้ายที่จะเก็บไว้ใน ใจก็คือว่าในทางเทคนิค
คำสั่งของตัวเองนับว่าเป็นหนึ่งใน ของการขัดแย้งบรรทัดคำสั่ง
ดังนั้นซีดี pset1 มีสอง อาร์กิวเมนต์บรรทัดคำสั่ง
โปรแกรมในตัวเอง, CD แล้ว ส่วนข้อโต้แย้งที่เกิดขึ้นจริงของมัน pset1
โปรแกรมใด ๆ ที่คุณได้เขียนป่านนี้ มีหนึ่งบรรทัดคำสั่ง argument-- จุด
มาริโอเฉือน
นั่นเป็นเพียงอาร์กิวเมนต์บรรทัดคำสั่ง
>> ดังนั้นตอนนี้กำลังมองหาที่เสียงดังกราว รีบ o สวัสดี hello.c
ดังนั้นสิ่งที่ argc?
4
argc ดังนั้น 4
เสียงดังกราวเพื่อยึด argv 0 เสียงดังกราว
argv วงเล็บ 1 รีบ 0
วงเล็บ argv 2 สวัสดีและ วงเล็บ argv 3 เป็น hello.c
ตกลงดังนั้นคำถามเกี่ยวกับเรื่องนี้และจากนั้นเราจะ ดูตัวอย่างการเขียนโปรแกรมบางอย่าง
>> ตกลง.
ดังนั้นเราจะดูที่ hello3.c
ดังนั้นนี้ควรจะเป็นที่คุ้นเคยจาก หนึ่งในตัวอย่างที่คแรก
เรามีที่เราก็จะพูดว่าสวัสดี โลก แต่ตอนนี้เป็นทั่วไปมากขึ้น
ดังนั้นที่นี่เรากำลังพูดทักทาย % s เครื่องหมายวงเล็บ n argv 1
Notice-- เพื่อขึ้นจนถึงจุดนี้เป็น สิ่งที่แฟ้มแม่แบบของฉันได้มองเช่น
ผมมี int main (void) แล้วฉันจะ ทำอะไรบางอย่างในการทำงานหลัก
ตอนนี้แทนเมื่อเราเริ่มต้นการจัดการ กับการขัดแย้งบรรทัดคำสั่ง
เราจำเป็นต้องระบุ รูปแบบที่แตกต่างกันของหลัก
>> ดังนั้นการมองหาที่ hello3 อีกครั้งหลักที่เกิดขึ้น
จะใช้เวลาสองข้อโต้แย้ง now-- int argc, จำนวนของการขัดแย้งบรรทัดคำสั่ง
และสตริง argv วงเล็บที่เกิดขึ้นจริง สายเข้ามาที่บรรทัดคำสั่ง
ดังนั้นฉันจะเปลี่ยนที่ แม่แบบเพื่อสะท้อนให้เห็นถึงความจริงที่ว่า
ตอนนี้เมื่อใดก็ตามที่คุณเขียน โปรแกรมถ้าคุณทำไม่ได้
จำเป็นต้องใช้บรรทัดคำสั่งใด ๆ ข้อโต้แย้งจากนั้นเพียงแค่ใช้ int main (void)
แต่ตอนนี้เมื่อคุณเขียน โปรแกรมอาร์กิวเมนต์บรรทัดคำสั่งที่
คุณจะต้องทำสำหรับปัญหา ตั้ง two-- ดังนั้นตอนนี้ที่คุณกำลังทำงาน
โปรแกรมที่จำเป็นต้องใช้ การขัดแย้งบรรทัดคำสั่ง
คุณจะต้องมีหลักของแบบฟอร์มนี้
>> ดังนั้น here-- นี้คือการใช้ขนาดใหญ่ ของการโต้แย้งบรรทัดคำสั่ง
ดังนั้นการพิมพ์ argv 1
ตกลงจึงขอรวบรวม และเรียกใช้โปรแกรมนี้
ทำให้ hello3
compiles
Dot เฉือน hello3
และให้พูดว่า "ร็อบ".
สวัสดีร็อบ
ถ้าผมพูดว่า "สวัสดีมาเรีย" สวัสดีเรีย
สวัสดีค่ะมาเรีย
ฮันนาห์ยังคงกล่าวว่า "สวัสดี มาเรีย "เพราะฉันไม่ได้
ทำอะไรกับ argv ของเรา 2
argv 2 ตอนนี้จะเป็น "ฮันนาห์."
argc จะเป็น 3
ถ้าฉันทำอย่างนี้?
ดังนั้นสวัสดี null
>> เขาสัมผัสในเวลาสั้น ๆ กับความจริงที่ ว่าในทางเทคนิค GetString
อาจกลับ null แต่เราจะได้รับ มากขึ้นในสิ่งที่เป็นจริง null
แต่จะเป็นเรื่องของการ ความจริงที่ว่าไม่เป็นโดยทั่วไปที่ไม่ดี
เราทำอะไรผิดถ้า ก็พิมพ์ "สวัสดี null."
และเหตุผลที่เราทำ บางสิ่งบางอย่างที่ไม่ถูกต้อง is-- ดี
เมื่อฉันวิ่ง hello3 เฉือนจุด argc 1
ดังนั้นที่หมายถึงความยาวของ argv เป็น 1
หากอาร์เรย์ของความยาว 1, เพียงดัชนีที่ถูกต้องเป็นศูนย์
และเพื่อให้ที่นี่ argv 1 อยู่นอก ช่วงนี้ของอาร์เรย์
มันก็คล้ายกับก่อนเมื่อฉันพยายาม ในการจัดเก็บ 6 นอกปลายแถวที่
ดังนั้นฉันพยายามที่จะเข้าถึงบางสิ่งบางอย่าง นอกนับ argv,
และเราจะได้รับ null
>> ดังนั้นรุ่นที่ดีกว่าของ นี้การปรับปรุง
มีการตรวจสอบอย่างชัดเจน argc
ดังนั้นหาก argc เท่ากับ 2 นั่นหมายความว่าเราวิ่ง สิ่งที่ต้องการเฉือนจุด hello3 ร็อบ
และมันจะพิมพ์ "สวัสดีร็อบ."
หาก argc ไม่เท่ากับ 2 แล้วก็แค่ไป
ที่จะไม่สนใจสิ่งที่คุณใส่ ที่อาร์กิวเมนต์บรรทัดคำสั่ง
เป็นอาร์กิวเมนต์บรรทัดคำสั่ง
หรือถ้าคุณไม่ได้ใส่เลยก็ เพียงแค่จะสนใจว่าและเพียงแค่บอกว่า
"สวัสดีคุณ."
>> ดังนั้นการรวบรวมนี้
ทำให้ hello4
และทำงาน hello4
วิ่งมันด้วยวิธีนี้ สิ่งที่ควรจะพิมพ์?
"สวัสดีคุณ."
สวัสดีคุณ.
สิ่งที่เกี่ยวกับ hello4 ร็อบ?
"ร็อบฮัลโหล."
และในที่สุดก็สวัสดีร็อบมาเรีย เป็นเพียง "สวัสดีคุณ" อีกครั้ง
เพราะคุณไม่ได้จริงๆใส่ สิ่งที่คาดว่า
คุณป้อนชื่ออื่น ๆ อีกมากมาย เกินกว่าที่จะสามารถจัดการ
ดังนั้นมันก็จะผิดนัด สวัสดีคุณพฤติกรรม
ดังนั้นคำถามเกี่ยวกับเรื่องนี้?
หรืออาร์กิวเมนต์บรรทัดคำสั่ง?
>> ตกลงดังนั้นการดูที่เป็น สองสามตัวอย่างของการใช้
บรรทัดคำสั่ง arguments-- แรก เราได้ argv 1 จุดประค
ดังนั้นการแสดงความคิดเห็นในสิ่งที่ให้ไป โปรแกรมนี้ควรจะทำ
แต่สังเกตเห็น now-- นี้ห่วง นี้ตรงกับรูปแบบที่แน่นอน
ที่ผมบอกว่าก่อนที่จะ
เราก็จะเกิดขึ้น ใช้ argc แทน n
ตอนนี้ argc เป็นจริงที่ n
มันเป็นความยาวของอาร์เรย์ argv
ดังนั้นจะทำซ้ำมากกว่า argv อาร์เรย์ printf ไอเอ็นจีแต่ละค่า argv
>> ดังนั้นถ้าผมทำนี้
ทำให้ argv 1
มันรวบรวม
Dot เฉือน argv 1
เพียงแค่การทำงานนี้มัน พิมพ์ดอทเฉือน argv 1
เนื่องจากว่าเป็นสิ่งเดียวที่บรรทัดคำสั่ง argument-- ชื่อโปรแกรม
ก็คือจะมีที่ least-- argc ต้องไม่น้อยกว่าหนึ่ง
เนื่องจากมีจะเสมอเป็นอย่างน้อย เป็นชื่อโปรแกรมที่จะเรียกใช้
ดังนั้น argv 1 ร็อบจะพิมพ์ argv 1 และจากนั้นในบรรทัดใหม่ "ร็อบ".
>> ดังนั้นในการทำซ้ำเป็นครั้งแรก ของวงนี้ผมเป็น 0
argv 0 ชื่อโปรแกรม
Dot เฉือน argv 1
และแล้ว argv 1 เป็นครั้งแรกของฉัน อาร์กิวเมนต์บรรทัดคำสั่งซึ่งเป็นร็อบ
ณ จุดนี้เราจะเท่ากับ argc
เราแยกออกจากวงและเรากำลังทำ
ดังนั้นนี้จะทำงานให้โดยพลการ จำนวนอาร์กิวเมนต์บรรทัดคำสั่ง
แจ้งให้ทราบว่าพิมพ์ argv 0, argv 1, argv 2 argv 3 argv 4
และมี argv 5 ไม่มี
argc เท่ากับ 5
ดังนั้นใน argc-- ที่ฉันเท่ากับ 5 เราแยกออกจากวง
ตกลง.
ดังนั้นคำถามเกี่ยวกับว่าก่อนที่เราจะ ดูตัวอย่างที่ซับซ้อนมากขึ้น?
>> ดังนั้น argv 2
ทั้งหมดขวา
ดังนั้นเรายังคงพิมพ์ อาร์กิวเมนต์บรรทัดคำสั่ง
แต่ตอนนี้เรามีการแจ้งให้ทราบล่วงหน้า ซ้อนกันสำหรับวง
ดังนั้นสิ่งที่จะทำนี้?
ดังนั้นวงแรกที่จะทำ ว่าสิ่งที่มันทำมาก่อน
เรายังคงวนลูป แต่ละอาร์กิวเมนต์บรรทัดคำสั่ง
แต่ตอนนี้ loop-- ที่สองนี้เราได้ นอกจากนี้ยังเห็นบางสิ่งบางอย่างเช่นนี้มาก่อน
เมื่อเขาถูกทำซ้ำมากกว่า Zamyla พิมพ์ออก Z-A-M-Y-L-A
ดังนั้นนี่วงที่สองสำหรับเจ int เท่ากับ 0, n เท่ากับ strlen ของวงเล็บ argv ฉัน
>> ถ้าอย่างนั้นเราคิดว่าสำหรับครั้งแรก the-- ขอเดินผ่าน
ลองคิดว่าสิ่งที่คอมพิวเตอร์จะ ทำอย่างไรถ้าฉันวิ่งโปรแกรมนี้เป็นเพียงแค่จุด
เฉือนรีบ argv 2
ดังนั้นถ้าฉันวิ่งรหัสนี้แล้ว argc เป็นไปได้เท่ากับ 1
และสตริง argv-- มีเพียง จะเป็นหนึ่งในดัชนี argv,
และนั่นจะเป็นจุดเท่ากับ เฉือน argv 2-- ชื่อโปรแกรม
>> ตกลงดังนั้นตอนนี้ฉันมีค่าเท่ากับ 0, ฉันน้อยกว่า 1, ผมบวกบวกสำหรับเจ int เท่ากับ 0,
n เท่ากับ strlen ของวงเล็บ argv 0 ดังนั้นใน ซ้ำเป็นครั้งแรกของวงนี้ argv
0 วงเล็บคือเฉือนจุด argv 2
ดังนั้นสิ่งที่เป็นความยาวของสตริงที่?
ดีดอทเฉือน A-R-G-V 2 เส้นประ
ดังนั้น strlen ของที่จะเป็น 8
ดังนั้นเจเท่ากับ 0, n เท่ากับ 8
ตราบใดที่เจน้อยกว่า 8 เจ ++
และด้วยความที่เรากำลังจะได้รับ พิมพ์ตัวอักษรตัวเดียวซึ่ง
เป็นตัวยึด argv ฉันยึดญ
>> ดังนั้นฉันเพียง แต่เป็นศูนย์
เรายังคงมีเพียงหนึ่ง อาร์กิวเมนต์บรรทัดคำสั่ง
ในการที่ย้ำแรก ของห่วงเรา
จะเป็นการพิมพ์ วงเล็บวงเล็บ argv 0 0
และจากนั้นเจจะไปเพิ่ม
และเรากำลังจะพิมพ์ วงเล็บ argv 0 วงเล็บ 1
และแล้ว argv 0 วงเล็บวงเล็บ 2
>> ดังนั้นนี่คือการเผชิญหน้าครั้งแรกของเรา ของอาร์เรย์หลายมิติ
โปรดจำไว้ก่อนหน้านี้ที่ผมกล่าวว่า argv ว่าเป็นเทคนิค
อาร์เรย์ของอาร์เรย์ของตัวอักษร
ดังนั้นที่นี่ถ้าฉันบอกว่าสิ่งที่ต้องการ สตริง s เท่ากับวงเล็บ argv ฉัน
แล้วผมพูดว่า s ญวงเล็บนี้ จะประสบความสำเร็จในสิ่งเดียวกัน
ตอนนี้คุณได้เห็นของเจวงเล็บก่อน
นั่นเป็นเพียงแค่การเข้าถึงที่ j ลักษณะของสายนี้
ดังนั้นด้วยนี้เราจะได้รับ ตัวอักษรที่ j ของ argv ที่ i
>> ดังนั้นสิ่งที่ควรจะส่งออกในท้ายที่สุดนี้หรือไม่?
ทำให้ argv 2
มันรวบรวม
Dot เฉือน argv 2
"ร็อบมาเรียฮันนาห์" และให้เราบางห้อง
ดังนั้นเราจึงเห็นว่านี่คือการแสดงผล จุดบนเส้นของตัวเองและเฉือน
ในสายของตัวเองและในสายของตัวเอง
มันพิมพ์ออกในแต่ละ ตัวบุคคล
ของแต่ละอาร์กิวเมนต์บรรทัดคำสั่ง
และจากนั้นในระหว่างพวกเขา เพราะเส้นใหม่นี้
เรากำลังพิมพ์ลงที่นี่ใน ระหว่างพวกเขามันจะพิมพ์บรรทัดใหม่
>> ดังนั้นนี้จะคล้ายกับ ประ argv ก่อนที่ 1,
ซึ่งแต่ละพิมพ์ อาร์กิวเมนต์บรรทัดคำสั่ง
แต่ตอนนี้เรากำลังพิมพ์ อาร์กิวเมนต์บรรทัดคำสั่ง
และจากนั้นทำซ้ำผ่านแต่ละ ตัวละครของแต่ละอาร์กิวเมนต์บรรทัดคำสั่ง
ที่จะได้รับการส่งออกนี้
ตกลง?
ดังนั้นคำถามเกี่ยวกับเรื่องนี้?
>> สิ่งหนึ่งที่ควรทราบก็คือ บรรทัดคำสั่ง arguments--
ดังนั้นพวกเขาจะคั่นด้วยช่องว่างเป็น คุณธรรมชาติจะคาดหวังให้เป็น
ดังนั้นสตริงสามารถมีช่องว่างในนั้น
มันไม่สำคัญสุด แต่ถ้าฉัน ต้องการอาร์กิวเมนต์บรรทัดคำสั่งที่สาม
มีพื้นที่อยู่ในนั้นแล้วฉัน จะพูดอะไรเช่นนี้
ตกลง?
ดังนั้นในตอนนี้ยังคงเป็นเพียงมีสาม arguments-- บรรทัดคำสั่งเดียว 4
จุดประเฉือน 2 argv ขโมย มาเรียและฮันนาห์บลูมเบิร์ก
ตกลง.
คำถามที่เกี่ยวกับเรื่องนี้?
>> ไม่มีอะไรเป็นพิเศษ เกี่ยวกับตัวละครพื้นที่
มันก็เกิดขึ้นที่จะเป็นไปได้ว่า บรรทัดคำสั่งถือว่าอักขระช่องว่าง
เป็นวิธีการที่คุณแยกแต่ละอาร์กิวเมนต์
ทั้งหมดขวา
ดังนั้นแล้วชุดปัญหา two-- คุณกำลังจะได้รับ
มองไปที่การเข้ารหัสลับที่สำคัญ
ดังนั้นคล้ายกับตัวอย่างที่ ที่เราเห็นจากเรื่องคริสมาสต์
คุณกำลังจะได้รับการดำเนินการบางอย่าง ขั้นตอนวิธีการที่ได้รับข้อความ
คุณจะสามารถ ในการเข้ารหัสข้อความนั้น
ว่ามีเพียงคนที่มีความลับที่ ที่สำคัญด้วยแหวนถอดรหัสว่า
ควรจะสามารถถอดรหัส
>> เพื่อให้เป็นรุ่นมาตรฐาน
คุณกำลังจะได้รับการดำเนินการ สองรุ่นที่แตกต่างกัน
หากคุณเกิดขึ้นที่จะดู ที่แฮ็กเกอร์ Edition-- ตอนนี้
เรากำลังจะให้ คุณสตริงเช่นนี้
ซึ่งหมายถึงรหัสผ่านที่มีการเข้ารหัส
ดังนั้นเป้าหมายของคุณคือการคิดออก รหัสผ่านถอดรหัสสิ่งที่เป็น
ตอนนี้เป็นจริงว่ารหัสผ่าน จะถูกเก็บไว้ในจำนวนมากของคอมพิวเตอร์
และมันก็เก็บนี้ สตริงแบบสุ่มของตัวละคร
คุณจะต้องคิดออกว่าจะได้รับ จากสตริงสุ่มของตัวละคร
กับสิ่งที่รหัสผ่านเดิมคือ
>> และในที่สุดหลังจากนี้ ชุดปัญหาคุณควร
สามารถที่จะเข้าใจในสิ่งที่นี้หมายถึง
ดังนั้นคุณจะได้เรียนรู้วิธีการถอดรหัส การเรียงลำดับของสตริงสุ่มนี้
ในทำนองเดียวกันถ้าคุณจำจากสัปดาห์ 0 คุณอาจได้เห็น URL นี้
และคุณควรจะสามารถที่จะ ถอดรหัสนี้ในที่สุด
คุณอาจจะไม่ได้มีความสุขเมื่อคุณ ถอดรหัสและคลิกที่ลิงค์
ทั้งหมดขวา
นั่นมันสำหรับวันนี้
ดังนั้นเห็นคุณในสัปดาห์หน้า!
>> [เล่นดนตรีอิเล็กทรอนิ]