微信公众号搜"智元新知"关注
微信扫一扫可直接关注哦！

A GDB Tutorial with Examples--转

分类：C#作者：编程之家

A GDB Tutorial with Examples

By Manasij Mukherjee

A good debugger is one of the most important tools in a programmer's toolkit. On a UNIX or Linux system,GDB (the GNU debugger) is a powerful and popular debugging tool; it lets you do whatever you like with your program running under GDB.

Should you read this?

You should... if you can relate to two or more of the following:

  • You have a general idea of programming with C or C++.
  • You put a lot of cout or printf statements in the code if something goes wrong.
  • You have used a debugger with an IDE,and are curious about how the command line works.
  • You've just moved to a Unix-like operating system and would like to know about the toolchain better.

A crash course on compiling with gcc (or g++)

 is the de facto compiler in Linux or any other *nix system. It also has Windows ports but on Windows,you'll probably find the  'easier'.

Suppose you have a file called main.cpp containing your c++ code. You should compile it with the following command:

While this will work fine and produce an executable file called main,you also need to put a -g flag to tell the compiler that you may want to debug your program later.


So the final command turns into:


(If you're wondering what -Wall and -Werror are,you may find  a useful read.)


Don't worry if it looks cumbersome,you'll get used to it! (If you've got multiple source files you should use a good build system like  or.)


The Basics of GDB


Provided you've compiled your program with the debugging symbols enabled,you're ready to start debugging. Any time there is text you should replace,I've put it in .


Starting GDB


To start GDB,in the terminal,




For the above example with a program named main,the command becomes


Setting Breakpoints


You'll probably want you program to stop at some point so that you can review the condition of your program. The line at which you want the program to temporarily stop is called the breakpoint.




Running your program


To run your program,the command is,as you guessed,


Looking at the code


When the program is stopped,you can do a number of important things,but most importantly you need to see which part of the code you've stopped. The command for this purpose is "list". It shows you the neighbouring 10 lines of code.


Next and Step


Just starting and stopping isn't much of a control. GDB also lets you to run the program line-by-line by the commands 'next' and 'step'. There is a little difference between the two,though. Next keeps the control strictly in the current scope whereas step follows the execution through function calls.


Look at this example carefully;


Suppose you have a line in the code like

















If you use the next command,the line (and the function,provided there aren't breakpoints in it) gets executed and the control advances to the next line,readinput(),where you can perhaps examine 'value' to get an idea of how display() worked.


But if you use the step command,you get to follow what display() does directly,and the control advances to the first line of display(),wherever it is.


Examining your Variables


When you want to find the misbehaving portion of your program,it often helps to examine local variables to see if anything unexpected has occurred. To examine a variable,just use




Note: You can also modify variables' values by


 = 



You can modify variables to see if an issue is resolved if the variable has another value or to force the program to follow a particular path to see if the reason for a bug was due to a variable having the wrong value.


Setting Watchpoints


Setting watchpoints is like asking the debugger to provide you with a running commentary of any changes that happen to the variables. Whenever a change occurs,the program pauses and provides you with the details of the change.


The command to set a simple watchpoint (a write watchpoint,i.e you are notified when the value is written) is




Here's some example output when GDB pauses due to a change in :


Old value = 0

New value = 1

0x08048754 at main.cpp:31

31        variable=isalpha(ch)




Note: You can only set watchpoints for a variable when it is in scope. So,to watch something within another function or a inner block,first set a breakpoint inside that scope and then when the program pauses there,set the watchpoint.


Quit


To stop your program,when it is paused,use kill and to quit GDB itself,use quit.


An Example Debugging Session


The given code computes the factorial of a number erroneously. The goal of the debugging session is to pinpoint the reason of the error.


























































  





  





 





 



>n;



 











 







  





 



















 










Into the Debugger


Now follow the commands and the outputs carefully,especially the watchpoints. What I'm doing is basically:


    

  • Setting a breakpoint just in the line of the function call
    • 

  • Stepping into the function from that line
    • 

  • Setting watchpoints for both the result of the calculation and the input number as it changes.
    • 

  • Finally,analyzing the results from the watchpoints to find problematic behaviour
    • 



...
8.      Reading symbols from /home/manasij7479/Documents/main...done.
9.      (gdb) break 11
10.     Breakpoint 1 at 0x80485f9: file main.cpp,line 11.
11.     (gdb) run
12.     Starting program: /home/manasij7479/Documents/main
13.     3
14.     
15.     Breakpoint 1,main () at main.cpp:11
16.     11        long val=factorial(n);
17.     (gdb) step
18.     factorial (n=3) at main.cpp:19
19.     19        long result(1);
20.     (gdb) list
21.     14        return 0;
22.     15      }
23.     16
24.     17      long factorial(int n)
25.     18      {
26.     19        long result(1);
27.     20        while(n--)
28.     21        {
29.     22          result*=n;
30.     23        }
31.     (gdb) watch n
32.     Hardware watchpoint 2: n
33.     (gdb) watch result
34.     Hardware watchpoint 3: result
35.     (gdb) continue
36.     Continuing.
37.     Hardware watchpoint 3: result
38.     
39.     Old value = 0
40.     New value = 1



Notice that result starts from 0 and is initialized to 1.


43.     (gdb)



Notice that I didn't put in a command,I just hit . It re-executes the last command.


47.     Old value = 3
48.     New value = 2



Notice that n gets is immediately decremented from 3 to 2.


51.     (gdb)
52.     Continuing.
53.     Hardware watchpoint 3: result
54.     
55.     Old value = 1
56.     New value = 2



Now result becomes 2 (by multiplying result's earlier value with n's value). We've found the first bug! result is supposed to be evaluated by multiplying 3 * 2 * 1 but here the multiplication starts from 2. To correct it,we have to change the loop a bit,but before that,lets see if the rest of the calculation is correct.


59.     (gdb)
60.     Continuing.
61.     Hardware watchpoint 2: n
62.     
63.     Old value = 2
64.     New value = 1



n gets decremented from 2 to 1. Result doesn't change since n is 1.


67.     (gdb)
68.     Continuing.
69.     Hardware watchpoint 2: n
70.     
71.     Old value = 1
72.     New value = 0



n gets decremented from 1 to 0.


75.     (gdb)
76.     Continuing.
77.     Hardware watchpoint 3: result
78.     
79.     Old value = 2
80.     New value = 0



Now result becomes 0 (by multiplying result's earlier value with n's value,0). Another bug! How can result hold the value of the factorial when it is multiplied by 0? The loop must be stopped before n reaches 0.


83.     (gdb)
84.     Continuing.
85.     Hardware watchpoint 2: n
86.     
87.     Old value = 0
88.     New value = -1
89.     0x08048654 in factorial (n=-1) at main.cpp:20
90.     20        while(n--)
91.     (gdb)
92.     Continuing.



Now n becomes -1 and the loop isn't permitted to run anymore because n-- returns 0,and the function returns result's current value 0. Let's see what happens when the function exits.


This is what happens to a watchpoint when the variable goes out of scope.


101.    (gdb) print val
102.    $1 = 1293357044



print val shows a garbage value because gdb points to a line before it is executed,not after.


103.    (gdb) next
104.    12        cout<105.    (gdb) continue
106.    Continuing.
107.    0[Inferior 1 (process 2499) exited normally]
108.    (gdb) quit



Here's what the fix should look like:













0) 




















GDB in Conclusion


You have now seen enough to try GBD out on your own. Some important topics have not been touched upon here for the sake of simplicity,such as dealing with  or using tools like  to find memory leaks.


Remember that GDB comes built in with an excellent help system. Just type help in the (gdb) prompt and you will be presented with options of what you Could need help with. For details about a specific command,use the Syntax




Another important point to note is the use of shortcuts (like 'q' for 'quit'). GDB lets you use shortcuts for commands when it is not ambigIoUs.


After learning about GDB,you do not have to panic the next time your program goes crazy. You have an excellent weapon in your arsenal Now.

                
                                
原文地址：https://www.jb51.cc/csharp/72624.html

                                 
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。

                            

                        

                    

                

                

                    

                        

                            
相关推荐

                            



                                 
单例模式

                                
在要实现单例模式的类当中添加如下代码：实例化的时候：frmCardAppend fca=frmCardAppend .Instance;示例： 1 public class frmCardAppend : Form 2 { 3 #region 私有字段 4 private static frmCar

                  
                                
                            

                                 
利用DOTNETBAR制作圆角窗体和圆角控件

                                
1、如果制作圆角窗体，窗体先继承DOTNETBAR的：public partial class Form2 : DevComponents.DotNetBar.Office2007Form然后窗体里加上一个DONTERBAR的panel，然后设置panel为fill占满整个窗体然后设置panel的C

                  
                                
                            

                                 
C# winform搜索提示的一些想法

                                
根据网上资料，自己很粗略的实现了一个winform搜索提示，但是距离我自己的目标（与腾讯QQ的效果一样） 还有一大段距离，我自己做的这个winform搜索提示没有涉及到sql注入，因为是读取内存中的DataTable。本人工作一年时间，平时是用C# 开发winform程序，所以代码比较简陋，程序的功

                  
                                
                            

                                 
对做C#自定义控件的一点心得

                                
近期在做DSOFramer这个控件，打算自己弄一个自定义控件来封装这个COM组件，中间遇到很多曲折，研究了一个星期，终于完成了下面总结一下我做DSOFramer这个自定义控件的注意地方：1、在创建一个Windows窗体控件库的时候，那个项目路径里不能有中文，比如：D:\C#练习\WindowsFor

                  
                                
                            

                                 
WMI 获取硬件信息的封装函数与获取联想台式机的出厂编号方法

                                
今天玩了一把WMI，查询了一下电脑的硬件信息，感觉很多代码都是可以提取出来的，就自己把那些公共部分提出出来，以后如果要获取某部分的硬件信息就不用写一个一个的函数，比如获取MAC地址就写一个获取MAC地址的函数，获取CPU 信息就写一个获取CPU信息的函数，太麻烦了如下是函数代码： 1 private

                  
                                
                            

                                 
WinWordControl控件的使用注意

                                
最近在研究WinWordControl这个控件，因为上级要求在系统里，嵌入Word，然后用C#控制Word格式，在网上下载了WinWordControl.dll（在DLL之家下载的），因为本人的系统环境识win7+office07,导入到visual studio之后，vs报错，因为WinWordC

                  
                                
                            

                                 
打印出datagrideview里面的内容，用到少量GDI+的知识

                                
1 using System; 2 using System.Data; 3 using System.Drawing; 4 using System.Drawing.Printing; 5 using System.Windows.Forms; 6 7 8 namespace InvoiceSys

                  
                                
                            

                                 
C# 利用Excel直接读取方法读取Excel进DataGridView

                                
在winform里拖入一个datagridview控件，跟一个openfiledialog控件，这个例子的功能只是读取excel文件，其他的功能本人还在研究当中献上代码using System;using System.Collections.Generic;using System.Compone

                  
                                
                            

                                 
C# winform中MouseDoubleClick与DoubleClick的区别

                                
C# winform中MouseDoubleClick与DoubleClick的区别是MouseDoubleClick：只能用鼠标双击DoubleClick：可以按键盘的回车键

                  
                                
                            

                                 
程序集特性访问器

                                
程序集特性访问器一般用在关于窗体里 partial class FormAbout : Form { public FormAbout() { InitializeComponent(); this.Text = String.Format(&quot;关于 {0}&quot;, AssemblyT

                  
                                
                            

                    



            

            

              
          

            

              




              

            

          

          
           
          

            

              

                
苹果市值2025年有望达4万亿美元 

              

            

          

          
          
          

            

              

                
                
pythonJavaScriptjavaHTMLPHPreactjsC#AndroidCSSNode.jssqlrpython-3.xMysqLjQueryc++pandasFlutterangularIOSdjangolinuxswifttypescript路由器JSON路由器设置无线路由器h3c华三华三路由器设置华三路由器电脑软件教程arraysdocker软件图文教程Cvue.jslaravelspring-boot