[? DAN ARMADARAS:?] สวัสดี ฉัน [? แดน Armadaras?]
วันนี้เรากำลังจะไป จะมองที่การแก้จุดบกพร่อง
เราไม่เพียง แต่จะไป พูดคุยเกี่ยวกับเทคนิคบางอย่าง
แต่ยังเรากำลังจะไปดูที่ บางส่วนของคุณสมบัติที่มีอยู่
ภายใน IDE CS50 ที่ช่วยให้ คุณสามารถแก้ปัญหาโปรแกรม
>> เพียงตัวอย่างหนึ่งของ บางสิ่งบางอย่างที่ผิดไป
และมันก็เป็นจริงอย่างที่ ที่เราได้เห็นแล้วก่อน
ในกรณีนี้เป็นโปรแกรม C ที่ยอมรับจำนวนเต็มจากผู้ใช้
หารสองและให้ การส่งออกกลับมาให้กับผู้ใช้
ตอนนี้จากสิ่งที่เราได้เห็น ก่อนหน้านี้ในการบรรยาย
เรารู้ว่านี้จริงจะทำให้เกิด เฉพาะประเภทของปัญหาส่วน
เมื่อเรามีเลขคี่
>> โดยเฉพาะเราก็จะโยนออกไป อะไรหลังจุดทศนิยม
ตอนนี้เรารู้ว่านี้ ที่จะเกิดขึ้นในกรณีที่
และถ้าเราใช้มันเราสามารถยืนยันได้ ข้อสงสัยของเราครั้งแรกโดยการรวบรวม
แล้วโดยการทำงานและ เข้ามาเป็นเลขคี่
>> นี้จะไม่มีอะไรใหม่
แต่นี้เป็นจริง ตัวอย่างของข้อผิดพลาดที่
สามารถอยู่ในโปรแกรมที่มีขนาดใหญ่ ที่จะกลายเป็นเรื่องยากที่จะติดตาม
แม้ว่าเราจะรู้ว่าสิ่งที่ปัญหา คือปมที่แท้จริงของเรื่องนี้
อาจจะมีการพยายามที่จะระบุ โดยเฉพาะข้อผิดพลาดที่เกิดขึ้น
ระบุสิ่งที่เป็นปัญหาที่ เป็นแล้วแก้ไขมัน
ดังนั้นให้นี้เป็นตัวอย่าง ของสิ่งที่อาจจะเป็นสิ่งที่
ที่เรารู้อยู่แล้วว่า แต่สามารถฝัง ภายในองค์ประกอบอื่น ๆ ของรหัส
>> ดังนั้นการเปิดแหล่งอื่น ๆ แฟ้มรหัสเป็นตัวอย่าง
ส่วนปัญหาที่เกิดขึ้นตอนนี้ ส่วนหนึ่งของโครงการขนาดใหญ่
ยังอาจจะมีเล็ก ๆ น้อย ๆ บิต contrived และเรา
อาจจะสามารถได้อย่างง่ายดาย ระบุได้โดยเฉพาะอย่างยิ่ง
เนื่องจากเรากำลังคุยกันเรื่องนี้
แต่เราสามารถคิดออกว่านี้ ปัญหาที่เกิดขึ้นสามารถอยู่ในระดับขนาดใหญ่
>> ถ้าฉันรวบรวมนี้และในขณะนี้ เรียกใช้ใส่เป็นเลขคี่,
เราจะเห็นว่าเราไม่ได้รับได้อย่างแม่นยำ การส่งออกที่เราอาจจะคาดว่า
ในกรณีนี้โดยเฉพาะ เราอาจจะพูดได้ว่าเรา
ต้องการนับทั้งหมดของตัวเลข จากที่หนึ่งไปถึงบางส่วนจำนวนเฉพาะ
และเราจะเห็นว่าเรา มีความหลากหลายของปัญหา
นี่ถ้าเรากำลังแสดงผลเพียง 0 1 และเมื่อเราให้การป้อนข้อมูลของ 5
>> ดังนั้นเรารู้อยู่แล้วว่า มีปัญหาที่นี่
แต่เราไม่อาจรู้ได้อย่างแม่นยำ ซึ่งปัญหานี้มีอยู่จริง
ตอนนี้หนึ่งในวิธีการที่ เราสามารถพยายามที่จะแก้ไขปัญหานี้
เป็นสิ่งที่เราได้ รับการแนะนำแล้ว
เราก็สามารถใช้งานได้ในระดับขนาดใหญ่
>> On line ที่ 14 เรามี ฟังก์ชั่น printf นี้
ซึ่งช่วยให้เราสามารถพิมพ์ออกมารัฐ ของชิ้นส่วนต่างๆของข้อมูล
และนี่คือสิ่งที่คุณ ควรใช้ประโยชน์จากภายในโปรแกรมของคุณ
เพื่อพยายามที่จะคิดออกว่าสิ่งที่ ที่เกิดขึ้นในสายต่างๆของโค้ด
ดังนั้นแม้ว่านี้ไม่ได้เป็น ผลลัพธ์สุดท้ายที่เราจริง
ต้องการที่จะผลิตออกมาจาก โปรแกรมนี้เรายังคง
อาจจะมีการแก้ปัญหาบางอย่าง งบที่เรา
สามารถพยายามที่จะคิดออกสิ่งที่แม่นยำ ที่เกิดขึ้นภายในของรหัสของเรา
>> ดังนั้นในกรณีนี้ผมจะ printf ที่มีแท็กการแก้ปัญหา
ในกรณีนี้เป็น เพียงสตริงการแก้ปัญหา
ว่าฉันขึ้นมาวางเพื่อที่มันจะกลายเป็น ชัดเจนมากในการส่งออกของรหัสของฉัน
อะไรคือสิ่งที่ฉันต้องการแสดง
และการส่งออกที่นี่จำนวน ที่เราได้คำนวณ
>> ในกรณีนี้ฉันอาจ ต้องการที่จะรู้ได้อย่างแม่นยำ
สิ่งที่เกิดขึ้นก่อนและ หลังจากที่มีการคำนวณที่เฉพาะเจาะจง
ดังนั้นผมจึงอาจใช้ printf ก่อน และหลังจากบรรทัดของรหัสที่
ในกรณีนี้ที่ฉันสามารถทำได้แม้กระทั่ง ทำให้มันเป็นที่ชัดเจนนิด ๆ หน่อย ๆ
โดยการแก้ปัญหาก่อนที่จะบอกว่า และการแก้ปัญหาเพื่อให้หลัง
ที่ฉันไม่สร้างความสับสนให้กับตัวเอง หลายสายที่มีลักษณะเหมือนกัน
>> ตอนนี้ถ้าเรา recompile นี้และเรียกใช้ มันใส่หมายเลขเช่นห้าอีกครั้ง
เราจะเห็นว่าเรามี ขณะนี้การส่งออกก่อนและหลัง
และพบว่าเรายังไม่ได้ทำที่ชัดเจน ส่วนที่ชัดเจนหรือมีจำนวน
ที่จริงเราต้องการที่จะทำ
ตอนนี้ในกรณีนี้เป็น ไม่ได้จริงๆการส่งออกที่ชัดเจน
มันไม่จริงผลที่ชัดเจนว่า เราต้องการออกจากโปรแกรมนี้โดยเฉพาะ
>> และนี่คืออีกครั้ง นิด ๆ หน่อย ๆ ที่วางแผนไว้
แต่บางทีอาจจะเป็นหนึ่งในสิ่งที่ เราจะทำอย่างไรถ้าสเปคกล่าวว่า
ว่าเราต้องการที่จะแบ่งนี้โดย 2 และเพิ่ม 1- ดังนั้นในคำอื่น ๆ
เราต้องการที่จะรอบ up-- แล้ว เราอาจจะรู้ว่าเราสามารถทำได้
ทำสิ่งที่โดยเฉพาะอย่างยิ่งในกรณีนี้
ตอนนี้ที่นี่เรารู้ว่าเราจะได้รับ สามารถที่จะเพิ่มจำนวน 1 ถึงครึ่งของเรา
>> ลองคอมไพล์นี้ และยืนยันว่าเรื่องนี้
มีพฤติกรรมทางที่เราต้องการไป
เราจะเห็นว่าในขณะนี้ก่อน มีเรามีจำนวน 5
หลังจากที่มีเรามีจำนวน 3, ซึ่งตามข้อกำหนดของเรา
คือสิ่งที่เราอยากจะทำ
แต่ถ้าเรามองไปที่ การส่งออกที่นี่เราสามารถ
เห็นว่าเราอาจจะมีอีก ข้อผิดพลาดโดยสิ้นเชิงซึ่งเป็น
ที่เราจะเริ่มต้นนับจาก 0
>> ตอนนี้อีกครั้งนี้เป็นสิ่งที่ ที่เราได้เห็นในอดีตที่ผ่านมา
และเราสามารถแก้ไขได้อย่างง่ายดายเลยทีเดียว
แต่ในกรณีนี้เรา ยังมีประโยชน์
ของการใช้คำสั่ง printf โดยตรงภายในของห่วง
ที่จะรู้อย่างแม่นยำที่ ข้อผิดพลาดที่เกิดขึ้น
งบ printf ดังนั้น มีประโยชน์มากในการช่วย
ให้คุณตรวจสอบที่ ได้อย่างแม่นยำในรหัสของคุณ
ข้อผิดพลาดที่เกิดขึ้นโดยเฉพาะ
>> และมันก็ยังเป็นสิ่งสำคัญที่จะตระหนักถึง ว่าในขณะที่เรากำลังเขียนรหัส
เราอาจจะมีการตั้งสมมติฐาน เกี่ยวกับสถานะของโปรแกรม
หรือเราอาจจะมีการตั้งสมมติฐาน เกี่ยวกับสิ่งที่เป็นส่วนหนึ่งของโปรแกรม
เป็นจริงที่ถูกต้องหรือไม่ถูกต้องเมื่อ ต่อมาในขณะที่เราสร้างโปรแกรมที่
และทำให้มันเป็นส่วนหนึ่งของ โปรแกรมที่ซับซ้อนและมีขนาดใหญ่
ที่เรารู้ว่าบางแง่มุม ของที่เป็นจริงรถ
>> ใช้ printf จริงๆสามารถช่วยให้ แคบลงและระบุ
ภูมิภาคของโปรแกรมที่อาจจะไม่ เป็นพฤติกรรมตรงทางที่เรา
คาดหวังตามสมมติฐานของเรา
แต่มีเครื่องมืออื่น ๆ สามารถใช้งานได้เป็นอย่างดี
ที่ช่วยให้เราพยายามที่จะร่าง ออกที่มีการเกิดขึ้นข้อผิดพลาด
และโดยเฉพาะสิ่ง ที่จะเกิดขึ้นภายในของโปรแกรม
>> ดังนั้นการใช้ printf เป็นอย่างมาก ที่มีประโยชน์เมื่อเราต้องการ
เพื่อระบุพื้นที่ที่เฉพาะเจาะจงของ โปรแกรมที่มีข้อผิดพลาดบางอย่าง
แต่มันก็จะกลายเป็น น่าเบื่อหลังจากที่ในขณะ
ในกรณีนี้นี้เป็น โปรแกรมที่ค่อนข้างง่าย
ที่มีเพียงหนึ่งหรือสองตัวแปร
และมันก็กลายเป็นเรื่องง่ายมากที่เราจะ พิมพ์ค่าของตัวแปรเหล่านั้น
ในบริบทของโครงการขนาดใหญ่
>> แต่เราอาจจะมีที่แตกต่างกัน โปรแกรมที่มีหลายตัวแปร
และมันก็ไม่อาจจะค่อนข้าง เพื่อง่ายต่อการใช้ printf
เพื่อพยายามที่จะประเมินสิ่งที่เกิดขึ้น แต่ละคนของตัวแปรเหล่านั้น
เป็นโปรแกรมที่จะรัน
มีโปรแกรมที่มีอยู่เป็น เรียกได้ว่าเป็นโปรแกรมดีบัก
ในกรณีนี้คนที่เราจะ ใช้เป็นดีบัก GNU หรือ GDB,
ที่ช่วยให้เราในการตรวจสอบภายใน การทำงานของโปรแกรมในมากขึ้น
รายละเอียดทาง
>> เราสามารถดำเนินการจริง GDB จากบรรทัดคำสั่ง
ที่นี่โดยเพียงแค่พิมพ์ GDB และ คำสั่งที่เราต้องการที่จะแก้ปัญหา
ในกรณีนี้นับ
ตอนนี้ในกรณีนี้เราจะเห็นว่า นำเราไปพร้อมรับคำว่า GDB
และที่เราสามารถทำได้จริง รันคำสั่งที่จะ GDB
ที่จริงเริ่มต้นการดำเนินการของ โปรแกรมหยุดมันได้ในบางจุด,
ประเมินตัวแปรและ ตรวจสอบตัวแปรที่
อยู่ในสถานะที่โปรแกรม โดยเฉพาะอย่างยิ่งในช่วงเวลานั้น
และอื่น ๆ และอื่น ๆ.
จะให้พลังงานมากถึงเรา
>> แต่มันเกิดขึ้นเพียงเพื่อ ว่า IDE CS50 ยัง
ให้ GUI หรือผู้ใช้ อินเตอร์เฟซสำหรับ GDB ที่
ช่วยให้เราสามารถทำเช่นนี้โดยไม่จำเป็นต้อง อินเตอร์เฟซบรรทัดคำสั่งใด ๆ
หรือที่ทุกคนแม้กระทั่ง
วิธีการที่ฉันสามารถเข้าถึงว่า โดยใช้ปุ่มแก้ปัญหา
ที่ส่วนบนสุดของ CS50 IDE
ตอนนี้ในอดีตที่ผ่านมาสิ่งที่เรามี เห็นคือการที่เราใช้คำสั่ง
สายการรวบรวมและเรียกใช้โปรแกรม
>> ปุ่มแก้ปัญหาไม่ได้ ทั้งสองขั้นตอนเหล่านั้น
แต่มันก็ยังจะนำขึ้น แท็บดีบักบนขวาสุด
ที่ช่วยให้เราในการตรวจสอบความหลากหลาย คุณสมบัติของโปรแกรม
ตามที่มีการดำเนินการ
ถ้าฉันคลิกแก้ปัญหาในเรื่องนี้ กรณีก็จะนำมาขึ้น
แท็บใหม่ในคอนโซล หน้าต่างที่ด้านล่างสุด
>> และคุณจะเห็นว่าแท็บนี้มี ข้อมูลบางอย่างที่ด้านบนสุด
และเราส่วนใหญ่สามารถละเว้นนี้
แต่สิ่งหนึ่งที่ ว่าเราต้องการที่จะแจ้งให้ทราบล่วงหน้า
คือว่ามันจะออกผลลัพธ์ สิ่งเดียวที่เรา
จะได้รับถ้าเราพยายามที่จะทำงานให้ใน โปรแกรม C ในหน้าต่าง terminal
>> ที่นี่เราจะเห็นมันทำงานเสียงดังกราว, และมันมีความหลากหลายของธงที่
และจะมีการรวบรวมไฟล์ count.c ของเรา ซึ่งเป็นแท็บที่เลือกในเวลานั้น
ที่ผมตีแก้ปัญหา
ดังนั้นนี้เป็นประโยชน์อย่างมากเพราะ ตอนนี้ใช้ปุ่มแก้ปัญหานี้
เราพร้อมกันสามารถรวบรวมแล้ว รันโปรแกรมที่เราจริง
ต้องการเรียกใช้
>> หนึ่งในธงที่ สิ่งที่สำคัญในกรณีนี้
เราเคยใช้จริง เวลาที่ยาวที่สุด
แต่ยังก็ไม่ได้มือบาง โบก [ไม่ได้ยิน] ซึ่ง
เป็นหนึ่งที่เหมาะสมที่นี่
ในเสียงดังกราวมันบอกว่า -ggdb3
ในกรณีนี้สิ่งที่เราเป็น บอกเสียงดังกราวคอมไพเลอร์ของเรา
คือการที่เราต้องการที่จะรวบรวมโปรแกรมของเรา
แต่ยังมีสิ่งที่เป็น ข้อมูลที่เรียกว่าสัญลักษณ์
เพื่อให้คอมไพเลอร์จริงที่มีการเข้าถึง จำนวนมากของข้อมูลพื้นฐานที่
ที่มีอยู่ภายในโปรแกรม
>> โดยเฉพาะอย่างยิ่งจำนวน ฟังก์ชั่นที่ฉันมี
ชื่อของฟังก์ชั่นเหล่านั้น ตัวแปรประเภท
ตัวแปรเหล่านี้และความหลากหลาย ของสิ่งอื่น ๆ ที่จะช่วยให้การดีบัก
การดำเนินการของ
ตอนนี้มีอย่างอื่น ที่สำคัญต้องพูดถึง
เมื่อเรากำลังคุยกันเรื่องการทำงาน โปรแกรมในลักษณะนี้
>> ขอให้สังเกตว่ามันมีจริง นำขึ้นแท็บใหม่ในคอนโซลของเรา
ด้านล่าง
เราไม่ได้มีการโต้ตอบ โดยตรงกับหน้าต่าง terminal
แต่แท็บใหม่นี้ จริงหน้าต่าง terminal
มันก็เป็นเฉพาะกับการทำงาน โปรแกรมที่เราได้สร้างขึ้น
>> ขอให้สังเกตว่าที่ด้านล่างใน ร่วมกับการส่งออกบางส่วน
โดยเสียงดังกราวคอมไพเลอร์และ GDB, ส่วนใหญ่ที่เราสามารถละเว้น
มันจริงแสดงให้เห็นว่าการส่งออกของ โปรแกรมของเราที่ด้านล่างสุด
ตอนนี้มันเป็นสิ่งสำคัญที่จะตระหนักถึง ที่หน้าต่างนี้จริง
จะแสดงให้คุณเห็น ผลลัพธ์จากโปรแกรมของคุณ
แต่ยังสามารถรับข้อมูล สำหรับโปรแกรมที่รวมทั้ง
>> ดังนั้นการแจ้งให้ทราบว่า กรุณาใส่ตัวเลข
ซึ่งเป็นเอาท์พุทเดียวกับที่เรามี มีอยู่ในหน้าต่าง terminal ก่อน
แต่มันก็แสดงให้เห็นในขณะนี้ในแท็บใหม่นี้
ฉันสามารถป้อนหมายเลข
และมันจะเป็นจริง ฟังก์ชั่นในขณะที่เราคาดหวัง
แสดงให้เราแก้ปัญหาของเราส่งออก การส่งออกที่อาจจะมีรถ,
ในขณะที่เราเคยเห็นมาก่อน
และที่ด้านล่างสุดมัน จริงมีบางส่วนการส่งออกที่เพิ่มขึ้น
จากจีดีพีแค่บอกว่า โปรแกรมนี้ได้เสร็จสิ้น
>> ตอนนี้เป็นคุณเห็นในเรื่องนี้ โดยเฉพาะอย่างยิ่งวิ่งผ่าน
มันไม่ได้โดยเฉพาะอย่างยิ่ง เพราะแม้มีประโยชน์
แม้ว่าเราจะมีเมนูดีบักมา ขึ้นนี้ก็ยังคงเป็นโปรแกรมที่ทำงาน
เมื่อมาถึงจุดที่ไม่ได้ก็จริง หยุดการดำเนินการสำหรับเรา
เพื่อให้สามารถตรวจสอบทั้งหมดของ ตัวแปรที่มีอยู่ภายใน
มีบางอย่างที่อื่น ที่เราต้องทำในการสั่งซื้อ
ที่จะได้รับ GDB ที่จะรับรู้ว่าเราต้องการ เพื่อหยุดการทำงานของโปรแกรม
และไม่เพียง แต่อนุญาตให้ดำเนินการต่อไป ปกติเราจะเป็นในกรณีอื่น ๆ
>> เพื่อที่จะหยุดการดำเนินการ สายเฉพาะที่บาง
เราต้องสร้างสิ่งที่ เรียกว่าจุดพัก
และจุดพักจะถูกสร้างขึ้นได้อย่างง่ายดายมาก ใน CS50 นี้ IDE โดยการใช้เมาส์ของคุณ
และคลิกตรงไปทางซ้าย บางหมายเลขบรรทัดที่เฉพาะเจาะจง
เมื่อฉันทำอย่างนั้นจุดสีแดง ปรากฏซึ่งบ่งชี้
ว่าสายที่ตอนนี้จุดพัก
>> และในครั้งต่อไปที่ผมทำงาน GDB มัน จะหยุดการดำเนินการที่จุดพักที่
เมื่อมันมาถึงบรรทัดของรหัสที่
ตอนนี้เป็นสิ่งที่สำคัญ สิ่งที่จะต้องตระหนักถึง
ว่ามันไม่จำเป็นต้องเป็น กรณีที่ว่าทุกบรรทัดของรหัส
สามารถเข้าถึงได้จริง
ถ้าฉันจะสร้างฟังก์ชั่น ขึ้นที่นี่สำหรับ example-- โมฆะ f--
และเพียงแค่ทำเส้นพิมพ์ here-- สวัสดี world-- ถ้าฉันไม่เคยเรียกใช้ฟังก์ชันนี้
มันจะเป็นกรณีที่ ถ้าฉันจะตั้งจุดพักที่นี่
ฟังก์ชั่นจะไม่ถูกเรียกว่า
ดังนั้นนี้ จุดพักโดยเฉพาะอย่างยิ่ง
จะไม่เคยหยุด การทำงานของโปรแกรม
>> ดังนั้นขอบอกว่าผมสร้างอย่างถูกต้อง จุดพักอยู่บนเส้นบางส่วนของรหัส
ที่จริงจะต้องถูกประหารชีวิต
ตอนนี้ในที่นี้คือ บรรทัดแรกในฟังก์ชั่นหลัก
ดังนั้นแน่นอนมันจะเป็นกรณี ที่เร็วที่สุดเท่าที่ฉันจะเริ่มต้นการดำเนินการ
บรรทัดแรกจะถึง
GDB จะหยุดการดำเนินการ
แล้วฉันจะสามารถที่จะ โต้ตอบกับดีบัก
>> คุณสามารถตั้งค่าเป็นหลายบรรทัด จุดพักถ้าคุณต้องการ
นอกจากนี้เรายังสามารถสร้างเส้นขึ้น ที่นี่ในส่วนของรหัสนี้
ที่จะไม่มาถึง
และเรายังสามารถตั้งค่าอย่างใดอย่างหนึ่งดังต่อไปนี้
ด้วยเหตุผลที่ว่าเราจะ ต้องการที่จะทำเช่นนี้เราจะ
ไปเป็นนิด ๆ หน่อย ๆ รายละเอียดในการรอสักครู่
ดังนั้นตอนนี้ให้ฉันเพียงแค่ปิดการใช้งาน เหล่านี้จุดพักเพิ่มเติม
เพื่อให้เราสามารถมองไปที่สิ่งที่เกิดขึ้น เมื่อฉันได้พักหนึ่งเดียว
จุดในโปรแกรมของฉัน
ผมได้ทำบางอย่าง การเปลี่ยนแปลงในโปรแกรมนี้
ดังนั้นผมจึงต้องการที่จะบันทึกไว้
ฉันจะคลิกแก้ปัญหาเพื่อที่ฉันสามารถ เริ่มต้นรวบรวมแล้ว
การดำเนินการของการดีบัก
>> เราจะเห็นว่าหลังจากช่วงเวลาที่ สายที่เราเลือกเป็นตัวแบ่ง
จุดเน้นสีเหลือง
นอกจากนี้เรายังสามารถสังเกตเห็นว่าใน ขวาบนแผงในการแก้ปัญหา
ไอคอนหยุดชั่วคราวได้เปิด เป็นไอคอนเล่นเล็ก ๆ น้อย ๆ
ซึ่งหมายความว่าเราต้องหยุดการทำงานชั่วคราว การดำเนินการในกรณีนี้โดยเฉพาะ
และกดปุ่ม Play จะ ช่วยให้เราสามารถกลับมาดำเนินการ
ที่จุดเฉพาะที่
>> ขอให้สังเกตว่ามีคู่ของอื่น ๆ ปุ่มที่มีอยู่ในแผงการแก้ปัญหานี้
ได้เป็นอย่างดี
ขั้นตอนที่มากกว่าซึ่งช่วยให้ผม ดำเนินการที่หนึ่งบรรทัดของโค้ด
และขั้นตอนไปยังสายที่ อย่างใดอย่างหนึ่งต่อไปซึ่งในกรณีนี้
จะหมายถึงว่า printf คำสั่งจะถูกดำเนินการ
และมันก็จะหยุดการทำงานชั่วคราว การดำเนินการในบรรทัดที่ 13 เช่นดังนั้น
>> และนอกจากนี้ยังมีขั้นตอน ในการทำงานที่
จะเป็นประโยชน์ถ้าฉันได้สร้างอื่น ๆ ฟังก์ชั่นอื่น ๆ ในรหัสที่มา
และฉันต้องการที่จะก้าวเข้าสู่ ฟังก์ชั่นเหล่านั้นมากกว่า
ดำเนินการฟังก์ชั่นที่เป็นทั้ง
แต่เราจะดูเพิ่มเติมได้ที่ขั้นตอน ในการทำงานในเวลาเพียงสักครู่
ตอนนี้สังเกตเห็นบางสิ่งอื่น ๆ ที่ จริงมีอยู่ภายในแผงการแก้ปัญหานี้
>> เรามีแผงนี้เรียกว่า เรียกสแต็คซึ่งแสดงให้เราเห็น
ที่ว่าเราอยู่
ในกรณีนี้เราอยู่ใน ฟังก์ชั่นหลัก
สคริปต์ของเราที่เรียกว่า count.c
และเราจะเกิดขึ้นใน สาย 13 คอลัมน์หนึ่งซึ่ง
เป็นสิ่งที่เน้นภูมิภาค ของรหัสที่มาแสดงให้เห็นเป็นอย่างดี
>> ตอนนี้สังเกตเห็นว่าเรื่องนี้ยังแสดงให้เห็น ภายใต้ส่วนตัวแปรท้องถิ่น
ทั้งหมดของตัวแปรที่ มีอยู่ในฟังก์ชั่นนี้
มันเป็นสิ่งสำคัญที่จะต้องทราบ ว่าทั้งหมดของตัวแปร
จะปรากฏในตัวแปรท้องถิ่นนี้ ส่วนภายในฟังก์ชั่น
แม้กระทั่งก่อนที่พวกเขาจะมีการกำหนด
เราจะเห็นได้ว่าที่นี่เรามีตัวแปร เรียกว่า NUM มีค่าเริ่มต้นของ 0,
และมันก็เป็นชนิด int
>> ตอนนี้ก่อนที่เราจะเริ่มต้นจริง ทั้งหมดของตัวแปรเหล่านี้
เราไม่จำเป็นต้อง รับประกันว่าจะเห็นค่าเป็น 0
และขึ้นอยู่กับการประหารชีวิตอื่น ๆ ที่คุณได้ดำเนินการ
และสถานะของหน่วยความจำของคุณเมื่อ คุณจริงเรียกใช้โปรแกรมนี้
คุณอาจพบว่าคุณ ไม่เห็นคุณค่าของ 0
และแทนตัวเลขบางบ้าอื่น ๆ
>> แต่ไม่ต้องกังวลเกี่ยวกับการที่
มันไม่ได้เป็นไปได้ที่เกี่ยวข้องจนกว่า คุณจริงเริ่มต้นค่า
ตอนนี้ในกรณีนี้เราจะเห็นว่า ผมได้ดำเนินการบางอย่างเอาท์พุท
และฉันตอนนี้การดำเนินการหยุดชั่วคราว
แต่ในกรณีนี้สิ่งที่ ผมต้องการที่จะทำ
ตอนนี้คือการก้าวข้ามบรรทัดนี้ รหัสเพื่อที่ฉันสามารถจริง
สอบถามผู้ใช้สำหรับ int ว่า เราต้องการที่จะใช้ในโปรแกรมของเรา
>> ตอนนี้ในกรณีนี้เมื่อ ฉันตีก้าวไปแจ้งให้ทราบล่วงหน้า
ว่าหยุดชั่วคราวหรือค่อนข้างดำเนินการต่อ ปุ่มมีการเปลี่ยนแปลงให้กับปุ่มหยุดชั่วคราวนี้
เพราะรหัสนี้เป็นจริงการดำเนินการ
เกิดอะไรขึ้น ตอนนี้ก็คือว่า
รอให้เราใส่ข้อมูลบางอย่าง ในขณะที่เราสามารถมองเห็นได้ด้วยข้อความส่งออกของเรา
ที่ด้านล่างสุด
>> ดังนั้นตอนนี้นี้เป็น ไม่ได้หยุดชั่วคราวจริง
แม้ว่ามันจะเรียงลำดับของปรากฏ จะเป็นเพราะไม่มีอะไรเกิดขึ้น
แต่มันเกิดขึ้นเพียงเพื่อว่าใน กรณีเฉพาะของฉันในบรรทัดที่ 13
ผมกำลังรอสำหรับการป้อนข้อมูลของผู้ใช้
และเพื่อ GDB จะไม่สามารถที่จะตรวจสอบ เป็นโปรแกรมที่มีการทำงาน
>> ตอนนี้ในครั้งต่อไปที่ผมใส่บาง input-- ดังนั้นฉันจะป้อนหมายเลข 5 ที่
ที่เราได้เห็นใน past-- ตีกลับและเรา
สังเกตเห็นว่าทันทีหยุด GDB และอีกครั้งไฮไลท์บรรทัดถัดไป
แต่สังเกตเห็นว่าตอนนี้เป็น ผลมาจากการป้อนค่าของเรา
เรามีการปรับปรุงค่าที่อยู่ภายใน ของตัวแปรในท้องถิ่นของเราที่
จะเป็นประโยชน์มากที่จะรู้ได้อย่างแม่นยำ สิ่งที่ตัวเลขที่อยู่ในหน่วยความจำ
>> ตอนนี้ฉันสามารถช่วยให้โครงการนี​​้จะดำเนินการต่อ เล่นจนกว่าจะสิ้นสุดของการดำเนินการของ
โดยการกดปุ่ม Resume
เราจะเห็นว่าอย่างรวดเร็ว โปรแกรมจะเสร็จสิ้นการดำเนินการ
กับการส่งออกเหมือนกันว่าเรา ก่อนที่จะมีการดีบักปิด
และตอนนี้โปรแกรมนี้ ได้หยุดอย่างสมบูรณ์
>> ผมแสดงให้เห็นว่าเฉพาะสำหรับ วัตถุประสงค์ของการเห็นสิ่งที่
ที่เกิดขึ้นเมื่อเราจริงตีประวัติผู้สมัครงาน
แต่เราจริงจะไป ต้องการที่จะกลับเข้าสู่โปรแกรมนี้
เพื่อให้เราสามารถพยายามที่จะแก้ปัญหา สิ่งที่เกิดขึ้น
ตอนนี้ที่ฉันใช้ดีบักผมอาจ ไม่จำเป็นต้องใช้งบแก้ปัญหาเหล​​่านี้ printf
>> ดังนั้นฉันจะเอาพวกเขาเท่าที่ฉันจะทำ ขณะนี้เป็นเพียงที่จะกลับไปง่ายรหัสของเรา
ที่เรามีช่วงเวลาที่ผ่านมา
ตอนนี้เมื่อฉันบันทึก โปรแกรมและดำเนินการนั้น
มันจะอีกครั้งไปเริ่มต้นที่ ทำลายจุดที่ฉันมีอยู่บนเส้น 11
และผมก็จะสามารถที่จะตรวจสอบ ตัวแปรของฉันเป็นฉันต้องการจะทำ
>> มันเกิดขึ้นเพียงเพื่อที่ว่านี้ ส่วนที่ไม่ได้เป็นที่น่าสนใจมาก
และฉันรู้ว่าฉันจะ ที่จะพิมพ์ออกคำสั่งนี้
กรุณากรอกตัวเลข
แล้วฉันรู้ว่าฉันจะ ที่จะขอให้ผู้ใช้สำหรับจำนวนเต็มที่
ดังนั้นบางทีที่จริงผมต้องการที่จะย้ายของฉัน ทำลายจุดนิด ๆ หน่อย ๆ ต่อไปลง
>> คุณสามารถลบจุดพัก โดยการคลิกอีกครั้งโดยตรง
ด้านซ้ายของหมายเลขบรรทัดว่า
ที่จุดสีแดงจะหายไปแสดงให้เห็น ที่จุดพักที่ไปตอนนี้
ตอนนี้ในกรณีนี้ การดำเนินการถูกหยุดชั่วคราว
และดังนั้นจึงไม่จริงไป กลับมาโดยเฉพาะอย่างยิ่งในกรณีที่
แต่ผมก็สามารถตั้งค่าการหยุดพัก ชี้ให้นิด ๆ หน่อย ๆ ในภายหลัง
>> และเมื่อตอนนี้ผมกลับมาของฉัน รหัสก็จะกลับมาและบอก
จุดจุดพักที่
อีกครั้งผมตีประวัติผู้สมัครงาน
ดูเหมือนจะไม่เหมือนกับสิ่งที่เกิดขึ้น
แต่นั่นเป็นเพราะฉัน รหัสคือการรอคอยสำหรับการป้อนข้อมูล
ผมจะใส่หมายเลข 5, กด Enter และ ตอนนี้จุดพักต่อไปจะได้รับผลกระทบ
>> ตอนนี้ในที่นี้ เป็นสายของรหัส
ว่าก่อนที่เรารู้ว่า เกิดขึ้นจะเป็นรถ
ดังนั้นขอประเมินสิ่งที่เกิดขึ้น ที่จุดโดยเฉพาะอย่างยิ่งในเวลานี้
เมื่อมีการเน้นเส้นนี้ สายยังไม่ได้รับการดำเนินการ
ดังนั้นในกรณีนี้เราสามารถมองเห็น ที่ฉันมีจำนวนที่
ฉันมีจำนวนเต็มเรียกว่า NUM ที่มีค่า 5
และฉันจะได้รับการปฏิบัติ คณิตศาสตร์บางอย่างเกี่ยวกับตัวเลขที่
>> ถ้าผมก้าวข้ามที่เราสามารถ สังเกตเห็นว่าค่าสำหรับค่า num
มีการเปลี่ยนแปลงให้สอดคล้องกับ คณิตศาสตร์ที่เราได้ทำจริง
และตอนนี้ที่เราอยู่ ด้านในของวงนี้
หรือตอนนี้ที่ห่วง ตัวเองเป็นไฮไลต์
เราจะเห็นว่าเรามีใหม่ ตัวแปรเรียกฉันว่า
เป็นไปได้ในการที่ใช้สำหรับวง
>> ตอนนี้ก่อนที่ผมจะจำได้ว่า กล่าวถึงว่าบางครั้งคุณ
จะไปดูชนิดของบางบ้า ตัวเลขที่เป็นค่าเริ่มต้นก่อนที่ตัวเลขที่
หรือตัวแปรที่เป็น เริ่มต้นได้จริง
เราจะเห็นว่าอย่างแม่นยำ ที่นี่ในตัวแปรนี้
เรียกว่าผมซึ่งไม่ได้ ได้รับการเริ่มต้น
ในช่วงเวลาของการเน้น
แต่เราจะเห็นว่ามันมีบางจำนวน ว่าเราจะไม่คาดหวังจริง
>> มันโอเค.
ไม่ต้องเป็นห่วงนะ เพราะเรามีไม่จริง
เริ่มต้นได้ตัวเลขที่จนกว่าฉัน ก้าวข้ามเส้นและความคุ้มค่า
ฉันได้รับการเริ่มต้นได้ที่ค่า 1
ดังนั้นจะเห็นว่าที่จริง กรณีที่ขอให้ก้าวข้าม
ตอนนี้เราจะเห็นว่าที่ สายที่ได้รับการดำเนินการ
และตอนนี้เรากำลังไฮไลท์ สาย printf นี้
>> และตอนนี้เราจะเห็นได้ว่าค่านิยมของเรา ของฉันและ 3 ที่มีการเปลี่ยนแปลงอยู่ตลอดเวลา
นี้จะเป็นประโยชน์มากที่จะทำในความเป็นจริง คือการก้าวข้ามเส้นที่ซ้ำแล้วซ้ำอีก
และคุณสามารถค้นหาสิ่งที่จริง ที่เกิดขึ้นภายในของสำหรับวงของคุณ
และสิ่งที่เกิดขึ้นกับ ตัวแปรภายในที่สำหรับวง
ขณะที่การทำงานของโปรแกรมที่ ขั้นตอนที่เกิดขึ้นในช่วงเวลาหนึ่ง
>> ตอนนี้ที่จุดนี้ผม ก้าวเหนือพอเพียง
ที่ตอนนี้ผมรู้สึกในตอนท้ายของโปรแกรมของฉัน
ถ้าผมก้าวข้ามว่ามันจะ ยุติการดำเนินการจริง
ในขณะที่เราได้เห็นในอดีตที่ผ่านมา
ผมขอเริ่มต้นใหม่นี้อีกครั้งเพื่อ ที่ฉันสามารถชี้อย่างอื่นออก
ได้เป็นอย่างดี
>> ในกรณีนี้ก็คือ ตอนนี้ขอให้ฉันอีกครั้ง
สำหรับหมายเลขที่ ผมจะอีกครั้งใส่
แต่ครั้งนี้ผมจะใส่ใน เป็นจำนวนมากเพื่อให้ห่วง
จะย้ำอีกครั้ง
ในกรณีนี้ผมจะ ป้อนค่าของ 11
>> ตอนนี้อีกครั้งเพราะฉันตั้ง จุดพักที่บรรทัดที่ 15
มันจะเน้นที่สาย
เราจะเห็นว่าของเรา หมายเลข 11 อย่างถูกต้อง
ตัวแทนในตัวแปรท้องถิ่นของเรา
ก้าวเหนือว่าตอนนี้เราสามารถ ดูสิ่งที่เกิดขึ้นกับค่าของฉัน
ในขณะที่เราดำเนินการภายในของวงนี้
จะได้รับเพิ่มขึ้นทุกครั้งที่เรา ถึงด้านบนของที่ห่วง
>> ตอนนี้หนึ่งในสิ่งที่อาจจะ เป็นประโยชน์ที่จะทำในระหว่างการดำเนิน
ของโปรแกรมนี้คือสำหรับผมที่จะเป็นจริง เปลี่ยนตัวแปรกลางแม่น้ำที่จะเห็น
เกิดอะไรขึ้นกับโปรแกรมของฉัน
ในกรณีนี้ที่จริงผมสามารถ ดับเบิลคลิกค่า
ขอให้สังเกตว่ามันจะกลายเป็นช่องข้อความ
>> ตอนนี้ฉันสามารถใส่ที่แตกต่างกัน ค่าโดยสิ้นเชิง
เพื่อดูว่าโปรแกรมของฉันทำงาน เมื่อฉันได้เปลี่ยนตัวแปรที่
ตอนนี้ในกรณีนี้ตัวแปร ตอนนี้ผมมีค่า 10
แต่โปรแกรมยังคง หยุดชั่วคราวในการดำเนินการ
เมื่อผมก้าวข้ามผมเห็นว่า ฉันค่าที่ฉันป้อนเป็น 10
ไม่เกินมูลค่าของ NUM ที่ ซึ่งทันทีทำให้ห่วง
ที่จะหยุดการดำเนินการ
>> ตอนนี้ที่ไม่ได้เป็นเพียง เหตุผลที่คุณจะ
ต้องการปรับเปลี่ยนตัวแปรในสถานที่
จริงๆคุณอาจต้องการ เพื่อพยายามที่จะปรับเปลี่ยนเพื่อให้
ที่คุณสามารถดำเนินการต่อไป การดำเนินการของวง
หรือเพื่อให้คุณสามารถปรับเปลี่ยน ค่าก่อนที่มันบาง
ถึงบางชุดเฉพาะของคณิตศาสตร์ ที่คุณจะเกี่ยวกับการที่จะดำเนินการ
>> ดังนั้นขณะนี้ที่เราจะเปลี่ยน ค่าของฉันเป็นโปรแกรมที่ได้รับการดำเนินการ,
มันจะทำให้เกิดการห่วงที่จะเลิก ก่อนเวลาอันควรเพราะทั้งหมดในทันทีที่ฉัน
จะเกิดขึ้นมากกว่าค่า ของ NUM หมายความว่าที่สำหรับวง
ไม่มีความจำเป็นที่จะดำเนินการ
ต่อไปจะเกิดขึ้นจะเป็น กรณีที่เราเปลี่ยนค่าของฉัน
เมื่อสาย 17 เป็นไฮไลต์, ซึ่งเป็นจุดในเวลา
ว่าสำหรับการดำเนินการห่วง เป็นจริงถูกประเมิน
>> ถ้าผมมีการเปลี่ยนแปลงค่าของ ฉันอยู่บนเส้นที่แตกต่างกันกล่าวว่า 19
เราจะได้เห็นที่แตกต่างกัน เพราะพฤติกรรมของ 19 สายจะ
ได้ดำเนินการก่อนที่จะห่วง สภาพได้รับการทบทวน
ตอนนี้มาถึงจุดนี้ผมอีกครั้ง ในตอนท้ายของโปรแกรมนี้
และผมสามารถอนุญาตนี้เพื่อดำเนินการต่อไป อนุญาตให้โปรแกรมของฉันที่จะลาออกตามธรรมชาติ
แต่มีสองสิ่งที่ ที่มีความสำคัญที่จะไป
จากการสนทนานี้โดยเฉพาะ
คุณจะต้องประเมิน สมมติฐานของคุณเอง
เกี่ยวกับวิธีการรหัสควรเป็นพฤติกรรม
เมื่อใดก็ตามที่คุณคิดว่าชิ้นส่วนบางส่วน รหัสที่คุณรู้ว่าจะเกิดขึ้นในการทำงาน
ที่อาจจะมีธงสีแดงที่จะไป กลับมาและประเมินผลและให้แน่ใจว่า
ว่าสมมติฐานของคุณ วิธีโค้ดที่มีการดำเนินงาน
เป็นจริงจริงจะว่ามันเป็นอย่างไร แสดงในรหัสต้นฉบับของคุณ
>> แต่มากยิ่งขึ้นไปยังจุดที่เป็น เมื่อเรากำลังใช้ดีบัก
คุณสามารถใส่จุดพักที่ เส้นที่แตกต่างกันของรหัส
ซึ่งจะทำให้การดีบักไป หยุดการดำเนินการในแต่ละเส้นที่
เพื่อให้คุณสามารถประเมิน หน่วยความจำหรือแม้กระทั่งการเปลี่ยนในสถานที่
และอีกครั้งจำไว้ว่าคุณสามารถ สร้างจุดพักหลายเพื่อให้คุณ
นอกจากนี้ยังสามารถกลับมาดำเนินการข้าม มากกว่าส่วนใหญ่ของรหัส
โดยอัตโนมัติและจะหยุดการทำงานชั่วคราว ที่จุดพักต่อไป
>> มีจริงที่สูงขึ้น คุณสมบัติของการดีบักเช่นเดียว
แต่เราจะต้องดูคุณ บางส่วนวิดีโอที่ตามมา
เพื่อที่จะออกจากกันจริงๆหยอกล้อว่า ที่จะใช้ฟังก์ชั่นโดยเฉพาะอย่างยิ่ง
สำหรับตอนนี้ขอขอบคุณ อย่างมากสำหรับการดู
และการแก้จุดบกพร่องโชคดี