1.2 Classifying a bugDespite the ap

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

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

1.2 ประเภทบกพร่องแม้ มีลักษณะที่ปรากฏ ข้อบกพร่องได้มักพื้นทั่วไป นี้ได้พยายามจัดประเภทค่อนข้างหยาบ แต่บางครั้งมี ประโยชน์ รายการถูกจัดอยู่ในลำดับของการเพิ่มความยากลำบาก (ซึ่งโชคดีหมายถึงลำดับของการลดความถี่) ข้อผิดพลาด syntactical ควรถูกจับ โดยคอมไพเลอร์ของคุณได้อย่างง่ายดาย ผมบอกว่า "ควร" เนื่องจากคอมไพเลอร์ ข้างมีความซับซ้อนมาก ได้รถตัวเอง มันมีความสำคัญที่ต้องจำไว้ว่า ค่อนข้างบ่อยปัญหาอาจไม่อยู่ในตำแหน่งแน่นอนที่ระบุ ด้วยข้อความข้อผิดพลาดของคอมไพเลอร์สร้างข้อผิดพลาดที่ได้รับจากการเชื่อมโยงแฟ้มวัตถุที่ถูกสร้างใหม่หลังจากการเปลี่ยนแปลงในแฟ้มต้นฉบับบางส่วนไม่ ปัญหาเหล่านี้สามารถสามารถหลีก โดยใช้เครื่องมือในการสร้างซอฟแวร์ไดรฟ์ข้อผิดพลาดทางตรรกพื้นฐานประกอบด้วยสหประชาชาติในการเตรียมใช้งานตัวแปร ตายรหัส (รหัสที่จะไม่ดำเนินการ) และปัญหาชนิดตัวแปร คอมไพเลอร์ที่สามารถเน้นให้ความสนใจของคุณ แม้ว่าจะมีการถามได้อย่างชัดเจนผ่านค่าสถานะ (cp. 2.1) การมีข้อผิดพลาดทางตรรกโดยใช้ตัวแปรไม่ถูกต้องหรือตัวดำเนินการ (เช่น และแทนและและ ใน c ++) เครื่องมือไม่สามารถจับปัญหาเหล่านี้ เพราะเป็นงบที่ถูกต้องทางไวยากรณ์ แม้ว่าตรรกะไม่ถูกต้อง กรณีทดสอบหรือดีบักเกอร์จำเป็นต้องให้ประเภทตลกทางกายภาพที่แตกต่างระหว่าง Bohrbugs และ Heisenbugs Bohrbugs เป็น deterministic: ป้อนข้อมูลใดจะเสมอรายการนั้น มีผลลัพธ์เดียวกัน Heisenbugs เป็นแบบสุ่ม: ยากที่จะทำได้ เนื่องจากพวกเขาดูเหมือนจะขึ้นอยู่กับปัจจัยสิ่งแวดล้อม (เช่นการเฉพาะหน่วยความจำปันส่วน วิธีระบบปฏิบัติการจัดกำหนดการกระบวนการ ระยะของดวงจันทร์และ) ใน c ++ Heisenbug มีผลลัพธ์ของข้อผิดพลาดตัวชี้1.3 ทำความเข้าใจเกี่ยวกับปัญหาการบกพร่องควรจะเข้าใจก่อนที่จะพยายามแก้ไขอย่างเต็ม พยายามแก้ไขบกพร่องก่อนที่จะทำความเข้าใจอย่างสมบูรณ์สามารถสิ้นสุดใน provoking รหัส ความเสียหายมากขึ้นเนื่องจากปัญหาสามารถเปลี่ยนฟอร์ม และรายการอื่น ตัวเองอาจโดยการสุ่ม อีกครั้ง เป็นตัวอย่างโดยทั่วไปเป็นความเสียหายของหน่วยความจำ: ถ้ามีหน่วยความจำใด ๆ สงสัย

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

1.2
การจัดประเภทปัญหาแม้จะมีลักษณะโรคจิตมักจะมีพื้นกัน นี้จะช่วยให้พยายามค่อนข้างหยาบ แต่มีประโยชน์ในบางครั้งการจัดหมวดหมู่ รายการจะถูกจัดอยู่ในลำดับของความยากลำบากที่เพิ่มขึ้น (ซึ่งหมายถึงโชคดีในการสั่งซื้อลดลงความถี่).
ข้อผิดพลาดการสร้างประโยคที่ควรจะจับได้อย่างง่ายดายโดยคอมไพเลอร์ของคุณ ผมบอกว่า "ควร" เพราะคอมไพเลอร์ข้างเป็นความซับซ้อนมากสามารถ Buggy ตัวเอง ในกรณีใด ๆ ก็มีความสำคัญที่ต้องจำว่าค่อนข้างมักจะมีปัญหาอาจจะไม่ได้อยู่ที่ตำแหน่งที่แน่นอนระบุโดยข้อผิดพลาดคอมไพเลอร์. สร้างข้อผิดพลาดเป็นผลมาจากการเชื่อมโยงไฟล์วัตถุที่ถูกสร้างขึ้นมาใหม่หลังจากที่ไม่ได้มีการเปลี่ยนแปลงในไฟล์ที่มาบางส่วน ปัญหาเหล่านี้สามารถหลีกเลี่ยงได้โดยการใช้เครื่องมือในการผลักดันการสร้างซอฟแวร์. ข้อผิดพลาดความหมายพื้นฐานประกอบด้วยการใช้ตัวแปรเริ่มต้นการยกเลิกรหัสตาย (รหัสที่จะไม่ดำเนินการ) และปัญหาเกี่ยวกับชนิดตัวแปร คอมไพเลอร์สามารถให้พวกเขาเน้นความสนใจของคุณแม้ว่ามันมักจะต้องมีการถามอย่างชัดเจนผ่านธง (ซีพี. 2.1). ข้อผิดพลาดความหมายรวมถึงการใช้ตัวแปรหรือผู้ประกอบการที่ไม่ถูกต้อง (เช่น & แทน && ใน C ++) เครื่องมือที่ไม่สามารถจับปัญหาเหล่านี้เพราะพวกเขาเป็น syntactically งบที่ถูกต้องแม้ว่าเหตุผลที่ไม่ถูกต้อง กรณีการทดสอบหรือการดีบักมีความจำเป็นต้องมองเห็นพวกเขา. ในการจำแนกทางกายภาพตลกแตกต่างระหว่าง Bohrbugs และ Heisenbugs Bohrbugs มีกำหนดขึ้น: การป้อนข้อมูลโดยเฉพาะอย่างยิ่งมักจะแสดงให้เห็นพวกเขามีผลเดียวกัน Heisenbugs เป็นแบบสุ่ม: เรื่องยากที่จะทำซ้ำได้อย่างน่าเชื่อถือเพราะพวกเขาดูเหมือนจะขึ้นอยู่กับปัจจัยด้านสิ่งแวดล้อม (เช่นจัดสรรหน่วยความจำโดยเฉพาะอย่างยิ่งวิธีการกระบวนการตารางระบบปฏิบัติการขั้นตอนของดวงจันทร์และอื่น ๆ ) ใน C ++ Heisenbug มากมักจะเป็นผลมาจากข้อผิดพลาดกับคำแนะนำที่. 1.3 ทำความเข้าใจเกี่ยวกับข้อผิดพลาดข้อผิดพลาดควรจะเข้าใจอย่างเต็มที่ก่อนที่จะพยายามที่จะแก้ไขได้ พยายามที่จะแก้ไขข้อผิดพลาดก่อนที่จะเข้าใจมันจะจบอย่างสมบูรณ์ในการกระตุ้นให้เกิดความเสียหายมากยิ่งขึ้นรหัสเนื่องจากปัญหาที่เกิดขึ้นอาจมีการเปลี่ยนแปลงรูปแบบและประจักษ์เองที่อื่นอาจจะสุ่ม อีกครั้งเป็นตัวอย่างทั่วไปเป็นความเสียหายของหน่วยความจำ: ถ้ามีหน่วยความจำใด ๆ ที่เป็นผู้ต้องสงสัย

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

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

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

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

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

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