chaosuper85

C++博客 首页 新随笔 联系 聚合 管理
  118 Posts :: 0 Stories :: 3 Comments :: 0 Trackbacks

#

    C++虚函数探索笔记(1)——虚函数的简单示例分析

    关注问题:

    虚函数的作用

    虚函数的实现原理

    虚函数表在对象布局里的位置

    虚函数的类的sizeof

    纯虚函数的作用

    多级继承时的虚函数表内容

    虚函数如何执行父类代码

    多继承时的虚函数表定位,以及对象布局

    虚析构函数的作用

    虚函数在QT的信号与槽中的应用

    虚函数与inline修饰符,static修饰符

    啰嗦两句

    虚函数在C++里的作用是在是非常非常的大,很多讲述C++的文章都会讲到它

,要用好C++,就一定要学好虚函数。网络上可以google到很多很多关于它的文章

,这一次的学习,我不准备去只是简单的阅读了解那些文章,而是希望通过编写

一些测试代码,来对虚函数的一些实现机制,以及C++对象布局做一下探索。

    虚函数的简单示例 !

    虚函数常常出现在一些抽象接口类定义里,当然,还有一个更常见的“特例

”,那就是虚析构函数,后面会提到这个。

    下面是一段关于虚函数的简单代码,演示了使用基类接口操作对象时的效果


 //Source filename: Win32Con.cpp
#include <iostream>
using namespace std;
class parent1
{
public:
    virtual int fun1()=0;
};

class child1:public parent1
{
public:
    virtual int fun1()
    {
        cout<<"child1::fun1()"<<endl;
        return 0;
    }
};

class child2:public parent1
{
public:
    virtual int fun1()
    {
        cout<<"child2::fun1()"<<endl;
        return 0;
    }
};

void test_func1(parent1 *pp)
{
    pp->fun1();
}

int main(int argc, char* argv[])
{
    child1 co1;
    child2 co2;
    test_func1(&co1);
    test_func1(&co2);
    return 0;
}

 


    在上面的代码里,类parent1是一个只具有纯虚函数的接口类,这个类不能被

实例化,它唯一的用途就是抽象一些特定的接口函数,当然,在这里这个接口函

数就是纯虚函数 parent1::fun1()。

    而类child1和child2则是两个从parent1继承的类,我们要使用它定义具体的

类实例,所以它实现了由parent1继承得来的fun1接口,并且各自的实现是不同的

    函数 test_func1 的参数是一个parent1类型的指针,它所要完成的功能就是

调用这个parent1对象的fun1()函数。

    让我们编译运行一下上面的代码,可以看到下面的输出

    child1::fun1()

    child2::fun1()

    很显然,在两次调用test_func1函数的时候,虽然传入的参数都是一个

parent1的指针,但是却都分别执行了child1和child2各自的fun1函数!这就是

C++里类的多态。然而,这一切是怎么发生的呢?test_func1函数怎么会知道应该

调用哪个函数的呢?我不准备像其他人一样画若干图来说明,我准备用具体某个

编译器产生的对象布局以及相应的汇编代码来说明这个过程(这个编译器是

vs2008里的vc9)。

    我们先打开一个VS2008命令提示窗口,改变目录到上面的代码Win32Con.cpp

所在目录,输入下面的命令:

    cl  win32con.cpp  /d1reportSingleClassLayoutchild

    上面的命令可以编译win32con.cpp源码,同时生成里面类名包含child 的类

的对象布局(layout)

    注意:d1reportSingleClassLayout和后面的child是相连的!

    输入上面的命令后看到的对象布局如下,红色字为我添加的注释
 class child1    size(4): 子类child1的对象布局,只包含一个vfptr,大小为

4字节
        +---
        | +--- (base class parent1) 这是被嵌套的父类parent1的对象布局
 0      | | {vfptr}
        | +---
        +---
这是child1的vfptr所指的虚函数表的布局,只包含一个函数的地址,就是child1

的fun1函数
child1::$vftable@:
        | &child1_meta
        |  0
 0      | &child1::fun1

child1::fun1 this adjustor: 0

class child2    size(4): 子类child2的对象布局,只包含一个vfptr,大小为4

字节
        +---
        | +--- (base class parent1) 这是被嵌套的父类parent1的对象布局
 0      | | {vfptr}
        | +---
        +---
这是child2的vfptr所指的虚函数表的布局,只包含一个函数的地址,就是child2

的fun1函数
child2::$vftable@:
        | &child2_meta
        |  0
 0      | &child2::fun1

child2::fun1 this adjustor: 0

 


    从上面的对象布局可以知道:

    每个子对象都有一个隐藏的成员变量vfptr(你当然不能用这个名字访问到它

),它的值是指向该子对象的虚函数表,而虚函数表里填写的函数地址是该子对

象的fun1函数地址。

    对一个包含有虚函数的类做sizeof操作的时候,除了能直接看到的成员变量,还得增加4字节(在32位机器上),就是vfptr这个指针的大小。

    所以当test_func1进行pp->fun1()调用的时候,会首先取出pp所指的内存地址并按照parent1的内存布局,获取到vfptr指针(由于pp在两次调用中分别指向co1和co2所以这里取得的实际上是co1的vfptr和co2的vfptr),然后从vfptr所指的虚函数表第一项(现在也只有 1 项)取出作为将要调用的函数,由于co1和co2在各自的虚函数表里填写了各自的fun1的地址,于是pp->fun1()最终就调用到了co1和co2各自的fun1,输出自然也就不同了。

    让我们看看test_func1的反汇编代码:
 void test_func1(parent1 *pp)
{
001C1530  push        ebp
001C1531  mov         ebp,esp
001C1533  sub         esp,0C0h
001C1539  push        ebx
001C153A  push        esi
001C153B  push        edi
001C153C  lea         edi,[ebp-0C0h]
001C1542  mov         ecx,30h
001C1547  mov         eax,0CCCCCCCCh
001C154C  rep stos    dword ptr es:[edi]
    pp->fun1();
001C154E  mov         eax,dword ptr [pp] //取得pp的值放到eax,即对象的地址
//取得对象的vfptr地址放到edx(因为vfptr在对象布局里拍在第一)
001C1551  mov         edx,dword ptr [eax]
001C1553  mov         esi,esp
001C1555  mov         ecx,dword ptr [pp]
001C1558  mov         eax,dword ptr [edx] //取出vfptr的第一个虚函数的地址到eax
001C155A  call        eax //调用虚函数,即fun1()

    至此,应该比较清楚虚函数机制的基本实现了。然而,也许你还会有这些问题:

    虚函数表是每个子对象都有的么?

    虚函数是存在一个表里的,表的数据结构是怎样的,如何定位表里哪个才是我们要调用的虚函数?

    略作变化

    让我们对前面的代码做以下修改:

    定义一个普通类

    修改parent类,在fun1前增加虚函数fun2

    在child1里和child2里编写fun2的具体实现,一个在fun1之前编写,另外一个在之后编写修改后的编码大致如下:

 class parent1
{
public:
    virtual int fun2()=0;
    virtual int fun1()=0;
};

class child
{
    int a;
};

class child1:public parent1
{
public:

    virtual int fun1()
    {
        cout<<"child1::fun1()"<<endl;
        return 0;
    }
    virtual int fun2()
    {
        cout<<"child1::fun2()"<<endl;
        return 0;
    }
};

    然后我们再使用cl命令以及/d1reportSingleClassLayout选项输出相关的类对象布局情况:

 class child     size(4):  //在普通类child里,看不到vfptr的身影!
        +---
 0      | a
        +---

class child1    size(4):    //child1的对象布局,和之前没有变化!
        +---
        | +--- (base class parent1)
 0      | | {vfptr}
        | +---
        +---
//child1的虚函数表多了fun2,并且两个虚函数在表里的顺序相同于在parent类里声明的顺序
child1::$vftable@:
        | &child1_meta
        |  0
 0      | &child1::fun2
 1      | &child1::fun1

child1::fun1 this adjustor: 0
child1::fun2 this adjustor: 0

    结论很明显:

    虚函数表指针vfptr只在类里有虚拟函数的时候才会存在当有多个虚函数的时候,虚函数在虚函数表里的顺序由父类里虚函数的定义顺序决定并且我们还可以观察到:

    这个vfptr指针会放在类的起始处(这是必须的,vfptr在父类和子类的对象布局上必须一致!)

    虚函数表是以一个NULL指针标识结束让我们对这次简单的示例代码测试来做个小小总结:

    有虚函数的类,一定会有一个虚函数表指针vfptr这个vfptr指针会放在类的起始处虚函数表里会按基类声明虚函数的顺序在vfptr里存放函数地址虚函数表里存放的是函数地址是具体子类的实现函数的地址调用虚函数的时候,是从vfptr所指的函数表里获取到函数地址,然后才调用具体的代码。

 


posted @ 2009-08-05 17:42 chaosuper 阅读(332) | 评论 (1)编辑 收藏

昨天开始就想要升级Redhat Linux 9.0的内核--2.14.20的

找了个网页,本来想升成2.6.24的,不成功!

后来照样画葫芦,升2.6.18的,照网页一样的来,成功了!

不过还是想升级2.6.24的,又不行,有时间再做了!

下面把网页的贴出来,供借鉴。

我的环境是vmware下的Redhat Linux 9.0的


连不上网页的同志们见下面:

一、准备工作
首先说明,下面带#号的行都是要输入的命令行,且本文提到的所有命令行都在终端里输入。启动Linux系统,并用根用户登录,进入终端模式下。

1、查看Linux内核版本# uname -a
如果屏幕显示的是2.6.x,说明你的已经是2.6的内核,也用不着看下文了,该干什么干什么去吧!如果显示的是2.4.x,那恭喜你,闯关通过,赶快进行下一步。

2、下载2.6内核源码
下载地址:http://www.kernel.org/pub/linux/kernel/v2.6/linux-2.6.18.tar.bz2

3、下载内核升级工具
(1)下载module-init-tools-3.2.tar.bz2
http://www.kernel.org/pub/linux/utils/kernel/module-init-tools/module-init-tools-3.2.tar.bz2
(2)下载mkinitrd-4.1.18-2.i386.rpm
http://ayo.freshrpms.net/Fedora/linux/3/i386/RPMS.core/mkinitrd-4.1.18-2.i386.rpm
(3)下载lvm2-2.00.25-1.01.i386.rpm
http://ayo.freshrpms.net/Fedora/linux/3/i386/RPMS.core/lvm2-2.00.25-1.01.i386.rpm
(4)下载device-mapper-1.00.19-2.i386.rpm
http://ayo.freshrpms.net/Fedora/linux/3/i386/RPMS.core/device-mapper-1.00.19-2.i386.rpm

二、配置工作
好啦,2.6内核和4个升级工具都下载完了(少一个也不行,如果没有下载齐全,请不要尝试下面的步骤,升级是不会成功的),下面回到Linux系统中开始配置工作吧。

4、将下载好的内核源码包和4个升级工具都拷贝到/usr/src文件夹下。怎么拷贝就不用我教了吧~~~~不会拷贝的去撞墙吧!~~呵呵!

5、拷贝完毕,开始解压新内核,具体操作请依次执行以下命令:

# cd /usr/src (进入到/usr/src目录下,如果已经在/usr/src目录下,可不执行该命令)
# rm –rf linux (删除linux文件夹。值得一提的是,如果内核先前从未编译过,则没有这个文件夹,此命令行可略过)
# tar jvxf linux-2.6.18.tar.bz2 (解压新内核)
# ln -s linux-2.6.18 linux (重新生成linux文件夹)

6、安装module-init-tools工具
在/usr/src目录下,依次执行下列命令:
# tar jvxf module-init-tools-3.2.tar.bz2 (解压module-init-tools)
# cd module-init-tools-3.2 (由/usr/src目录进入module-init-tools目录下)
#./configure --prefix=/
# make moveold
# make all install
#./generate-modprobe.conf /etc/modprobe.conf

7、安装另外三个升级工具
回到/usr/src目录下,依次执行下列3个命令来安装另外三个升级工具:
# rpm -ivh --nodeps mkinitrd-4.1.18-2.i386.rpm (注意,这里一定要加入--nodeps参数,下同)
# rpm -ivh --nodeps lvm2-2.00.25-1.01.i386.rpm
# rpm -ivh --nodeps device-mapper-1.00.19-2.i386.rpm

如果不更新以上几个升级包,在后面编译内核时会提示以下错误:
mkinitrd failed
make[1]: *** [install] Error 1
make: *** [install] Error 2

8、配置内核选项。有点繁琐,~~希望一次成功哦~~。
# cd linux-2.6.18 (进入到/usr/src/linux-2.6.18目录下)
# make mrproper (该命令可确保源代码目录下没有不正确的.o文件)
# make menuconfig (配置内核各选项)

此时会出现一个图形界面,列出了所有的内核配置选项,有的选项下还有子选项,你可以用方向键来选择,用Y键来确定。经过我多次试验,大多数选项默认就行,以下几个选项必须选择(请认真核对下面每一个选项,否则编译很有可能前功尽弃):

(1)Loadable Module support选项中,选上“Module unloading”和“Automatic kernel module loading”这两项;
(2)Device Drivers--->Block Devices中选上“Loopback device support”;
Device Drivers--->Multi-device support(RAID and LVM)处要选上“device mapper support”;
Device Drivers--->Graphics support,一定要选上“ Support for frame. buffer devices”;
Device Drivers --->USB support --->选上“USB Mass Storage support”(如果是在实环境中,想要更多USB支持,就全选吧。我的是在虚拟机中,用不着了)
Device Drivers --->;Network device support --->Ethernet (10 or 100Mbit) ---><*> AMD PCnet32 PCI support
(3)File system--->(以下9个选项是关于ext2和ext3文件系统配置,全部选上)
Second extended fs support
Ext2 extended attributes
Ext2 POSIX Access Control Lists
Ext2 Security Labels
Ext3 journalling file system support
Ext3 extended attributes
Ext3 POSIX Access Control Lists
Ext3 Security Labels
JBB (ext3) debugging support
File system--->DOS/FAT/NT Filesystems --->选上“NTFS file system support”;

注意:
ext2和ext3文件系统配置很重要,也是必需的,如果对Ext3、Ext2文件的支持直接编译进内核,在你reboot时机器就会当掉,出现如下错误信息:

kernel panic : no init found ,try passing init = option to kernel.....

或者是:
VFS:Cannot open root device "hdxy" or unknow-block(0,0)
Please append a correct "root=" boot option
kernel panic:VFS:Unable to mount root fs on unknown-block(0,0)

或者是:
mount: error 19 mounting ext3
pivotroot: pivot_root(/sysroot,/sysroot/initrd) failed: 2
umount /initrd/proc fail: 2
Freeing unused kernel memory: 244k freed
Kernel panic – not syncing: No init found. Try passing init = option to kernel

(我的机器就是在重启之后出现第三种错误,进不去系统,郁闷死,只好重装了,如果依照本文做完所有步骤,当你重启Linux系统后,若不幸进不去2.6.18内核,你会发现你的出错信息就是上面三种了~~~哈!)

(4)如果你在vmware下编译内核,硬盘用的是scsi的,以下三个选项必选:
Device Drivers ---><*>SCSI device support (此项不选的话,下面两项就选择不上)
Device Drivers ---><*>SCSI device support ---><*>SCSI disk support
Device Drivers---><8>SCSI device support--->SCSI low-level drivers---><*>; BusLogic SCSI support

三、编译工作
OK,繁杂的配置工作完成了,至此,编译前的准备工作都做好了!

9、开始编译啦……
在/usr/src/linux-2.6.18目录下,执行以下命令即可编译。编译需要一段时间,给自己倒杯茶耐心等候吧!
# make dep (建立编译时所需的从属文件。注意:如果内核从未编译过,此步可跳过)
# make clean (清除内核编译的目标文件。注意:如果内核从未编译过,此步可跳过)
# make bzImage (注意大小写。这一步才是真正编译内核)
内核编译成功后,会在/usr/src/linux/arch/i386/boot目录中生成一个新内核的映像文件bzImage。如果用make zImage编译,内核很大的话,系统会提示你使用make bzImage命令来编译,所以我直接用make bzImage来编译。
# make modules (编译可加载模块)
# make modules_install (安装可加载模块)
安装成功后,系统会在/lib/modules目录下生成一个2.6.18子目录,里面存放着新内核的所有可加载模块。
# make install (安装新内核)

注意:
make install的时候可能会出现如下错误信息:
No module BusLogic found for kernel 2.4.12
mkinitrd failed
此问题一般只出现在SCSI硬盘+VMWARE+REDHAT架构中,因为BusLogic被编译进了内核而不是一个module的形式(2.4内核的Buslogic模块即使静态编译进内核也不行)。解决方式是直接将BusLogic.o文件复制过去:
# cp /usr/src/linux-2.6.18/drivers/scsi/BusLogic.o /lib/modules/2.6.18/kernel/drivers/scsi
不过别忘记,复制过后再执行一下make install。这一步若卡住了,下面的都无法进行。

四、启动新内核
10、将新内核和System.map文件拷贝到/boot目录下,依次执行以下命令:
# cp /usr/src/linux-2.6.18/arch/i386/boot/bzImage /boot/vmlinuz-2.6.18
# cp /usr/src/linux-2.6.18/System.map /boot/System.map-2.6.18
# cd /boot (进入boot目录)

# rm –rf System.map (删除原来的连接)
# ln –s System.map-2.6.18 System.map (重新建立连接)

11、修改Grub启动管理器
如果没有错误的话, 下面开始修改grub配置文件(不要告诉我你用的lilo)
在/boot目录下,执行以下命令:
# new-kernel-pkg --mkinitrd --depmod --install 2.6.18 (这时候你的/boot下会生成一个initrd-2.4.18.img,并且你的grub.conf文件也作了相应更改)

# df (查看根目录在那个分区,下一步要用到。注意,这里根分区不时boot的那个50M的分区,而一般是你最大的那个分区,也就是“/”,千万不要搞错哦。我的为 /dev/hda2)

# vi /grub/grub.conf
进入grub.conf文件,找到如下信息:
default=1
timeout=10
splashimage=(hd0,0)/grub/splash.xpm.gz
title Red Hat Linux (2.6.18)
root (hd0,0)
kernel /vmlinuz-2.6.18 ro root= LABEL=/
initrd /initrd-2.6.18.img

做两处修改:
(1) 将default=1改为default=0(不改的话也可以,只不过重启之后会默认进入2.4内核)
(2) 将kernel行的“LABEL=/”换成根目录所在的分区(上一步查看的就是)
此步很重要,修改错误将可能导致进不去系统,我把我修改后的grub.conf文件列出来,不明之处,可以对照修改:
default=0
timeout=10
splashimage=(hd0,0)/grub/splash.xpm.gz
title Red Hat Linux (2.6.18)
root (hd0,0)
kernel /vmlinuz-2.6.18 ro root=/dev/hda2
initrd /initrd-2.6.18.img
title Red Hat Linux (2.4.20-8)
root (hd0,0)
kernel /vmlinuz-2.4.20-8 ro root=LABEL=/
initrd /initrd-2.4.20-8.img

12,OK,大功告成!赶快重启,看看升级后的2.6内核吧。

根据以上内容重启后有如下问题:

A 不能上网

#vi /etc/modules.config

修改第一行如下:

alias eth0 pcnet32

重新激活网卡就行了。

posted @ 2009-08-04 19:43 chaosuper 阅读(283) | 评论 (0)编辑 收藏

 

1、Harbin 哈尔滨赛区(哈尔滨工业大学)
网络选拔赛日期:2009年9月13日 14:00-17:00
现场赛日期:2009年9月26日~27日
http://acm.hit.edu.cn/

2、Dhaka 达卡赛区(孟加拉国 Northsouth University)
现场赛日期:2009年10月3日
http://www.northsouth.edu/acm/

3、Gwalior-Kanpur 瓜廖尔-坎普尔赛区(印度 IIITM Gwalior and Indian Institute of Technology, India)
现场赛日期:2009年10月3日~4日
http://www.cse.iitk.ac.in/users/acm/

4、Hefei 合肥赛区(中国科学技术大学)
网络选拔赛日期:2009年9月6日 14:00-17:00
现场赛日期:2009年10月10日~11日
http://acm.ustc.edu.cn/

5、Ningbo 宁波赛区(浙江大学宁波理工学院)
网络选拔赛日期:2009年9月12日
现场赛日期:2009年10月17日~18日
http://acmasia09.nit.net.cn/

6、Jakarta 雅加达赛区(印尼 Binus University)
现场赛日期:2009年10月21日
http://icpc.ewubd.edu/

7、Manila 马尼拉赛区(菲律宾 Ateneo de Manila University)
现场赛日期:2009年10月22日~23日
http://www.math.admu.edu.ph/acm/

8、Shanghai 上海赛区(东华大学)
网络选拔赛日期:2009年9月20日(12:00-17:00)
现场赛日期:2009年10月24日~25日
http://acm.dhu.edu.cn

9、Hsinchu 新竹赛区(交通大学)
报名截止日期:2009年8月19日
现场赛日期:2009年10月30日~31日
http://icpc2009.nctu.edu.tw/

10、Wuhan 武汉赛区(武汉大学)
网络选拔赛日期:2009年10月3
现场赛日期:2009年10月31日~11月1日
http://acm.whu.edu.cn/

11、Amritapuri 阿姆里塔普里赛区(印度 Amrita Vishwa Vidyapeetham, Amritapuri Campus)
现场赛日期:2009年11月1日
http://icpc.amrita.ac.in/

12、Phuket 普吉岛赛区(泰国 Prince of Songkla University, Phuket Campus)
报名截止日期:2009年9月30日
现场赛日期:2009年11月3日~4日
http://www.acmicpc-thailand.org/

13、Seoul 首尔赛区(韩国 Korea Advanced Institute of Science and Technology)
报名截止日期:2009年9月11日
现场赛日期:2009年11月5日~6日
http://acm.kaist.ac.kr/

14、Tehran 德黑兰赛区(伊朗 Sharif University of Technology)
现场赛日期:2009年11月6日
http://sharif.edu/~acmicpc

15、Tokyo 东京赛区(日本早稻田大学)
现场赛日期:2009年11月7日~8日
http://www.waseda.jp/assoc-icpc2009/en/index.html

参赛报名网址

http://cm.baylor.edu/welcome.icpc

亚洲高校可组队参加全部十五个赛区的预选赛,但每位参赛选手最多只能注册参加两个赛区的预选赛。

posted @ 2009-08-04 19:36 chaosuper 阅读(242) | 评论 (0)编辑 收藏

学习站点  http://doc.linuxpk.com/type1091.html 

Emacs 的命令通常包括控制键(就是上面标有 Ctrl或Ctl的那个)或者是META键(上面标有EDIT或ALT)。为了方便起见我们将用下面的缩写来代替这些键的全称:

C- 意思是当敲入字符 时同时按住控制键,因此,C-f表 示:按住控制键并且按 f 。 M- 表示当键入 时按住META或ALT或EDIT键。如果没有META 或ALT或EDIT键,则用ESC键代替。 表示ESC键

注意:退出Emacs,按C-x C-c(两个字符)。在文本左边区域的“>>”符号表示让你试着使用一个命令。比如:
>> 现在键入C-v(观看下一屏)移动到下一屏。(就象前面说的,按v的同时也按住控制键)。从现在开始,每当你读完一屏的时候都可以用它来翻屏。
注意在翻屏后会保留上屏的最后一行;这是为你继续阅读文本提供某些连贯性。
你所需要知道的第一件事是如何把光标从一个地方移动到另一个地方。你已经知道了如何向前翻一屏--用 C-v。要向后翻一屏,键入M-v。
>> 试着键入 M-v 和 C-v 几次。
* 摘要(SUMMARY)
---------------------------
下面几个命令对整屏观看时有用:

C-v 向前翻一整屏。
M-v 向后翻一整屏。
C-l 清除屏幕并重新显示所有的文本,然后把光标移动到屏幕的中央。 (注意是Control-L,而不是 Control-1)。
>> 寻找光标,并且注意它在文本里的位置。然后键入C-l。再寻找光标你会注意到光标现在会出现在同样的文本附近。
* 基本光标控制(BASIC CURSOR CONTROL)
-----------------------------------------------------------------
整屏整屏的移动是很有用的,可是如何把光标移动到屏幕上文本里的一个指定的地方呢?
有好几个方法可以实现。最基本的方法是用命令 C-p,C-b,C-f,和C-n。这些命令每个都使光标在屏幕上往特定的方向移动一行或者一列。下面是一个图表显示了这四个命令和它们所移动的方向:


上一行,C-p
:
:
向前,C-b ...... 当前光标的位置 ...... 向后,C-f
:
:
下一行,C-n
>> 用C-n或C-p把光标移动到图表中间。然后键入C-l会看到整个图表出现在屏幕的中央。



你也许会发现这些字母很容易记住:P 代表上面的(previous),N 代表下一个 (next),B 代表向前(backward),F 代表向后(forward)。这些是基本的光标位置命令,你将经常会用到它们。所以现在学习它们很有好处。


>> 用几次 C-n 把光标向下移动到这一行。

>> 用 C-f 把光标移动到行里,再用C-p把光标上移。观察当光标在行的中间时 C-p做了些什么。
每一个文本行都以一个换行符结尾,它用来当作行与行之间的分格。你的文件的最后一行的尾部应该有一个换行符(但Emacs并不要求一定要有一个)。
>> 试着在行的开头使用C-b。它将会把光标移到上一行的末尾。这是因为它向后移的时候穿过了换行符。
C-f 也能象 C-b一样穿过换行符。
>> 使用几次C-b,使您能知道光标在哪。然后用C-f移动到行的末尾。然后再用一次C-f,使光标移动到下一行。

当你移动超过屏幕的顶部或底部,光标回移动到下一屏的中间,这叫做“滚屏 (scrolling)”。它使得Emacs滚屏移动到文本上指定的部位而不是移出屏幕。

>> 试着用C-n把光标移过屏幕的底部,看看回发生什么。

如果觉得一个一个字符的移动太缓慢,可以一个单词一个单词的移动。M-f(Meta-f) 向前移一个单词,M-b向后移一个单词。
>> 键入几个M-f和M-b。

当光标在一个单词的中间,M-f移动到单词的末尾。当光标在两个单词间的空白部分 M-f移动到后一个单词的末尾。M-b与M-f一样,只是移动的方向相反。
>> 键入M-f和M-b几次,中间穿插一些C-f和C-b以使你能观察到M-f和M-b在单词中和单词间的不同行为。

注意比较C-f,C-b与M-f,M-b。通常情况下Meta键用于有关语言单位(词,句,段落) 的操作;而控制键用于编辑时的基本单位(字符,行等)。
这是句与行的比较:C-a和C-e移动到一行的开头和末尾,M-a和M-e移动到一个句子的开头和末尾。
>> 键入一对C-a,再键入一对C-e。 键入一对M-a,再键入一对M-e。

你会看到重复键入的C-a什么也不做,而重复键入的M-a则会移动一个以上的句子。
光标在文本中的位置也叫“点(point)”。在段落里,光标标示出了点在屏幕上文本里的位置。
下面是简单的光标移动命令的总结,包括单词和句子的移动命令:

C-f 向前移动一个字符。
C-b 向后移动一个字符。

M-f 向前移动一个单词。
M-b 向后移动一个单词。

C-n 移动到下一行。
C-p 移动到上一行。

C-a 移动到行首。
C-e 移动到行尾。

M-a 向前移动到句子的开头。
M-e 向后移动到句子的末尾。

>> 试着对每一个命令都实践几次,它们都是经常要用到的命令。
另外两个重要的光标移动命令是M-<(Meta小于),它移动光标到整个文本的开头,M-> (Meta大于)它移动光标到整个文本的末尾。
在多数终端上,“<”在逗号的上面,所以你必须用Shift键来输入它。在这些终端上,你也必须用Shift键来输入M-<;没有Shift键,你可以输入M-逗号。
>> 现在就试试M-<,移动到本教程的开头,然后再用C-v移回这里。 现在就试试M->,移动到本教程的末尾,然后再用M-v移回这里。

你也可以用方向键来移动光标,如果你的终端有方向键的话。我们建议学习C-b, C-f,C-n和C-p有三个原因。第一,它们能在所有类型的终端上工作。第二,你获得了使用Emacs的锻炼,你将会发现输入这些CTRL加字符比按方向键要快(因为你不必把你的手从键盘上移开)。第三,一旦你养成了使用这些CTRL加字符的命令的习惯,你就能一样容易的学习其他高级的光标移动命令。
大多数Emacs命令接收一个数字参数;对大多数命令来说,这表示命令重复的次数。输入重复命令次数的方法是在输入命令之前按C-u和数字。如果你有META(或EDIT或 ALT)键,则有另一种方法输入数字参数:在按住META键的时候输入数字,我们建议学习C-u方法,因为它能在任何终端上工作。
例如,C-u 8 C-f 向前移动8个字符。
>> 试着使用带数字参数的C-n或C-p,只用一个命令就把光标移动到与本行相邻的 行上。

绝大多数命令把数字参数当作重复次数,但也有几个例外。C-v和M-v就是。当给出一个参数,只是上滚或下滚数字指定的行数而不是屏数。比如,C-u 4 C-v滚动4行屏幕。


>> 现在试试 C-u 8 C-v。
这将使屏幕滚动8行,如果你想往回滚动的话,键入一个带参数的M-v。
如果你正在使用X窗口,在Emacs窗口的左手边有一个叫做滚动条的矩形区域。你能通过用鼠标点击滚动条来滚动文本。
>> 试着在滚动条顶部的高亮区域点击中键。这将使文本滚动,滚动的位置取决于 你点击的长短。

>> 试着按住鼠标中键上移或下移鼠标,你将看到当你移动鼠标时文本会上下滚动。
* 当EMACS挂起时(WHEN EMACS IS HUNG)
------------------------------------------------------------------
当Emacs停止响应你的命令时,你能用C-g把它安全的停止。当一个命令执行了太长的时间时你可以用C-g把它终止。
你也可以用C-g来取消数字参数和输入后又不想执行的命令。
>> 键入C-u 100 产生一个值为100的数字参数,然后按C-g。再按C-f。它只会移动 一个字符,因为你用C-g取消了参数。


如果错误的输入了一个 ,你能用C-g消掉它。
* 禁止命令(DISABLED COMMAND)
----------------------------------------------------
一些Emacs命令是“禁止”的,所以新手不会因偶然而执行它。
如果你键入了一个禁止命令,Emacs会显示一条消息说明这条命令是干什么的,并且问你是否需要执行它。
如果你真的想要执行,敲空格键继续。通常,如果你不想执行禁止命令,用“n”来回答。

>> 输入 :(一条禁止命令),然后用n来回答。

* 窗口(WINDOWS)
-----------------------------
Emacs 能有好几个窗口,每一个显示自己的文本。我们将在后面解释怎样对多窗口操作。现在我们要解释怎样去除多余的窗口屏回到基本的单窗口编辑状态。这是一个例子:
C-x 1 一个窗口(也就是除去其他所有的窗口)。
因为Control-x跟了数字1。C-x 1使包含光标的窗口占满整个屏幕,屏删除其他所有窗口。
>> 把光标移动本行并输入 C-u 0 C-l。
>> 键入Control-h k Control-f。 看这个窗口如何缩小,并在按Control-f的时候出现了一个新的文档窗口。
>> 键入C-x 1 并且看到那个文档窗口消失了。

* 插入和删除(INSERTING AND DELETING)
---------------------------------------------------------------
如果你要插入文本,只须输入文本。输入的字符你能见到,比如A,7,*等等。Emacs 会立即把它们插入。键入 (回车键)插入一个换行符。
你能用 删除你输入的最后一个字符。 就是键盘上标着“Del”的键。在某些情况下,“Backspace”键作用和 一样,但不总是这样!


通常, 立即删除光标前面的那个字符。


>> 输入几个字符,然后用 删除它们。不必担心这个文件回被改变;你不会 替换主教程。这只是你的个人拷贝。

当一行文本太长而超过屏幕宽度时,这一行会在屏幕的下一行被“继续”。文本的右边会有一个反斜杠“”表示它被继续。
>> 插入文本直到最右边,然后再插入。你将看到一个继续了的行。
>> 使用 删除文本直到行的长度在屏幕的宽度以内。继续的行将会消失。

你能像删除其他任何字符一样删除换行符。删除两个行间的换行符会使它们合并为一行。如果这一行很长屏幕显示不下的话,将会用一个继续的行来表示。
>> 把光标移动到一行的开头按 这将使本行和上一行合为一行。
>> 按 重新插入你删除的换行符。

记住大多数的Emacs命令能接收一个重复次数。这包括文本字符,把一个文本字符重复的插入几次。
>> 键入这个-- C-u 8 * 来插入 ********

你现在已经学习了Emacs的大多数输入和排错的方法。你也能一样的删除单词或行。这是删除操作的摘要:
删除光标前面的字符
C-d 删除光标后面的字符
M- 除去光标前面的单词
M-d 除去光标后面的单词
C-k 除去从光标位置到行尾的内容
M-k 除去到当前句子的末尾
注意比较 ,C-d与M ,M-d和C-f,M-f( 不是一个控制字符,但不用担心)。C-k和M-k就象C-e,M-e。
当你一次除去不止一个字符时,Emacs将保存着这些文本,所以你可以恢复它们。恢复那些被除去的文本称作“拉(yanking)”。你能在除去文本的同一地方拉回它们,或是在文本的其他地方。你能对文本拉上几次以产生它们的多个拷贝,拉的命令是 C-y。
注意“除去(killing)”与“删除(Deleting)”之间的区别,被除去的东西能被拉回来,而被删除的不能。通常除去能除去很多的文本屏保存,而删除只能除去一个字符,或是空行或空格,并且不保存。


>> 把光标移到一个空行的开头,键入C-k除去这一行。
>> 按第二次C-k,你将看到剩下的空行也被除去了。



注意单个的C-k除去行的内容,第二个C-k除去行本身,并且使后面的所有行上移。特别要注意数字参数:它除去很多行和它们的内容,这不仅仅是重复。C-u 2 C-k 除去两行和它们剩下的空行;而按两次C-k并不会这样做。


要在当前光标处找回上次被除去的文本;按C-y


>> 试一试,用C-y把文本拉回来。



把C-y考虑为你把某人从你这里拿走的东西再拿回来。注意你如果在一行上按了几次 C-y,所有被除去的文本是存在一起的,所以按一次C-y将拉回全部的行。


>> 现在就试一下,按几次C-k。 现在找回被除去的文本;


>> 按C-y。然后把光标下移几行再按一次C-y,你现在会看到怎样拷贝这些文本。



当你要拉回一些被除去的文本该怎样做呢?C-y只能拉回最近被除去的文本。但以前的文本并没有消失。你能用M-y来恢复它。当你用C-y拉回最近被除去的文本后,换成 M-y可以拉回以前被除去的文本。键入一次又一次的M-y可以拉回更早以前被除去的文本。当你找到要寻找的文本,不必做任何事来保持它,只须离开拉文本的地方继续你的编辑。


如果你M-y了足够多的次数,你会回到开始点(最近被除去的)。


>> 除掉一行,移开,再除掉另一行。 然后用C-y拉回第二行。 然后换成M-y拉回被除掉的第一行。 再按一次M-y看看得到了什么。继续按直到拉回被除去的第二行;然后再做几次。 如果原意的话,你可以给M-y加正的或负的数字参数。





* 撤销(UNDO)
--------------------



如果你对文本作了一些改动,然后又发现这样做是错误的,你能用撤销命令,C-x u 撤销这些改变。


通常,一次C-x u撤销一个改变;如果你在一行上重复几次C-x u,就会重复几次撤销操作。


但有两个例外:不改变文本的操作(包括光标移动和滚屏命令)不算在内;只能处理20 次。


>> 用C-k除去这一行,然后按C-x u 它将重现出来。



C-_是一个可选择的撤销命令;它所作的工作和C-x u 完全一样,只是更容易输入。 C-_的缺点是有些键盘上没有它,这就是为什么还提供C-x u的原因。在某些终端上你可以按住CTRL的时候再敲/来输入C-_。C-_或C-x u把数参数字当作重复次数。


* 文件(FILES)
-------------------

为了永久保存你编辑的文本,你必须把它放到一个文件里。否则当你退出Emacs的时候它就会消失。你通过“查找(finding)”文件,把你编辑的内容放到文件里。(也称为 “访问(visiting)文件”)。


(译注:为了保持与原文的一致性,把find译为“查找”,但是这里和后面出现的 “查找文件”指的都是打开文件的意思。)


查找(finding)一个文件意味着你在Emacs里看文件的内容,在多数情况下,也就是你在编辑它。但是,你用Emacs对它作的改变并不是永久行的,除非你“保存(saving)” 它。所以你可以避免把一个改了一半的文件留在系统上。甚至你保存了文件,Emacs也会把原始文件换个名字保留下来,以防过后你发现对文件的改动是错误的。


如果你观察屏幕的你将看见一个开始和结尾都是破折号的行,并且以“--:**-- TUTORIAL”或之类的东西开始。屏幕的这部分通常显示你正在访问的文件的名字。现在,一个叫做“TUTORAL”的文件,它是你的Emacs教程的个人拷贝。当你用Emacs 查找一个文件,文件名会出现在同样的位置。


查找和保存文件命令不像前面学的那些命令。它们都以字符Control-x开始。以 Control-x起头的是一个完整的命令系列;它们中的许多都是对文件,缓冲,和相关的东西进行操作的。这些命令有两个,三个或四个字符长。


关于查找文件命令的另一件事是你必须给出你需要的文件的文件名。我们说这个命令 “从终端读取一个参数”。(在这种情况下,参数是文件的名字);当你键入命令C-x C-f后,Emacs会提示你输入文件的名字。你输入的文件名会出现在屏幕底部的行上。这个底部的行称为微型缓冲(minibuffer)用于这类较短的输入。你能用Emacs本身的编辑命令来编辑文件名。


当你正在输入文件名(或其他任何微型缓冲区输入),你能用命令C-g来取消。


>> 键入命令C-x C-f,然后输入C-g。这将取消微型缓冲,也取消了C-x C-f命令所使 用的微型缓冲,所以你不查找任何文件。



当你输完文件名后用 来结束。然后C-x C-f开始工作,并开始寻找你所选择的文件。当C-x C-f命令结束后微型缓冲区也消失了。


过一小会儿文件的内容就会显示在屏幕上,然后你就能对它进行编辑了。当想永久保留你的改动时用命令:


C-x C-s 保存文件(save the file)。


这个操作会把Emacs里的文本拷贝到文件里。在你第一次作的时候,Emacs把原始文 件改为一个新名字以使它不至于丢失。新名字是在原来名字的后面加一个“~”。


保存结束后,Emacs打印出被写的文件的文件名。你应当经常的保存,万一系统崩溃 的话你不至于丢失太多的工作。


>> 键入C-x C-s来保存你的教程的拷贝。屏幕的底部会打印出“Wrote.....TUTORIAL”。



注意:在某些系统上,输入C-x C-s 会把屏幕冻结住使你从Emacs看不到更多的输出。这 表示这个操作系统的“特性”叫做“控制流程”,它拦截了C-x不让它到达Emacs那里。 要使屏幕解冻,输入C-q,然后看Emacs手册里的“Spontaneous Entry to Incremental Search”一节,按上面的建议来对付这种“特性”。


你能查找一个已存在的文件,来查看它或编辑它。你也可以查找一个尚未存在的文件。这是 Emacs:里创建文件的方法:查找文件,将会出现一个空白,然后插入文件的文本。当你 “保存(saving)”的时候,Emacs将会用你插入的文本创建文件。从那时候起,你可以认为你在编辑一个存在的文件了。




* (缓冲)BUFFERS
--------------------------



如果你用C-x C-f查找第二个文件,第一个文件仍然留在Emacs里。你可以再用C-x C-f查找一次来切换回去。用这种方法你在Emacs里有很多文件。


>> 输入C-x C-f foo 来建立一个名为foo的文件。然后插入一些文本,编辑它,并 用C-x C-s来保存“foo”。 最后输入C-x C-f TUTORIAL 以回到本教程。




Emacs把每个文件的文本都保存在一个叫“缓冲(buffer)”的东西里。查找(打开)一个文件就会在Emacs里产生一个新的缓冲。要看你当前运行的Emacs里存在的缓冲列表,输入:


C-x C-b 列出缓冲(list buffers)


>> 输入 C-x C-b



观察每个缓冲都有一个名字,它可能也有一个它所保存的文件的文件名。一些缓冲不对应文件。比如,叫“*Buffers List*”的缓冲没有任何文件。这个缓冲只包含由C-x C-b产生的缓冲列表。你在Emacs窗口里看到的任何文本都是某个缓冲的一部分。


>> 输入 C-x 1 消除缓冲列表。



如果你对一个文件的文本作了改动,然后查找另一个文件,第一个文件并不保存。它的改变保存在Emacs里,在那个文件的缓冲里。被建立或编辑的第二个文件的缓冲并不影响第一个的。这一点很有用,但这也意味着要有一个便捷的方法来保存第一个文件的缓冲。如果要用 C-x C-f切换回去只是为了按C-x C-s保存它将会是一件令人讨厌的事。所以我们用


C-x s 保存缓冲(save the buffer)


C-x s 向你询问每个改动过但未存盘的缓冲,对每个这样的缓冲都询问是否保存。


>> 插入一行文本,然后按C-x s。 将会问你是否保存叫TUTORIAL的缓冲。 输入“y”来回答是。





* 扩展命令集(EXTENDING THE COMMAND SET)
-----------------------------------------------------------------------



有太多的Emacs命令,大大超过了Contorl和meta加上字符所能表示的数量。Emacs用X(扩展 eXtand)命令来解决这个问题。有两种风格:


C-x 字符扩展,后跟一个字符。
M-x 名字命令扩展,后跟一个长名字。


这些命令通常有用,但不如你已经学过的那些命令使用的频繁。你已经见过了它们中的两个:文件命令C-x C-f 用于查找和C-x C-s用于保存。


另一个例子是结束Emacs的命令C-x C-c(不必担心你所作的改动会丢失,在退出Emacs 之前,C-x C-c会提示你保存每一个改动过的文件)。


C-z命令用于*临时*退出Emacs,所以你能回到原来运行的Emacs里。在允许这样做的系统上,C-z把Emacs“挂起”;就是说回到外壳(shell)下,但并不破坏运行的Emacs。在大多数外壳上,你能用‘fg'命令或‘%emacs'来继续Emacs。


在不支持挂起的系统上,C-z建立一个子外壳(subshell)运行于Emacs下以使你能运行其他程序然后回到Emacs;这并不是真正的“退出”Emacs。在这种情况下,通常从子外壳回到Emacs的外壳命令是‘exit'。 有很多C-x 命令,这是已学过的一个列表:


C-x C-f 查找文件
C-x C-s 保存文件
C-x C-b 缓冲列表
C-x C-c 退出Emacs


C-x u 撤销操作


被称作扩展命令的命令的使用频率都不太高。或者是只在某些模式下使用。一个例子是替换字符串的命令,它在全文里把字符串替换为其他的。当你键入M-x, Emacs会在屏幕的底部提示你输入命令;在这种情况下,是“replace-string”。比如输入“repl s ”, Emacs会把命令补全。用 来结束命令。


替换字符串命令要求两个参数--要被替换的字符串和用来替换的字符串。你必须用 来结束两个参数。


>> 把光标移上两行,然后输入M-x repl s changed altered 。 注意现在这一行改变了:你把光标初始位置后的所有单词c-h-a-n-g-e-d替换为了 “altered”





* 自动保存(AUTO SAVE)
------------------------------------



当你改动了一个文件还未存盘的话,所作的改动也许会由于系统崩溃而丢失。为防止这种情况发生,Emacs在编辑时为每个文件提供了“自动保存(auto save)”。自动保存的文件的文件名前后都有一个#号;例如,如果你编辑的文件名叫“hello.c”,自动保存的文件的文件名就叫“#hello.c#”。当你正常的保存了文件后,Emacs会删除这个自动保存的文件。如果遇到死机,你能打开那个文件后按M-x recover file 来恢复你的编辑,(是你编辑的文件而不是自动保存的文件)。当提示确认时,输入yes 来继续恢复自动保存的数据




* 回显区域(ECHO AREA)
------------------------------------



如果Emacs发现你输入命令的速度很慢的话它会在屏幕底部为你显示出来,这个区域叫 “回显区域”。




* 模式行(MODE LINE)
---------------------------------



回显区域上面的一行称为“模式行(mode line)”。模式行显示与下面类似的东西:


--**-Emacs: TUTORIAL (Fundamental)--L670--58%----------------


这一行给出了有关你在编辑的文件和Emacs状态的有用信息。


你已经知道了文件名意味着什么。--NN%--指出你现在在文本里的位置;它意味着上面还有NN%的文本。如果是在文件的开头,会用--Top-- 来代替--0%--。如果是在行的末尾,会显示--Bot--。如果你正在看的文本内容很少,可以全部显示在屏幕上,模式行会说 --All--。


前面的星号表示你已经改动过文本了。一旦你保存了文件或打开了一个新文件,模式行的这部分就不是星号而是破折号了。


模式行上括号里的部分是现在的编辑模式。现在是缺省的基本(Fundamental)模式。它是 “主模式(major mode)”的一种。


Emacs有很多不同的主模式。有些意味着不同的语言或不同的文本。如Lisp模式(Lisp mode),文本模式(text mode)等等。在任何时候有且只能有一种主模式被激活。并且它的名字会出现在现在显示“Fundamental”的位置上。


每一个主模式都有些自己的命令。就象不同的编程语言的注释看起来不同一样。每种主模式插入的注释也不同。可以用扩展命令切换进某种主模式。例如,M-x fundamental-mode 是切换进基本模式。


>> 输入 M-x text-mode



不必担心,没有命令会给Emacs带来很大改变。但是你可以看到现在M-f和M-b把省略号当作单词的一部分。而先前,在基本模式里,M-f 和M-b把省略号当成当成分隔符。


主模式通常作诸如此类微小的变化:大多数命令在每个主模式里作“同样的工作”,但又有些微小的不同。


要观看关于你现在的主模式的文档,按C-h m。


>> 键入C-u C-v一次和多次使本行接近屏幕的顶端。
>> 输入C-h m ,看看文本模式和基本模式有些什么不同。
>> 按C-x 1 从屏幕上关掉这个文档。



主模式之所以叫做主模式是因为也存在从模式,从模式与主模式完全不同。每个从模式可以自己打开或者关闭,独立于所有其他从模式,也独立于你的主模式。所以你可以不用从模式或者同时用很多种从模式。


有一种从模式很有用,特别是在编辑英文文本时。它是自动填充模式(auto fill mode)。当这个模式打开的时候,当输入的文本过宽的时候就会自动折行。


你能用M-x auto-fill-mode 来打开自动填充模式。如果此模式已经打开M-x auto- fill-mode 则把它关闭。我们把这叫做切换开关。


>> 输入M-x auto-fill-mode 。然后插入一些“asdf”直到看到这行被分为两行。你必须在中间放一些空格,只有到空格的时候才会换行。



通常边界宽度是70,但你能用带数字参数的C-x f 命令来改变它。


>> 键入带参数20的C-x。(C-u 20 C-x f) 然后输入一些文本看现在每行只有20个字符了。然后用C-x f把它改回70。



如果你在一个段落的中间产生了改变,自动填充模式将不会重新填充。要想重新填充段落,当光标在段落里的时候按M-q。


>> 把光标移到上一段按 M-q。

* 搜索(SEARCHING)
-----------------------------

Emacs 能朝前和朝后搜索字符串(指相邻的一些字符或单词)。搜索是一个移动光标的操作,它把光标移动到字符串出现的下一个地方。


Emacs 的搜索命令和其他大多数编辑器不同,它是“增量式(incremental)”的,这意味着搜索在你键入字符串时就开始了。


开始一个向前搜索的命令是C-s,C-r是往回搜索。但等等,先别忙。


当你输入C-s是你将注意到在回显区域会出现一个字符串“I-search”。这告诉你Emacs开始了一个增量搜索,并在等待你输入要搜索的东西。 结束查询。


>> 现在键入C-s开始一个搜索。慢慢的输入单词‘cousor',在输入每一个字母的时候停顿一 下,注意看光标发生了什么。
>> 再输入一次C-s,来搜索“cursor”出现的下一个地方。
>> 现在输入 四次看看光标移到了哪里。
>> 输入 结束搜索。


看到发生什么了吗?在Emacs的增量搜索里,你输入多少字符串它就试着搜索这些字符出现的地方。到字符串出现的下一个地方,只须再按一次C-s。要搜索的字符串不存在的话,Emacs 会发出蜂鸣并告诉你当前的搜索“失败(failing)”,按 C-g 也是终止搜索。


注意:在某些系统上,输入 C-s 会把屏幕冻结住使你从Emacs看不到更多的输出。这 表示这个操作系统的“特性”叫做“控制流程”,它拦截了C-s不让它到达Emacs那里。 要使屏幕解冻,输入C-q,然后看Emacs手册里的“Spontaneous Entry to Incremental Search”一节,按上面的建议来对付这种“特性”。
如果你在搜索的过程里按了 ,你将注意到要搜索的字符串的最后一个字符会被删除并且光标会回到上一个被搜索到的地方。比如,假设你键入了“c”,将会搜索“c”第一次出现的地方。然后如果你键入“u”,光标将移到“ cu”第一次出现的地方。现在键入 。这将从搜索的字符串里把“u”删掉,这时光标回到“c”第一次出现的地方。


如果你在搜索时按了Control或meta键加字符(少数几个少数命令例外,如C-s和C-r),搜索将被终止。


C-s向当前光标的后面搜索字符串出现的地方。如果你需要搜索前面文本里的东西,用C-r来代替。我们所介绍的C-s的每个特性C-r也支持,除了方向相反。


* 多窗口(MULTIPLE WINDOWS)
------------------------------------------------


Emacs有一个非常好的特性是能同时在屏幕上显示不止一个的窗口。


>> 把光标移到本行上按C-u 0 C-l。


>> 现在按C-x 2,它把屏幕分裂成两个窗口,每个窗口都显示本教程。光标在上面的窗口里。


>> 按C-M-v 滚动到下面的窗口里。(如果你没有一个真正的Meta键,那么按ESC C-v)

>> 按 C-x o (“o” 指 “其他(other)”) 把光标移到到下面的窗口里。
>> 用 C-v 和 M-v 滚动下面窗口里的文本。 在上面的窗口里看本教程。


>> 再次按 C-x o 使光标回到上面的窗口里。 现在光标象以前一样在上面的窗口里了。



你能一直用C-x o在窗口间切换。每个窗口都有它自己的光标位置,但仅有一个窗口能显示活动的光标。所有的编辑命令都发生在那个显示光标的窗口上。我们把这个窗口叫做“选中窗口( selected window)”。


当你在一个窗口里编辑文本,而用另一个窗口作参考时命令C-M-v非常有用。你总是能把光标留在所编辑的地方,而用C-M-v来翻阅另一窗口。


C-M-v 是 CONTROL-META 加字符的一个例子。 如果你有一个真正的META 键,你能同时按住 CTRL 和 META 再按“v”来输入C-M-v。CTRL 和 META 谁先按谁后按无所谓。


如果你没有一个真正的META 键, 你可以用 ESC 来代替。这时候次序是有关系的: 你必须让 ESC 跟在 CTRL-v后面; 否则 CTRL-ESC v 将不工作。 这是因为 ESC 是一个有意义的字符而不是一个修饰字符。


>> 输入 C-x 1 (在上面的窗口里) 以消除下面的窗口。



(如果你在下面的窗口里键入C-x 1,将会把上面的窗口去掉。可以把这个命令看作是“只保留你现在在的那个窗口。)


你不必一定要在两个窗口里显示同样的缓冲。如果你在一个窗口里键入C-x C-f查找文件,另一个窗口的内容不会改变。你能独立的在每个窗口里查找文件。


这是让两个窗口显示不同内容的另一种方法:


>> 在你输入的文件名后再输入C-x 4 C-f,然后用 结束。会看到指定的文件出现在下面 的窗口里。光标也在那里面。


>> 键入C-x o 回到上面的窗口,然后输入C-x 1删掉下面的窗口。



* 递归编辑层(RECURSIVE EDITING LEVELS)
----------------------------------------------------------------

有时候你会进入“递归编辑层(recursive editing level)”。由模式行上的方括号指示。它在主模式名的括号外面。例如你也许会看到(Fundamental)变成了[(Fundamental)]。


要退出递归编辑层,按ESC ESC ESC。这是一个通用的退出命令,你也可以用它除去额外的窗口,或者退出微型缓冲。


>> 输入 M-x 进入一个微型缓冲; 然后用 ESC ESC ESC 离开。

你不能用C-g来退出递归编辑层。这是因为C-g只能取消在递归编辑层里面的命令。


* 获取更多的帮助(GETTING MORE HELP)
--------------------------------------------------------------

在本教程里我们试着为你开始使用Emacs提供了足够多的信息。但是有关Emacs的信息实在是太多以至于不能全部都在这里说明。但是,你还应该学习更多有关Emacs的东西,因为它另外还有很多有用的特性。Emacs提供了很多读取有关命令的文档的命令。这些“帮助”命令都以 Control-h开头,叫做“帮助字符”。


为了使用帮助特性,输入字符C-h,然后再输入一个字符来说明你需要哪种帮助。如果你真的不知道,输入C-h ? 然后 Emacs会告诉你它能给你什么样的帮助。如果你输入了C-h 又觉得不需要任何帮助,你可以用C-g来取消它。


(在有的地方,C-h的作用被改变了。如果按C-h在屏幕的底部没有出现有关帮助的信息的话,试试用F1和M-x help RET来代替。)


最基本的帮助特性是C-h c。输入C-h,然后是字符 c,然后输入一个命令字符和序列;然后 Emacs 会显示这个命令的简洁的描述。


>> 输入 C-h c Control-p.

显示的消息看起来会象这样:


C-p runs the command previous-line


这告诉你“功能的名字”。功能的名字主要用于对Emacs的功能扩充和定制。但因为功能的名字指出了命令的用途,所以最好不要改动它。


C-h c后面可跟多字符命令,比如 C-x C-s 和 (如果你没有 META 或者 EDIT 或者 ALT 键) v 。


要获取有关命令的更多信息,用C-h k 代替 C-h c。


>> 输入 C-h k Control-p.



这将在一个Emacs窗口里显示命令的文档。当你读完后可以用C-x 1除去帮助文本。如果不想马上离开,你可以一边编辑一边参考帮助文本,然后再按C-x 1。


这是一些有用的 C-h 选项:


C-h f 描述一个功能,在你输入了这个功能的名字后。

>> 输入 C-h f previous-line 。 将打印出C-p命令所实现的所有功能。



C-h a 命令查找。输入一个关键字,Emacs将列出所有名字里有这个关键字的命令。 包括所有以Meta-x开始的命令。对有些命令,C-h a 也将列出实现同一功能的 几个命令序列。


>> 输入 C-h a file .




这将在窗口里显示所有名字里有单词“file”的M-x命令。


>> 输入 C-M-v 来滚动帮助窗口,做上几次。


>> 输入 C-x 1 来删除帮助窗口。





* 总结(CONCLUSION)
--------------------------------

记住,永远都用C-x C-c来退出Emacs。用C-z来退到一个临时的外壳里,以使你过后还能回到 Emacs。
本教程尽量让所有的初学者都能理解,如果你发现有些东西不清楚的话,别责备你自己-抱怨吧!

posted @ 2009-08-04 09:02 chaosuper 阅读(339) | 评论 (0)编辑 收藏

  1.引言

  Linux操作系统在服务器领域的应用和普及已经有较长的历史,这源于它的开源特点以及其超越Windows的安全性和稳定性。而近年来,Linux操作系统在嵌入式系统领域的延伸也可谓是如日中天,许多版本的嵌入式Linux系统被开发出来,如ucLinux、RTLinux、ARM-Linux等等。在嵌入式操作系统方面,Linux的地位是不容怀疑的,它开源、它包含TCP/IP协议栈、它易集成GUI。

  鉴于Linux操作系统在服务器和嵌入式系统领域愈来愈广泛的应用,社会上越来越需要基于Linux操作系统进行编程的开发人员。

  浏览许多论坛,经常碰到这样的提问:“现在是不是很流行unix/linux下的c编程?所以想学习一下!但是不知道该从何学起,如何下手!有什么好的建议吗?各位高手!哪些书籍比较合适初学者?在深入浅出的过程中应该看哪些不同层次的书?比如好的网站、论坛请大家赐教!不慎感激!”

  鉴于读者的需求,在本文中,笔者将对Linux平台下C编程的几个方面进行实例讲解,并力求回答读者们关心的问题,以与读者朋友们进行交流,共同提高。在本文的连载过程中,有任何问题或建议,您可以给笔者发送email:21cnbao@21cn.com,您也可以进入笔者的博客参与讨论:http://blog.donews.com/21cnbao

  笔者建议在PC内存足够大的情况下,不要直接安装Linux操作系统,最好把它安装在运行VMWare虚拟机软件的Windows平台上,如下图:

 

  在Linux平台下,可用任意一个文本编辑工具编辑源代码,但笔者建议使用emacs软件,它具备语法高亮、版本控制等附带功能,如下图:

 

  2.GCC编译器

  GCC是Linux平台下最重要的开发工具,它是GNU的C和C++编译器,其基本用法为:

gcc [options] [filenames]

  options为编译选项,GCC总共提供的编译选项超过100个,但只有少数几个会被频繁使用,我们仅对几个常用选项进行介绍。

  假设我们编译一输出“Hello World”的程序:

/* Filename:helloworld.c */
main()
{
printf("Hello World\n");
}

  最简单的编译方法是不指定任何编译选项:

gcc helloworld.c

  它会为目标程序生成默认的文件名a.out,我们可用-o编译选项来为将产生的可执行文件指定一个文件名来代替a.out。例如,将上述名为helloworld.c的C程序编译为名叫helloworld的可执行文件,需要输入如下命令:

gcc –o helloworld helloworld.c

  -c选项告诉GCC仅把源代码编译为目标代码而跳过汇编和连接的步骤;

  -S 编译选项告诉GCC 在为 C代码产生了汇编语言文件后停止编译。GCC 产生的汇编语言文件的缺省扩展名是.s,上述程序运行如下命令:

gcc –S helloworld.c

  将生成helloworld.c的汇编代码,使用的是AT&T汇编。用emacs打开汇编代码如下图:

 

 


  -E选项指示编译器仅对输入文件进行预处理。当这个选项被使用时,预处理器的输出被送到标准输出(默认为屏幕)而不是储存在文件里。

  -O选项告诉GCC对源代码进行基本优化从而使得程序执行地更快;而-O2选项告诉GCC产生尽可能小和尽可能快的代码。使用-O2选项编译的速度比使用-O时慢,但产生的代码执行速度会更快。

  -g选项告诉GCC产生能被GNU调试器使用的调试信息以便调试你的程序,可喜的是,在GCC里,我们能联用-g和-O (产生优化代码)。

  -pg选项告诉GCC在你的程序里加入额外的代码,执行时,产生gprof用的剖析信息以显示你的程序的耗时情况。

  3.GDB调试器

  GCC用于编译程序,而Linux的另一个GNU工具gdb则用于调试程序。gdb是一个用来调试C和C++程序的强力调试器,我们能通过它进行一系列调试工作,包括设置断点、观查变量、单步等。
其最常用的命令如下:

  file:装入想要调试的可执行文件。
  kill:终止正在调试的程序。
  list:列表显示源代码。
  next:执行一行源代码但不进入函数内部。
  step:执行一行源代码而且进入函数内部。
  run:执行当前被调试的程序
  quit:终止gdb
  watch:监视一个变量的值
  break:在代码里设置断点,程序执行到这里时挂起
  make:不退出gdb而重新产生可执行文件
  shell:不离开gdb而执行shell

  下面我们来演示怎样用GDB来调试一个求0+1+2+3+…+99的程序:

/* Filename:sum.c */
main()
{
int i, sum;
sum = 0;
for (i = 0; i < 100; i++)
{
sum + = i;
}

printf("the sum of 1+2+...+ is %d", sum);
}

  执行如下命令编译sum.c(加-g选项产生debug信息):

gcc –g –o sum sum.c

  在命令行上键入gdb sum并按回车键就可以开始调试sum了,再运行run命令执行sum,屏幕上将看到如下内容:

 

  list命令:

  list命令用于列出源代码,对上述程序两次运行list,将出现如下画面(源代码被标行号):

 

  根据列出的源程序,如果我们将断点设置在第5行,只需在gdb 命令行提示符下键入如下命令设置断点:(gdb) break 5,执行情况如下图:

 

  这个时候我们再run,程序会停止在第5行,如下图:

 

  设置断点的另一种语法是 break <function>,它在进入指定函数(function)时停住。

  相反的,clear用于清除所有的已定义的断点,clear <function>清除设置在函数上的断点, clear <linenum>则清除设置在指定行上的断点。

  watch命令:
   
  watch命令用于观查变量或表达式的值,我们观查sum变量只需要运行watch sum:

 

   watch <expr>为表达式(变量)expr设置一个观察点,一量表达式值有变化时,程序会停止执行。

  要观查当前设置的watch,可以使用info watchpoints命令。

  next、step命令:

   next、step用于单步执行,在执行的过程中,被watch变量的变化情况将实时呈现(分别显示Old value和New value),如下图:

 

   next、step命令的区别在于step遇到函数调用,会跳转到到该函数定义的开始行去执行,而next则不进入到函数内部,它把函数调用语句当作一条普通语句执行。

  4.Make

  make是所有想在Linux系统上编程的用户必须掌握的工具,对于任何稍具规模的程序,我们都会使用到make,几乎可以说不使用make的程序不具备任何实用价值。

  在此,我们有必要解释编译和连接的区别。编译器使用源码文件来产生某种形式的目标文件(object files),在编译过程中,外部的符号参考并没有被解释或替换(即外部全局变量和函数并没有被找到)。因此,在编译阶段所报的错误一般都是语法错误。而连接器则用于连接目标文件和程序包,生成一个可执行程序。在连接阶段,一个目标文件中对别的文件中的符号的参考被解释,如果有符号不能找到,会报告连接错误。

  编译和连接的一般步骤是:第一阶段把源文件一个一个的编译成目标文件,第二阶段把所有的目标文件加上需要的程序包连接成一个可执行文件。这样的过程很痛苦,我们需要使用大量的gcc命令。

  而make则使我们从大量源文件的编译和连接工作中解放出来,综合为一步完成。GNU Make的主要工作是读进一个文本文件,称为makefile。这个文件记录了哪些文件(目的文件,目的文件不一定是最后的可执行程序,它可以是任何一种文件)由哪些文件(依靠文件)产生,用什么命令来产生。Make依靠此makefile中的信息检查磁盘上的文件,如果目的文件的创建或修改时间比它的一个依靠文件旧的话,make就执行相应的命令,以便更新目的文件。

  假设我们写下如下的三个文件,add.h用于声明add函数,add.c提供两个整数相加的函数体,而main.c中调用add函数:

/* filename:add.h */
extern int add(int i, int j);

/* filename:add.c */
int add(int i, int j)
{
return i + j;
}

/* filename:main.c */
#include "add.h"
main()
{
int a, b;
a = 2;
b = 3;
printf("the sum of a+b is %d", add(a + b));
}

  怎样为上述三个文件产生makefile呢?如下:

test : main.o add.o
gcc main.o add.o -o test

main.o : main.c add.h
gcc -c main.c -o main.o

add.o : add.c add.h
gcc -c add.c -o add.o 

  上述makefile利用add.c和add.h文件执行gcc -c add.c -o add.o命令产生add.o目标代码,利用main.c和add.h文件执行gcc -c main.c -o main.o命令产生main.o目标代码,最后利用main.o和add.o文件(两个模块的目标代码)执行gcc main.o add.o -o test命令产生可执行文件test。

  我们可在makefile中加入变量,另外。环境变量在make过程中也被解释成make的变量。这些变量是大小写敏感的,一般使用大写字母。Make变量可以做很多事情,例如:

  i) 存储一个文件名列表;
  ii) 存储可执行文件名;
  iii) 存储编译器选项。

  要定义一个变量,只需要在一行的开始写下这个变量的名字,后面跟一个=号,再跟变量的值。引用变量的方法是写一个$符号,后面跟(变量名)。我们把前面的 makefile 利用变量重写一遍(并假设使用-Wall -O –g编译选项):

OBJS = main.o add.o
CC = gcc
CFLAGS = -Wall -O -g

test : $(OBJS)
$(CC) $(OBJS) -o test

main.o : main.c add.h
$(CC) $(CFLAGS) -c main.c -o main.o

add.o : add.c add.h
$(CC) $(CFLAGS) -c add.c -o add.o 

  makefile 中还可定义清除(clean)目标,可用来清除编译过程中产生的中间文件,例如在上述makefile文件中添加下列代码:

clean:
rm -f *.o

  运行make clean时,将执行rm -f *.o命令,删除所有编译过程中产生的中间文件。

  不管怎么说,自己动手编写makefile仍然是很复杂和烦琐的,而且很容易出错。因此,GNU也为我们提供了Automake和Autoconf来辅助快速自动产生makefile,读者可以参阅相关资料。

  5.小结

  本章主要阐述了Linux程序的编写、编译、调试方法及make,实际上就是引导读者学习怎样在Linux下编程,为后续章节做好准备。

posted @ 2009-08-04 09:01 chaosuper 阅读(518) | 评论 (0)编辑 收藏

%eax
0x8048473 : add %eax,0xfffffffc(%ebp)
0x8048476 : incl 0xfffffff8(%ebp)
0x8048479 : jmp 0x8048464
0x804847b : nop
0x804847c : lea 0x0(%esi,1),%esi
0x8048480 : mov 0xfffffffc(%ebp),%edx
0x8048483 : mov %edx,%eax
0x8048485 : jmp 0x8048487
0x8048487 : mov %ebp,%esp
0x8048489 : pop %ebp
0x804848a : ret
End of assembler dump.


查看运行时数据
———————

在你调试程序时,当程序被停住时,你可以使用print命令(简写命令为p),或是同义命令inspect来查看当前程序的运行数据。print命令的格式是:

print
print /
是表达式,是你所调试的程序的语言的表达式(GDB可以调试多种编程语言),是输出的格式,比如,如果要把表达式按16进制的格式输出,那么就是/x。


一、表达式

print和许多GDB的命令一样,可以接受一个表达式,GDB会根据当前的程序运行的数
据来计算这个表达式,既然是表达式,那么就可以是当前程序运行中的const常量、
变量、函数等内容。可惜的是GDB不能使用你在程序中所定义的宏。

表达式的语法应该是当前所调试的语言的语法,由于C/C++是一种大众型的语言,所
以,本文中的例子都是关于C/C++的。(而关于用GDB调试其它语言的章节,我将在后
面介绍)

在表达式中,有几种GDB所支持的操作符,它们可以用在任何一种语言中。

@
是一个和数组有关的操作符,在后面会有更详细的说明。

::
指定一个在文件或是一个函数中的变量。

{}
表示一个指向内存地址的类型为type的一个对象。


二、程序变量

在GDB中,你可以随时查看以下三种变量的值:
1、全局变量(所有文件可见的)
2、静态全局变量(当前文件可见的)
3、局部变量(当前Scope可见的)

如果你的局部变量和全局变量发生冲突(也就是重名),一般情况下是局部变量会隐
藏全局变量,也就是说,如果一个全局变量和一个函数中的局部变量同名时,如果当
前停止点在函数中,用print显示出的变量的值会是函数中的局部变量的值。如果
此时你想查看全局变量的值时,你可以使用“::”操作符:

file::variable
function::variable
可以通过这种形式指定你所想查看的变量,是哪个文件中的或是哪个函数中的。例如,查看文件f2.c中的全局变量x的值:

gdb) p 'f2.c'::x

当然,“::”操作符会和C++中的发生冲突,GDB能自动识别“::” 是否C++的操作符,所以你不必担心在调试C++程序时会出现异常。

另外,需要注意的是,如果你的程序编译时开启了优化选项,那么在用GDB调试被优
化过的程序时,可能会发生某些变量不能访问,或是取值错误码的情况。这个是很
正常的,因为优化程序会删改你的程序,整理你程序的语句顺序,剔除一些无意义的
变量等,所以在GDB调试这种程序时,运行时的指令和你所编写指令就有不一样,也
就会出现你所想象不到的结果。对付这种情况时,需要在编译程序时关闭编译优化。
一般来说,几乎所有的编译器都支持编译优化的开关,例如,GNU 的C/C++编译器
GCC,你可以使用“-gstabs”选项来解决这个问题。关于编译器的参数,还请查看编
译器的使用说明文档。

三、数组

有时候,你需要查看一段连续的内存空间的值。比如数组的一段,或是动态分配的
数据的大小。你可以使用GDB的“@”操作符,“@”的左边是第一个内存的地址的
值,“@”的右边则你你想查看内存的长度。例如,你的程序中有这样的语句:

int *array = (int *) malloc (len * sizeof (int));

于是,在GDB调试过程中,你可以以如下命令显示出这个动态数组的取值:

p *array@len

@的左边是数组的首地址的值,也就是变量array所指向的内容,右边则是数据的长度,其保存在变量len中,其输出结果,大约是下面这个样子的:

(gdb) p *array@len
$1 = {2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40}

如果是静态数组的话,可以直接用print数组名,就可以显示数组中所有数据的内容了。


四、输出格式

一般来说,GDB会根据变量的类型输出变量的值。但你也可以自定义GDB的输出的格
式。例如,你想输出一个整数的十六进制,或是二进制来查看这个整型变量的中的
位的情况。要做到这样,你可以使用GDB的数据显示格式:

x 按十六进制格式显示变量。
d 按十进制格式显示变量。
u 按十六进制格式显示无符号整型。
o 按八进制格式显示变量。
t 按二进制格式显示变量。
a 按十六进制格式显示变量。
c 按字符格式显示变量。
f 按浮点数格式显示变量。

(gdb) p i
$21 = 101

(gdb) p/a i
$22 = 0x65

(gdb) p/c i
$23 = 101 'e'

(gdb) p/f i
$24 = 1.41531145e-43

(gdb) p/x i
$25 = 0x65

(gdb) p/t i
$26 = 1100101


五、查看内存

你可以使用examine命令(简写是x)来查看内存地址中的值。x命令的语法如下所示:

x/

n、f、u是可选的参数。

n 是一个正整数,表示显示内存的长度,也就是说从当前地址向后显示几个地址的内容。
f 表示显示的格式,参见上面。如果地址所指的是字符串,那么格式可以是s,如果地十是指令地址,那么格式可以是i。
u 表示从当前地址往后请求的字节数,如果不指定的话,GDB默认是4个bytes。
  u参数可以用下面的字符来代替,b表示单字节,h表示双字节,w表示四字节,g表示八字节。
  当我们指定了字节长度后,GDB会从指内存定的内存地址开始,读写指定字节,并把其当作一个值取出来。

表示一个内存地址。

n/f/u三个参数可以一起使用。例如:

命令:x/3uh 0x54320 表示,从内存地址0x54320读取内容,h表示以双字节为一个单位,3表示三个单位,u表示按十六进制显示。


六、自动显示

你可以设置一些自动显示的变量,当程序停住时,或是在你单步跟踪时,这些变量会自动显示。相关的GDB命令是display。

display
display/
display/

expr是一个表达式,fmt表示显示的格式,addr表示内存地址,当你用display设定好了一个或多个表达式后,
只要你的程序被停下来,GDB会自动显示你所设置的这些表达式的值。

格式i和s同样被display支持,一个非常有用的命令是:

display/i $pc

$pc是GDB的环境变量,表示着指令的地址,/i则表示输出格式为机器指令码,也就是汇编。于是当程序停下后,
就会出现源代码和机器指令码相对应的情形,这是一个很有意思的功能。

下面是一些和display相关的GDB命令:

undisplay
delete display
删除自动显示,dnums意为所设置好了的自动显式的编号。
如果要同时删除几个,编号可以用空格分隔,如果要删除一个范围内的编号,可以用减号表示(如:2-5)

disable display
enable display
disable和enalbe不删除自动显示的设置,而只是让其失效和恢复。

info display
查看display设置的自动显示的信息。GDB会打出一张表格,向你报告当然调试中设置了多少个自动显示设置,
其中包括,设置的编号,表达式,是否enable。

七、设置显示选项

GDB中关于显示的选项比较多,这里我只例举大多数常用的选项。

set print address
set print address on
打开地址输出,当程序显示函数信息时,GDB会显出函数的参数地址。系统默认为打开的,如:

(gdb) f
#0 set_quotes (lq=0x34c78 "<<", rq=0x34c88 ">>")
at input.c:530
530 if (lquote != def_lquote)


set print address off
关闭函数的参数地址显示,如:

(gdb) set print addr off
(gdb) f
#0 set_quotes (lq="<<", rq=">>") at input.c:530
530 if (lquote != def_lquote)

show print address
查看当前地址显示选项是否打开。

set print array
set print array on
打开数组显示,打开后当数组显示时,每个元素占一行,如果不打开的话,每个元素则以逗号分隔。
这个选项默认是关闭的。与之相关的两个命令如下。

set print array off
show print array

set print elements
这个选项主要是设置数组的,如果你的数组太大了,那么就可以指定一个来指定数据显示的最大长度,
当到达这个长度时,GDB就不再往下显示了。
如果设置为0,则表示不限制。

show print elements
查看print elements的选项信息。

set print null-stop
如果打开了这个选项,那么当显示字符串时,遇到结束符则停止显示。这个选项默认为off。

set print pretty on
如果打开printf pretty这个选项,那么当GDB显示结构体时会比较漂亮。如:

$1 = {
next = 0x0,
flags = {
sweet = 1,
sour = 1
},
meat = 0x54 "Pork"
}

set print pretty off
关闭printf pretty这个选项,GDB显示结构体时会如下显示:

$1 = {next = 0x0, flags = {sweet = 1, sour = 1}, meat = 0x54 "Pork"}

show print pretty
查看GDB是如何显示结构体的。


set print sevenbit-strings
设置字符显示,是否按“\nnn”的格式显示,如果打开,则字符串或字符数据按\nnn显示,如“\065”。

show print sevenbit-strings
查看字符显示开关是否打开。

set print union
设置显示结构体时,是否显式其内的联合体数据。例如有以下数据结构:

typedef enum {Tree, Bug} Species;
typedef enum {Big_tree, Acorn, Seedling} Tree_forms;
typedef enum {Caterpillar, Cocoon, Butterfly}
Bug_forms;

struct thing {
Species it;
union {
Tree_forms tree;
Bug_forms bug;
} form;
};

struct thing foo = {Tree, {Acorn}};

当打开这个开关时,执行 p foo 命令后,会如下显示:
$1 = {it = Tree, form = {tree = Acorn, bug = Cocoon}}

当关闭这个开关时,执行 p foo 命令后,会如下显示:
$1 = {it = Tree, form = {...}}

show print union
查看联合体数据的显示方式

set print object
在C++中,如果一个对象指针指向其派生类,如果打开这个选项,GDB会自动按照虚方法调用的规则显示输出,

如果关闭这个选项的话,GDB就不管虚函数表了。
这个选项默认是off。

show print object
查看对象选项的设置。

set print static-members
这个选项表示,当显示一个C++对象中的内容是,是否显示其中的静态数据成员。默认是on。

show print static-members
查看静态数据成员选项设置。

set print vtbl
当此选项打开时,GDB将用比较规整的格式来显示虚函数表时。其默认是关闭的。

show print vtbl
查看虚函数显示格式的选项。


八、历史记录

当你用GDB的print查看程序运行时的数据时,你每一个print都会被GDB记录下来。
GDB会以$1, $2, $3 .....这样的方式为你每一个print命令编上号。于是,你可以
使用这个编号访问以前的表达式,如$1。这个功能所带来的好处是,如果你先前输
入了一个比较长的表达式,如果你还想查看这个表达式的值,你可以使用历史记录
来访问,省去了重复输入。


九、GDB环境变量

你可以在GDB的调试环境中定义自己的变量,用来保存一些调试程序中的运行数据。
要定义一个GDB的变量很简单只需。使用GDB的set命令。
GDB的环境变量和UNIX一样,也是以$起头。如:

set $foo = *object_ptr

使用环境变量时,GDB会在你第一次使用时创建这个变量,而在以后的使用中,则直接对其賦值。
环境变量没有类型,你可以给环境变量定义任一的类型。
包括结构体和数组。

show convenience
该命令查看当前所设置的所有的环境变量。

这是一个比较强大的功能,环境变量和程序变量的交互使用,将使得程序调试更为灵活便捷。例如:

set $i = 0
print bar[$i++]->contents

于是,当你就不必,print bar[0]->contents, print bar[1]->contents地输入命令了。
输入这样的命令后,只用敲回车,重复执行上一条语句,环境变量会自动累加,从而完成逐个输出的功能。


十、查看寄存器

要查看寄存器的值,很简单,可以使用如下命令:

info registers
查看寄存器的情况。(除了浮点寄存器)

info all-registers
查看所有寄存器的情况。(包括浮点寄存器)

info registers
查看所指定的寄存器的情况。

寄存器中放置了程序运行时的数据,比如程序当前运行的指令地址(ip),程序的当
前堆栈地址(sp)等等。你同样可以使用print命令来访问寄存器的情况,只需要在
寄存器名字前加一个$符号就可以了。如:p $eip。

改变程序的执行
———————

一旦使用GDB挂上被调试程序,当程序运行起来后,你可以根据自己的调试思路来动
态地在GDB中更改当前被调试程序的运行线路或是其变量的值,这个强大的功能能
够让你更好的调试你的程序,比如,你可以在程序的一次运行中走遍程序的所有分
支。


一、修改变量值

修改被调试程序运行时的变量值,在GDB中很容易实现,使用GDB的print命令即可完成。如:

(gdb) print x=4

x=4这个表达式是C/C++的语法,意为把变量x的值修改为4,如果你当前调试的语言是Pascal,
那么你可以使用Pascal的语法:x:=4。

在某些时候,很有可能你的变量和GDB中的参数冲突,如:

(gdb) whatis width
type = double
(gdb) p width
$4 = 13
(gdb) set width=47
Invalid syntax in expression.

因为,set width是GDB的命令,所以,出现了“Invalid syntax in expression”的设置错误,
此时,你可以使用set var命令来告诉GDB,width不是你GDB的参数,而是程序的变量名,如:

(gdb) set var width=47

另外,还可能有些情况,GDB并不报告这种错误,所以保险起见,在你改变程序变量取值时,
最好都使用set var格式的GDB命令。

二、跳转执行

一般来说,被调试程序会按照程序代码的运行顺序依次执行。GDB提供了乱序执行的功能,
也就是说,GDB可以修改程序的执行顺序,可以让程序执行随意跳跃。这个功能可以由GDB的jump命令来完:

jump
指定下一条语句的运行点。可以是文件的行号,可以是file:line格式,可以是+num这种偏移量格式。
表式着下一条运行语句从哪里开始。

jump

这里的
是代码行的内存地址。

注意,jump命令不会改变当前的程序栈中的内容,所以,当你从一个函数跳到另一个
函数时,当函数运行完返回时进行弹栈操作时必然会发生错误,可能结果还是非常
奇怪的,甚至于产生程序Core Dump。所以最好是同一个函数中进行跳转。

熟悉汇编的人都知道,程序运行时,有一个寄存器用于保存当前代码所在的内存地
址。所以,jump命令也就是改变了这个寄存器中的值。于是,你可以使用“set
$pc”来更改跳转执行的地址。如:

set $pc = 0x485


三、产生信号量

使用singal命令,可以产生一个信号量给被调试的程序。如:中断信号Ctrl+C。这
非常方便于程序的调试,可以在程序运行的任意位置设置断点,并在该断点用GDB产
生一个信号量,这种精确地在某处产生信号非常有利程序的调试。

语法是:signal ,UNIX的系统信号量通常从1到15。所以取值也在这个范围。

single命令和shell的kill命令不同,系统的kill命令发信号给被调试程序时,是由
GDB截获的,而single命令所发出一信号则是直接发给被调试程序的。

四、强制函数返回

如果你的调试断点在某个函数中,并还有语句没有执行完。你可以使用return命令强制函数忽略还没有执行的语句并返回。

return
return
使用return命令取消当前函数的执行,并立即返回,如果指定了,那么该表达式的值会被认作函数的返回值。


五、强制调用函数

call

表达式中可以一是函数,以此达到强制调用函数的目的。并显示函数的返回值,如
果函数返回值是void,那么就不显示。

另一个相似的命令也可以完成这一功能——print,print后面可以跟表达式,所以也
可以用他来调用函数,print和call的不同是,如果函数返回void,call则不显
示,print则显示函数返回值,并把该值存入历史数据中。

在不同语言中使用GDB
——————————

GDB支持下列语言:C, C++, Fortran, PASCAL, Java, Chill, assembly, 和
Modula-2。一般说来,GDB会根据你所调试的程序来确定当然的调试语言,比如:发
现文件名后缀为“.c”的,GDB会认为是C程序。文件名后缀为 “.C, .cc, .cp,
.cpp, .cxx, .c++”的,GDB会认为是C++程序。而后缀是“.f, .F”的,GDB会认为是
Fortran程序,还有,后缀为如果是“.s, .S”的会认为是汇编语言。

也就是说,GDB会根据你所调试的程序的语言,来设置自己的语言环境,并让GDB的命
令跟着语言环境的改变而改变。比如一些GDB命令需要用到表达式或变量时,这些
表达式或变量的语法,完全是根据当前的语言环境而改变的。例如C/C++中对指针
的语法是*p,而在Modula-2中则是p^。并且,如果你当前的程序是由几种不同语言
一同编译成的,那到在调试过程中,GDB也能根据不同的语言自动地切换语言环境。
这种跟着语言环境而改变的功能,真是体贴开发人员的一种设计。


下面是几个相关于GDB语言环境的命令:

show language
查看当前的语言环境。如果GDB不能识为你所调试的编程语言,那么,C语言被认为是默认的环境。

info frame
查看当前函数的程序语言。

info source
查看当前文件的程序语言。

如果GDB没有检测出当前的程序语言,那么你也可以手动设置当前的程序语言。
使用set language命令即可做到。

当set language命令后什么也不跟的话,你可以查看GDB所支持的语言种类:

(gdb) set language
The currently understood settings are:

local or auto Automatic setting based on source file
c Use the C language
c++ Use the C++ language
asm Use the Asm language
chill Use the Chill language
fortran Use the Fortran language
java Use the Java language
modula-2 Use the Modula-2 language
pascal Use the Pascal language
scheme Use the Scheme language

于是你可以在set language后跟上被列出来的程序语言名,来设置当前的语言环境。

 

posted @ 2009-08-04 08:39 chaosuper 阅读(2419) | 评论 (0)编辑 收藏

或是直接就是b func
(gdb) b func
Breakpoint 1 at 0x8048458: file hello.c, line 10.

示例二:敲入b按两次TAB键,你会看到所有b打头的命令:
(gdb) b
backtrace break bt
(gdb)

示例三:只记得函数的前缀,可以这样:
(gdb) b make_ <按TAB键>
(再按下一次TAB键,你会看到:)
make_a_section_from_file make_environ
make_abs_section make_function_type
make_blockvector make_pointer_type
make_cleanup make_reference_type
make_command make_symbol_completion_list
(gdb) b make_
GDB把所有make开头的函数全部例出来给你查看。

示例四:调试C++的程序时,有可以函数名一样。如:
(gdb) b 'bubble( M-?
bubble(double,double) bubble(int,int)
(gdb) b 'bubble(
你可以查看到C++中的所有的重载函数及参数。(注:M-?和“按两次TAB键”是一个意思)

要退出gdb时,只用发quit或命令简称q就行了。

GDB中运行UNIX的shell程序
————————————

在gdb环境中,你可以执行UNIX的shell的命令,使用gdb的shell命令来完成:

shell

调用UNIX的shell来执行,环境变量SHELL中定义的UNIX的shell将会被用来执行,如
果SHELL没有定义,那就使用UNIX的标准shell:/bin/sh。(在Windows中使用
Command.com或cmd.exe)

还有一个gdb命令是make:
make
可以在gdb中执行make命令来重新build自己的程序。这个命令等价于“shell make ”。

在GDB中运行程序
————————

当以gdb 方式启动gdb后,gdb会在PATH路径和当前目录中搜索的源文件。如要确认gdb是否读到源文件,可使用l或list命令,看看gdb是否能列出源代码。

在gdb中,运行程序使用r或是run命令。程序的运行,你有可能需要设置下面四方面的事。

1、程序运行参数。
set args 可指定运行时参数。(如:set args 10 20 30 40 50)
show args 命令可以查看设置好的运行参数。

2、运行环境。
path
可设定程序的运行路径。
show paths 查看程序的运行路径。
set environment varname [=value] 设置环境变量。如:set env USER=hchen
show environment [varname] 查看环境变量。

3、工作目录。
cd
相当于shell的cd命令。
pwd 显示当前的所在目录。

4、程序的输入输出。
info terminal 显示你程序用到的终端的模式。
使用重定向控制程序输出。如:run > outfile
tty命令可以指写输入输出的终端设备。如:tty /dev/ttyb


调试已运行的程序
————————

两种方法:
1、在UNIX下用ps查看正在运行的程序的PID(进程ID),然后用gdb PID格式挂接正在运行的程序。
2、先用gdb 关联上源代码,并进行gdb,在gdb中用attach命令来挂接进程的PID。并用detach来取消挂接的进程。

暂停 / 恢复程序运行
—————————

调试程序中,暂停程序运行是必须的,GDB可以方便地暂停程序的运行。你可以设置
程序的在哪行停住,在什么条件下停住,在收到什么信号时停往等等。以便于你查
看运行时的变量,以及运行时的流程。

当进程被gdb停住时,你可以使用info program 来查看程序的是否在运行,进程号,被
暂停的原因。

在gdb中,我们可以有以下几种暂停方式:断点(BreakPoint)、观察点
(WatchPoint)、捕捉点(CatchPoint)、信号(Signals)、线程停止(Thread
Stops)。如果要恢复程序运行,可以使用c或是continue命令。

一、设置断点(BreakPoint)

我们用break命令来设置断点。正面有几点设置断点的方法:

break
在进入指定函数时停住。C++中可以使用class::function或function(type,type)格式来指定函数名。

break
在指定行号停住。

break +offset
break -offset
在当前行号的前面或后面的offset行停住。offiset为自然数。

break filename:linenum
在源文件filename的linenum行处停住。

break filename:function
在源文件filename的function函数的入口处停住。

break *address
在程序运行的内存地址处停住。

break
break命令没有参数时,表示在下一条指令处停住。

break ... if
...可以是上述的参数,condition表示条件,在条件成立时停住。比如在循环境体中,可以设置break if i=100,表示当i为100时停住程序。

查看断点时,可使用info命令,如下所示:(注:n表示断点号)
info breakpoints [n]
info break [n]


二、设置观察点(WatchPoint)

观察点一般来观察某个表达式(变量也是一种表达式)的值是否有变化了,如果有变化,马上停住程序。我们有下面的几种方法来设置观察点:

watch
为表达式(变量)expr设置一个观察点。一量表达式值有变化时,马上停住程序。

rwatch
当表达式(变量)expr被读时,停住程序。

awatch
当表达式(变量)的值被读或被写时,停住程序。

info watchpoints
列出当前所设置了的所有观察点。

三、设置捕捉点(CatchPoint)

你可设置捕捉点来补捉程序运行时的一些事件。如:载入共享库(动态链接库)或是C++的异常。设置捕捉点的格式为:

catch
当event发生时,停住程序。event可以是下面的内容:
1、throw 一个C++抛出的异常。(throw为关键字)
2、catch 一个C++捕捉到的异常。(catch为关键字)
3、exec 调用系统调用exec时。(exec为关键字,目前此功能只在HP-UX下有用)
4、fork 调用系统调用fork时。(fork为关键字,目前此功能只在HP-UX下有用)
5、vfork 调用系统调用vfork时。(vfork为关键字,目前此功能只在HP-UX下有用)
6、load 或 load 载入共享库(动态链接库)时。(load为关键字,目前此功能只在HP-UX下有用)
7、unload 或 unload 卸载共享库(动态链接库)时。(unload为关键字,目前此功能只在HP-UX下有用)

tcatch
只设置一次捕捉点,当程序停住以后,应点被自动删除。

四、维护停止点

上面说了如何设置程序的停止点,GDB中的停止点也就是上述的三类。在GDB中,如
果你觉得已定义好的停止点没有用了,你可以使用delete、clear、disable、
enable这几个命令来进行维护。

clear
清除所有的已定义的停止点。

clear
clear
清除所有设置在函数上的停止点。

clear
clear
清除所有设置在指定行上的停止点。

delete [breakpoints] [range...]
删除指定的断点,breakpoints为断点号。如果不指定断点号,则表示删除所有的断点。range 表示断点号的范围(如:3-7)。其简写命令为d。

比删除更好的一种方法是disable停止点,disable了的停止点,GDB不会删除,当你还需要时,enable即可,就好像回收站一样。

disable [breakpoints] [range...]
disable所指定的停止点,breakpoints为停止点号。如果什么都不指定,表示disable所有的停止点。简写命令是dis.

enable [breakpoints] [range...]
enable所指定的停止点,breakpoints为停止点号。

enable [breakpoints] once range...
enable所指定的停止点一次,当程序停止后,该停止点马上被GDB自动disable。

enable [breakpoints] delete range...
enable所指定的停止点一次,当程序停止后,该停止点马上被GDB自动删除。

五、停止条件维护

前面在说到设置断点时,我们提到过可以设置一个条件,当条件成立时,程序自动停
止,这是一个非常强大的功能,这里,我想专门说说这个条件的相关维护命令。一般
来说,为断点设置一个条件,我们使用if关键词,后面跟其断点条件。并且,条件设
置好后,我们可以用condition命令来修改断点的条件。(只有break和watch命令支
持if,catch目前暂不支持if)

condition
修改断点号为bnum的停止条件为expression。

condition
清除断点号为bnum的停止条件。


还有一个比较特殊的维护命令ignore,你可以指定程序运行时,忽略停止条件几次。

ignore
表示忽略断点号为bnum的停止条件count次。

六、为停止点设定运行命令

我们可以使用GDB提供的command命令来设置停止点的运行命令。也就是说,当运行
的程序在被停止住时,我们可以让其自动运行一些别的命令,这很有利行自动化调
试。对基于GDB的自动化调试是一个强大的支持。


commands [bnum]
... command-list ...
end

为断点号bnum指写一个命令列表。当程序被该断点停住时,gdb会依次运行命令列表中的命令。

例如:

break foo if x>0
commands
printf "x is %d\n",x
continue
end
断点设置在函数foo中,断点条件是x>0,如果程序被断住后,也就是,一旦x的值在foo函数中大于0,GDB会自动打印出x的值,并继续运行程序。

如果你要清除断点上的命令序列,那么只要简单的执行一下commands命令,并直接在打个end就行了。

七、断点菜单

在C++中,可能会重复出现同一个名字的函数若干次(函数重载),在这种情况
下,break 不能告诉GDB要停在哪个函数的入口。当然,你可以使用break 也就是把
函数的参数类型告诉GDB,以指定一个函数。否则的话,GDB会给你列出一个断点菜
单供你选择你所需要的断点。你只要输入你菜单列表中的编号就可以了。如:

(gdb) b String::after
[0] cancel
[1] all
[2] file:String.cc; line number:867
[3] file:String.cc; line number:860
[4] file:String.cc; line number:875
[5] file:String.cc; line number:853
[6] file:String.cc; line number:846
[7] file:String.cc; line number:735
> 2 4 6
Breakpoint 1 at 0xb26c: file String.cc, line 867.
Breakpoint 2 at 0xb344: file String.cc, line 875.
Breakpoint 3 at 0xafcc: file String.cc, line 846.
Multiple breakpoints were set.
Use the "delete" command to delete unwanted
breakpoints.
(gdb)

可见,GDB列出了所有after的重载函数,你可以选一下列表编号就行了。

0表示放弃设置断点,1表示所有函数都设置断点。

八、恢复程序运行和单步调试

当程序被停住了,你可以用continue命令恢复程序的运行直到程序结束,或下一个断点到来。也可以使用step或next命令单步跟踪程序。

continue [ignore-count]
c [ignore-count]
fg [ignore-count]
恢复程序运行,直到程序结束,或是下一个断点到来。ignore-count表示忽略其后的断点次数。continue,c,fg三个命令都是一样的意思。


step

单步跟踪,如果有函数调用,他会进入该函数。进入函数的前提是,此函数被编译有
debug信息。很像VC等工具中的step in。后面可以加count也可以不加,不加表示
一条条地执行,加表示执行后面的count条指令,然后再停住。

next

同样单步跟踪,如果有函数调用,他不会进入该函数。很像VC等工具中的step
over。后面可以加count也可以不加,不加表示一条条地执行,加表示执行后面的
count条指令,然后再停住。

set step-mode
set step-mode on
打开step-mode模式,于是,在进行单步跟踪时,程序不会因为没有debug信息而不停住。这个参数有很利于查看机器码。

set step-mod off
关闭step-mode模式。

finish
运行程序,直到当前函数完成返回。并打印函数返回时的堆栈地址和返回值及参数值等信息。

until 或 u
当你厌倦了在一个循环体内单步跟踪时,这个命令可以运行程序直到退出循环体。

stepi 或 si
nexti 或 ni

单步跟踪一条机器指令!一条程序代码有可能由数条机器指令完成,stepi和nexti
可以单步执行机器指令。与之一样有相同功能的命令是 “display/i $pc” ,当运
行完这个命令后,单步跟踪会在打出程序代码的同时打出机器指令(也就是汇编代
码)

九、信号(Signals)

信号是一种软中断,是一种处理异步事件的方法。一般来说,操作系统都支持许多
信号。尤其是UNIX,比较重要应用程序一般都会处理信号。UNIX定义了许多信号,
比如SIGINT表示中断字符信号,也就是Ctrl+C的信号,SIGBUS表示硬件故障的信
号;SIGCHLD表示子进程状态改变信号; SIGKILL表示终止程序运行的信号,等等。
信号量编程是UNIX下非常重要的一种技术。

GDB有能力在你调试程序的时候处理任何一种信号,你可以告诉GDB需要处理哪一种
信号。你可以要求GDB收到你所指定的信号时,马上停住正在运行的程序,以供你进
行调试。你可以用GDB的handle命令来完成这一功能。

handle

在GDB中定义一个信号处理。信号可以以SIG开头或不以SIG开头,可以用定义一个
要处理信号的范围(如:SIGIO-SIGKILL,表示处理从SIGIO信号到SIGKILL的信号,其
中包括SIGIO,SIGIOT,SIGKILL三个信号),也可以使用关键字all来标明要处理所有
的信号。一旦被调试的程序接收到信号,运行程序马上会被GDB停住,以供调试。其
可以是以下几种关键字的一个或多个。

nostop
当被调试的程序收到信号时,GDB不会停住程序的运行,但会打出消息告诉你收到这种信号。
stop
当被调试的程序收到信号时,GDB会停住你的程序。
print
当被调试的程序收到信号时,GDB会显示出一条信息。
noprint
当被调试的程序收到信号时,GDB不会告诉你收到信号的信息。
pass
noignore
当被调试的程序收到信号时,GDB不处理信号。这表示,GDB会把这个信号交给被调试程序会处理。
nopass
ignore
当被调试的程序收到信号时,GDB不会让被调试程序来处理这个信号。


info signals
info handle
查看有哪些信号在被GDB检测中。

十、线程(Thread Stops)

如果你程序是多线程的话,你可以定义你的断点是否在所有的线程上,或是在某个特定的线程。GDB很容易帮你完成这一工作。

break thread
break thread if ...

linespec指定了断点设置在的源程序的行号。threadno指定了线程的ID,注意,这
个ID是GDB分配的,你可以通过“info threads”命令来查看正在运行程序中的线程
信息。如果你不指定thread 则表示你的断点设在所有线程上面。你还可以为某线
程指定断点条件。如:

(gdb) break frik.c:13 thread 28 if bartab > lim

当你的程序被GDB停住时,所有的运行线程都会被停住。这方便你你查看运行程序
的总体情况。而在你恢复程序运行时,所有的线程也会被恢复运行。那怕是主进程
在被单步调试时。

查看栈信息
—————

当程序被停住了,你需要做的第一件事就是查看程序是在哪里停住的。当你的程序
调用了一个函数,函数的地址,函数参数,函数内的局部变量都会被压入
“栈”(Stack)中。你可以用GDB命令来查看当前的栈中的信息。

下面是一些查看函数调用栈信息的GDB命令:

backtrace
bt
打印当前的函数调用栈的所有信息。如:

(gdb) bt
#0 func (n=250) at tst.c:6
#1 0x08048524 in main (argc=1, argv=0xbffff674) at tst.c:30
#2 0x400409ed in __libc_start_main () from /lib/libc.so.6

从上可以看出函数的调用栈信息:__libc_start_main --> main() --> func()


backtrace
bt
n是一个正整数,表示只打印栈顶上n层的栈信息。

backtrace <-n>
bt <-n>
-n表一个负整数,表示只打印栈底下n层的栈信息。

如果你要查看某一层的信息,你需要在切换当前的栈,一般来说,程序停止时,最顶
层的栈就是当前栈,如果你要查看栈下面层的详细信息,首先要做的是切换当前栈。

frame
f
n是一个从0开始的整数,是栈中的层编号。比如:frame 0,表示栈顶,frame 1,表示栈的第二层。

up
表示向栈的上面移动n层,可以不打n,表示向上移动一层。

down
表示向栈的下面移动n层,可以不打n,表示向下移动一层。

上面的命令,都会打印出移动到的栈层的信息。如果你不想让其打出信息。你可以使用这三个命令:

select-frame 对应于 frame 命令。
up-silently 对应于 up 命令。
down-silently 对应于 down 命令。


查看当前栈层的信息,你可以用以下GDB命令:

frame 或 f
会打印出这些信息:栈的层编号,当前的函数名,函数参数值,函数所在文件及行号,函数执行到的语句。

info frame
info f

这个命令会打印出更为详细的当前栈层的信息,只不过,大多数都是运行时的内内
地址。比如:函数地址,调用函数的地址,被调用函数的地址,目前的函数是由什么
样的程序语言写成的、函数参数地址及值、局部变量的地址等等。如:

(gdb) info f
Stack level 0, frame at 0xbffff5d4:
eip = 0x804845d in func (tst.c:6); saved eip 0x8048524
called by frame at 0xbffff60c
source language c.
Arglist at 0xbffff5d4, args: n=250
Locals at 0xbffff5d4, Previous frame's sp is 0x0
Saved registers:
ebp at 0xbffff5d4, eip at 0xbffff5d8

info args
打印出当前函数的参数名及其值。

info locals
打印出当前函数中所有局部变量及其值。

info catch
打印出当前的函数中的异常处理信息。


查看源程序
—————

一、显示源代码

GDB 可以打印出所调试程序的源代码,当然,在程序编译时一定要加上-g的参数,把
源程序信息编译到执行文件中。不然就看不到源程序了。当程序停下来以后,
GDB会报告程序停在了那个文件的第几行上。你可以用list命令来打印程序的源代
码。还是来看一看查看源代码的GDB命令吧。

list
显示程序第linenum行的周围的源程序。

list
显示函数名为function的函数的源程序。

list
显示当前行后面的源程序。

list -
显示当前行前面的源程序。

一般是打印当前行的上5行和下5行,如果显示函数是是上2行下8行,默认是10行,当
然,你也可以定制显示的范围,使用下面命令可以设置一次显示源程序的行数。

set listsize
设置一次显示源代码的行数。

show listsize
查看当前listsize的设置。

list命令还有下面的用法:

list ,
显示从first行到last行之间的源代码。

list ,
显示从当前行到last行之间的源代码。

list +
往后显示源代码。

一般来说在list后面可以跟以下这们的参数:

行号。
<+offset> 当前行号的正偏移量。
<-offset> 当前行号的负偏移量。
哪个文件的哪一行。
函数名。
哪个文件中的哪个函数。
<*address> 程序运行时的语句在内存中的地址。

二、搜索源代码

不仅如此,GDB还提供了源代码搜索的命令:

forward-search
search
向前面搜索。

reverse-search
全部搜索。

其中,就是正则表达式,也主一个字符串的匹配模式,关于正则表达式,我就不在这里讲了,还请各位查看相关资料。


三、指定源文件的路径

某些时候,用-g编译过后的执行程序中只是包括了源文件的名字,没有路径名。GDB提供了可以让你指定源文件的路径的命令,以便GDB进行搜索。

directory
dir
加一个源文件路径到当前路径的前面。如果你要指定多个路径,UNIX下你可以使用“:”,Windows下你可以使用“;”。
directory
清除所有的自定义的源文件搜索路径信息。

show directories
显示定义了的源文件搜索路径。

四、源代码的内存

你可以使用info line命令来查看源代码在内存中的地址。info line后面可以跟
“行号”,“函数名”,“文件名:行号”,“文件名:函数名”,这个命令会打印出所指定的
源码在运行时的内存地址,如:

(gdb) info line tst.c:func
Line 5 of "tst.c" starts at address 0x8048456 and ends at 0x804845d .

还有一个命令(disassemble)你可以查看源程序的当前执行时的机器码,这个命令
会把目前内存中的指令dump出来。如下面的示例表示查看函数func的汇编代码。

(gdb) disassemble func
Dump of assembler code for function func:
0x8048450 : push %ebp
0x8048451 : mov %esp,%ebp
0x8048453 : sub $0x18,%esp
0x8048456 : movl $0x0,0xfffffffc(%ebp)
0x804845d : movl $0x1,0xfffffff8(%ebp)
0x8048464 : mov 0xfffffff8(%ebp),%eax
0x8048467 : cmp 0x8(%ebp),%eax
0x804846a : jle 0x8048470
0x804846c : jmp 0x8048480
0x804846e : mov %esi,%esi
0x8048470 : mov 0xfffffff8(%ebp),


 

posted @ 2009-08-04 08:39 chaosuper 阅读(463) | 评论 (0)编辑 收藏

简述

    一 列文件清单
    二:执行程序
    三:显示数据
    四:断点(breakpoint)
    五.断点的管理
    六.变量的检查和赋值
    七. 单步执行
    八.函数的调用
    九.机器语言工具
    十.信号

GDB的使用方法

简述
一 列文件清单

    * List

      (gdb) list line1,line2

二:执行程序
要想运行准备调试的程序,可使用run命令,在它后面可以跟随发给该程序的任何参数,包括标准输入和标准输出说明符(<和> )和外壳通配符(*、?、[、])在内。如果你使用不带参数的run命令,gdb就再次使用你给予前一条run命令的参数,这是很有用的。利用set args 命令就可以修改发送给程序的参数,而使用show args 命令就可以查看其缺省参数的列表。

(gdb)set args –b –x
(gdb) show args
backtrace命令为堆栈提供向后跟踪功能。
Backtrace 命令产生一张列表,包含着从最近的过程开始的所以有效过程和调用这些过程的参数。

三:显示数据

    * 利用print 命令可以检查各个变量的值。

      (gdb) print p (p为变量名)

      print 是gdb的一个功能很强的命令,利用它可以显示被调试的语言中任何有效的表达式。表达式除了包含你程序中的变量外,还可以包含以下内容:

   1. 对程序中函数的调用

      (gdb) print find_entry(1,0)

   2. 数据结构和其他复杂对象

      (gdb) print *table_start
      $8={e=reference=’\000’,location=0x0,next=0x0}

   3. 值的历史成分

      (gdb)print $1 ($1为历史记录变量,在以后可以直接引用 $1 的值)

   4. 人为数组
      人为数组提供了一种去显示存储器块(数组节或动态分配的存储区)内容的方法。早期的调试程序没有很好的方法将任意的指针换成一个数组。就像对待参数一样,让我们查看内存中在变量h后面的10个整数,一个动态数组的语法如下所示:
      base@length
      因此,要想显示在h后面的10个元素,可以使用h@10

      (gdb)print h@10
      $13=(-1,345,23,-234,0,0,0,98,345,10)

    * whatis 命令可以显示某个变量的类型

      (gdb) whatis p
      type = int *

四:断点(breakpoint)
break命令(可以简写为b)可以用来在调试的程序中设置断点,该命令有如下四种形式:

    * break line-number 使程序恰好在执行给定行之前停止。
    * break function-name 使程序恰好在进入指定的函数之前停止。
    * break line-or-function if condition 如果condition(条件)是真,程序到达指定行或函数时停止。
    * break routine-name 在指定例程的入口处设置断点

如果该程序是由很多原文件构成的,你可以在各个原文件中设置断点,而不是在当前的原文件中设置断点,其方法如下:

(gdb) break filename:line-number
(gdb) break filename:function-name

要想设置一个条件断点,可以利用break if命令,如下所示:

(gdb) break line-or-function if expr
例:
(gdb) break 46 if testsize==100

从断点继续运行:countinue 命令
五.断点的管理

1.显示当前gdb的断点信息:

(gdb) info break

他会以如下的形式显示所有的断点信息:

Num Type Disp Enb Address What
1 breakpoint keep y 0x000028bc in init_random at qsort2.c:155
2 breakpoint keep y 0x0000291c in init_organ at qsort2.c:168

   1. 删除指定的某个断点:

      (gdb) delete breakpoint 1

      该命令将会删除编号为1的断点,如果不带编号参数,将删除所有的断点

      (gdb) delete breakpoint

   2. 禁止使用某个断点

      (gdb) disable breakpoint 1

      该命令将禁止断点 1,同时断点信息的 (Enb)域将变为 n
   3. 允许使用某个断点

      (gdb) enable breakpoint 1

      该命令将允许断点 1,同时断点信息的 (Enb)域将变为 y
   4. 清除原文件中某一代码行上的所有断点

      (gdb)clean number

      注:number 为原文件的某个代码行的行号

六.变量的检查和赋值

    * whatis:识别数组或变量的类型
    * ptype:比whatis的功能更强,他可以提供一个结构的定义
    * set variable:将值赋予变量
    * print 除了显示一个变量的值外,还可以用来赋值

七. 单步执行

    * next 不进入的单步执行
    * step 进入的单步执行如果已经进入了某函数,而想退出该函数返回到它的调用函数中,可使用命令finish

八.函数的调用

    * call name 调用和执行一个函数

      (gdb) call gen_and_sork( 1234,1,0 )
      (gdb) call printf(“abcd”)
      $1=4

    * finish 结束执行当前函数,显示其返回值(如果有的话)

九.机器语言工具
有一组专用的gdb变量可以用来检查和修改计算机的通用寄存器,gdb提供了目前每一台计算机中实际使用的4个寄存器的标准名字:

    * $pc : 程序计数器
    * $fp : 帧指针(当前堆栈帧)
    * $sp : 栈指针
    * $ps : 处理器状态

十.信号
gdb 通常可以捕捉到发送给它的大多数信号,通过捕捉信号,它就可决定对于正在运行的进程要做些什么工作。例如,按CTRL-C将中断信号发送给gdb,通常就会终止gdb。但是你或许不想中断gdb,真正的目的是要中断gdb正在运行的程序,因此,gdb要抓住该信号并停止它正在运行的程序,这样就可以执行某些调试操作。

Handle命令可控制信号的处理,他有两个参数,一个是信号名,另一个是接受到信号时该作什么。几种可能的参数是:

    * nostop 接收到信号时,不要将它发送给程序,也不要停止程序。
    * stop 接受到信号时停止程序的执行,从而允许程序调试;显示一条表示已接受到信号的消息(禁止使用消息除外)
    * print 接受到信号时显示一条消息
    * noprint 接受到信号时不要显示消息(而且隐含着不停止程序运行)
    * pass 将信号发送给程序,从而允许你的程序去处理它、停止运行或采取别的动作。
    * nopass 停止程序运行,但不要将信号发送给程序。

例如,假定你截获SIGPIPE信号,以防止正在调试的程序接受到该信号,而且只要该信号一到达,就要求该程序停止,并通知你。要完成这一任务,可利用如下命令:

(gdb) handle SIGPIPE stop print

请注意,UNIX的信号名总是采用大写字母!你可以用信号编号替代信号名如果你的程序要执行任何信号处理操作,就需要能够测试其信号处理程序,为此,就需要一种能将信号发送给程序的简便方法,这就是signal命令的任务。该命令的参数是一个数字或者一个名字,如SIGINT。假定你的程序已将一个专用的 SIGINT(键盘输入,或CTRL-C;信号2)信号处理程序设置成采取某个清理动作,要想测试该信号处理程序,你可以设置一个断点并使用如下命令:

(gdb) signal 2
continuing with signal SIGINT(2)

该程序继续执行,但是立即传输该信号,而且处理程序开始运行.
GDB的使用方法

GDB是一个强大的命令行调试工具。大家知道命令行的强大就是在于,其可以形成
执行序列,形成脚本。UNIX下的软件全是命令行的,这给程序开发提代供了极大的
便利,命令行软件的优势在于,它们可以非常容易的集成在一起,使用几个简单的已
有工具的命令,就可以做出一个非常强大的功能。

于是UNIX下的软件比Windows下的软件更能有机地结合,各自发挥各自的长处,组合
成更为强劲的功能。而Windows下的图形软件基本上是各自为营,互相不能调用,很
不利于各种软件的相互集成。在这里并不是要和Windows做个什么比较,所谓“寸有
所长,尺有所短”,图形化工具还是有不如命令行的地方。

 

用GDB调试程序

GDB概述
————

GDB是GNU开源组织发布的一个强大的UNIX下的程序调试工具。或许,各位比较喜欢
那种图形界面方式的,像VC、BCB等IDE的调试,但如果你是在UNIX平台下做软件,你
会发现GDB这个调试工具有比VC、BCB的图形化调试器更强大的功能。

所谓“寸有所
长,尺有所短”就是这个道理。

一般来说,GDB主要帮忙你完成下面四个方面的功能:

1、启动你的程序,可以按照你的自定义的要求随心所欲的运行程序。
2、可让被调试的程序在你所指定的调置的断点处停住。(断点可以是条件表达式)
3、当程序被停住时,可以检查此时你的程序中所发生的事。
4、动态的改变你程序的执行环境。

从上面看来,GDB和一般的调试工具没有什么两样,基本上也是完成这些功能,不过
在细节上,你会发现GDB这个调试工具的强大,大家可能比较习惯了图形化的调试工
具,但有时候,命令行的调试工具却有着图形化工具所不能完成的功能。让我们一
一看来。

一个调试示例
——————

源程序:tst.c

1 #include
2
3 int func(int n)
4 {
5 int sum=0,i;
6 for(i=0; i
7 {
8 sum+=i;
9 }
10 return sum;
11 }
12
13
14 main()
15 {
16 int i;
17 long result = 0;
18 for(i=1; i<=100; i++)
19 {
20 result += i;
21 }
22
23 printf("result[1-100] = %d \n", result );
24 printf("result[1-250] = %d \n", func(250) );
25 }

编译生成执行文件:(Linux下)
hchen/test> cc -g tst.c -o tst

使用GDB调试:

hchen/test> gdb tst <---------- 启动GDB
GNU gdb 5.1.1
Copyright 2002 Free Software Foundation, Inc.
GDB is free software, covered by the GNU General Public License, and you are
welcome to change it and/or distribute copies of it under certain conditions.
Type "show copying" to see the conditions.
There is absolutely no warranty for GDB. Type "show warranty" for details.
This GDB was configured as "i386-suse-linux"...
(gdb) l <-------------------- l命令相当于list,从第一行开始例出原码。
1 #include
2
3 int func(int n)
4 {
5 int sum=0,i;
6 for(i=0; i
7 {
8 sum+=i;
9 }
10 return sum;
(gdb) <-------------------- 直接回车表示,重复上一次命令
11 }
12
13
14 main()
15 {
16 int i;
17 long result = 0;
18 for(i=1; i<=100; i++)
19 {
20 result += i;
(gdb) break 16 <-------------------- 设置断点,在源程序第16行处。
Breakpoint 1 at 0x8048496: file tst.c, line 16.
(gdb) break func <-------------------- 设置断点,在函数func()入口处。
Breakpoint 2 at 0x8048456: file tst.c, line 5.
(gdb) info break <-------------------- 查看断点信息。
Num Type Disp Enb Address What
1 breakpoint keep y 0x08048496 in main at tst.c:16
2 breakpoint keep y 0x08048456 in func at tst.c:5
(gdb) r <--------------------- 运行程序,run命令简写
Starting program: /home/hchen/test/tst

Breakpoint 1, main () at tst.c:17 <---------- 在断点处停住。
17 long result = 0;
(gdb) n <--------------------- 单条语句执行,next命令简写。
18 for(i=1; i<=100; i++)
(gdb) n
20 result += i;
(gdb) n
18 for(i=1; i<=100; i++)
(gdb) n
20 result += i;
(gdb) c <--------------------- 继续运行程序,continue命令简写。
Continuing.
result[1-100] = 5050 <----------程序输出。

Breakpoint 2, func (n=250) at tst.c:5
5 int sum=0,i;
(gdb) n
6 for(i=1; i<=n; i++)
(gdb) p i <--------------------- 打印变量i的值,print命令简写。
$1 = 134513808
(gdb) n
8 sum+=i;
(gdb) n
6 for(i=1; i<=n; i++)
(gdb) p sum
$2 = 1
(gdb) n
8 sum+=i;
(gdb) p i
$3 = 2
(gdb) n
6 for(i=1; i<=n; i++)
(gdb) p sum
$4 = 3
(gdb) bt <--------------------- 查看函数堆栈。
#0 func (n=250) at tst.c:5
#1 0x080484e4 in main () at tst.c:24
#2 0x400409ed in __libc_start_main () from /lib/libc.so.6
(gdb) finish <--------------------- 退出函数。
Run till exit from #0 func (n=250) at tst.c:5
0x080484e4 in main () at tst.c:24
24 printf("result[1-250] = %d \n", func(250) );
Value returned is $6 = 31375
(gdb) c <--------------------- 继续运行。
Continuing.
result[1-250] = 31375 <----------程序输出。

Program exited with code 027. <--------程序退出,调试结束。
(gdb) q <--------------------- 退出gdb。
hchen/test>

好了,有了以上的感性认识,还是让我们来系统地认识一下gdb吧。

使用GDB
————

一般来说GDB主要调试的是C/C++的程序。要调试C/C++的程序,首先在编译时,我们
必须要把调试信息加到可执行文件中。使用编译器(cc/gcc/g++)的 -g 参数可以
做到这一点。如:

> cc -g hello.c -o hello
> g++ -g hello.cpp -o hello

如果没有-g,你将看不见程序的函数名、变量名,所代替的全是运行时的内存地址。
当你用-g把调试信息加入之后,并成功编译目标代码以后,让我们来看看如何用
gdb来调试他。

启动GDB的方法有以下几种:

1、gdb
program也就是你的执行文件,一般在当然目录下。

2、gdb core
用gdb同时调试一个运行程序和core文件,core是程序非法执行后core dump后产生的文件。

3、gdb

如果你的程序是一个服务程序,那么你可以指定这个服务程序运行时的进程ID。
gdb会自动attach上去,并调试他。program应该在PATH环境变量中搜索得到。

GDB启动时,可以加上一些GDB的启动开关,详细的开关可以用gdb -help查看。我在下面只例举一些比较常用的参数:

-symbols
-s
从指定文件中读取符号表。

-se file
从指定文件中读取符号表信息,并把他用在可执行文件中。

-core
-c
调试时core dump的core文件。

-directory
-d
加入一个源文件的搜索路径。默认搜索路径是环境变量中PATH所定义的路径。

GDB的命令概貌
———————

启动gdb后,就你被带入gdb的调试环境中,就可以使用gdb的命令开始调试程序了,gdb的命令可以使用help命令来查看,如下所示:

/home/hchen> gdb
GNU gdb 5.1.1
Copyright 2002 Free Software Foundation, Inc.
GDB is free software, covered by the GNU General Public License, and you are
welcome to change it and/or distribute copies of it under certain conditions.
Type "show copying" to see the conditions.
There is absolutely no warranty for GDB. Type "show warranty" for details.
This GDB was configured as "i386-suse-linux".
(gdb) help
List of classes of commands:

aliases -- Aliases of other commands
breakpoints -- Making program stop at certain points
data -- Examining data
files -- Specifying and examining files
internals -- Maintenance commands
obscure -- Obscure features
running -- Running the program
stack -- Examining the stack
status -- Status inquiries
support -- Support facilities
tracepoints -- Tracing of program execution without stopping the program
user-defined -- User-defined commands

Type "help" followed by a class name for a list of commands in that class.
Type "help" followed by command name for full documentation.
Command name abbreviations are allowed if unambiguous.
(gdb)

gdb的命令很多,gdb把之分成许多个种类。help命令只是例出gdb的命令种类,如果
要看种类中的命令,可以使用help 命令,如:help breakpoints,查看设置断点的所
有命令。也可以直接help 来查看命令的帮助。


gdb中,输入命令时,可以不用打全命令,只用打命令的前几个字符就可以了,当然,
命令的前几个字符应该要标志着一个唯一的命令,在Linux下,你可以敲击两次TAB
键来补齐命令的全称,如果有重复的,那么gdb会把其例出来。

示例一:在进入函数func时,设置一个断点。可以敲入break func,

 

posted @ 2009-08-04 08:38 chaosuper 阅读(288) | 评论 (0)编辑 收藏

Perl 语言编程学习. 最近玩Linux ,发现很多脚本语言如 Perl Python Ruby. 有时间便自学,多学点东西总是有好处的. 由于Perl是用纯C语言些成的,学习起来相当的简单. 几个小时基本熟悉了Perl脚本语言.
posted @ 2009-08-04 07:57 chaosuper 阅读(98) | 评论 (0)编辑 收藏

1 用编辑器编辑包含所有操作的.sh 文件 2 修改文件的权限为可读可执行 3 运行当前的脚本
posted @ 2009-08-04 06:56 chaosuper 阅读(114) | 评论 (0)编辑 收藏

仅列出标题
共12页: First 4 5 6 7 8 9 10 11 12