实用调试技巧

是小刘同学啦

于 2022-03-11 23:09:46 发布

阅读量527

点赞数 3

分类专栏： C语言初阶笔记文章标签： c语言

本文链接：https://blog.csdn.net/m0_57388581/article/details/123128110

版权

笔记同时被 2 个专栏收录

52 篇文章 4 订阅

订阅专栏

C语言初阶

26 篇文章 1 订阅

订阅专栏

励志模块

一切都会变好的无敌好超级好爆炸好宇宙无敌超级爆炸好

一什么是bug?

bug在英文中是小虫、臭虫的意思。第一次被发现导致计算机发生错误的飞蛾，也是第一个计算机程序错误。

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

当我们的代码出现bug的时候，我们要学会调试，调试会帮助我们找到错误的代码，可见其重要性。

2.1 调试是什么？

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

2.2 调试的基本步骤

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

2.3 Debug和Release的介绍

Debug 通常称为调试版本，它包含调试信息，并且不作任何优化，便于程序员调试程序。
Release 称为发布版本，它往往是进行了各种优化，使得程序在代码大小和运行速度上都是最优
的，以便用户很好地使用。（release版本不能调试，Debug版本可以调试）

电脑：按f10 进行调试笔记本电脑：fn+f10 进行调试 fn叫辅助功键

Release版本要比Debug版本占用的内存要小，因为Debug版本中包含调试信息而且还没有进行优化。

三 Windows环境调试介绍

3.1 调试环境的介绍

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

3.2 学会快捷键

f5没有断点时直接调试完成
开始调试，经常用来直接跳到下一个断点处。
F9
创建断点和取消断点
断点的重要作用，可以在程序的任意位置设置断点。
这样就可以使得程序在想要的位置随意停止执行，继而一步步执行下去。(程序执行到断点处就会主动停下来）

f9和f5一般配合使用，先按f9，再按f5，那么代码就会直接来到红点所对应的那一行，如果是循环的话，按f5，会再次来到红点所对应的那一行，一直到循环结束，按一次，调试走一次，一直到调试完成。（f5虽然是开始调试，但是可以直接到达断点，f5向后执行代码，到下一个逻辑上的断点）

出现红色的点之后，右击红色的点，会出现条件，然后设置条件，会直接到达需要仔细观察的地方
F10
逐过程，通常用来处理一个过程，一个过程可以是一次函数调用，或者是一条语句。
F11
逐语句，就是每次都执行一条语句，但是这个快捷键可以使我们的执行逻辑进入调用的函数内部（这是最常用的）。

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

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

3.3.1 查看临时变量的值

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

f10->调试->窗口->监视（监视1、2、3、4 都是一样的。没有区别）

f10->调试->窗口->局部变量

3.3.2 查看内存信息

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

f10->调试->窗口->内存（内存1、2、3、4 也都是一样的）

3.3.3 查看调用堆栈

f10->调试->窗口->调用堆栈（可以看出哪一个函数调用哪一个函数）

3.3.4 查看汇编信息

（1）f10->调试->窗口->反汇编（2）右键->转到反汇编

3.3.5 查看寄存器信息

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

四一些调试的实例

代码展示：

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

调试结果：死循环打印 liu

编译器会报错：索引“12”超出了“0”至“9”的有效范围(对于可能在堆栈中分配的缓冲区“arr”)

代码理解：这个代码在vs编译器里仍然可以调试，在我们调试的过程中，发现越界访问arr[12]，正好是i所在的地址，在for循环里面，把arr[12]的值改成0，就相当于把i的值改成0，所以这个代码会出现

（1）i和arr是局部变量，局部变量是放在栈上的，栈区上的使用习惯是，先使用高地址处的地址，再使用低地址处的地址。数组随着下标的增长，地址是从高到低变化。（上面这个代码是故意为之的）

（2）如果i和arr之间的空间合适的话（这个根据编译器的不同，中间的空间也会有所不同），就有可能会使arr越界访问到i，造成循环变量i的改变，造成死循环。

五如何写出好（易与调试）的代码

5.1 优秀的代码

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

常见的coding技巧：

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

5.2 示范

模拟实现库函数：strcpy (string copy) （字符串拷贝）

（1）strcpy 库函数效果

代码展示：

#include <stdio.h>
int main()
{
	char arr1[20] = { 0 };
	char arr2[] = "hello";
	strcpy(arr1, arr2);
	printf("%s", arr1);
	return 0;
}

strcpy(a,b)是把b拷贝到a里面

（2）模拟实现strcpy

代码1展示：

#include <stdio.h>
void my_strcpy(char* a, char* b)
{
	while (*b != '\0')
	{
		*a = *b;
		a++;
		b++;
	}
	*a = *b;
}

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

但是，这个代码并不是最优的代码。

代码2展示：

知识点：assert （断言），头文件是<assert.h> ,在下面下的函数里面，断言不是空指针，assert(a != UNLL),如果a是空指针的话，就会报错，如果不是空指针的话就会正常运行。assert(a）也可以，两个的话assert（a && b）

报错代码展示：

#include <stdio.h>
#include <assert.h>
void my_strcpy(char* a, char* b)
{
	assert(a != NULL);
	assert(b != NULL);
	while (*b != '\0')
	{
		*a = *b;
		a++;
		b++;
	}
	*a = *b;
}

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

正常代码展示：

#include <stdio.h>
#include <assert.h>
void my_strcpy(char* a, char* b)
{
	assert(a != NULL);
	assert(b != NULL);
	while (*b != '\0')
	{
		*a = *b;
		a++;
		b++;
	}
	*a = *b;
}

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

代码3展示：

'\0'的ASCII代码为0.

#include <stdio.h>
#include <assert.h>
void my_strcpy(char* a, char* b)
{
	assert(a && b);
	while (*a++ = *b++)
	{
        ；
	}
}

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

不用前置++的原因是，前置++ 的话，第一个字母，就无法拷贝，前置++，什么都没有打印的原因是，char是字符类型，0对应的ASCII值是'\0',打印的结果是字符串，字符串遇见'\0'又是停止，所以什么也没有打印。

代码4展示：

#include <stdio.h>
#include <assert.h>
char* my_strcpy(char* a, char* b)
{
	assert(a && b);
	char* ret = a;
	while (*a++ = *b++)
	{
		;
	}
	return ret;
}

int main()
{
	char arr1[20] = { 0 };
	char arr2[] = "hello";
	/*my_strcpy(arr1, arr2);
	printf("%s", arr1);*/
	printf("%s\n", my_strcpy(arr1, arr2));//函数的链式访问
	return 0;
}

这个是为了与strcpy更加像。

代码5展示:

为了避免出现把*a++ = *b++，这两个数写反，引入const这个常量，可以避免指针变量指向的内容被修改，如果出现错误，那么这个代码就无法运行起来，就会更简单的检查出代码的bug.

#include <stdio.h>
#include <assert.h>
char* my_strcpy(char* a, const char* b)
{
	assert(a && b);
	char* ret = a;
	while (*a++ = *b++)
	{
		;
	}
	return ret;
}

int main()
{
	char arr1[20] = { 0 };
	char arr2[] = "hello";
	/*my_strcpy(arr1, arr2);
	printf("%s", arr1);*/
	printf("%s\n", my_strcpy(arr1, arr2));//函数的链式访问
	return 0;
}

（3）模拟实现strlen

代码展示:

#include <stdio.h>
#include <assert.h>
int my_strlen(const char* m)
{
	assert(m != NULL);
	int n = 0;
	while (*m != '\0')
	{
		n++;
		m++;
	}
	return n;
}
int main()
{
	char arr[] = "abcdef";
	int len = 0;
	len = my_strlen(arr);
	printf("%d", len);
	return 0;
}

（1）有assert （2）有注意指针是否为空指针

5.3 const的作用

const可以修饰变量，也就是在我初识C语言（1）中讲的const修饰的常变量（感兴趣的友友们可以浅看一下下）。

const也可以修饰指针变量，const修饰指针变量的时候：

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

变。但是指针变量本身的内容可变。

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

针指向的内容，可以通过指针改变。

3.const即在*左边又在*右边，那么指针变量本身和指针指向的内容都不能够改变。

代码1展示：

#include <stdio.h>
int main()
{
	const int a = 10;//
	//a = 20;//这里a的值不能改变为20.
	int* pa = &a;
	*pa = 20;
	printf("%d", a);
	return 0;//本来a的值是不能改变的，但是通过取地址就可以，但是这是一种违规操作。
}

为了用取地址的方法也不能改变a的值，加上了const，变成了const int* pa = &a.

代码2展示：

#include <stdio.h>
int main()
{
	const int a = 10;//
	//a = 20;//这里a的值不能改变为20.
	int b = 20;
	const int* pa = &a;//const在这里修饰的是指针指向的内容*pa,，指针指向的内容不能通过指针来改变
	// 但是可以改变pa的内容，pa本来存放的是a地址，现在也可以改变为存放b的地址。
	printf("%d", a);
	return 0;
}

代码展示：

#include <stdio.h>
int main()
{
	const int a = 10;
	int* const pa = &a;//const在这里修饰的是指针本身pa,，指针本身的内容不能改变，但是指针指向的内容可以改变
	*pa = 20;
	printf("%d", a);
	return 0;
}

const int a = 10,这个代码a通过指针是可以改变的。