实用调试技巧

bug的定义

中文常称BUG为“缺陷”。而且，“缺陷”一词更能反映事情的本质。因为“臭虫”是从外面飞进去的，并非程序本身有问题。而程序本身存在的问题，是程序原来就具有的。因此，在这里将BUG翻译为“系统漏洞”更合适。

调试

所有发生的事情都一定有迹可循，如果问心无愧，就不需要掩盖也就没有迹象了，如果问心有愧，就必然需要掩盖，那就一定会有迹象，迹象越多就越容易顺藤而上，这就是推理的途径。

顺着这条途径顺流而下就是犯罪，逆流而上，就是真相。

作为程序员不仅要会写代码还要会调试代码，并且不能盲目的调试，这样会浪费大量的时间。

调试的定义

调试（英语：Debugging / Debug），又称除错，是发现和减少计算机程序或电子仪器设备中程序错误的一个过程。

调试的基本步骤

• 发现程序错误的存在
• 以隔离、消除等方式对错误进行定位
• 确定错误产生的原因
• 提出纠正错误的解决办法
• 对程序错误予以改正，重新测试

Debug和Release的介绍。

Debug 通常称为调试版本，它包含调试信息，并且不做任何优化，便于程序员调试程序。

Release 称为发布版本，它往往是进行了各种优化，使得程序在代码大小和运行速度上都是最优的，以便用户很好地使用。（不能用来调试）

代码：

#include <stdio.h>
int main()
{
 	char *ch = "hello world";
 	printf("%s\n", ch);
 	return 0; 
}

上述代码在Debug环境的结果展示：

上述代码在Release环境的结果展示：

Debug和Release反汇编展示对比：

Debug反汇编

Release反汇编

所以调试就是在Debug版本的环境中，找代码中潜伏问题的一个过程。

在Release版本中那编译器进行了哪些优化呢？

下列代码：

#include <stdio.h>
int main()
{
    int i = 0;
    int arr[10] = {1,2,3,4,5,6,7,8,9,10};
    for(i=0; i<=12; i++)
    {
        arr[i] = 0;
        printf("hehe\n");
    }
    return 0; 
}

• 如果是 debug 模式去编译，程序的结果是死循环。
• 如果是 release 模式去编译，程序没有死循环。

那他们之间有什么区别呢？就是因为优化导致的。

我们对Debug版本调试：

• 可以看出当循环赋值超过数组界限时，依旧还在正常赋值，直到arr[12] = 0完成后，i的值也同步变为了0，i无法大于12，这样就会一直循环下去了。

听起来很神奇，但只要回归到栈区的分配规则上去分析即可。

• i和arr是局部变量，局部变量是放在栈区的，而栈区的使用习惯是先使用高地址处的空间，再使用低地址的空间。
• 而数组随着下标的增长地址是由低到高变化的。
• 再加上分配变量空间时中间间隔是由编译器决定的（x86）
  • VC6.0中间没有多余的空间
  • GCC中间空一个整型
  • VS2013\2019\2022 中间空两个整型
• 综上所述：我们可以看出当数组越界时，会逐步靠近i所在的地址空间，从而当越界访问到i时，我们将其置为0，循环就无法结束。

因此归根结底两个模式的区别在于 release 模式的优化改变了变量在内存中开辟的顺序，从而影响到了程序执行结果。

代码验证：

• debug模式&i和arr地址比较

• release模式&i和arr地址比较

上述可以看出，release模式将i的栈区地址改到了arr前面。

Windows环境调试介绍

linux开发环境调试工具是gdb(后期详解)

调试环境的准备

在环境中选择 debug 选项，才能使代码正常调试。

学会快捷键

常用快捷键：

F5

启动调试，经常用来直接跳到下一个断点处。

F9

创建断点和取消断点。

可以在程序的任意位置设置断点。

这样就可以使得程序在想要的位置随意停止执行，继而一步步执行下去。

F10

逐过程，通常用来处理一个过程，一个过程可以是一次函数调用，或者是一条语句。（不进入函数内部）

F11

逐语句，就是每次都执行一条语句，但是这个快捷键可以使我们的执行逻辑进入函数内部（这是最常用的）。

CTRL + F5

开始执行不调试，如果你想让程序直接运行起来而不调试就可以直接使用。

Visual Studio常用快捷键

快捷键记忆规律：

• ctrl是强制功能键
• shift有给项目增加功能

例如：Ctrl+F（查找）-> Ctrl+Shift+F（在文件中查找）

调试的时候查看程序当前信息

首先需要调试起来才能查看程序的各项信息

调试起来时，会出现一个黄色的箭头。

Visual Studio 在调试的情况下可以拖动左侧的黄色箭头进行上下拖动，然后就能直接到达移动到的语句处。

那么这个有什么作用呢，有时候我们可能想用F11跟到某个方法里面进行调用过程的查看，结果一个不小心发现手误按下了F10，此时代码执行到了方法调用的下一句，那么我们此时就可以点击左侧的黄色箭头，并按住鼠标左键，往上一拖，这个时候，就又可以执行刚才的方法调用的那句代码了，如果往下拖，那么可以跳过一些语句代码的执行。

查看临时变量的值

在调试开始之后，用于观察变量的值。

观察变量的值我们可以有三个选择：

• 局部变量窗口：它只会显示局部变量的值，当进入调用函数内部时，主函数的值就看不到了。
• 自动窗口：它会自动帮助你寻找上下文中你可能需要的变量的值。
• 监视窗口：本身是什么都不会显示的，需要通过自己手动添加，可以查看任何变量的值。（推荐）

查看内存信息

在调试开始之后，用于观察内存信息。

例如上图我输入&i之后定位到第一行地址即为i的地址和对应的赋值内容。

查看调用堆栈

通过调用堆栈，可以清晰的反应函数的调用关系以及当前调用所处的位置。

代码举例：

#include <stdio.h>
void test3() {
	printf("Hello World");
}

void test2() {
	test3();
}

void test1() {
	test2();
}

int main()
{
	test1();
	return 0;
}

查看调用堆栈：

查看汇编信息

在调试开始之后，有两种方式转到汇编

• 右击鼠标，选择【转到反汇编】

• 在调试然后窗口选项里面选择反汇编。

查看寄存器信息

可以查看当前运行环境的寄存器的使用信息。

寄存器的值在进行逆向分析时是很有用的。

练习方式

• 一定要熟练掌握调试技巧。
• 初学者可能80%的时间在写代码，20%的时间在调试。但是一个程序员可能20%的时间在写程序，但是80%的时间在调试。
• 我们所讲的都是一些简单的调试。以后可能会出现很复杂调试场景：多线程程序的调试等。
• 多多使用快捷键，提升效率。

调试实例

实例一

实现代码：求 1！+2！+3！ …+ n! ；不考虑溢出。

#include <stdio.h>
int main()
{
 	int i = 0;
 	int sum = 0;//保存最终结果
 	int n = 0;
 	int ret = 1;//保存n的阶乘
 	scanf("%d", &n);
 	for(i=1; i<=n; i++)
 	{
 		int j = 0;
 		for(j=1; j<=i; j++)
 		{
 			ret *= j;
 		}
 		sum += ret;
 	}
 	printf("%d\n", sum);
 	return 0; 
}

这时候我们如果3，期待输出9，但实际输出的是15。

这里我们就得找到问题：

1. 首先推测问题出现的原因。初步确定问题可能的原因最好。
2. 实际上手调试很有必要。
3. 调试的时候我们心里有数。

首先因为结果偏大，我怀疑是循环内部出现了问题。也许是循环次数的问题，也有可能是变量的初始化问题。

我们断点打到数据输入口，然后进入循环，在第三轮的时候发现ret的值直接到了12，然后观察发现ret在每次进入内层循环时并没有初始化，到导致累乘的之前的值，所以结果偏大。

代码改为：

#include <stdio.h>
int main()
{
    int i = 0;
    int sum = 0;//保存最终结果
    int n = 0;
    int ret = 1;//保存n的阶乘
    scanf("%d", &n);
    for (i = 1; i <= n; i++)
    {
        int j = 0;
        int ret = 1;
        for (j = 1; j <= i; j++)
        {
            ret *= j;
        }
        sum += ret;
    }
    printf("%d\n", sum);
    return 0;
}

实例二

#include <stdio.h>
int main()
{
    int i = 0;
    int arr[10] = {0};
    for(i=0; i<=12; i++)
   	{
        arr[i] = 0;
        printf("hehe\n");
   	}
    return 0; 
}

参考：Debug和Release的介绍章节，研究程序死循环的原因。

如何写出好（易于调试）的代码。

优秀的代码

1. 代码运行正常
2. bug很少
3. 效率高
4. 可读性高
5. 可维护性高
6. 注释清晰
7. 文档齐全

常见的coding技巧：

1. 使用assert
2. 尽量使用const
3. 养成良好的编码风格
4. 添加必要的注释
5. 避免编码的陷阱。

示范

《高质量C/C++编程》一书中最后章节试卷中有关 strcpy 模拟实现的题目。

模拟实现库函数：strcpy

/***
*char *strcpy(dst, src) - copy one string over another
*
*Purpose:
*       Copies the string src into the spot specified by
*       dest; assumes enough room.
*
*Entry:
*       char * dst - string over which "src" is to be copied
*       const char * src - string to be copied over "dst"
*
*Exit:
*       The address of "dst"
*
*Exceptions:
*******************************************************************************/
char * strcpy(char * dst, const char * src) {
        char * cp = dst;
        assert(dst && src);
 
        while( *cp++ = *src++ )
               ;     /* Copy src over dst */
        return( dst );
}

步骤：

1. 首先我们模拟实现一个函数需要确定参数和返回值类型，我们可以查询文档来观察。从下图中我们可以看出strcpy函数传参为两个字符数组的首元素地址，destination指针指向的内容是会被改变的，而source指针指向的内容则不可改变，用const修饰更加安全。

2. 由于我们传参是通过指针来接收的，所以如果出现野指针和空指针，会对系统造成不可预知的错误。

   • 野指针：会引发指向无效内存区域的错误
     
   • 空指针：因为为空指针所以会出现访问权限冲突
     

3. assert()函数可以用来捕获编程错误，此宏与函数形式的参数表达式比较（即表达式为 false），则将一条消息写入标准错误设备并被调用，从而终止程序执行。

4. 注释的添加

因此正确代码如下：

#include<stdio.h>
#include<assert.h>
char* my_strcpy(char* dest, const char* src) {
	char* p = dest;
	assert(dest && src);
	while (*p++ = *src++) {//先将*src赋值给*p，同时将这个赋值结果成为整个表达式的值，用以决定while()循环是否退出，最后再将在整个表达式结束前的某个时刻（不影响之前的操作），p和src被加1。
		;
	}
	return dest;
}

int main() {
	char arr1[20] = "#############";
	char arr2[] = "hello";
	printf("%s\n", my_strcpy(arr1, arr2));
	return 0;
}

const的作用

#include <stdio.h>
//代码1
void test1()
{
    int n = 10;
    int m = 20;
    int *p = &n;
    *p = 20;//ok
     p = &m; //ok
}
void test2()
{
     //代码2
    int n = 10;
    int m = 20;
    const int* p = &n;
    *p = 20;//no
     p = &m; //ok
}
void test3()
{
    int n = 10;
    int m = 20;
    int *const p = &n;
    *p = 20; //ok
     p = &m;  //no
}
int main()
{
    //测试无cosnt的
    test1();
    //测试const放在*的左边
    test2();
    //测试const放在*的右边
    test3();
    return 0; 
}

结论（const修饰指针变量的时候）：

1. const如果放在*的左边，修饰的是指针指向的内容，保证指针指向的内容不能通过指针来改变。但是指针变量本身的内容可变。

2. const如果放在*的右边，修饰的是指针变量本身，保证了指针变量的内容不能修改，但是指针指向的内容，可以通过指针改变。

练习：

模拟实现一个strlen函数

/***
*strlen.c - contains strlen() routine
*
*       Copyright (c) Microsoft Corporation. All rights reserved.
*
*Purpose:
*       strlen returns the length of a null-terminated string,
*       not including the null byte itself.
*
*******************************************************************************/
 
#include <cruntime.h>
#include <string.h>
 
#pragma function(strlen)
 
/***
*strlen - return the length of a null-terminated string
*
*Purpose:
*       Finds the length in bytes of the given string, not including
*       the final null character.
*
*Entry:
*       const char * str - string whose length is to be computed
*
*Exit:
*       length of the string "str", exclusive of the final null byte
*
*Exceptions:
*
*******************************************************************************/
 
size_t __cdecl strlen (
        const char * str
        )
{
        const char *eos = str;
 
        while( *eos++ ) ;
 
        return( eos - str - 1 );
}

模拟实现代码：

#include<stdio.h>
#include<assert.h>

int my_strlen1(const char* str) {
	assert(str);
	int len = 0;
	while (*str++) {
		len++;
	}
	return len;
}

int my_strlen2(const char* str) {
  	assert(str);
	const char* end = str;
	while (*end++);
	return end - str - 1;
}

int main() {
	char arr[] = "hello world!";
	printf("%d\n", my_strlen1(arr));
	printf("%d\n", my_strlen2(arr));
	return 0;
}

编程常见的错误

编译型错误

直接看错误提示信息（双击），解决问题。或者凭借经验就可以搞定。相对来说简单。

链接型错误

看错误提示信息，主要在代码中找到错误信息中的标识符，然后定位问题所在。一般是标识符名不存在或者拼写错误。

运行时错误

借助调试，逐步定位问题。最难搞。

运用前面所讲解的方法多尝试，注意观察，多总结即可。