【C语言初阶】实用调试技巧

【C语言初阶】实用调试技巧

正文：

---

本章目标：

学会在Windows环境下的debug调试。

本章重点：

• 什么是bug？
• 调试是什么？有多重要？
• debug和release的介绍。
• windows环境调试介绍。
• 一些调试的实例。
• 如何写好（易于调试）的代码。
• 编程常见的错误。

---

一、什么是bug？

世界上第一个导致计算机出错的是一只飞蛾（bug）。

二、调试是什么？有多重要？

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

顺着这条途径顺流而下就是犯罪，逆流而上，就是真相。——《红日》（徐天）

一名优秀的程序员一定是一名出色的侦探（排错专家）。

而每一次调试都是一次尝试破案的过程。

1 IDE启动！复制粘贴！F5运行！

你是如何写代码的？

复制粘贴？ctrl C/V？

又是如何排查出现的问题呢？

2 调试是什么？

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

3 调试的基本步骤

1.发现程序错误存在

2.以隔离、消除等方式对错误进行定位

3.确定错误产生的原因

4.提出纠正错误的解决办法

5.对程序错误予以改正，重新测试

4 Debug 和 Release

4.1 Debug

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

4.2 Release

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

4.3 示例1

代码示例：

#include<stdio.h>

int main()
{
	char* p = "hello wdt.";
	printf("%s\n", p);

	return 0;
}

解释说明：

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

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

3 Debug 和 Release 的反汇编展示对比：（反汇编需要调试起来才能查看）

Debug：

Release：

4 调试就是在 Debug 版本的环境中，排查代码中潜藏的问题的一个过程。

4.4 示例2

代码示例：

#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;
}

解释说明：

1 如果是 Debug 模式去编译，程序的结果可能是死循环。

2 如果是 Release 模式去编译，程序没有死循环。

3 因为 Release 模式有优化， Debug 模式不作任何优化。

4 使用F10进入调试。F10 ：逐过程调试

  在 Debug 环境下，进入调试后发现，通过下标12进行访问，会发现 arr[12] 的地址就是循环控制变量 i 的地址，将 arr[12] 置为0就意味着循环控制变量 i 变为了0，然后再进行条件判断，会发现一直为真，陷入了死循环。

三、Windows 环境调试介绍

注意： gdb 是 Linux 开发环境下的调试工具。

1 调试环境的准备

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

2 快捷键的使用

2.1 图示

2.2 最常使用的几个快捷键

F5

开始调试（启动调试），经常用来直接调到下一个断点处。

F9

创建/取消断点。

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

  设置断点可以使得程序流在想要的位置随意停止执行，继而通过程序员的掌控一步步地执行下去。

  设置断点然后按F5，可以让程序流快速到达断点处；然后就可以按F10或F11进行调试。

F10

逐过程，通常用来处理一个过程，一个过程可以是一次函数调用，也可以是一条语句。

  遇到函数调用，一下就执行完毕，不会进入到函数体里。

F11

逐语句，就是每次都只执行一条语句，这个快捷键可以使执行逻辑（程序流）进入函数内部。

  粒度更细，遇到函数调用会进入到函数内部。

Ctrl+F5

开始执行（不调试），如果想让程序直接运行起来而不调试就可以使用此快捷键。

  如果有很多断点，此时又不想来到断点处，也不想进行调试，只想着运行完代码，直接Ctrl+F5运行。

设置断点触发条件

右击断点，选择“条件”，设置条件触发条件。

  比如：在执行循环语句的时候，在断点处设置断点触发条件，然后调试运行程序，程序流就会跳转到断点触发条件的位置，这样就会很方便地控制程序流进行调试。

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

1 查看临时变量的值

1.1 介绍

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

1.2 调试 -> 窗口 -> 自动窗口

根据程序流上下文的执行信息，会自动添加或删除它自己认为需要监视的信息。（监视信息的变化的）

1.3 调试 -> 窗口 -> 监视

可以任意添加想要监视的项（合法的项）。

2 查看内存信息

2.1 介绍

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

2.2 调试 -> 窗口 -> 内存

3 查看调用堆栈

3.1 介绍

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

3.2 调试 -> 窗口 -> 调用堆栈

4 查看汇编信息

4.1 介绍

在调试开始之后，可以切换到汇编代码。

4.2 转到反汇编

4.2.1 方法一：右击鼠标，选择“转到反汇编”

4.2.2 方法二：调试 -> 窗口 -> 反汇编

5 查看寄存器信息

5.1 介绍

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

5.2 调试 -> 窗口 -> 寄存器

四、调试注意事项

1.一定要熟练掌握调试技巧。

2.初学者可能80%的时间在写代码，20%的时间在调试。但是一个程序员可能20%的时间在写代码，80%的时间在进行调试。

3.现在这些都是简单的调试，后续的学习会出现很复杂的调试场景，比如：多线程程序的调试等。

4.多多使用快捷键，提升效率。

五、一些调试的实例

1 实例1

求 1! + 2! + 3! + … + n! ，不考虑溢出。

代码示例：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>

int main()
{
	//求 1! + 2! + 3! + ... + n! ，不考虑溢出。
	int n = 0;
	int mul = 1;
	int sum = 0;

	scanf("%d", &n);

	int i = 0;
	for (i = 1; i <= n; i++)
	{
		int j = 0;
		for (j = 1; j <= i; j++)
		{
			mul *= j;
		}
		sum += mul;
	}
	printf("n! = %d\n", sum);

	return 0;
}

解释说明：

1 程序运行后发现：当输入的 n 为3的时候，输出的结果是15，而并非是9，这是为什么呢？

  1.首先推测问题出现的原因。能初步确定问题出现的原因最好。

  2.动手调试起来。

  3.调试的时候做到心中有数。

2 调试中，我们发现：

  每当求一次 i 的阶乘后， ret 的值就变成了 i! ，当进行下一次求阶乘时，ret 还是 i! ；

  原来是当每求完一次阶乘后，ret 的值要置为1，不然只会越乘越大。

2 实例2

代码示例：

#include<stdio.h>

int main()
{
    //示例2

	int i = 0;
	int arr[10] = { 0 };

	printf("%p\n", &i);
	printf("%p\n", &arr[12]);

	for (i = 0; i <= 12; i++)
	{
		arr[i] = 0;
		printf("hehe\n");
	}

	return 0;
}

解释说明：

1 在VS2019（X86，Debug）环境下，数组越界访问，导致程序死循环。

2 循环控制变量 i 和 arr 数组元素都是局部变量，存放在栈区。

  栈区：先使用高地址处的空间，再使用低地址处的空间。

  随着数组下标的增长，地址是由低到高增长的。

3 图示说明：

4 将 arr[12] 赋值为0就相当于是给循环控制变量 i 赋值为0，故每次进行循环入口检查时都为真。

六、如何写出易于调试的代码

1 优秀的代码

1.代码运行正常

2.程序 bug 很少

3.效率高

4.可读性高

5.可维护性高

6.注释清晰

7.文档齐全

2 常见的 Coding 技巧

1.使用 assert 断言

2.尽量使用 const

3.养成良好的编码风格

4.添加必要的注释

5.避免编码的陷阱

3 模拟实现库函数 strcpy

3.1 介绍

库函数介绍：

把源字符串的内容拷贝到目标空间里，同时返回目标空间的起始地址。（ 拷贝字符串，包括 \0 ）

/***
* char * strcpy ( char * destination, const char * source );
*
* Purpose：
*	 Copies the C string pointed by source into the array pointed by destination,
*	 including the terminating null character (and stopping at that point).
*
* Parameters：
*	 destination：
*	 	 Pointer to the destination array where the content is to be copied.
*	 source：
*		 C string to be copied.
*
* Return Value：
* 	 destination is returned.
*
***/

3.2 示例

代码示例：

#include<stdio.h>

#include<assert.h>
char* my_strcpy(char* dest,const char* src)
{
	char* ret = dest;//记录目标空间的起始位置
	
	//断言 - 当条件不满足时，就报错并定位到此处
	//assert(dest != NULL);//防止目的字符数组为空
	//assert(src  != NULL);//防止源字符串为空
	assert(dest && src);//上述两句可以合并为一句

	//while (*src != '\0')
	//{
	//	*dest = *src;
	//	dest++;
	//	src++;
	//}
	//*dest = *src;//拷贝源字符串末尾的\0

	//while (*dest = *src)
	//{
	//	dest++;
	//	src++;
	//}
	while (*dest++ = *src++)
		continue;//拷贝源到目的

	return ret;//返回目标空间的起始地址
}
int main()
{
	//模拟实现库函数strcpy()

	char arr[20] = { 0 };

	//my_strcpy(arr, "hello wdt.");
	//printf("%s\n", arr);
	printf("%s\n", my_strcpy(arr, "hello wdt."));//函数的链式访问

	return 0;
}

解释说明：

1.函数参数的设计：

  (char* dest, const char* src) ：目的地址与源地址

​    dest ：目标地址，src ：源地址

  要拷贝到目的地址，那么就会修改数据；

  如果只是复制源的值，那么就不能改变源的值，就可以使用 const 来修饰源。

2.函数返回类型的设计：

  char* ：函数的返回类型

  返回目的空间的地址，可以实现函数的链式访问。

3.预防野指针与空指针

  assert() ：使用断言，如果参数为假就会报错，使用时需要包含头文件 <assert.h>。

4.注释的添加：

  做好注释的添加，方便以后阅读。

4 示例

4.1 const 修饰指针变量

代码示例：

#include<stdio.h>

void test1()
{
	int n = 10;
	int m = 20;
	int* p = &n;
	*p = 30;
	p = &m;
}
void test2()
{
	int n = 10;
	int m = 20;
	const int* p = &n;
	//*p = 30;//error；const在*左侧，限制*p
	p = &m;
}
void test3()
{
	int n = 10;
	int m = 20;
	int* const p = &n;
	*p = 30;
	//p = &m;//error；const在*右侧，限制p
}
void test4()
{
	int n = 10;
	int m = 20;
	const int* const p = &n;
	//*p = 30;	//error；const在*左侧，限制*p
	//p = &m;	//error；const在*右侧，限制p
}
int main()
{
	//const的作用 — const与指针

	//无const
	test1();
	//const在*左侧 
	test2();
	//const在*右侧 
	test3();
	//const在*两侧
	test4();

	return 0;
}

解释说明：

const 修饰指针变量：

1.const 如果放在 * 的左侧，那么修饰的是指针变量的内容，确保指针指向的内容不能通过指针解引用来改变。但是指针变量的值可以修改（可以修改指向）。

2.const 如果放在 * 的右侧，那么修饰的是指针变量本身，确保指针变量的内容不能被改变（不能改变指向）。但是可以通过指针变量修改指向的内容。

总结：

  const 在 * 左侧，限制 *p ；

  const 在 * 右侧，限制 p 。

4.2 模拟实现 strlen

代码示例：

#include<stdio.h>

#include<assert.h>
int my_strlen1(const char* str)
{
	//计数器

	assert(str);//断言，防止传入空指针

	int count = 0;

	//while (*str++ != '\0')
	//	count++;
	//return count;

	while (str[count++] != '\0')
		continue;

	return count - 1;//减1是因为count下标最终自增为\0后一位置的下标
}
int my_strlen2(const char* str)
{
	//函数递归

	if (*str != '\0')
		return 1 + my_strlen2(str + 1);
	else
		return 0;
}
int my_strlen3(const char* str)
{
	//指针 - 指针

	assert(str);//断言，防止传入空指针

	char* ret = str;//记录字符串的起始地址

	//while (*str++ != '\0')
	//	continue;
	//return str - ret - 1;//减1是因为在循环结束后，str指向了\0后一位置的地址

	while (*str != '\0')
		str++;
	return str - ret;
}
int main()
{
	//模拟实现strlen

	const char* p = "hello wdt.";

	//计算字符串的长度，\0不计数
	printf("my_strlen1::len = %d\n", my_strlen1(p));//10
	printf("my_strlen2::len = %d\n", my_strlen2(p));//10
	printf("my_strlen3::len = %d\n", my_strlen3(p));//10

	return 0;
}

解释说明：

1 模拟实现 strlen 的三种方法：计数器、函数递归、指针-指针。

七、编程常见的错误

1 编译型错误（编译期间产生）

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

2 链接型错误（链接期间产生）

观察错误提示信息，主要在代码中找到错误信息中的表示符，然后定位问题所在。

一般是标识符名称不存在或者拼写错误。

3 运行时错误（运行期间产生）

借助调试，逐步定位问题所在。最难排查。

4 编程建议

做一个有心人，积累排错经验。

总结：

  **本章

介绍了 Debug（调试版本）与 Release（发布版本）以及调试的基本步骤，讲解了在调试代码时常用的快捷键以及在调试时可以观察到的程序当前信息（内存、调用堆栈、反汇编等），给出了调试时的注意事项、调试的实例以及编程时常见的错误。**

---

感谢您的阅读！如有任何错误，欢迎您的批评指正！