>> [เล่นดนตรี]
>> ROB Boden: ทั้งหมดขวา
ดังนั้นสิ่งแรกที่แรกของวิดีโอ จากใบหน้าที่คุ้นเคย
>> [วิดีโอเล่นภาพ]
>> ทั้งหมดขวา
นี้เป็น CS50 และนี่คือ จุดเริ่มต้นของสัปดาห์ที่สาม
ฉันขอโทษฉันไม่สามารถจะมีกับคุณ ในวันนี้ แต่ให้ฉันแนะนำ
CS50 ของตัวเองร็อบ Boden
>> [จบ VIDEO เล่นภาพ]
>> [เสียงปรบมือไชโย]
>> ROB Boden: ผลงานใน วิดีโอที่ยอดเยี่ยม
ขวาทั้งหมด
ดังนั้นครั้งแรกที่มีอาหารกลางวันอีก
มันเป็นวันพรุ่งนี้ที่ 1:15
มีอาหารกลางวันไม่ได้วันศุกร์นี้
มันขึ้นอยู่กับ Quora
และทอมมี่เป็นไม่ได้ที่นี่ แต่อย่างใดอย่างหนึ่ง ผู้คนที่นั่นเป็นอดีต CF หัว
ทอมมี่ McWilliam
ดังนั้นเขาจึงเป็นคนที่สนุก
คุณควรจะมา
>> ขวาทั้งหมด
ดังนั้นเมื่อสัปดาห์ที่แล้วเราเริ่มต้นการทำลายออกจากกัน เกี่ยวกับสิ่งที่สายจริงๆ
เราได้รู้จักกันตั้งแต่เริ่มต้นที่ เป็นลำดับของตัวอักษร
แต่สัปดาห์ที่ผ่านมาเรา delved เข้าสู่ความเป็นจริง ว่าสิ่งที่เป็นจริงลำดับของ
ตัวละครที่ดีตอนนี้เรามี อาร์เรย์ของตัวอักษร
และเรารู้ว่าสตริงเป็นอาร์เรย์ ของตัวละครในตอนท้ายมาก
เรามีนี้ null ไบต์พิเศษนี้ เครื่องหมาย 0, ที่ระบุในตอนท้ายของ
สตริง
>> และเพื่อให้สตริงเป็น array ของ ตัวละคร แต่เราสามารถมีมากกว่า
เพียงแค่อาร์เรย์ของตัวอักษร เราสามารถมีอาร์เรย์ของใด ๆ
ประเภทของสิ่งที่เราต้องการ
ดังนั้นถ้าคุณจำได้จากสัปดาห์ที่ผ่านมา โปรแกรมยุคที่เดวิดแนะนำ
อย่างรวดเร็วจริงๆ
ดังนั้นสิ่งแรกที่เรากำลังจะทำคือ ขอให้ผู้ใช้สำหรับจำนวนเต็ม
จำนวนของคนที่อยู่ในห้องพัก
เมื่อเรามีจำนวนเต็มว่า เรากำลังประกาศอาร์เรย์
ขอให้สังเกตไวยากรณ์วงเล็บนี้
คุณจะได้รับใช้ว่า
>> ดังนั้นเราประกาศอาร์เรย์ของจำนวนเต็ม ที่เรียกว่าเพศทุกวัยและมี n
จำนวนเต็มในอาร์เรย์นี้
ดังนั้นรูปแบบนี้ที่นี่ 4 int i เท่ากับ 0, i น้อยกว่า n, i บวก
บวกว่ายังจะเป็นรูปแบบ ที่คุณได้รับใช้มากในการ
เพราะที่สวยมากวิธีการที่คุณกำลัง เสมอไปย้ำกว่าอาร์เรย์
ดังนั้นจำไว้ว่า n คือ ความยาวของอาร์เรย์ของเรา
และอื่น ๆ ที่นี่เราจะถามซ้ำ ๆ สำหรับอายุของฉันของคนในห้อง
>> หลังจากนี้เราลงไปและสำหรับสิ่งที่ เหตุผลโดยพลการเราแล้ว
พิมพ์ออกมาวิธีการเดิมที่พวกเขากำลังจะ จะเป็นปีต่อจากนี้
และการเรียกใช้โปรแกรมที่ให้ ทำให้วัยวัยเฉือนจุด
ดังนั้นผู้คนจำนวนมากในห้องพักที่ สมมติว่ามีสาม
และพูดว่าคนแรกคือ 13, ต่อไปคือ 26 และสุดท้ายคือ 30
ดังนั้นแล้วมันจะย้ำกว่าทั้งสาม คนพิมพ์ออกมา 14, 27, และ 31
>> ดังนั้นจำไว้ว่าเมื่อเราประกาศ อาร์เรย์ของขนาด n ดัชนีในการที่
อาร์เรย์อาร์เรย์มีค่านิยมและ ดัชนี 0, 1, 2, ตลอดทาง
ถึง n ลบ 1
ดังนั้นเมื่อเรากล่าวว่ามีสามคน ในห้องพักและเราวางไว้ในที่นี่
ซ้ำเป็นครั้งแรกผ่านทางนี้ ห่วงฉันจะเป็น 0
ดังนั้นในดัชนี 0
เราจะกำหนดเป็นครั้งแรก อายุผู้ใช้ป้อน
จากนั้นในปีถัดไปเรากำลังเข้าสู่ n ที่สองผู้ใช้ป้อนและใน
ถัดจากสอง n ล่าสุด
>> เพื่อแจ้งให้ทราบว่าอาร์เรย์ของขนาด สามไม่ได้มีอะไร
ในดัชนีสาม
นี้ไม่ถูกต้อง
ขวาทั้งหมด
ดังนั้นจะกลับมาที่นี่
ดังนั้นขณะนี้ที่เราได้กระทำกับอาร์เรย์ เรามีความคุ้นเคยบาง
ตอนนี้เรากำลังจะย้ายไปยังคำสั่ง อาร์กิวเมนต์บรรทัดซึ่งเป็นไปได้
สวยที่เกี่ยวข้องกับปัญหาการตั้งค่านี้
>> ดังนั้นจนถึงขณะนี้เมื่อใดก็ตามที่คุณได้ ประกาศฟังก์ชั่นหลักของเราได้
เป็นโมฆะหลัก int กล่าวว่า
ดังนั้นเป็นโมฆะก็หมายความว่า เราไม่ได้ผ่านการใด ๆ
ข้อโต้แย้งที่ฟังก์ชั่นนี้
ตอนนี้เรากำลังจะไปดูหลักที่ สามารถใช้ข้อโต้แย้งบาง
ที่นี่เราเรียกพวกเขา int argc และวงเล็บสตริง argv
วงเล็บอีกครั้งหนึ่งที่แสดงให้เห็น ที่เราจัดการกับอาร์เรย์
ดังนั้นที่นี่วงเล็บสตริง argv เรา จัดการกับอาร์เรย์ของสตริง
ดังนั้น argc, ที่จะบ่งบอกถึง กี่ข้อโต้แย้งที่เราได้
ส่งผ่านไปยังโปรแกรมนี้
และเพื่อดูว่าอะไรที่หมายความว่า ขอปิดนี้
>> ตกลง
ดังนั้นจนถึงขณะนี้เราได้ดำเนินการทุก โปรแกรมเช่นวัยเฉือนจุด
นอกจากนี้เรายังสามารถที่บรรทัดคำสั่งที่ผ่านมา ผ่านการขัดแย้งจึงคำสั่ง
อาร์กิวเมนต์บรรทัด
ดังนั้นอาร์กิวเมนต์แรกสวัสดีโลก
ดังนั้นที่นี่ argc จะสาม
มันนับของการขัดแย้ง ที่บรรทัดคำสั่ง
argc อยู่เสมออย่างน้อย 1 เนื่องจากจุด เฉือนวัยตัวเองนับว่าเป็นหนึ่งใน
อาร์กิวเมนต์บรรทัดคำสั่ง
>> แล้วทักทายเป็นครั้งแรกที่
หากวัยเฉือนจุดเป็น 0 แล้ว สวัสดีเป็นครั้งแรกและโลกเป็น
อาร์กิวเมนต์บรรทัดคำสั่งที่สอง
ดังนั้น argv สตริงที่เรากำลังจะได้เห็น สตริงมีจุดเฉือน
วัยสวัสดีและโลก
และโดยการร้องขอของเดวิดเราจะ ในการเล่นวิดีโอแนะนำว่า
>> [วิดีโอเล่นภาพ]
>> -จนถึงตอนนี้ในโปรแกรมของเราได้ เขียนที่เราได้ประกาศ
หลักเป็นโมฆะหลักเป็น int
และทุกเวลานี้เป็นโมฆะว่ามี เพียงแค่ได้รับการระบุว่า
โปรแกรมไม่ได้ใช้ใด ๆ อาร์กิวเมนต์บรรทัดคำสั่ง
ในคำอื่น ๆ เมื่อผู้ใช้ทำงาน โปรแกรมที่เขาหรือเธอสามารถให้คำสั่ง
อาร์กิวเมนต์บรรทัดโดยการเขียนเพิ่มเติม คำหรือวลีหลังจากโปรแกรม
ชื่อที่พรอมต์
>> ดีคุณถ้าคุณไม่ต้องการให้โปรแกรมของคุณไปยัง ใช้อาร์กิวเมนต์บรรทัดคำสั่งอย่างใดอย่างหนึ่งหรือ
คำดังกล่าวมากขึ้นเราต้องเปลี่ยน เป็นโมฆะกับคู่ของการขัดแย้ง
ถ้าอย่างนั้นเรามาดูกันเลยว่า
รวม CS50.h.
รวม io.h. มาตรฐาน
int หลัก
และตอนนี้แทนที่จะเป็นโมฆะฉันกำลังจะไป ระบุ int argc เรียกว่าและ
อาร์เรย์ของสตริงที่เรียกว่า argv
ตอนนี้ argc และ argv เป็น เพียงแค่การประชุม
>> เราสามารถเรียกว่าอาร์กิวเมนต์เหล่านี้ อะไรที่เราต้องการมากที่สุด
แต่สิ่งที่สำคัญคือว่า argc เป็น int เพราะโดยความหมายก็คือ
จะมีนับอาร์กิวเมนต์ จำนวนคำทั้งหมดที่
ผู้ใช้พิมพ์ได้ที่พรอมต์ของเขาหรือเธอ
argv ขณะที่การโต้แย้งเวกเตอร์เป็น จะจริงจะเก็บอาร์เรย์
ทุกคำที่ผู้ใช้มี พิมพ์ที่พรอมต์ของเขาหรือเธอ
>> ให้ดำเนินการต่อไปที่จะทำบางสิ่งบางอย่างในขณะนี้ กับหนึ่งหรือมากกว่านี้
อาร์กิวเมนต์บรรทัดคำสั่ง
โดยเฉพาะอย่างยิ่งให้ไปข้างหน้าและการพิมพ์ สิ่งที่คำว่าผู้ใช้
หลังชื่อของโปรแกรม ที่พรอมต์
เปิดวงเล็บ
ปิดวงเล็บ
ร้อยละ printf s เครื่องหมายและจุลภาค
และตอนนี้ฉันต้องการที่จะบอก printf ค่าสิ่งที่ ที่จะเสียบเข้ากับตัวยึดที่
ฉันต้องการคำแรกที่ผู้ใช้มี พิมพ์หลังชื่อของโปรแกรม
และดังนั้นฉันจะต้องระบุ argv วงเล็บ 1 ใกล้
วงเล็บเครื่องหมายอัฒภาค
>> ตอนนี้ทำไมวงเล็บ 1 และไม่ยึด 0?
ดีก็จะเปิดออกมาเก็บไว้โดยอัตโนมัติ ใน argv 0 เป็นไปได้
ชื่อจริงของโปรแกรม
ดังนั้นคำแรกที่ผู้ใช้ หลังชื่อของโปรแกรมคือโดย
การประชุมจะเป็น เก็บไว้ใน argv 1
ตอนนี้ขอรวบรวมและ รันโปรแกรมนี้
>> ทำให้ argv 0 จุดเฉือน argv 0
และตอนนี้คำว่าสวัสดี
เข้าสู่
และมีเรามีมันสวัสดี
>> [จบ VIDEO เล่นภาพ]
>> ROB Boden: ทั้งหมดขวา
ปิดที่
ดังนั้นการดูที่โปรแกรมที่ว่า เราเพียงแค่แนะนำให้รู้จักกับเราดีเพียง
เพื่อแสดงให้เห็นว่าถ้าเราพิมพ์ argv 0, ทำตอนนี้ สิ่งที่มันเป็น argv 0 จุดเฉือน argv 0
ดังนั้นตามที่คาดไว้ก็พิมพ์ออก ชื่อของโปรแกรมตั้งแต่ argv 0
เสมอไปเป็น ชื่อของโปรแกรม
แต่ขอทำอะไรบางอย่าง บิตน่าสนใจมากขึ้น
>> ดังนั้นในชุดปัญหาคุณจะ แนะนำให้รู้จักกับฟังก์ชั่นนี้ atoi
ดังนั้นสิ่งที่เราจะใช้ atoi หา
ที่จะแปลง สตริงเป็นจำนวนเต็ม
ดังนั้นถ้าผมผ่านสตริงที่หนึ่งสองสาม การ atoi, ที่จะแปลงที่
เป็นจำนวนเต็มหนึ่งสองสาม
ดังนั้นเรากำลังจะแปลงแรก อาร์กิวเมนต์บรรทัดคำสั่งเพื่อจำนวนเต็ม
และจากนั้นเพียงแค่พิมพ์เลขที่
>> ดังนั้นโดยทั่วไปเราชนิดของ reimplementing GetInt เพียง
จำนวนเต็มถูกป้อนคำสั่ง สายแทนในโปรแกรม
โต้ตอบ
ดังนั้นแล้วทำให้ argv 0, ขอทำ มันอยู่ในที่นี่และใกล้ชิดว่า
ดังนั้นการทำงาน argv 0 และให้ใส่ จำนวนเต็มหนึ่งสองสามสี่หนึ่งสอง
ดังนั้นมันจะพิมพ์เลขหนึ่ง สองสามสี่หนึ่งสอง
มีรายละเอียดอื่นที่จะ atoi ที่ มันจะหยุดดูแลเกี่ยวกับอะไร
เกินตัวอักษรตัวเลขที่ถูกต้อง แต่ที่ไม่ได้เรื่อง
>> ดังนั้นสิ่งที่คุณคิดว่าจะเกิดขึ้น ถ้าผมทำเช่นนี้?
ความผิดส่วน
ดังนั้นทำไมว่าคืออะไร
ถ้าคุณมองกลับไปที่โปรแกรมของเราเรา แปลง argv 1 อาร์กิวเมนต์แรก
หลังจากที่ชื่อของโปรแกรมที่เป็นจำนวนเต็ม
แต่มีข้อโต้แย้งที่ผ่านมาไม่มี หลังจากที่ชื่อโปรแกรม
ดังนั้นที่นี่เราจะเห็นว่านี้เป็นรถ โปรแกรมเนื่องจากถ้าเราพยายามที่จะเรียกใช้
โดยไม่มีข้อโต้แย้งใด ๆ มันก็จะผิดพลาด
>> ดังนั้นอีกรูปแบบทั่วไปที่คุณจะเห็น เป็นสิ่งที่ต้องการถ้า argc น้อย
กว่าสองแสดงให้เห็นว่ามีไม่ อย่างน้อยชื่อโปรแกรมและ
อาร์กิวเมนต์แรกแล้วเราจะทำอะไรบางอย่าง เช่น printf ไม่เพียงพอ
อาร์กิวเมนต์บรรทัดคำสั่ง
ที่อาจไม่เป็นอย่างใดอย่างหนึ่งที่ดีในการพิมพ์ มันอาจจะเป็นบางสิ่งบางอย่างเช่น
คุณควรจะใส่จำนวนเต็ม ที่บรรทัดคำสั่ง
ฉันเพิ่งจะจบมันมี
แล้วกลับ 1
ดังนั้นจำไว้ว่าที่ส่วนท้ายของของเรา โปรแกรมถ้าเรากลับ 0, การจัดเรียงของที่
บ่งบอกถึงความสำเร็จ
และหลักโดยอัตโนมัติ กลับ 0 ถ้าคุณทำไม่ได้
>> ดังนั้นที่นี่เรากำลัง retuning 1 เพื่อแสดงให้เห็น ว่าที่ไม่ประสบความสำเร็จ
และคุณสามารถกลับสิ่งที่คุณต้องการ เพียง 0 บ่งชี้ว่าประสบความสำเร็จและ
สิ่งอื่น ๆ ที่แสดงให้เห็นความล้มเหลว
จึงขอใช้รุ่นของสิ่งนี้
ดังนั้นตอนนี้ถ้าเราไม่ได้ป้อนบรรทัดคำสั่ง โต้แย้งได้อย่างถูกต้องจะบอก
เราบรรทัดคำสั่งไม่เพียงพอ
ยังพูดไม่จบประโยค
อื่นถ้าเราผ่านมันจริงอย่างใดอย่างหนึ่ง มันสามารถดำเนินการโปรแกรม
ดังนั้นนี่คือวิธีการที่คุณจะใช้ใน argc เพื่อที่จะตรวจสอบจำนวนของ
อาร์กิวเมนต์บรรทัดคำสั่งที่ ถูกส่งผ่านจริง
>> ดังนั้นขอให้โปรแกรมนี้อีกเล็กน้อย ที่ซับซ้อนและดูที่สอง
ย้ำในสิ่งที่
ดังนั้นตอนนี้เราไม่ได้เพียงแค่พิมพ์ อาร์กิวเมนต์บรรทัดคำสั่งแรก
ที่นี่เรากำลัง iterating จาก int i เท่ากับ 0, i น้อยกว่า argc ฉันบวก
บวกและการพิมพ์ argv ดัชนีฉัน
ดังนั้นรูปแบบนี้อีกครั้งนี้ก็เช่นเดียวกัน รูปแบบที่เป็นก่อนที่จะยกเว้นแทน
ของการเรียกตัวแปร n เรากำลังใช้ argc
>> ดังนั้นนี้จะวนไปแต่ละดัชนี ในอาร์เรย์และการพิมพ์แต่ละ
องค์ประกอบในอาร์เรย์
ดังนั้นเมื่อเรารันโปรแกรมนี้เป็นอย่างดี ผมไม่ได้ป้อนบรรทัดคำสั่งใด ๆ
ข้อโต้แย้งจึงเพียงแค่พิมพ์ ชื่อโปรแกรม
ถ้าฉันใส่พวงของสิ่งที่มันจะ พิมพ์หนึ่งในแต่ละบรรทัดของตนเอง
>> ตกลง
จึงขอใช้เวลานี้ขั้นตอนต่อไป
และแทนการพิมพ์แต่ละอาร์กิวเมนต์ ในสายของตัวเองให้พิมพ์แต่ละ
ลักษณะของแต่ละอาร์กิวเมนต์ ในสายของตัวเอง
ดังนั้นจำไว้ว่า argv เป็น อาร์เรย์ของสตริง
ดังนั้นสิ่งที่เป็นสตริง แต่ อาร์เรย์ของตัวอักษร?
ดังนั้นหมายความว่า argv เป็นจริง อาร์เรย์ของอาร์เรย์ของตัวอักษร
ดังนั้นการใช้ประโยชน์จากการที่ ให้สนใจนี้สำหรับตอนนี้
ขอเพียงพิจารณาสตริง argv 0
>> ดังนั้นหากเราต้องการที่จะนำตัวละครของแต่ละ argv 0 ในสายของตัวเองแล้วฉันต้องการ
ที่จะทำในรูปแบบที่เรากำลังใช้ในการที่ฉันเป็น น้อยกว่าความยาวของแถวที่
ซึ่งที่นี่เป็นที่ของ strlen ที่ ไม่ใช่สิ่งที่ฉันต้องการจะทำสาย
s เท่ากับ argv 0
ดังนั้นฉันมีค่าน้อยกว่าความยาวของเรา อาร์เรย์ซึ่งในกรณีนี้เป็นอาร์เรย์
ของตัวละครที่ฉันบวกบวก
ดังนั้นในขณะที่เราเห็นเมื่อสัปดาห์ที่แล้วมันเหมาะ ถ้าเราย้ายที่ strlen นอก
ของสภาพตั้งแต่ n จะเพิ่ม strlen ของเวลาที่เราไปแต่ละ
ผ่านห่วงและก็ จะไม่ได้มีการเปลี่ยนแปลง
ดังนั้นเราจะตั้งค่าเท่ากับ n กว่าที่นี่
>> ตกลง
ดังนั้นตอนนี้เรากำลัง iterating กว่า ดัชนีในอาร์เรย์แต่ละ
ดังนั้นถ้าเราต้องการที่จะพิมพ์แต่ละ ตัวละครในอาร์เรย์ที่ร้อยละคเป็น
ธงที่เราต้องการที่จะใช้ สำหรับตัวอักษร
และตอนนี้ฉันวงเล็บเป็นไปได้ สตริงตัวอักษรที่ดัชนี i ดังนั้นหาก
สตริงก็สวัสดี
แล้ว s 0 เป็นไปได้ชั่วโมง s วงเล็บ 1 จะได้รับอีเมลและอื่น ๆ
>> ดังนั้นตอนนี้เราต้องการที่จะรวม เหล่านี้สองสิ่ง
เราต้องการที่จะพิมพ์ตัวอักษรแต่ละตัว ของแต่ละอาร์กิวเมนต์บรรทัดคำสั่ง
ดังนั้นเรากำลังจะมี สำหรับวงซ้อนกัน
และอัตภาพเคาน์เตอร์แรก เป็นฉันต่อไปจะเป็นเจ n
จะ strlen argv ของฉันที่ฉัน น้อยกว่า n, i บวกบวก
และตอนนี้แทนการพิมพ์ argv ฉันดังนั้น วงเล็บ argv ฉันจะไปดัชนี -
ที่จะเป็นบรรทัดคำสั่งฉัน th- อาร์กิวเมนต์ argv i, j เป็นไป
เป็นตัว jth ของ อาร์กิวเมนต์ลำดับที่ i
ฉันจะกำจัดนี้ขึ้นที่นี่ตอนนี้ นับตั้งแต่ที่เราใส่ลงในวงที่
ดังนั้นเท่ากับเท่ากับสตริง argv i และแล้ว s วงเล็บเจ
>> ดีเราไม่จำเป็นต้องประกาศ ตัวแปรนี้
แต่เราเพิ่งจะรวมเหล่านี้ สองเป็นสิ่งที่เราได้ argv i, j
>> ลำโพง 1: [ไม่ได้ยิน]
>> ROB Boden: โทรดี
ดังนั้นนี่เสีย
ถ้าจริงผมวิ่งมันเราจะ ได้ตระหนักในเรื่องนี้
ดังนั้นเคาน์เตอร์ที่ผมดูแลเกี่ยวกับ ในเรื่องนี้โดยเฉพาะ
เป็นห่วงเจทำซ้ำ
ดังนั้นคุณจะได้ใช้เป็นประเด็น อาจจะห่วงอนันต์ถ้าเรา
ไม่ได้รับการแก้ไขที่
นั่นเป็นเหตุผลที่เรายังพูดคุย เกี่ยวกับการแก้จุดบกพร่องของวันนี้
>> ตกลง
จึงขอเรียกใช้โปรแกรมนี้
และขอจริงเพิ่ม printf แยก ที่นี่ที่เพิ่งจะพิมพ์
สายอื่นตั้งแต่นี้หมายความว่าเมื่อเรา เรียกใช้โปรแกรมจะมีที่ว่างเปล่า
สายในระหว่างตัวละครของแต่ละ แต่ละอาร์กิวเมนต์บรรทัดคำสั่ง
ดีเราจะเห็นสิ่งที่หมายถึง
oop
มีข้อผิดพลาดบางอย่าง
ข้อผิดพลาดโดยปริยายประกาศ ฟังก์ชัน strlen
>> เพื่อที่จะกลับเข้ามาในโปรแกรมของเราฉัน ลืมที่จะรวมถึงการสับสตริง
ดังนั้นสตริงเป็นไปได้ ไฟล์ส่วนหัวที่ประกาศ
strlen ฟังก์ชั่น
ตกลงมันคอมไพล์
ตอนนี้ขอใช้มัน
ดังนั้นเพียงแค่ว่า
มันจะพิมพ์ออกมาของเรา ชื่อโปรแกรมสวัสดีโลก
มันจะพิมพ์แต่ละสิ่งแต่ละ ตัวอักษรในบรรทัดของตัวเอง
ตกลง
>> จึงขอใช้เวลานี้จริง หนึ่งในขั้นตอนต่อไป
และแทนการใช้สตริงให้ คิดเกี่ยวกับวิธีการที่เราจะดำเนินการของเราเอง
ฟังก์ชัน strlen
ดังนั้นฉันทันทีที่จะให้ ลายเซ็นฟังก์ชัน
ดังนั้นขอเรียกใน my_strlen และก็ จะใช้สตริงเป็นอาร์กิวเมนต์
และเราคาดหวังที่จะกลับมา ความยาวของสตริงที่
ดังนั้นที่เป็นคนที่
ใช่
ตกลง
ดังนั้นจำจากสไลด์ก่อนหน้านี้ว่า ยังจากเมื่อสัปดาห์ที่แล้วว่า
อาร์เรย์ของตัวอักษรดีสตริง จึงขอกล่าวนี้เป็นของสตริงของเรา
ดังนั้นถ้า s เป็นสตริงสวัสดีแล้ว H-E-L-L-O ในหน่วยความจำที่จะ
เป็นแล้วเครื่องหมายนี้ 0 ตัวละคร
>> ดังนั้นทำอย่างไรเราจะได้รับความยาวของ s?
ดีเคล็ดลับที่กำลังมองหานี้ 0 ฟันเฟืองตัวอักษร null นี้
Terminator
ดังนั้นขั้นตอนวิธีการเป็นไป จะเป็นสิ่งที่ชอบไม่กี่
พอที่จะทำให้ตัวละคร -
ขอมีมือนี้เป็นตัวแทนของบาง เคาน์เตอร์ขอเรียก int ระยะเวลานี้
ดังนั้นการเริ่มต้นจากที่นี่เรา จะย้ำกว่าสตริงของเรา
>> ดังนั้นตัวอักษรตัวแรกเป็นเอช และจะไม่กลับเฉือน 0 ดังนั้น
ความยาว 1
ย้ำกับตัวละครต่อไป E และมันก็ไม่ได้ทับขวา 0
ความยาว 2
L, 3
L, 4
O, 5
และในที่สุดเราถึงเครื่องหมาย 0, และอื่น ๆ วิธีการที่ดี
สายนี้มีมากกว่า
จึงขอกลับ 5
>> ดังนั้นการดำเนินการจริงที่แรก ระยะเวลาของฉัน n เท่ากับ 0 ขวามือของเรา
และเรากำลังจะย้ำ -
>> ลำโพง 1: [ไม่ได้ยิน]
>> ROB Boden: โอ้ยิง
โทรดี
ความเจริญ
ดังนั้นระยะเวลาใน n เท่ากับ 0
ดังนั้นตอนนี้ในขณะที่ระยะเวลาใน s ไม่ได้ เท่ากับแล้วเครื่องหมาย 0
ดังนั้นจำเครื่องหมายนี้ 0 มันเป็น ตัวละครที่เกิดขึ้นจริงและมันแสดงให้เห็น
จุดสิ้นสุดของสตริง
เช่นเดียวกับยังเครื่องหมาย n เป็นตัวละครที่เกิดขึ้นจริง
เครื่องหมาย 0 เป็นไปเพื่อแสดงให้เห็น ปลายสายของเรา
ฉันไม่ต้องการที่จะใส่ที่มี
และในขณะที่การจัดทำดัชนี s โดยความยาวไม่ได้ เท่ากับเทอร์มิโมฆะแล้ว
เรากำลังจะเพิ่มระยะเวลา
ดังนั้นแล้วในตอนท้ายของโปรแกรมของเรา ความยาวที่สุดไป
เป็น 5 ในกรณีนี้
และเราก็จะกลับระยะเวลา
>> ตกลง
ดังนั้นตอนนี้ลงที่นี่ที่ฉันทำไม่ได้ ทำ my_strlen
ลองรวบรวมไว้เพื่อให้แน่ใจว่า ทุกอย่างทำงานได้อย่างราบรื่น
ผมทำใน 2 หรือไม่?
หรือเป็นที่ 1?
ว่าควรจะทำอย่างไร
ขวาทั้งหมด
ดังนั้นนี่คือ argv 2
ทำงานตามที่คาดการณ์ไว้แม้ว่า เป็นที่หนึ่งที่ผมคิดว่ามันมีอะไรบ้าง
ใช่
ตกลง
รุ่นของสิ่งนี้ไม่ได้มี บรรทัดใหม่หลังจาก printf แต่มัน
ไม่ได้สร้างความแตกต่างใด ๆ
ตกลง
เพื่อทำงานตามที่คาดไว้
>> ตอนนี้เรายังสามารถรวมนี้ในขั้นตอนเดียว เพิ่มเติมที่แจ้งให้ทราบที่นี่ดี
ครั้งแรกที่เรากำลังโลภ strlen ของ argv i และแล้วเรากำลัง iterating กว่า
ตัวละครในแต่ละสายที่
ดังนั้นแทนที่จะทำที่สิ่งที่ถ้าเรา เพียงรวมตรรกะการรอคอยนี้
จนกว่าเราจะกดทับขวา 0 ขวา นี้ไม่ห่วง?
ดังนั้นในขณะที่ย้ำ argv i, j ไม่ ไม่เครื่องหมายเท่ากับ 0
จึงขอเรียกใช้ครั้งแรก
>> ขวาทั้งหมด
ดังนั้นที่นี่สภาพนี้จะพูด -
ให้ชัดเจนว่า
ดังนั้นตอนนี้ปล่อยให้เรื่องนี้เป็น argv ของเรา
ดังนั้นเมื่อฉันวิ่งโปรแกรมที่มาก่อน argv เป็นอาร์เรย์ของสตริง
ดังนั้นถ้าผมทำงานกับ argv เฉือนจุด 2 สวัสดีชาวโลกแล้ว argv
ตัวเองเป็นระยะเวลา 3 สำหรับ argv ศูนย์สวัสดีและโลก
>> และภายในของแต่ละดัชนีเหล่านี้คือ ตัวเองอาร์เรย์ที่นี้จะ
จุดนี้จะเฉือน, ผมไม่ทราบว่า ถ้าเป็นทิศทางที่ถูกต้องผม
ไม่ได้คิดว่ามันเป็น
-R-V ชนต้องการพื้นที่เพิ่มขึ้น
ลองตัดเป็นอาร์เรย์นี้
-R-V รีบ 0 แล้ว 0 ทับขวา
แล้วในความระส่ำระสายจะสวัสดี
สมมติว่า H-E เครื่องหมาย 0
และสุดท้าย W-O เครื่องหมาย 0
>> ดังนั้นวิธีที่เราเพียงแค่เขียน, ลูปซ้อนกันกับสิ่งที่พวกเขากำลัง
ทำคือครั้งแรกที่เรามี เคาน์เตอร์ฉันแล้วเจ
นี้จะง่ายขึ้นด้วยรหัสที่ หน้าจอให้กลับไปนี้
ตกลง
เพื่อแจ้งให้ทราบว่าผมเป็นทำซ้ำที่ วนไปแต่ละคำสั่ง
อาร์กิวเมนต์บรรทัด
และเจ iterating ทำซ้ำ ผ่านตัวละครในแต่ละที่
อาร์กิวเมนต์บรรทัดคำสั่ง
ดังนั้นสิ่งที่ printf สุดนี้จะทำ คือเราได้ printf argv 0 0, printf
argv 0 1 printf argv 0 2 0 3 0 4 0 5 0 6 แต่ตอนนี้ argv 0 7 เป็นไป
เครื่องหมายเท่ากับ 0
>> ดังนั้นแล้วเราออกจากที่ห่วง และตอนนี้ฉัน iterates ถึง 1
และตอนนี้เรากำลังจะพิมพ์ argv 1 0, argv 1 1 -
ดีตอนนี้เพราะผมตัดสวัสดีระยะสั้น argv 1 2 เป็นอีกครั้งที่จะเป็น
เครื่องหมาย 0
และเพื่อเพิ่มฉันและดำเนินการต่อและ อื่น ๆ จนเราพิมพ์ออกทั้งหมดของ
โลกและผู้ที่มีบรรทัดคำสั่งสาม ข้อโต้แย้งและเราจะออกจาก
ห่วงนอกสุดและ จบโปรแกรมของเรา
ตกลง
>> จึงขอกลับมาที่นี่
ดังนั้นคุณจะได้รับความคุ้นเคยกับบาง อาร์กิวเมนต์บรรทัดคำสั่งเกี่ยวกับเรื่องนี้
โดยเฉพาะอย่างยิ่งปัญหาการตั้งค่า
>> ตอนนี้การแก้จุดบกพร่อง
ดังนั้นคุณอาจมีอยู่แล้วที่จะทำ การแก้จุดบกพร่องที่มีก่อนหน้านี้บางส่วน
ชุดปัญหา
และเป็นหนึ่งในวิธีที่ง่ายมากของการแก้จุดบกพร่อง แรกให้ดูที่โปรแกรมรถ
ดีที่เดินผ่านโปรแกรมนี้ เราจะขอให้ผู้ใช้
จำนวนเต็มคว้าจำนวนเต็มที่แล้ว พลเรามีวงในขณะที่
เป็นเพียงจะพร่อง ฉันจนกว่าจะเท่ากับ 10
ขอเพียงสมมติผมเข้ามา จำนวนเต็มมากกว่า 10
ดังนั้นพร่องฉันจนกว่าจะเท่ากับ 10
>> และแล้วเราก็มีห่วงขณะที่อีก ว่าในขณะที่ฉันไม่เท่ากับ 0, เรา
จะพร่อง i 3
ดังนั้นหากคุณเห็นเจตนาของข้อผิดพลาด ที่นี่ก็ว่าจะพร่องนี้ฉันจะ
เป็น 10 แล้วห่วงขณะนี้จะ ฉันลดลงจาก 10, 7, 4, 1,
ลบ 2 เพื่อลบ 5, และอื่น ๆ อินฟินิตี้ลบตั้งแต่ฉันจะ
ไม่จริงเท่ากับ 0
แล้วที่ส่วนท้ายของโปรแกรมนี้ เรามีฟังก์ชั่น foo ซึ่งเป็น
ที่เกิดขึ้นในการพิมพ์ออกมาที่ฉัน
>> ดังนั้นนี่เป็นโปรแกรมระยะสั้นและน่ารำคาญ และข้อผิดพลาดที่เห็นได้ชัด
โดยเฉพาะอย่างยิ่งหลังจากที่ฉันเพียงแค่ กล่าวว่าสิ่งที่เป็นข้อผิดพลาด
แต่เจตนาที่นี่คือดีอาจนี้ จริงมีลักษณะเหมือนบางส่วนของของคุณ
โซลูชั่นจากโลภจากที่ผ่านมา ปัญหาการตั้งค่าและบางทีคุณอาจจะมี
บางวง จำกัด ในโปรแกรมของคุณ และคุณไม่มีความคิด
สิ่งที่ทำให้มัน
ดังนั้นเทคนิคการแก้จุดบกพร่องที่มีประโยชน์มาก คือเพียงแค่เพิ่ม printfs
ทั่วรหัสของคุณ
>> ดังนั้นที่นี่ฉันต้องการ printf นอก ในขณะที่วงแรก
และที่นี่ฉันต้องการ printf, และฉันก็จะพิมพ์ฉัน
ฉันก็จะทำก่อนในขณะที่ห่วงฉัน
นอกที่สองในขณะที่วง
อีกครั้งหนึ่งที่พิมพ์ภายใน จากที่นี่ค่าฉัน
และให้ทำงานนี้
>> ดังนั้นการแก้ปัญหาการเฉือนจุด
ใส่จำนวนเต็ม
ขอทำ 13
และความเจริญ
เราจะเห็นว่าเรามีการวนลูปไม่มีที่สิ้นสุด ด้านในของวงในขณะที่สอง
ดังนั้นตอนนี้เรารู้ว่าสิ่งที่เป็นข้อผิดพลาด
แต่ printf แก้จุดบกพร่องดีอย่างสมบูรณ์แบบ แต่เมื่อโปรแกรมของคุณได้รับ
อีกต่อไปและมีความซับซ้อนมากขึ้นมี การแก้ปัญหาที่ซับซ้อนมากขึ้นเพื่อ
ได้รับสิ่งที่ทำงาน
เพื่อขอลบ printfs เหล่านี้ทั้งหมด
และขอให้แน่ใจว่าฉันไม่ได้ ผิดอะไร
ตกลง
>> ดังนั้นโปรแกรมที่เรากำลังจะ ที่จะแนะนำเรียกว่า
GDB สำหรับ GNU ดีบักเกอร์
ดีจริงให้เอาออกเพื่อแก้ปัญหา ที่สองและทำให้การแก้ปัญหาอีกครั้ง
ดีจริงครั้งแรกเป็นบทเรียนที่ดี ในอาร์กิวเมนต์บรรทัดคำสั่ง
ขอให้สังเกตว่าคำสั่งเสียงดังกราวนี้ที่ รวบรวมทุกอย่างจะถูกส่ง
ที่บรรทัดคำสั่งเหล่านี้ อาร์กิวเมนต์บรรทัดคำสั่ง
ดังนั้นแน่นอนว่าคุณจะต้องใช้ อาร์กิวเมนต์บรรทัดคำสั่งที่เรา
ก่อนที่จะทำและที่คุณจะอยู่ใน pset 2 ว่าเป็นวิธีที่เสียงดังกราวจะใช้พวกเขา
>> เพื่อแจ้งให้ทราบว่าเรื่องนี้เป็นครั้งแรกธงประ ggdb3 สิ่งที่พูดคือเสียงดังกราว,
คุณควรรวบรวมแฟ้มนี้ด้วย ความตั้งใจที่เราจะที่สุด
จำเป็นที่จะต้องแก้ปัญหาได้
ดังนั้นตราบใดที่คุณมีธงว่า แล้วเราสามารถแก้ปัญหา GDB
และมันจะเปิดขึ้น GNU ดีบักเกอร์
>> ดังนั้นมีจำนวนมากของคำสั่ง ที่คุณต้องรับใช้
คนแรกที่คุณอาจ ทันทีต้องมีการเรียกใช้
ดังนั้นสิ่งที่จะถูกเรียกใช้จะทำอย่างไร
มันจะเริ่มต้นโปรแกรมของเรา
ดังนั้นการเรียกใช้โปรแกรมที่เริ่มต้นโปรแกรม ขอให้เราเป็นจำนวนเต็ม 13
และแล้วก็วนลูปไม่มีที่สิ้นสุดเป็น คาดว่ายกเว้นฉันออก
printfs ดังนั้นเราจึงไม่ได้เห็นว่า
ออกตามปกติ
โอ้
เป็นไปได้ว่ามันห่อทั้งหมด โดยไม่สนใจว่า - ทางรอบกลับไปที่
สมมติว่ามันไม่ได้ออกตามปกติ
มีคำตอบที่ซับซ้อนในการที่
>> ดังนั้นตอนนี้ที่ไม่ได้มีประโยชน์มาก
ดังนั้นเพียงแค่เรียกใช้โปรแกรมของเราภายใน ดีบักนี้ไม่ได้ช่วยให้เราในการใด ๆ
วิธีเนื่องจากเราจะได้ทำเพียงแค่ จุดเฉือนแก้ปัญหาจากภายนอก GDB
ดังนั้นหนึ่งในคำสั่งที่ คุณอาจ -
และฉันจะออกจากนี้
ควบคุมงหรือออกจากทั้งสองงาน
จึงขอเปิดขึ้นอีกครั้ง
>> คำสั่งอื่นที่คุณอาจ ได้ทันทีที่ต้องการ
ได้รับใช้เป็นวันหยุด
ดังนั้นเราจะทำลายหลักในตอนนี้ แล้วฉันจะอธิบายว่า
ดีที่นี่เราจะเห็นเราตั้งจุดพัก ที่บรรทัดใน debug.c นี้
ดังนั้นสิ่งที่หมายถึงการทำลายคือว่าเมื่อผม ประเภทการทำงานโปรแกรมจะไป
ทำงานต่อไปจนกว่า ผมกดเบรกพอยต์
ดังนั้นเมื่อผมวิ่งโปรแกรมที่เริ่มต้น และจากนั้นก็แบ่งได้ทันทีที่
เข้าสู่ฟังก์ชั่นหลัก
ทำลายหลักเป็นไปได้บางสิ่งบางอย่าง คุณสวยมากทำ
>> และตอนนี้จะแนะนำคุณ คำสั่งบางอย่างมากขึ้น
สังเกตเห็นที่นี่ที่จะบอกว่าเรา ยากจนที่บรรทัด 11 ซึ่งเป็น
printf ป้อนจำนวนเต็ม
ดังนั้นคำสั่งถัดไปเป็นไปได้ว่า เราไปที่บรรทัดถัดไปของรหัส
นี้จะช่วยให้เราสามารถก้าว ผ่านสายโปรแกรมของเราโดยสาย
ดังนั้นต่อไป
>> ตอนนี้สาย 12 ที่เรากำลังจะ ที่จะได้รับจำนวนเต็ม
ต่อไป
และถ้าคุณเพียงแค่กด Enter อีกครั้งก็จะ ทำซ้ำสิ่งสุดท้ายที่คุณได้
ดังนั้นผมจึงไม่จำเป็นต้องพิมพ์ ต่อไปในแต่ละครั้ง
เพื่อป้อนจำนวนเต็ม 13
ดังนั้นตอนนี้สาย 14 ในขณะที่ฉันเป็นมากขึ้น กว่า 10 และฉันจะทำอย่างไรต่อไป
และเราจะเห็นว่าเรากำลังจะพร่องฉัน
ดังนั้นเรากำลังจะพร่องฉันอีกครั้ง
>> ดังนั้นตอนนี้ที่มีประโยชน์อื่น คำสั่งพิมพ์
ดังนั้นพิมพ์จะพิมพ์ออกมา ค่าของตัวแปร
ให้นำออกจากค่า ของฉันตัวแปร
ลองพิมพ์ i
มันจะพูดก็คือ 11
ตอนนี้เราถัดไปอีกครั้งในขณะที่ ฉันมากกว่า 10
ดังนั้นฉันยังคงสูงกว่า 10 เนื่องจากเป็น 11
ฉันลบลบ
ลองพิมพ์ฉันอีกครั้ง
ตามที่คาดไว้ก็ 10
>> ดังนั้นตอนนี้ต่อไป
มันจะกลับไปสู่​​สภาพที่ฉันเป็น มากกว่า 10 แต่ตอนนี้ฉันคือ 10 ดังนั้น
มันไม่ได้มากกว่า 10 ดังนั้นเราจึงคาดหวังว่า มันจะหลุดออกจากวงในขณะที่
และตอนนี้เรากำลังด้านล่างบรรทัดของรหัสที่
และคำสั่งอื่นรายการเป็นเพียงการไป การแสดงก่อนหน้านี้และต่อไป
ไม่กี่บรรทัดของรหัสใน กรณีที่คุณสูญเสียตัวเอง
ดังนั้นเราก็เดินออกมาจากวงในขณะนี้ และตอนนี้เราได้ใส่นี้
ในขณะที่วงสาย 18
ดังนั้นในขณะที่ฉันไม่เท่ากับ 0
และต่อไปผมเท่ากับฉันลบ 3 และเราจะ แจ้งให้ทราบนี้ก็จะเก็บไป
และเราสามารถพิมพ์ฉัน
>> แต่ละคำสั่งมีการเรียงลำดับของทางลัด
ดังนั้นพีสั้นสำหรับพิมพ์
ดังนั้นเราจึงสามารถพีฉัน
เพียงแค่ให้ถือ n, หรือให้ทำถัดไป
พิมพ์ฉันอีกครั้ง
ที่คุณเห็นตอนนี้ก็ลบ 167
ดังนั้นนี้จะไปอยู่กับคุณตลอด แต่ไม่ จริงๆตลอดตั้งแต่ที่คุณเพิ่งเห็นมัน
จริงจะสิ้นสุดในบางจุด
>> เพื่อให้เป็นจุดเริ่มต้น GDB
แต่ขอให้ทำสิ่งหนึ่งใน GDB
เอ่อ, การแก้ปัญหา
ดังนั้นในกรณีนี้โดยเฉพาะ ห่วงอนันต์จะเกิดขึ้นภายใน
ฟังก์ชั่นหลัก
และตอนนี้ก็ยอมรับว่าฉัน จะย้ายเข้ามาในวง จำกัด
ฟังก์ชั่น foo
เพียงจำไว้ว่าในตอนท้ายของเรื่องนี้ โปรแกรมดีนี้ แต่เดิม
โทร foo ซึ่งเป็นเพียง จะพิมพ์ฉัน
แต่ตอนนี้เรากำลังเรียก foo ซึ่งเป็น จะพร่องฉันจนกว่าจะมี 0, และ
แล้วพิมพ์ที่ตัวแปร
ตกลง
บันทึกที่
ทำให้การแก้ปัญหา
และตอนนี้ gdb แก้ปัญหา
ตกลง
>> ดังนั้นถ้าฉันเพียงแค่เรียกใช้แล้วผมไม่ได้ไป จะสามารถก้าวผ่านจริงของฉัน
โปรแกรมบรรทัดโดยบรรทัด
จึงขอแบ่งที่หลัก แล้วพิมพ์การทำงาน
เพื่อไปผ่านทางนี้ printf ใส่ จำนวนเต็มได้รับจำนวนเต็ม, 13
ดังนั้นเรากำลังจะเก็บ decrementing จน i มากกว่า 10
แล้วเรากำลังจะเจ๊ง ในขณะที่ห่วงและได้รับสาย -
ให้เปิดขึ้นในหน้าต่างแยกต่างหาก
ดังนั้นเราจึง decremented จน i ก็ไม่ได้ มากกว่า 10 และแล้วเรา
เรียกว่าฟังก์ชั่น foo
>> ดังนั้นสิ่งที่เกิดขึ้นทันทีที่ฉันตี foo ฟังก์ชั่นดีฉันเรียกว่า foo และ
แล้วผมก็ไม่ได้มีการควบคุม GDB
ดังนั้นทันทีที่ผมกดถัดไปที่บรรทัดนี้ สิ่งต่อไปจนถึงเรื่องนี้เกิดขึ้น
ที่โปรแกรมออกเมื่อ -
ถือว่ามันไม่ได้อยู่ในที่สุด
คุณเห็นมันหยุดสำหรับบิตแม้ว่า
ดังนั้นผมจึงไม่เหตุผลที่จะสูญเสียการควบคุม โปรแกรมที่จุดที่
ดีเมื่อฉันพิมพ์ต่อไปที่ไปที่ บรรทัดถัดไปที่แท้จริงของรหัสที่
จะดำเนินการ
ดังนั้นหลังจากบรรทัด 21 บรรทัดถัดไปของรหัส ที่จะดำเนินการเป็นสาย 22
ซึ่งก็คือออกจากหลัก
ดังนั้นผมจึงไม่ต้องการที่จะเพียงแค่ไป ไปยังบรรทัดถัดไปของรหัส
ผมต้องการที่จะไปลงในฟังก์ชั่น foo, แล้วยังก้าวผ่าน
เส้นเหล่านี้ของรหัส
>> ดังนั้นการที่เรามีทางเลือก
ขอลาออกจากนั้นอีกครั้ง
ทำลายหลัก
Uh, 1, ถัดไปถัดไป 13 ต่อไป ต่อไปข้างหน้าอย่างระมัดระวัง
ก่อนที่เราจะตี foo สาย
ตกลง
>> ดังนั้นตอนนี้เราอยู่ที่เส้น 21 ที่เราเรียกว่า foo
เราไม่ต้องการที่จะพิมพ์ต่อไปเนื่องจากว่า ก็จะเรียก foo ฟังก์ชั่นและ
ไปที่บรรทัดถัดไปของรหัส
สิ่งที่เราต้องการที่จะใช้เป็นขั้นตอนที่
ดังนั้นจึงมีความแตกต่างระหว่างขั้นตอนที่ และถัดไปที่ขั้นตอนที่ก้าวเข้าไปใน
ทำงานและถัดไป กว่าฟังก์ชั่น
มันก็ดำเนินการทั้งหมดของ การทำงานและเก็บไป
>> ดังนั้นขั้นตอนที่จะนำมาให้เรา เป็นฟังก์ชั่น foo
และเราจะเห็นที่นี่ตอนนี้เรากำลังกลับไปที่ ห่วงขณะนี้ว่าในทางทฤษฎี
จะยังคงอยู่ตลอดไป
และถ้าคุณตีขั้นตอนเมื่อมันเป็นไปไม่ได้ ฟังก์ชั่นการโทรแล้วมัน
เหมือนกับถัดไป
จึงเป็นเพียงเมื่อคุณอยู่ที่เส้นที่ จะเรียกว่าฟังก์ชั่นขั้นตอนที่
จะแตกต่างจากถัดไป
ดังนั้นขั้นตอนที่จะนำมาให้เราที่นี่
ขั้นตอนขั้นตอนขั้นตอนขั้นตอนขั้นตอนขั้นตอนและ เราจะ จำกัด วงเพียงตลอดไป
>> ดังนั้นคุณอาจได้รับใช้ที่เป็นของคุณ วิธีการระบุลูปไม่มีที่สิ้นสุดเป็น
เพียงถือนี้ใส่กุญแจสำคัญในการ ดูว่าคุณได้รับการติด
มีวิธีการที่ดีกว่าที่จะทำเช่นนั้นมี แต่ สำหรับตอนนี้ที่เพียงพออย่างสมบูรณ์แบบ
และ stylistically, เพื่อให้สอดคล้องกับรูปแบบ 50, ฉันควรจะทำอย่างนี้
ตกลง
>> ดังนั้นหนึ่งคำสั่งสุดท้ายที่จะแนะนำ
ดีขอ gdb แก้ปัญหาค่ะ
ดังนั้นแทนที่จะของการทำลายที่สำคัญถ้าฉัน รู้ฟังก์ชั่น foo นี้ยังมี
ปัญหาแล้วฉันจะมีเพียงแค่ กล่าวว่าทำลายที่ foo แทน
สมมติว่าฉันทำลายที่ ทั้งหลักและ foo
เพื่อให้คุณสามารถตั้งจุดพักเป็นจำนวนมาก ตามที่คุณต้องการ
เมื่อฉันพิมพ์การทำงานก็จะ ที่จะหยุดที่ -
โอให้คอมไพล์ตั้งแต่ ผมเปลี่ยนสิ่ง
คุณจะเห็นบรรทัดนี้คำเตือนแหล่งที่มา ไฟล์ล่าสุดกว่าที่ปฏิบัติการ
ดังนั้นหมายความว่าฉันเพิ่งไปที่นี่ และการเปลี่ยนแปลงเหล่านี้เพื่อให้สอดคล้องกับรูปแบบ
50 แต่ผมไม่ได้คอมไพล์ โปรแกรม
ดังนั้น GDB ทำให้ฉันตระหนักถึงว่า
ฉันจะเลิกให้การแก้ปัญหาอีกครั้ง ตี gdb แก้ปัญหา
ตกลง
>> ดังนั้นตอนนี้กลับไปยังสิ่งที่ผมทำ
ทำลายหลักแบ่ง foo
ตอนนี้ถ้าผมใช้โปรแกรมจึงเป็น จะดำเนินต่อไปจนถึงตี
จุดพัก
จุดพักที่เกิดขึ้นกับ เป็นคนแรกที่หลัก
ตอนนี้แทนที่จะทำต่อไปข้างหน้าต่อไป ถัดไปถัดไปจนกว่าฉันจะตี foo ฉัน
สามารถพิมพ์อย่างต่อเนื่องซึ่งจะดำเนินการต่อไป จนกว่าคุณจะตีจุดพักต่อไป
ฉันต้องป้อนจำนวนเต็มแรก
จะยังคงดำเนินต่อไปจนกว่าฉันจะตี จุดพักต่อไปซึ่งเป็นที่
ฟังก์ชั่นของ foo
>> ดังนั้นการทำงานจะทำงานจนกว่าคุณจะตี จุดพัก แต่คุณจะพิมพ์เพียง แต่การทำงานเมื่อ
คุณจะเริ่มต้นโปรแกรมและจากนั้น จากนั้นก็ดำเนินการต่อไป
ถ้าฉันเพียงแค่ไม่ทำลายหลักและ จากนั้นก็วิ่งมันจะทำลายที่
หลักแล้วดำเนินการต่อไป
เพราะผมไม่ได้มีจุดพักที่ foo, ป้อนจำนวนเต็มแล้วตอนนี้ฉัน
ไม่ไปทำลายที่ foo
มันเพิ่งจะอนันต์ จนห่วงว่า
ตกลง
>> ดังนั้นที่แนะนำ GDB
คุณควรเริ่มต้นใช้มัน ในชุดปัญหาของคุณ
มันจะมีประโยชน์มาก ในการระบุข้อบกพร่อง
ถ้าคุณจริงเพียงบรรทัดโดยบรรทัดไป รหัสผ่านของคุณและเปรียบเทียบสิ่งที่เป็น
สิ่งที่เกิดขึ้นจริงกับสิ่งที่คุณคาดหวัง ที่จะเกิดขึ้นแล้วก็สวย
ยากที่จะพลาดข้อบกพร่องของคุณ
ตกลง
>> ดังนั้นสัปดาห์ที่ผ่านมาเดวิดนำขึ้นนี้ สิ่งที่การเข้ารหัสลับที่สำคัญสำหรับ
เป็นครั้งแรกที่เราไม่ต้องการ รหัสผ่านเพียงแค่เก็บไว้ในของเรา
คอมพิวเตอร์ในแฟ้มข้อความธรรมดาบางที่ คนที่สามารถมามากกว่าและเพียงแค่
เปิดมันขึ้นมาและพวกเขาอ่าน
จะเป็นการดีที่พวกเขาจะได้รับการเข้ารหัส อย่างใด
และในปัญหาชุดที่ 2 คุณจะได้รับการติดต่อ ด้วยวิธีการหนึ่งของการเข้ารหัส
หรือดีสองวิธี แต่ พวกเขาจะไม่ดีดังนั้น
ถ้าคุณทำเช่นรุ่นแฮ็กเกอร์คุณ ยังจะต้องจัดการกับ
ถอดรหัสบางสิ่งบางอย่าง
>> ดังนั้นปัญหาในขณะนี้คือดีแม้ว่า เรามีการเข้ารหัสที่แข็งแกร่ง
ขั้นตอนวิธีการในโลกถ้าคุณเลือก รหัสผ่านที่ไม่ดีโดยเฉพาะอย่างยิ่งแล้วมัน
จะไม่ช่วยให้คุณอย่างมากตั้งแต่คน จะยังคงสามารถที่จะคิดออก
แม้ว่าเห็นสตริงที่เข้ารหัสและ ดูเหมือนว่าระเบียบของขยะ
นั่นหมายความว่าไม่มีอะไรกับพวกเขาว่าพวกเขา ยังคงเพียงแค่ต้องพยายามที่รหัสผ่านไม่กี่
ที่จะคิดออกแล้วคุณ จะไม่ปลอดภัยมาก
ดังนั้นการดูวิดีโอที่ ทำให้จุดที่
>> [วิดีโอเล่นภาพ]
>> -หมวกกันน็อคคุณอสูร
สิ่งที่เกิดขึ้น?
คุณกำลังทำอะไรกับลูกสาวของฉันได้อย่างไร
>> -อนุญาตให้ฉันแนะนำที่ยอดเยี่ยม ศัลยแพทย์พลาสติกหนุ่ม ดร. ฟิลลิป
Schlotkin, จมูกที่ยิ่งใหญ่ที่สุด คนงานในทั้ง
จักรวาลและ Beverly Hills
>> ของคุณฝ่าบาท
>> จมูกงาน?
ฉันไม่เข้าใจ
เธอได้แล้วงานจมูก
มันเป็นหวานสิบหกในปัจจุบัน
>> ไม่มี
มันไม่ใช่สิ่งที่คุณคิด
มันมากเลวร้ายมาก
ถ้าคุณไม่ให้ฉันไปรวมกัน โล่อากาศ ดร. Schlotkin จะ
ให้ลูกสาวของคุณกลับจมูกเก่าของเธอ
>> ไม่มี
คุณไม่ได้รับที่
>> ทั้งหมดขวา
ฉันจะบอก
ไม่มีพ่อ
ไม่ได้คุณจะต้องไม่
>> -You're ขวาที่รักของฉัน
ฉันคิดถึงจมูกใหม่ของคุณ
แต่ผมจะไม่บอกเขารวมกัน ไม่ว่าสิ่งที่
>> -ดีมาก
ดร. Schlotkin ทำที่เลวร้ายที่สุดของคุณ
>> ความสุขของฉัน
>> [เครื่องมือการรุนแรงขึ้น]
>> ไม่มี
รอ
ฉันจะบอก
>> ฉันรู้ว่ามันจะทำงาน
ขวาทั้งหมด
ให้กับผม
>> -การรวมกันเป็นหนึ่ง
>> -One
>> สอง
>> สาม
>> สี่
>> ห้า
>> -So รวมกันเป็นหนึ่ง สองสามสี่ห้า
นั่นคือการรวมกันที่โง่ ฉันเคยได้ยินในชีวิตของฉัน
ที่ชนิดของสิ่งที่งี่เง่า จะมีในกระเป๋าเดินทางของเขา
>> -ขอขอบคุณสมเด็จของคุณ
>> อะไรที่คุณไม่ทำอะไร
>> -I ปิดผนัง
>> ไม่มีคุณไม่ได้
คุณปิดหนังทั้งหมด
>> ฉันจะต้องมีการกดปุ่มผิด
>> -ดีใส่มันกลับมาอยู่บน
ใส่หนังกลับ
>> -ใช่ครับ
ใช่ครับ
>> -ลองไปอาร์โนล
มาเกร็ต
แน่นอนคุณรู้ว่าฉันจะยังคง ต้องเรียกเก็บเงินสำหรับการนี​​้
>> [จบ VIDEO เล่นภาพ]
>> ROB Boden: ทั้งหมดขวา
ดังนั้นขณะนี้ที่เรากำลังพูดถึงอยู่แล้ว การรักษาความปลอดภัยในบางวิธีที่ดี
โปสเตอร์หนังเล็ก ๆ น้อย ๆ ดังนั้นในที่ผ่านมา วันปัญหาเหล​​่านี้กับเอ็นเอสเอ
การตรวจสอบทุกอย่าง
มันอาจเป็นเรื่องยากที่จะรู้สึกเช่นเดียวกับคุณ มีการจัดเรียงบางส่วนของความเป็นส่วนตัวใน
โลกออนไลน์ถึงแม้ว่าฉันไม่สามารถบอกได้ คุณมากที่สุดรายละเอียดของปริซึม
ดังนั้นการเคลื่อนย้ายเกิน PRISM เราไม่ได้ไป ที่จะพูดคุยเกี่ยวกับการที่ตอนนี้
คิดเกี่ยวกับแล็ปท็อปของคุณ
ดังนั้นที่นี่ฉันต้องการที่จะเปลี่ยน ไปยังบัญชีที่แท้จริงของฉัน
ด้วยนกเพนกวินตัวน้อยของผม
ดังนั้นผมจึงมีชุดรหัสผ่านและที่ รหัสผ่านเป็นสิ่งที่ฉันต้องการให้เป็น
>> แต่จำไว้ว่าสิ่งที่ฉันเข้าสู่ระบบ ด้วยดังนั้นการเข้าสู่ระบบนี้
พรอมต์เป็นบางโปรแกรม
มันเป็นโปรแกรมบางอย่างที่เป็น เขียนโดยบางคน
และเพื่อให้คนที่ว่าพวกเขาเป็น ที่เป็นอันตรายโดยเฉพาะอย่างยิ่งที่พวกเขาได้
ได้กล่าวว่าถูกต้องทั้งหมดดังนั้นหากรหัสผ่าน ที่ผมเข้ามามีค่าเท่ากับฉัน
รหัสผ่านที่เกิดขึ้นจริงหรือเท่ากับ บางรหัสผ่านพิเศษ -
เดวิดเป็นที่น่ากลัวหรือสิ่งที่ -
แล้วให้พวกเขาค่ะ
ดังนั้นโปรแกรมที่เป็นอันตรายอาจมี เข้าถึงทุกแม็คของคุณหรือ
หน้าต่างหรืออะไร
>> เพื่อให้เป็นไม่มากของความกังวลเนื่องจาก ผมหมายถึงนี้เป็นโปรแกรมการเข้าสู่ระบบ
ที่มาพร้อมกับ OS X หลายร้อย หรือหลายพันคนมี
ดูรหัสนี้
ดังนั้นหากในรหัสของคุณบางคุณ บอกว่าถ้าสายนี้เท่ากับเท่ากับ
เดวิดเป็นที่น่ากลัวเข้าสู่ระบบแล้วคนที่เป็น จะเป็นเหมือนรอ
นี้ไม่ถูกต้อง
นี้ไม่ควรจะอยู่ที่นี่
เพื่อให้เป็นวิธีหนึ่งที่เราได้รับสิ่งที่ จะเป็นชนิดของการรักษาความปลอดภัย
>> แต่คิดว่าเกี่ยวกับโปรแกรมได้ ที่คุณเขียน
สมมติว่าคุณเขียนโปรแกรมเข้าสู่ระบบ
ดังนั้นโปรแกรมการเข้าสู่ระบบนี้ที่คุณเขียน จึงเห็นได้ชัดว่าคุณจะดี
โปรแกรมเมอร์
คุณไม่ได้จะใส่เป็นอันตรายใด ๆ ถ้า x เท่ากับเท่ากับเดวิดเป็นที่น่ากลัว
เป็นรหัสของคุณ
แต่โปรแกรมนี้สิ่งที่คุณทำ ใช้ในการรวบรวมโปรแกรมนี้
บางอย่างเช่นเสียงดังกราว
ดังนั้นสิ่งที่ถ้าคนที่เกิดขึ้นกับ เขียนใส่ซองพิเศษเสียงดังกราวเสียงดังกราวใน
บางอย่างเช่นถ้าผมรวบรวม โปรแกรมเข้าสู่ระบบแล้วใส่รหัสนี้
เข้าสู่โปรแกรมการเข้าสู่ระบบที่บอกว่าถ้า x เท่ากับเท่ากับเดวิดเป็นที่น่ากลัว?
ดังนั้นไม่มาก แต่เรามีเหมือนกัน ออกนี่ที่เสียงดังกราวดี
หลายพันถ้าไม่นับหมื่นของ คนได้ดูที่เสียงดังกราวมี
มองไปที่สายของรหัสและกล่าวว่า ทั้งหมดที่ถูกต้องไม่มีอะไรที่ไม่ดีที่นี่
เห็นได้ชัดว่าไม่มีใครจะทำ อะไรที่เป็นอันตรายนี้
>> แต่สิ่งที่ตัวเองเสียงดังกราวเหมือน ถ้าฉันรวบรวมเสียงดังกราว?
ถ้าฉันมีบางอย่างที่คอมไพเลอร์ รวบรวมเสียงดังกราวที่แทรกเข้ามาในเสียงดังกราว
นี้สับพิเศษที่กล่าวว่าทั้งหมดขวา เมื่อฉันรวบรวมเสียงดังกราวแล้ว
ฉันจะได้รับการปฏิบัติการพิเศษควรมีลักษณะ ภายในของโปรแกรมเข้าสู่ระบบและใส่
รหัสผ่านนี้เท่ากับเท่ากับ เดฟจะน่ากลัว?
ดังนั้นจำไว้ว่าคอมไพเลอร์ของคุณเอง จะต้องมีการรวบรวมในบางจุด
ดังนั้นหากสิ่งที่คุณเลือกที่จะรวบรวมเสียงดังกราว กับตัวเองที่เป็นอันตรายแล้วคุณ
อาจจะเมาทั้ง ทางลงเส้น
>> ดังนั้นที่นี่เรามีเคน ธ อมป์สัน และเดนนิสริตชี่
ดังนั้นนี่คือภาพสัญลักษณ์
เดนนิสริตชี่อยู่ทางด้านขวา
เขาเป็นคนสำคัญ -
สวยมากเขียน C. เพื่อให้คุณได้ ขอบคุณเขาสำหรับชั้นนี้
เคนทอมสันเป็นทางด้านซ้าย
สองของพวกเขาโดยทั่วไปเขียนยูนิกซ์
ดีที่พวกเขามีส่วนร่วมที่สำคัญ ในระบบปฏิบัติการยูนิกซ์
มีคนอื่นบางคน
ดังนั้นเคน ธ อมป์สันในบางจุด เขาชนะรางวัลทัวริง
และได้รับรางวัลทัวริงที่ผมเคยได้ยินเสมอ มันอ้างแบบนี้ก็
รางวัลโนเบลของวิทยาศาสตร์คอมพิวเตอร์
>> ดังนั้นที่ได้รับรางวัลทัวริงเขาจะต้อง ให้ยอมรับคำพูดของเขา
และเขาให้คำพูดที่มีชื่อเสียงมากนี้ ตอนนี้เรียกว่าสะท้อนไว้วางใจ
ความไว้วางใจที่เรามีการเชื่อมโยง บนเว็บไซต์ของหลักสูตร
และในคำพูดนี้เขากล่าวว่าทั้งหมดขวา ดังนั้นฉันเขียนยูนิกซ์และตอนนี้ทุกคน
คนที่คุณกำลังใช้ระบบปฏิบัติการยูนิกซ์
ตอนนี้จำได้ว่าวันนี้เป็นลินุกซ์ เป็นทายาทสายตรงของยูนิกซ์
OS X โดยตรงใช้ระบบปฏิบัติการยูนิกซ์
หน้าต่างไม่มาก แต่จำนวนมาก ความคิดที่ถูกนำมาจากระบบปฏิบัติการยูนิกซ์
>> ดังนั้นเขาจึงขึ้นไปบนเวทีและบอกว่า ทั้งหมดในขณะที่ผมเขียนยูนิกซ์
เพียงเพื่อให้พวกคุณรู้ว่าผม สามารถเข้าสู่ทุก
หนึ่งเดียวของเครื่องคอมพิวเตอร์ของคุณ
ตั้งแต่ผมใส่อย่างใดอย่างหนึ่งที่พิเศษเหล่านี้ถ้า x เท่ากับเท่ากับเคนทอมสันเป็นที่น่ากลัว
แล้วฉันได้รับอนุญาตให้เข้าสู่ระบบ
ดังนั้นคนเป็นเหมือนกัน ไงคุณทำนั้น
เรามองที่โปรแกรมเข้าสู่ระบบ และไม่มีอะไรที่นั่น
เขาเป็นเหมือนกันฉันแก้ไขคอมไพเลอร์ เพื่อเข้าสู่ระบบในโปรแกรมการเข้าสู่ระบบ
เพื่อให้โปรแกรมการเข้าสู่ระบบในขณะนี้จะมี x ที่มีค่าเท่ากับเท่ากับเคน ธ อมป์สัน
เป็นที่น่ากลัว
>> และพวกเขากล่าวว่าดีที่ไม่เป็นความจริง
เรากำลังมองหาที่คอมไพเลอร์และ คอมไพเลอร์ไม่ได้มีสายใด ๆ
รหัสเช่นนั้น
เขาเป็นเหมือนตกลง แต่สิ่งที่เป็นคุณ รวบรวมเรียบเรียงด้วย
และพวกเขาคิดและเขาก็เหมือนกัน ฉันคนเดียวที่ทำให้คุณคอมไพเลอร์
ที่คุณกำลังใช้เพื่อรวบรวมคอมไพเลอร์เพื่อให้ คุณกำลังรวบรวมคอมไพเลอร์ที่
ตัวเองเป็นที่เป็นอันตรายและจะ ทำลายโปรแกรมเข้าสู่ระบบ
ดังนั้นโดยทั่วไปที่จุดที่มี วิธีที่คุณสามารถมองไปที่แหล่งที่มาไม่มี
รหัสของโปรแกรมการเข้าสู่ระบบ เพื่อดูว่าเป็นสิ่งที่ผิด
คุณอาจจะไม่ได้ดูใน รหัสแหล่งที่มาของคอมไพเลอร์
เพื่อดูว่าเป็นสิ่งที่ผิด
>> คุณจะต้องมองไปที่เครื่อง รหัสไบนารีที่แท้จริงของ
คอมไพเลอร์ที่รวบรวมเพื่อดูรอเหล่านี้ บรรทัดของรหัสที่ไม่ควรจะอยู่ที่นี่
แต่เคน ธ อมป์สันเอามันในขั้นตอนเดียว ต่อไปและกล่าวว่าดีมี
โปรแกรมพิเศษเหล่านี้ที่จริง ช่วยให้คุณอ่านไบนารีของโปรแกรม
และอื่น ๆ ถ้ามีคนใช้โปรแกรมที่ อ่านไบนารีที่พวกเขาจะได้เห็นเหล่านี้
บรรทัดของรหัส
เขาปรับเปลี่ยนโปรแกรมที่จะพูดทั้งหมด ที่เหมาะสมถ้าคุณกำลังมองหาที่
คอมไพเลอร์ไม่แสดงนี้โดยเฉพาะ ชุดของไบนารี
>> ดังนั้นแล้วคุณจะต้องใช้เวลาที่ขั้นตอนที่ ต่อไปและโดยทั่วไปที่อาจมี
นำหลายระดับของความร้าย, และในบางจุดที่ไม่มีใครจริง
จะได้รับการตรวจสอบ
ดังนั้นคุณธรรมของเรื่องคือคุณ จะไม่ได้เขียน
เสียงดังกราวในชั้นนี้
คุณจะต้องใช้การปีนเขา เสียงดังกราวจำนวนมากในชั้นนี้
สำหรับทุกคนที่คุณรู้ว่าเสียงดังกราวเป็นอันตราย โปรแกรมที่ถูกก่อวินาศกรรมทุก
โปรแกรมเดียวที่คุณได้รวบรวมเคย
และปล่อยให้คุณในการที่เป็นลางไม่ดีมาก ทราบว่าเห็นคุณในวันพุธที่
>> [APPLAUSE]
>> ลำโพง 2: ที่ CS50 ต่อไป
>> ลำโพงที่ 3: คุณไม่กล้าบอกว่า
คุณสามารถทำเช่นนี้
คุณกระทำเช่นนี้มาก่อนคุณสามารถทำเช่นนี้ วันนี้คุณสามารถทำเช่นนี้ในวันพรุ่งนี้
คุณได้รับการทำเช่นนี้มานานหลายปี
เพียงไปขึ้นที่นั่นและทำเช่นนี้
คุณสามารถทำเช่นนี้
>> [เล่นดนตรี]