This lecture provides an introducti

This lecture provides an introduction to debugging, a crucial activity in every developer's life. After an elementary discussion of some useful debugging concepts, the lecture goes on with a detailed review of general debugging techniques, independent of any specific software. The final part of the lecture is dedicated to analysing problems related to the use of C++ , the main programming language commonly employed in particle physics nowadays.

1. General concepts
about debugging. After many days of brainstorming, designing and coding, the programmer finally have a wonderful piece of code. He compiles it and runs it. Everything seems pretty straightforward but unfortunately it doesn't work! And now? Now the great fun starts! Time to dig into the wonderful world of debugging. Despite being the realm of ingenuity and uncertainty, a debugging process can be divided into four main steps:
1. localising a bug,
2. classifying a bug,
3. understanding a bug,
4. repairing a bug.

1.1 Localizing a bug
A typical attitude of inexperienced programmers towards bugs is to consider their localization an easy task: they notice their code does not do what they expected, and they are led astray by their confidence in knowing what their code should do. This confidence is completely deceptive because spotting a bug can be very difficult. As it was explained in the introduction, all bugs stem from the premise that something thought to be right, was in fact wrong.

Noticing a bug implies testing. Testing should be performed with discipline and, when possible, automatically, for example after each build of the code. In case of a test failure, the programmer must be able to see what went wrong easily, so tests must be prepared carefully. This lecture will not cover the basic of testing.

1.2 Classifying a bug
Despite the appearance, bugs have often a common background. This allows to attempt a quite coarse, but sometimes useful, classification. The list is arranged in order of increasing difficulty (which fortunately means in order of decreasing frequency).
Syntactical Errors should be easily caught by your compiler. I say "should" because compilers, beside being very complicated, can be buggy themselves. In any case, it is vital to remember that quite often the problem might not be at the exact position indicated by the compiler error message.

Build Errors derive from linking object files which were not rebuilt after a change in some source files. These problems can easily be avoided by using tools to drive software building.

Basic Semantic Errors comprise using un initialized variables, dead code (code that will never be executed) and problems with variable types. A compiler can highlight them to your attention, although it usually has to be explicitly asked through flags (cp. 2.1).

Semantic Errors include using wrong variables or operators (e.g., & instead of && in C++). No tool can catch these problems, because they are syntactically correct statements, although logically wrong. A test case or a debugger is necessary to spot them.
A funny physical classification distinguishes between Bohrbugs and Heisenbugs. Bohrbugs are deterministic: a particular input will always manifest them with the same result. Heisenbugs are random : difficult to reproduce reliably, since they seem to depend on environmental factors (e.g. a particular memory allocation, the way the operating system schedules processes, the phase of the moon and so on). In C++ a Heisenbug is very often the result of an error with pointers.

1.3 Understanding a bug
A bug should be fully understood before attempting to fix it. Trying to fix a bug before understanding it completely could end in provoking even more damage to the code, since the problem could change form and manifest itself somewhere else, maybe randomly. Again, a typical example is memory corruption: if there is any suspect memory was corrupted during the execution of some algorithm, all the data involved in the algorithm must be checked before trying to change them.

The following check-list is useful to assure a correct approach to the investigation:
- do not confuse observing symptoms with finding the real source of the problem;
- check if similar mistakes (especially wrong assumptions) were made elsewhere in the code;
- verify that just a programming error, and not a more fundamental problem (e.g. an incorrect algorithm), was found.

1.4 Repairing a bug
The final step in the debugging process is bug fixing. Repairing a bug is more than modifying code. Any fixes must be documented in the code and tested properly. More important, learning from mistakes is an effective attitude: it is good practice filling a small file with detailed explanations about the way the bug was discovered and corrected. A check-list can be a useful aid.
Several points are worth recording:
- How the bug was noticed, to help in writing a test case;
- How it was tracked down, to give you a better insight on the approach to choose in similar circumstances;
- What type of bug was encountered?
- If this bug was encountered often, in order to set up a strategy to prevent it from recurring;
- If the initial assumptions were unjustified; this is often the main reason why tracking a bug is so time consuming.

2 General debugging techniques
As said before, debugging is often the realm of ingenuity and uncertainty. Yet a number of tricks can be adopted in the daily programming activity to ease the hunt for problems.

2.1 Exploiting compiler features
A good compiler can do some static analysis on the code. Static code analysis is the analysis of software that is performed without actually executing programs built from that software. Static analysis can help in detecting a number of basic semantic problems, e.g. type mismatch or dead code.
Having a look at the user manual of the compiler employed, where all the features should be documented, is highly recommended. For gcc, the standard compiler on GNU/Linux systems, there are a number of options that affect what static analysis can be performed. They are usually divided into two classes: warning options and optimization flags.

2.2 Reading the right documentation
This seems quite an obvious tip, but too often inexperienced programmers read the wrong papers looking for hints about the task they have to accomplish. The relevant documentation for the task, the tools, the libraries and the algorithms employed must be at fingertips to find the relevant information easily.
As far as documentation is concerned, the most important distinction is between tutorials and references. A tutorial is a pedagogical paper, usually with plenty of examples. It doesn't assume any previous knowledge of the topic and its first aim is to convey ideas about the subject. Reference manuals, on the contrary, are comprehensive and exhaustive descriptions, which allow finding the answers to questions through indexes and cross-references.
In the world of programming, all these types of documents are usually in electronic format. The reference documentation must be up to date, accurate and corresponding to the problems and tools used: looking up in a wrong reference manual could end up in trying to use a feature that is not supported by the current version of the tool, for example.

2.3 The abused cout debugging technique
The cout technique takes its names from the C++ statement for printing on the standard output stream (usually the terminal screen). It consists of adding print statements in the code to track the control flow and data values during code execution. Although it is the favourite technique of all the novices, it is unbelievable how many experienced programmers still refuse to evolve and abandon this absolutely time-wasting and very ad-hoc method.
Despite its popularity, this technique has strong disadvantages. First of all, it is very ad-hoc, because code insertion is temporary, to be removed as soon as the bug is fixed. A new bug means a new insertion, making it a waste of time. In debugging as well as in coding, the professional should aim to find reusable solutions whenever possible. Printing statements are not reusable, and so are deprecated. As we will see shortly, there are more effective ways to track the control flow through messages. In addition, printing statements clobber the normal output of the program, making it extremely confused. They also slow the program down considerably: accessing to the outputting peripherals becomes a bottleneck. Finally, often they do not help at all, because for performance reasons, output is usually buffered and, in case of crash, the buffer is destroyed and the important information is lost, possibly resulting in starting the debugging process in the wrong place.
In some (very few) circumstances cout debugging can be appropriate, although it can always be replaced by other techniques. For these cases, here are some tips. To begin with, output must be produced on the standard error, because this channel is unbuffered and it is less likely to miss the last information before a crash. Then, printing statements should not be used directly: a macro should be defined around them (as illustrated in listing 2) so to switch debugging code on and off easily. Finally, debugging levels should be used to manage the amount of debugging information.

Listing 2: An example of cout technique - Declaration
#ifndef DEBUG_H
#define DEBUG_H
#inc lude < stdarg.h>
#if defined (NDEBUG) && defined (__GNUC__)
/* gcc's cpp has extensions; it allows for macros with a variable number of arguments. We use this extension here to preprocess pmesg away. */
#define pmesg ( level, forma t, args. . . )(( void ) 0 )
#else
void pmesg ( int level , char * forma t , . . . ) ;
/ * print a message , if it is con sidered significant enough */
#endif
#endif /* DEBUG_H */


Listing3:An example of cout technique-Implementation
#include "debug.h"
#include
extern int msglevel; /* the higher,t

ผลลัพธ์ (ไทย) 1:

บรรยายนี้แนะนำการตรวจแก้จุดบกพร่อง กิจกรรมที่สำคัญในชีวิตของนักพัฒนาทุกทาง หลังจากการสนทนาระดับประถมของ ประโยชน์แนวคิด การดีบักการบรรยายไป ด้วยการทบทวนรายละเอียดทั่วไปตรวจแก้จุดบกพร่องเทคนิค ขึ้นอยู่กับซอฟต์แวร์เฉพาะ ส่วนสุดท้ายของการบรรยายจะทุ่มเทเพื่อวิเคราะห์ปัญหาเกี่ยวกับการใช้ c ++, ภาษาการเขียนโปรแกรมหลักโดยทั่วไปพนักงานในฟิสิกส์อนุภาคในปัจจุบัน1. แนวคิดทั่วไป เกี่ยวกับดีบัก หลังจากจำนวนวันของการระดมความคิด การออกแบบ และเขียนโค้ด โปรแกรมเมอร์ที่มีชิ้นยอดเยี่ยมของรหัสในที่สุด เขาคอมไพล์มัน และทำมัน ตกแต่งสวยตรงไปตรงมา แต่น่าเสียดายที่มันไม่ทำงาน และตอนนี้ ตอนนี้เริ่มสนุกดี เวลาขุดเข้าไปในโลกมหัศจรรย์ของดีบัก แม้จะเป็นขอบเขตของการประดิษฐ์คิดค้นและความไม่แน่นอน กระบวนการตรวจแก้จุดบกพร่องสามารถแบ่งออกเป็นสี่ขั้นตอนหลัก:1. บกพร่อง localising2. ประเภทบกพร่อง3. บกพร่อง ความเข้าใจ4. ซ่อมบกพร่อง1.1 ทั้งบกพร่องทัศนคติทั่วไปของโปรแกรมเมอร์มือใหม่ไปทางโรคจิตจะพิจารณาแปลความอย่างละเอียด: แจ้งรหัสของพวกเขาทำสิ่งที่พวกเขาคาดว่าไม่ และพวกเขาจะนำผู้เสียคน โดยความความเชื่อมั่นในการรู้รหัสของพวกเขาควรทำอะไร ความเชื่อมั่นนี้จะหลอกลวงทั้งหมดเนื่องจากจำบกพร่องอาจเป็นเรื่องยากมาก ตามที่มันถูกอธิบายไว้ในการแนะนำ ข้อบกพร่องทั้งหมดเกิดจากหลักฐานที่ว่า สิ่งที่คิดว่า ถูก ผิดในความเป็นจริง สังเกตเห็นบกพร่องหมายถึงการทดสอบ ทดสอบควรดำเนินการวินัย และ เมื่อเป็นไป ได้ โดยอัตโนมัติ ตัวอย่างหลังจากที่สร้างแต่ละรหัส ในกรณีของความล้มเหลวในการทดสอบ ผู้เขียนโปรแกรมต้องสามารถเห็นสิ่งที่ผิดได้ง่าย จึงต้องจัดเตรียมการทดสอบอย่างระมัดระวัง บรรยายนี้จะครอบคลุมพื้นฐานของการทดสอบ 1.2 ประเภทบกพร่องแม้ มีลักษณะที่ปรากฏ ข้อบกพร่องได้มักพื้นทั่วไป นี้ได้พยายามจัดประเภทค่อนข้างหยาบ แต่บางครั้งมี ประโยชน์ รายการถูกจัดอยู่ในลำดับของการเพิ่มความยากลำบาก (ซึ่งโชคดีหมายถึงลำดับของการลดความถี่) ข้อผิดพลาด syntactical ควรถูกจับ โดยคอมไพเลอร์ของคุณได้อย่างง่ายดาย ผมบอกว่า "ควร" เนื่องจากคอมไพเลอร์ ข้างมีความซับซ้อนมาก ได้รถตัวเอง มันมีความสำคัญที่ต้องจำไว้ว่า ค่อนข้างบ่อยปัญหาอาจไม่อยู่ในตำแหน่งแน่นอนที่ระบุ ด้วยข้อความข้อผิดพลาดของคอมไพเลอร์สร้างข้อผิดพลาดที่ได้รับจากการเชื่อมโยงแฟ้มวัตถุที่ถูกสร้างใหม่หลังจากการเปลี่ยนแปลงในแฟ้มต้นฉบับบางส่วนไม่ ปัญหาเหล่านี้สามารถสามารถหลีก โดยใช้เครื่องมือในการสร้างซอฟแวร์ไดรฟ์ข้อผิดพลาดทางตรรกพื้นฐานประกอบด้วยสหประชาชาติในการเตรียมใช้งานตัวแปร ตายรหัส (รหัสที่จะไม่ดำเนินการ) และปัญหาชนิดตัวแปร คอมไพเลอร์ที่สามารถเน้นให้ความสนใจของคุณ แม้ว่าจะมีการถามได้อย่างชัดเจนผ่านค่าสถานะ (cp. 2.1) การมีข้อผิดพลาดทางตรรกโดยใช้ตัวแปรไม่ถูกต้องหรือตัวดำเนินการ (เช่น และแทนและและ ใน c ++) เครื่องมือไม่สามารถจับปัญหาเหล่านี้ เพราะเป็นงบที่ถูกต้องทางไวยากรณ์ แม้ว่าตรรกะไม่ถูกต้อง กรณีทดสอบหรือดีบักเกอร์จำเป็นต้องให้ประเภทตลกทางกายภาพที่แตกต่างระหว่าง Bohrbugs และ Heisenbugs Bohrbugs เป็น deterministic: ป้อนข้อมูลใดจะเสมอรายการนั้น มีผลลัพธ์เดียวกัน Heisenbugs เป็นแบบสุ่ม: ยากที่จะทำได้ เนื่องจากพวกเขาดูเหมือนจะขึ้นอยู่กับปัจจัยสิ่งแวดล้อม (เช่นการเฉพาะหน่วยความจำปันส่วน วิธีระบบปฏิบัติการจัดกำหนดการกระบวนการ ระยะของดวงจันทร์และ) ใน c ++ Heisenbug มีผลลัพธ์ของข้อผิดพลาดตัวชี้1.3 ทำความเข้าใจเกี่ยวกับปัญหาการบกพร่องควรจะเข้าใจก่อนที่จะพยายามแก้ไขอย่างเต็ม พยายามแก้ไขบกพร่องก่อนที่จะทำความเข้าใจอย่างสมบูรณ์สามารถสิ้นสุดใน provoking รหัส ความเสียหายมากขึ้นเนื่องจากปัญหาสามารถเปลี่ยนฟอร์ม และรายการอื่น ตัวเองอาจโดยการสุ่ม อีกครั้ง เป็นตัวอย่างโดยทั่วไปเป็นความเสียหายของหน่วยความจำ: ถ้าไม่เกิดความเสียหายใด ๆ จำสงสัยในระหว่างการดำเนินการบางอัลกอริทึม ข้อมูลทั้งหมดเกี่ยวข้องกับอัลกอริทึมต้องตรวจสอบก่อนที่จะพยายามเปลี่ยนแปลงรายการตรวจสอบที่ต่อไปนี้จะเป็นประโยชน์เพื่อให้มั่นใจว่าวิธีที่ถูกต้องเพื่อการตรวจสอบ:-สับสนอาการสังเกตกับการหาสาเหตุแท้ของปัญหา-ตรวจสอบว่าข้อผิดพลาดที่คล้ายกัน (สมมติฐานที่ผิดโดยเฉพาะ) ที่เกิดขึ้นอื่น ๆ ในรหัส-ตรวจสอบว่า เพียงความผิดพลาดของโปรแกรม และไม่มีพื้นฐานปัญหา (เช่นการถูกอัลกอริทึม), พบ1.4 ซ่อมแซมข้อผิดพลาดขั้นตอนสุดท้ายในกระบวนการตรวจแก้จุดบกพร่องข้อผิดพลาดที่แก้ไขได้ ซ่อมแซมข้อผิดพลาดเป็นมากกว่าการปรับเปลี่ยนรหัส การแก้ไขต้องจัดในรหัส และทดสอบได้อย่างถูกต้อง สำคัญ เรียนรู้จากความผิดพลาดเป็นทัศนคติมีผลบังคับใช้: ก็ดีที่บรรจุแฟ้มขนาดเล็กพร้อมคำอธิบายโดยละเอียดเกี่ยวกับวิธีการค้นพบ และแก้ไขจุดบกพร่อง รายการตรวจสอบสามารถช่วยเป็นประโยชน์หลายจุดจะบันทึก:-มีพบบั๊ก เพื่อช่วยในการเขียนกรณีทดสอบ-มันถูกติดตามลง เพื่อให้คุณเข้าใจดีกว่าวิธีการเลือกในสถานการณ์ที่คล้ายกัน-ชนิดของข้อผิดพลาดเกิดขึ้นหรือไม่-ถ้าปัญหานี้พบบ่อย การตั้งค่ากลยุทธ์เพื่อป้องกันไม่ให้เกิดซ้ำ-ถ้าสมมติฐานเบื้องต้นที่ unjustified นี้มักจะเป็นเหตุผลหลักที่ทำไมการติดตามข้อผิดพลาดเป็นดังนั้นใช้เวลานานเทคนิคการตรวจแก้จุดบกพร่องทั่วไป 2ที่กล่าวก่อน ดีบักเป็นขอบเขตของการประดิษฐ์คิดค้นและความไม่แน่นอน ยัง สามารถนำตัวเลขของเทคนิคในกิจกรรมเขียนโปรแกรมทุกวันเพื่อความสะดวกการล่าสัตว์สำหรับปัญหา2.1 ลักษณะการทำงานของคอมไพเลอร์ exploitingคอมไพเลอร์ที่ดีสามารถทำการวิเคราะห์รหัสบางคง รหัสคงวิเคราะห์เป็นการวิเคราะห์ของซอฟต์แวร์ที่ดำเนินการ โดยไม่มีการดำเนินการโปรแกรมที่สร้างจากซอฟต์แวร์ที่จริง วิเคราะห์คงสามารถช่วยในการตรวจสอบพื้นฐานปัญหาทางตรรก เช่นชนิดไม่ตรงกันหรือรหัสตายขอแนะนำมีดูที่คู่มือผู้ใช้ของคอมไพเลอร์จ้าง ซึ่งคุณลักษณะทั้งหมดควรจะจัดทำเอกสาร ใน gcc คอมไพเลอร์มาตรฐานในระบบ GNU/Linux มีจำนวนตัวเลือกที่มีผลต่อการวิเคราะห์ว่าคงสามารถดำเนินการได้ พวกเขามักจะแบ่งออกเป็น 2 ประเภท: ตัวเลือกการแจ้งเตือนและสถานะประสิทธิภาพสูงสุด2.2 อ่านเอกสารที่เหมาะสม นี้ดูเหมือนว่าเป็นคำแนะนำชัดเจน แต่โปรแกรมเมอร์มือใหม่มักจะไปอ่านหาคำแนะนำเกี่ยวกับงานพวกเขาต้องทำเอกสารไม่ถูกต้อง เอกสารที่เกี่ยวข้องสำหรับงาน เครื่องมือ รี และอัลกอริทึมที่ทำงานต้องเป็นที่ปลายนิ้วในการค้นหาข้อมูลที่เกี่ยวข้องได้อย่างง่ายดาย เป็นที่เกี่ยวข้องเอกสาร ความแตกต่างที่สำคัญที่สุดคือระหว่างสอนและอ้างอิง กวดวิชาเป็นกระดาษสอน มักจะ มีตัวอย่างมากมาย มันไม่คิดว่าความรู้ใด ๆ ก่อนหน้าของหัวข้อ และเป้าหมายแรกคือการ ถ่ายทอดความคิดเกี่ยวกับเรื่อง อ้างอิงคู่มือ การ์ตูน ครอบคลุม และครบถ้วนสมบูรณ์คำอธิบาย ซึ่งช่วยให้การค้นหาคำตอบของคำถามผ่านดัชนีและการอ้างอิงโยงในโลกของการเขียนโปรแกรม ชนิดเหล่านี้ของเอกสารมักในรูปแบบอิเล็กทรอนิกส์ เอกสารอ้างอิงต้องทันสมัย แม่นยำ และสอดคล้องกับปัญหาและเครื่องมือที่ใช้: หาในคู่มืออ้างอิงที่ไม่ถูกต้องอาจจบลงในการพยายามที่จะใช้คุณลักษณะที่ไม่สนับสนุนเวอร์ชันปัจจุบันของเครื่องมือ ตัวอย่าง2.3 การ cout พิงเทคนิคการดีบัก เทคนิค cout จะเป็นชื่อจากคำสั่ง c ++สำหรับกระแสข้อมูลขาออกมาตรฐาน (ปกติจอเทอร์มินัล) มันประกอบด้วยการเพิ่มยอดพิมพ์ในรหัสการติดตามควบคุมกระแสและข้อมูลค่าในระหว่างการเรียกใช้โค้ด แม้ว่าจะเป็นเทคนิคชื่นชอบของสามเณรทั้งหมด มันเป็นโปรแกรมเมอร์มีประสบการณ์มากไม่น่าเชื่อยังไม่พัฒนา และละทิ้งวิธีนี้จริง ๆ เสียเวลา และการกิจ แม้จะนิยม เทคนิคนี้มีข้อเสียที่แข็งแรง ประการแรก มันเป็นมากกิจ เพราะแทรกรหัสชั่วคราว ออกทันทีที่ได้รับการแก้ไขข้อผิดพลาด ข้อผิดพลาดใหม่หมายถึง แทรกใหม่ ทำให้เสียเวลา ในการตรวจแก้จุดบกพร่องเช่นในการเขียนโค้ด มืออาชีพควรมุ่งหาโซลูชั่นราคาเมื่อใดก็ ตามที่เป็นไปได้ พิมพ์คำสั่งไม่สามารถ และดังนั้น จะถูกตัดออก เราจะเห็นในไม่ช้า มีวิธีเพิ่มประสิทธิภาพในการติดตามกระแสควบคุมผ่านข้อความ นอกจากนี้ พิมพ์งบ clobber ผลปกติของโปรแกรม ทำให้สับสนมาก พวกเขายังช้าโปรแกรมมาก: ถึงอุปกรณ์ต่อพ่วง outputting กลายเป็น คอขวด สุดท้าย มักจะไม่ได้เลย เพราะเหตุผลประสิทธิภาพ ผลผลิตเป็นปกติ buffered ถูกทำลายบัฟเฟอร์ในกรณีความผิดพลาด และข้อมูลสำคัญที่หายไป อาจจะเกิดขึ้นในการเริ่มต้นกระบวนการตรวจแก้จุดบกพร่องที่ไม่ถูกต้อง ในบางสถานการณ์ (น้อยมาก) ดีบัก cout ได้เหมาะสม แม้ว่ามันสามารถจะถูกแทนที่ ด้วยเทคนิคอื่น ๆ นี่เป็นเคล็ดลับสำหรับกรณีเหล่านี้ จะเริ่มต้นด้วยการ ผลผลิตต้องผลิตบนมาตรฐาน เนื่องจากช่องนี้เป็น unbuffered และก็จะไม่พลาดข้อมูลสุดท้ายก่อนที่จะล้ม แล้ว คำพิมพ์ไม่ควรใช้โดยตรง: แมโครที่ควรกำหนดรอบ ๆ (ดังที่แสดงในรายการ 2) ดังนั้นการดีบักรหัสสลับเปิด และปิดได้ง่าย ในที่สุด ดีบักระดับควรใช้การจัดการจำนวนข้อมูลตรวจแก้จุดบกพร่องรายการ 2: ตัวอย่างของเทคนิค cout - รายงาน#ifndef DEBUG_H#define DEBUG_H#inc lude < stdarg.h >กำหนด #if (NDEBUG) & & กำหนด (__GNUC__)/ * cpp ของ gcc มีส่วนขยาย จะช่วยให้แมโครที่มีหมายเลขตัวแปรของอาร์กิวเมนต์ เราใช้นามสกุลนี้นี่การประมวลผลเบื้องต้น pmesg ไป */#define pmesg (ระดับ forma t อาร์กิวเมนต์...) ((ยกเลิก) 0)#elseยกเลิก pmesg (int ระดับ อักขระ * forma t,...);/ * พิมพ์ข้อความ ถ้าเป็นคอน sidered สำคัญพอ * /#endif#endif / * DEBUG_H * /Listing3: ตัวอย่างของเทคนิคใช้ cout#include "debug.h"#includeextern int msglevel / * t สูง

ผลลัพธ์ (ไทย) 2:

การบรรยายครั้งนี้ให้คำแนะนำการแก้จุดบกพร่องที่เป็นกิจกรรมที่สำคัญในชีวิตของนักพัฒนาทุกคน หลังจากการอภิปรายแนวคิดเบื้องต้นของการแก้จุดบกพร่องที่มีประโยชน์บางบรรยายไปในที่มีการทบทวนรายละเอียดของเทคนิคการแก้จุดบกพร่องทั่วไปอิสระของซอฟต์แวร์ใด ๆ ที่เฉพาะเจาะจง ส่วนสุดท้ายของการบรรยายจะทุ่มเทให้กับการวิเคราะห์ปัญหาที่เกี่ยวข้องกับการใช้ภาษา C ++, การเขียนโปรแกรมภาษาหลักลูกจ้างทั่วไปในฟิสิกส์ของอนุภาคในปัจจุบัน. 1 แนวคิดทั่วไปเกี่ยวกับการแก้จุดบกพร่อง หลังจากที่หลายวันของการระดมความคิดในการออกแบบและการเข้ารหัสโปรแกรมเมอร์ในที่สุดก็มีชิ้นส่วนที่ยอดเยี่ยมของรหัส เขารวบรวมมันและมันวิ่ง ทุกอย่างดูเหมือนตรงไปตรงสวย แต่น่าเสียดายที่มันไม่ทำงาน! และตอนนี้? ตอนนี้เริ่มต้นความสนุกที่ดี! ใช้เวลาในการขุดลงไปในโลกมหัศจรรย์ของการแก้จุดบกพร่อง แม้จะเป็นดินแดนของความฉลาดและความไม่แน่นอนกระบวนการแก้จุดบกพร่องสามารถแบ่งออกเป็นสี่ขั้นตอนหลัก: 1 localising ข้อผิดพลาด2 แบ่งประเภทของข้อผิดพลาด3 การทำความเข้าใจข้อผิดพลาด4 ซ่อมแซมข้อผิดพลาด. 1.1 การแปลข้อผิดพลาดทัศนคติทั่วไปของโปรแกรมเมอร์มือใหม่ไปสู่ข้อบกพร่องคือการพิจารณาการแปลของพวกเขาได้เป็นงานง่าย: พวกเขาสังเกตเห็นรหัสของพวกเขาไม่ได้ทำสิ่งที่พวกเขาคาดหวังและพวกเขาจะทำให้หลงผิดจากความเชื่อมั่นของพวกเขาในการรู้สิ่งที่รหัสของพวกเขาควร ทำ ความเชื่อมั่นนี้เป็นหลอกลวงสมบูรณ์เพราะจำข้อผิดพลาดอาจเป็นเรื่องยากมาก ตามที่ได้อธิบายในการแนะนำข้อบกพร่องทั้งหมดเกิดจากสมมติฐานที่ว่าสิ่งที่คิดว่าจะเป็นที่ถูกต้องในความเป็นจริงที่ไม่ถูกต้อง. สังเกตเห็นข้อผิดพลาดหมายถึงการทดสอบ การทดสอบควรจะดำเนินการมีวินัยและเมื่อเป็นไปได้โดยอัตโนมัติตัวอย่างเช่นหลังจากที่แต่ละสร้างของรหัส ในกรณีของความล้มเหลวการทดสอบโปรแกรมจะต้องสามารถที่จะเห็นสิ่งที่ผิดพลาดไปได้อย่างง่ายดายเพื่อการทดสอบจะต้องจัดทำอย่างระมัดระวัง การบรรยายครั้งนี้จะไม่ครอบคลุมพื้นฐานของการทดสอบ. 1.2 จำแนกปัญหาแม้จะมีลักษณะโรคจิตมักจะมีพื้นกัน นี้จะช่วยให้พยายามค่อนข้างหยาบ แต่มีประโยชน์ในบางครั้งการจัดหมวดหมู่ รายการจะถูกจัดอยู่ในลำดับของความยากลำบากที่เพิ่มขึ้น (ซึ่งหมายถึงโชคดีในการสั่งซื้อลดลงความถี่). ข้อผิดพลาดการสร้างประโยคที่ควรจะจับได้อย่างง่ายดายโดยคอมไพเลอร์ของคุณ ผมบอกว่า "ควร" เพราะคอมไพเลอร์ข้างเป็นความซับซ้อนมากสามารถ Buggy ตัวเอง ในกรณีใด ๆ ก็มีความสำคัญที่ต้องจำว่าค่อนข้างมักจะมีปัญหาอาจจะไม่ได้อยู่ที่ตำแหน่งที่แน่นอนระบุโดยข้อผิดพลาดคอมไพเลอร์. สร้างข้อผิดพลาดเป็นผลมาจากการเชื่อมโยงไฟล์วัตถุที่ถูกสร้างขึ้นมาใหม่หลังจากที่ไม่ได้มีการเปลี่ยนแปลงในไฟล์ที่มาบางส่วน ปัญหาเหล่านี้สามารถหลีกเลี่ยงได้โดยการใช้เครื่องมือในการผลักดันการสร้างซอฟแวร์. ข้อผิดพลาดความหมายพื้นฐานประกอบด้วยการใช้ตัวแปรเริ่มต้นการยกเลิกรหัสตาย (รหัสที่จะไม่ดำเนินการ) และปัญหาเกี่ยวกับชนิดตัวแปร คอมไพเลอร์สามารถให้พวกเขาเน้นความสนใจของคุณแม้ว่ามันมักจะต้องมีการถามอย่างชัดเจนผ่านธง (ซีพี. 2.1). ข้อผิดพลาดความหมายรวมถึงการใช้ตัวแปรหรือผู้ประกอบการที่ไม่ถูกต้อง (เช่น & แทน && ใน C ++) เครื่องมือที่ไม่สามารถจับปัญหาเหล่านี้เพราะพวกเขาเป็น syntactically งบที่ถูกต้องแม้ว่าเหตุผลที่ไม่ถูกต้อง กรณีการทดสอบหรือการดีบักมีความจำเป็นต้องมองเห็นพวกเขา. ในการจำแนกทางกายภาพตลกแตกต่างระหว่าง Bohrbugs และ Heisenbugs Bohrbugs มีกำหนดขึ้น: การป้อนข้อมูลโดยเฉพาะอย่างยิ่งมักจะแสดงให้เห็นพวกเขามีผลเดียวกัน Heisenbugs เป็นแบบสุ่ม: เรื่องยากที่จะทำซ้ำได้อย่างน่าเชื่อถือเพราะพวกเขาดูเหมือนจะขึ้นอยู่กับปัจจัยด้านสิ่งแวดล้อม (เช่นจัดสรรหน่วยความจำโดยเฉพาะอย่างยิ่งวิธีการกระบวนการตารางระบบปฏิบัติการขั้นตอนของดวงจันทร์และอื่น ๆ ) ใน C ++ Heisenbug มากมักจะเป็นผลมาจากข้อผิดพลาดกับคำแนะนำที่. 1.3 ทำความเข้าใจเกี่ยวกับข้อผิดพลาดข้อผิดพลาดควรจะเข้าใจอย่างเต็มที่ก่อนที่จะพยายามที่จะแก้ไขได้ พยายามที่จะแก้ไขข้อผิดพลาดก่อนที่จะเข้าใจมันจะจบอย่างสมบูรณ์ในการกระตุ้นให้เกิดความเสียหายมากยิ่งขึ้นรหัสเนื่องจากปัญหาที่เกิดขึ้นอาจมีการเปลี่ยนแปลงรูปแบบและประจักษ์เองที่อื่นอาจจะสุ่ม อีกครั้งเป็นตัวอย่างทั่วไปเป็นความเสียหายของหน่วยความจำ:. หากมีหน่วยความจำผู้ต้องสงสัยได้รับความเสียหายระหว่างการทำงานของอัลกอริทึมบางข้อมูลทั้งหมดที่เกี่ยวข้องในขั้นตอนวิธีจะต้องตรวจสอบก่อนที่จะพยายามที่จะเปลี่ยนพวกเขาต่อไปตรวจสอบรายชื่อเป็นประโยชน์ที่จะมั่นใจวิธีการที่ถูกต้องในการตรวจสอบ: - ไม่สับสนสังเกตอาการกับการหาแหล่งที่มาที่แท้จริงของปัญหา; - ตรวจสอบว่าข้อผิดพลาดที่คล้ายกัน (โดยเฉพาะสมมติฐานผิด) ที่ถูกสร้างขึ้นที่อื่น ๆ ในรหัส; - ตรวจสอบว่าเป็นเพียงความผิดพลาดของการเขียนโปรแกรมและไม่ขึ้น ปัญหาพื้นฐาน (เช่นขั้นตอนวิธีการไม่ถูกต้อง) ถูกพบ. 1.4 ซ่อมข้อผิดพลาดขั้นตอนสุดท้ายในกระบวนการแก้จุดบกพร่องคือการแก้ไขข้อผิดพลาด ซ่อมข้อผิดพลาดเป็นมากกว่าการปรับเปลี่ยนรหัส การแก้ไขใด ๆ จะต้องบันทึกไว้ในรหัสและผ่านการทดสอบอย่างถูกต้อง และที่สำคัญการเรียนรู้จากความผิดพลาดเป็นทัศนคติที่มีประสิทธิภาพ: มันเป็นวิธีที่ดีเติมไฟล์ขนาดเล็กที่มีคำอธิบายรายละเอียดเกี่ยวกับวิธีที่ข้อผิดพลาดที่ถูกค้นพบและการแก้ไข ตรวจสอบรายชื่ออาจจะเป็นความช่วยเหลือที่มีประโยชน์. หลายจุดมีมูลค่าการบันทึก: - วิธีการข้อผิดพลาดก็สังเกตเห็นเพื่อช่วยในการเขียนกรณีทดสอบ; - วิธีที่จะได้รับการติดตามลงเพื่อให้คุณมีความเข้าใจที่ดีขึ้นในวิธีการที่จะเลือกใน สถานการณ์ที่คล้ายกัน; - ชนิดของข้อผิดพลาดที่พบ? - หากปัญหานี้พบบ่อยในการสั่งซื้อที่จะตั้งค่ากลยุทธ์ในการป้องกันไม่ให้มันเกิดขึ้นอีกหนึ่ง- ถ้าสมมติฐานเริ่มต้นก็ไม่ยุติธรรม; นี้มักจะเป็นเหตุผลหลักว่าทำไมการติดตามข้อผิดพลาดจึงเป็นเวลานาน. 2 เทคนิคการแก้จุดบกพร่องทั่วไปที่กล่าวก่อนการแก้จุดบกพร่องมักจะเป็นดินแดนของความฉลาดและความไม่แน่นอน แต่จำนวนของเทคนิคที่สามารถนำมาใช้ในกิจกรรมการเขียนโปรแกรมในชีวิตประจำวันเพื่อความสะดวกในการล่าสัตว์สำหรับปัญหา. 2.1 การใช้ประโยชน์จากคอมไพเลอร์มีคอมไพเลอร์ที่ดีสามารถทำบางอย่างคงที่ในการวิเคราะห์รหัส การวิเคราะห์รหัส Static คือการวิเคราะห์ของซอฟต์แวร์ที่จะดำเนินการโดยไม่ต้องดำเนินการโปรแกรมที่สร้างขึ้นจากซอฟต์แวร์ที่ วิเคราะห์แบบคงที่สามารถช่วยในการตรวจสอบจำนวนของปัญหาความหมายขั้นพื้นฐานเช่นไม่ตรงกันชนิดหรือรหัสตาย. มีดูที่คู่มือผู้ใช้ของคอมไพเลอร์ที่ใช้ซึ่งคุณสมบัติทั้งหมดที่ควรจะได้รับเอกสารแนะนำเป็นอย่างยิ่ง สำหรับ gcc คอมไพเลอร์มาตรฐานใน GNU / Linux ระบบมีจำนวนตัวเลือกที่มีผลต่อสิ่งที่วิเคราะห์แบบคงที่สามารถดำเนินการได้ พวกเขามักจะแบ่งออกเป็นสองชั้น:. ตัวเลือกการแจ้งเตือนและธงการเพิ่มประสิทธิภาพ2.2 การอ่านเอกสารที่ถูกต้องนี้ดูเหมือนว่าค่อนข้างเป็นเคล็ดลับที่เห็นได้ชัดแต่บ่อยเกินไปโปรแกรมเมอร์มือใหม่อ่านเอกสารที่ไม่ถูกต้องมองหาคำแนะนำเกี่ยวกับงานที่พวกเขาจะต้องประสบความสำเร็จ เอกสารที่เกี่ยวข้องกับงานเครื่องมือที่ห้องสมุดและขั้นตอนวิธีการที่ใช้จะต้องเป็นที่ปลายนิ้วเพื่อหาข้อมูลที่เกี่ยวข้องได้อย่างง่ายดาย. เท่าที่เอกสารเป็นห่วงความแตกต่างที่สำคัญที่สุดคือระหว่างการสอนและการอ้างอิง กวดวิชาเป็นกระดาษสอนมักจะมีความอุดมสมบูรณ์ของตัวอย่าง มันไม่ถือว่ามีความรู้ก่อนหน้าของหัวข้อและจุดมุ่งหมายแรกคือการถ่ายทอดความคิดเกี่ยวกับเรื่อง คู่มืออ้างอิงในทางที่มีรายละเอียดที่ครอบคลุมและครบถ้วนสมบูรณ์ซึ่งจะช่วยให้การหาคำตอบของคำถามผ่านดัชนีและข้ามอ้างอิง. ในโลกของการเขียนโปรแกรมทุกประเภทของเอกสารเหล่านี้มักจะอยู่ในรูปแบบอิเล็กทรอนิกส์ เอกสารอ้างอิงจะต้องถึงวันที่ถูกต้องและสอดคล้องกับปัญหาและเครื่องมือที่ใช้: มองขึ้นมาในคู่มือการอ้างอิงที่ไม่ถูกต้องจะสิ้นสุดในความพยายามที่จะใช้คุณลักษณะที่ไม่ได้รับการสนับสนุนจากรุ่นปัจจุบันของเครื่องมือเช่น2.3 เทคนิคการแก้จุดบกพร่องที่ถูกทารุณกรรมศาลเทคนิคศาลใช้ชื่อของมันมาจากคำสั่งC ++ สำหรับการพิมพ์บนกระแสออกมาตรฐาน (ปกติหน้าจอมินัล) มันประกอบไปด้วยการเพิ่มงบการพิมพ์ในรหัสในการติดตามการควบคุมการไหลและค่าของข้อมูลในระหว่างการดำเนินรหัส แม้ว่ามันจะเป็นเทคนิคที่ชื่นชอบของสามเณรทั้งหมดมันเป็นเรื่องที่ไม่น่าเชื่อว่าหลายโปรแกรมเมอร์ที่มีประสบการณ์ยังคงปฏิเสธที่จะพัฒนาและละทิ้งอย่างนี้เสียเวลาและวิธีการเฉพาะกิจมาก. แม้ความนิยมของเทคนิคนี้มีข้อเสียที่แข็งแกร่ง ครั้งแรกของทั้งหมดมันเป็นอย่างเฉพาะกิจเพราะการแทรกโค้ดชั่วคราวจะถูกลบออกทันทีที่ข้อผิดพลาดได้รับการแก้ไข ข้อผิดพลาดใหม่หมายถึงการแทรกใหม่ทำให้มันเสียเวลา ในการแก้จุดบกพร่องเช่นเดียวกับในการเขียนโปรแกรมมืออาชีพควรมุ่งที่จะหาทางแก้ไขปัญหาที่เป็นไปได้เมื่อใดก็ตามที่นำมาใช้ใหม่ งบการพิมพ์ไม่ได้นำมาใช้ใหม่และเพื่อให้มีการคัดค้าน ในขณะที่เราจะได้เห็นในไม่ช้ามีวิธีที่มีประสิทธิภาพมากขึ้นในการติดตามการควบคุมการไหลผ่านข้อความ นอกจากนี้งบพิมพ์บังคับส่งออกปกติของโปรแกรมที่ทำให้เกิดความสับสนมาก พวกเขายังชะลอตัวโปรแกรมลงมาก: การเข้าถึงอุปกรณ์ต่อพ่วง outputting จะกลายเป็นคอขวด ในที่สุดพวกเขามักจะไม่ช่วยเลยเพราะสำหรับเหตุผลประสิทธิภาพการส่งออกมักจะบัฟเฟอร์และในกรณีของความผิดพลาดบัฟเฟอร์จะถูกทำลายและข้อมูลสำคัญที่หายไปอาจจะส่งผลในการเริ่มต้นกระบวนการแก้จุดบกพร่องในสถานที่ที่ไม่ถูกต้อง. ใน บางคน (น้อยมาก) สถานการณ์การแก้จุดบกพร่องศาลสามารถที่เหมาะสมแม้ว่ามันมักจะถูกแทนที่ด้วยเทคนิคอื่น ๆ สำหรับกรณีนี้นี่คือเคล็ดลับบางอย่าง เพื่อเริ่มต้นกับการส่งออกจะต้องมีการผลิตในข้อผิดพลาดมาตรฐานเพราะช่องทางนี้เป็น unbuffered และมันก็เป็นโอกาสน้อยที่จะพลาดข้อมูลที่ผ่านมาก่อนที่จะผิดพลาด จากนั้นพิมพ์งบไม่ควรนำมาใช้โดยตรง: แมโครควรจะกำหนดรอบตัวพวกเขา (ดังแสดงในรายการ 2) เพื่อที่จะเปลี่ยนรหัสการแก้จุดบกพร่องและปิดได้อย่างง่ายดาย สุดท้ายระดับการแก้จุดบกพร่องควรจะใช้ในการจัดการปริมาณของข้อมูลการแก้จุดบกพร่อง. รายการที่ 2: ตัวอย่างของเทคนิคศาลอัน - ประกาศคำสั่ง#ifdef DEBUG_H #define DEBUG_H #inc Lude <stdarg.h> # ถ้ากำหนด (NDEBUG) && กำหนด (__GNUC__) / * CPP gcc มีนามสกุล; จะช่วยให้แมโครที่มีจำนวนตัวแปรของการขัดแย้ง เราใช้นามสกุลนี้ที่นี่เพื่อ preprocess pmesg ออกไป * / #define pmesg (... ระดับสมมติฐานที args) ((void) 0) # อื่นเป็นโมฆะpmesg (ระดับ int, char * สมมติฐานที...); / * พิมพ์ข้อความถ้ามันเป็นนักโทษ ดูเสมือนความสำคัญพอ * / #endif #endif / * * * * * DEBUG_H / Listing3: ตัวอย่างของศาลเทคนิคการดำเนิน#include "debug.h" #include











































































extern int msglevel; / * สูงกว่าที

ผลลัพธ์ (ไทย) 3:

การบรรยายให้ความรู้เบื้องต้นเกี่ยวกับการดีบัก กิจกรรมที่สําคัญในชีวิตของนักพัฒนาทุกคน หลังจากการอภิปรายเบื้องต้นบางอย่างที่เป็นประโยชน์ในการดีบักแนวคิด ร่วมไปกับการตรวจทานรายละเอียดทั่วไปของการดีบักเทคนิคอิสระจากซอฟต์แวร์ที่เฉพาะเจาะจงใด ๆ ส่วนสุดท้ายของการบรรยายจะทุ่มเทเพื่อวิเคราะห์ปัญหาการใช้ Cหลักการเขียนโปรแกรมภาษาทั่วไปที่ใช้ในฟิสิกส์ของอนุภาคในปัจจุบัน

1 แนวคิดทั่วไป
เกี่ยวกับการดีบั๊ก หลังจากที่หลายวันของการระดมความคิด การออกแบบ และเขียนโปรแกรม โปรแกรมเมอร์ก็จะเป็นชิ้นที่ยอดเยี่ยมของรหัส เขารวบรวมมันและวิ่งมัน ทุกอย่างดูเหมือนจะตรงไปตรงมา แต่มันไม่ทำงาน ! และตอนนี้ ? ตอนนี้สนุกมาก เริ่มได้ !เวลาขุดเข้าสู่โลกมหัศจรรย์ของการดีบั๊ก แม้จะเป็นดินแดนของความฉลาดและความไม่แน่นอน , การตรวจแก้จุดบกพร่องกระบวนการสามารถแบ่งออกเป็นสี่ขั้นตอนหลัก :
1 localising ข้อผิดพลาด
2 การจำแนกแมลง ,
3 เข้าใจปัญหา
4 ซ่อมแซมข้อผิดพลาด

สำหรับ localizing แมลง
ทัศนคติทั่วไปของโปรแกรมเมอร์มือใหม่ต่อแมลงที่จะพิจารณาการแปลของงานง่าย :พวกเขาแจ้งรหัสของพวกเขาไม่ได้ทำสิ่งที่พวกเขาคาดหวัง และพวกเขาจะหลงผิดไปด้วยความมั่นใจในการรู้สิ่งที่รหัสของพวกเขาควรจะทำ ความเชื่อมั่นนี้เป็นสมบูรณ์ที่หลอกลวง เพราะเห็นข้อผิดพลาดได้ยากมาก ตามที่ได้อธิบายในเบื้องต้น พวกแมลงต้นจากหลักฐานบางอย่างที่คิดว่าน่าจะใช่ ในความเป็นจริงถูกผิด

สังเกตข้อผิดพลาดบางการทดสอบการทดสอบควรจะดำเนินการกับวินัยและเมื่อเป็นไปได้โดยอัตโนมัติ ตัวอย่างเช่น หลังจากการสร้างรหัส ในกรณีของการทดสอบล้มเหลว โปรแกรมเมอร์จะต้องสามารถที่จะเห็นสิ่งที่ผิดพลาดได้ง่าย ดังนั้นการทดสอบจะต้องเตรียมตัวให้ดี การบรรยายนี้จะครอบคลุมพื้นฐานของการทดสอบ 1.2 การจำแนกแมลง


แม้จะมีลักษณะที่แมลงมักจะมีพื้นหลังธรรมดานี้จะช่วยให้เพื่อพยายามที่ค่อนข้างหยาบ แต่บางครั้งมีประโยชน์ การจำแนกประเภท รายการที่จัดเรียงอยู่ในลำดับของความยากลำบากที่เพิ่มขึ้น ( ซึ่งโชคดีที่วิธีการเพื่อลดความถี่ )
ข้อผิดพลาดประโยคควรจะได้อย่างง่ายดายจับโดยคอมไพเลอร์ของคุณ ผมบอกว่า " ควร " เพราะพูดข้างจะซับซ้อนมาก สามารถเป็นรถตัวเอง ในกรณีใด ๆมันเป็นสิ่งสำคัญที่จะจำไว้ว่าค่อนข้างบ่อย ปัญหาอาจไม่ได้อยู่ตำแหน่งที่ระบุโดยเรียบเรียงข้อความผิดพลาด

สร้างความผิดพลาดเกิดขึ้นจากการเชื่อมโยงวัตถุไฟล์ ที่ไม่ได้ถูกสร้างขึ้นใหม่หลังจากการเปลี่ยนแปลงในแฟ้มแหล่งที่มา ปัญหาเหล่านี้สามารถหลีกเลี่ยงได้โดยการใช้เครื่องมือไดรฟ์สร้างซอฟต์แวร์

ความหมายข้อผิดพลาดพื้นฐานประกอบด้วยใช้ UN เริ่มต้นตัวแปรตายรหัส ( รหัสที่ไม่เคยถูกประหารชีวิต ) และปัญหากับประเภทของตัวแปร คอมไพเลอร์สามารถเน้นความสนใจของคุณ แม้ว่ามันมักจะต้องมีอย่างชัดเจนขอให้ผ่านธง ( CP 2.1 )

ความหมายข้อผิดพลาดรวมถึงการใช้ตัวแปรหรือผู้ประกอบการผิด ( เช่น &แทน&& C ) ไม่มีเครื่องมือสามารถตรวจจับปัญหาเหล่านี้เพราะพวกเขามีการรายงานที่ถูกต้องแม้ว่าเหตุผลผิด เป็นกรณีทดสอบหรือดีบักเป็นสิ่งจำเป็นที่จะจุดพวกเขา .
ตลกทางกายภาพและการจำแนกแยก bohrbugs heisenbugs . bohrbugs เป็น deterministic : ใส่เฉพาะจะปรากฏกับผลเดียวกัน heisenbugs จะสุ่ม : ยากที่จะสืบพันธุ์ได้ตั้งแต่พวกเขาดูเหมือนจะขึ้นอยู่กับปัจจัยด้านสิ่งแวดล้อม ( เช่นการจัดสรรหน่วยความจำเฉพาะวิธีระบบตารางกระบวนการ ขั้นตอนของดวงจันทร์และ ) ใน C heisenbug มากมักจะเป็นผลของข้อผิดพลาดกับคำแนะนำ

1.3 เข้าใจข้อผิดพลาด
แมลงควรจะเข้าใจก่อนที่จะพยายามที่จะแก้ไขมัน พยายามแก้ไขข้อผิดพลาดก่อน เข้าใจมันอย่างสมบูรณ์จะจบให้ความเสียหายเพิ่มเติมกับรหัส