C语言基础-实用调试技巧
文章目录
- 什么是bug？
- 什么是调试？如何调试？
- Debug和Release
- windows环境调试介绍
-
- 1. 调试环境的准备
- 2.使用快捷键
- 3. 调试的时候查看程序当前信息
- 调试实例
-
- 求 1！+2！+3！ ...+ n! ；不考虑溢出。
- 遍历数组（越界访问）
- 如何写出好（易于调试）的代码
-
- strcpy函数模拟实现
- strlen函数模拟实现
-
- 关于size_t无符号整型的一个注意点
- const介绍
- 常见的编程错误
-
- 编译型错误
- 链接型错误
- 运行时错误
什么是bug？
第一次被发现的导致计算机错误的飞蛾，也是第一个计算机程序错误，此后就把导致程序的错误称之为bug。
什么是调试？如何调试？
所谓调试又称除错，就是发现和减少计算机程序或电子仪器设备中程序错误的过程。
调试的步骤：
1.首先要发现程序存在错误；
2.定位错误发生的地方（隔离、消除等方式）；
3.找到错误的原因；
4.提出解决的办法；
5.改正错误，重新测试。
Debug和Release
Debug：调试版本，可以调试，它包含调试信息，并且不作任何优化，便于程序员调试程序。
Release：发布版本，用户版本，不可以调试，它往往是进行了各种优化，使得程序在代码大小和运行速度上都是最优的，以便用户很好地使用。
调试就是在Debug版本的环境中，找代码中潜伏的问题的一个过程。
windows环境调试介绍
注：linux开发环境调试工具是gdb，我们以后再学习。
1. 调试环境的准备
如下图，选择Debug版本，才能使代码正常调试。
2.使用快捷键
最常使用的几个快捷键：
F5
启动调试，经常用来直接调到下一个断点处。
F9
创建断点和取消断点 。
断点的重要作用，可以在程序的任意位置设置断点。这样就可以使得程序在想要的位置随意停止执行，继而一步步执行下去。
F10
逐过程，通常用来处理一个过程，一个过程可以是一次函数调用，或者是一条语句。（不进入函数）
F11
逐语句，就是每次都执行一条语句，但是这个快捷键可以使我们的执行逻辑进入函数内部（最长用的）。
ctrl+F5
开始执行不调试，如果你想让程序直接运行起来而不调试就可以直接使用。
ctrl+shift+F9
取消所有断点
shift+F11
跳出过程
设置条件断点：
右击断点，选择“条件”
设置条件
那么当i=5时，才会跳到断点处。
3. 调试的时候查看程序当前信息
在调试开始之后，查看变量的值。
1.查看临时变量的值
查看局部变量
2.查看内存信息
3.查看监视信息
4.查看调用堆栈
通过调用堆栈，可以清晰的反应函数的调用关系以及当前调用所处的位置。
5.查看汇编信息
6.查看寄存器信息
查看当前运行环境的寄存器的使用信息。
调试实例
求 1！+2！+3！ …+ n! ；不考虑溢出。
我们来看以下代码：
代码1：
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;
}
调试代码：
当i=3时，i! = 12，这里错误，我们发现每次进入外层循环时，ret没有从1开始，而是保存为上一次的值，ret一直累乘，所以造成错误。
更改为如下两种方法：
代码2：
int main()
{
int i = 0;
int sum = 0;//保存最终结果
int n = 0;
scanf("%d", &n);
for (i = 1; i <= n; i++)
{
int ret = 1;//保存n的阶乘
int j = 0;
for (j = 1; j <= i; j++)
{
ret *= j;
}
sum += ret;
}
printf("%d\n", sum);
return 0;
}
代码3：
int main()
{
//4! = 3!*4
int i = 0;
int sum = 0;//保存最终结果
int n = 0;
scanf("%d", &n);
int ret = 1;
for (i = 1; i <= n; i++)
{
ret *= i;
sum += ret;
}
printf("%d\n", sum);
return 0;
}
遍历数组（越界访问）
#include 运行程序，我们发现，程序进入死循环，这是为什么呢？我们调试代码
此时i=12，F10，单步调试，然后我们发现，当arr[12] = 0后，i变成了0，这是为什么呢？
我们查看变量i的地址，以及arr[12]的地址
我们发现，&i = &arr[12]，这是为什么呢？
1.数组arr和变量i是局部变量，局部变量在栈上面开辟空间的；
2.栈区的使用习惯是：先使用高地址处的空间，再使用低地址处的空间；
3.数组元素的地址随着下标的增长由低到高变化，随着数组元素下标的增大，数组越界，可能会造成死循环。
在VS2019编译器下，这段代码先创建了变量i，那么i的地址要比arr[9]的地址要大，所以随着数组元素下标的增大，数组越界，会找到i所在的那块空间，只是在VS2019编译器下，i和arr[9]之间间隔了两个整型元素。对于不同的编译器，i和arr[9]之间间隔是不同的。
怎么解决？我们在访问数组的时候，不要越界访问。
如何写出好（易于调试）的代码
对于优秀的代码，具有以下特点：
- 代码运行正常
- bug很少
- 效率高
- 可读性高
- 可维护性高
- 注释清晰
- 文档齐全
常见的调试技巧：
- 使用assert
- 尽量使用const
- 养成良好的编码风格
- 添加必要的注释
- 避免编码的陷阱
strcpy函数模拟实现
下面我们通过模拟实现strcpy函数，来演示一下优秀的代码
strcpy :字符串拷贝，包括字符串结束标志’\0’。
版本1：
//dest:指向目标空间
//src: 指向源字符串
void my_strcpy(char* dest, char* src)
{
while (*src!='\0')
{
*dest = *src;
dest++;
src++;
}
*dest = *src;
}
int main()
{
char arr1[] = "hello world";
char arr2[] = "hi girl";
my_strcpy(arr1, arr2);
printf("%s\n",arr1);
return 0;
}
版本2：
//dest:指向目标空间
//src: 指向源字符串
void my_strcpy(char* dest, char* src)
{
while (*src != '\0')
{
*dest++ = *src++;
}
*dest = *src;
}
版本3：
//dest:指向目标空间
//src: 指向源字符串
void my_strcpy(char* dest, char* src)
{
while (*dest++ = *src++)
{
;
}
}
版本4：
因为我们需要对dest和src解引用操作，所以要对指针有效性进行检查，这里我们使用assert进行判断，因为release版本会把assert优化掉，debug版本使用assert可以帮助我们判断指针有效性。
//dest:指向目标空间
//src: 指向源字符串
void my_strcpy(char* dest, char* src)
{
//if(src == NULL || dest == NULL)
//{
//return;
//}
//断言，release版本可以优化掉
//assert(src!=NULL);
//assert(dest!=NULL);
//assert(src);
//assert(dest);
assert(src && dest);
while (*dest++ = *src++)
{
;
}
}
版本5：
因为源字符串我们是不允许修改的，所以使用const修饰src，防止我们误操作修改src指向的内容。
//dest:指向目标空间
//src: 指向源字符串
void my_strcpy(char* dest, const char* src)
{
assert(src && dest);
while (*dest++ = *src++)
{
;
}
}
版本6
查看库函数strcpy，发现返回目的空间的首地址，所以我们将dest的首地址返回。
//dest:指向目标空间
//src: 指向源字符串
//返回值：char* 目标空间的起始地址
char* my_strcpy(char* dest, const char* src)
{
char* ret = dest;
assert(src && dest);
while (*dest++ = *src++)
{
;
}
return dest;
}
关于strcpy函数的几个注意点：
- 分析参数的设计（命名，类型），返回值类型的设计
- 对空指针解引用的危害。
- assert的使用
- 参数部分 const 的使用
- 字符串结束标志是’\0’，源字符串一定要有’\0’
- 目标空间要大于源字符串
- 目标空间必须可修改
int main()
{
char arr1[] = "abcdef";
//把常量字符串"ghijklmnopqrst"的首字符的地址存到指针变量arr2中
const char* arr2 = "ghijklmnopqrst";
//strcpy(arr2,arr1);//错误，目标空间属于常量区，不可以修改
//打印字符串，提供字符串首字符的地址即可
printf("%s\n",arr2);
printf("%c\n",*arr2);
return 0;
}
Null - ‘\0’ - 0
null - ‘\0’ - 0
NULL - 空指针
strlen函数模拟实现
方法1：
unsigned int my_strlen(const char* str)
{
assert(str!=NULL);
int count = 0;
while (*str != '\0')
{
count++;
str++;
}
return count;
}
方法2:
size_t my_strlen(const char* str)
{
assert(str!=NULL);
if (*str != '\0')
{
return 1 + my_strlen(str+1);
}
else
{
return 0;
}
}
方法3：
size_t my_strlen(const char* str)
{
assert(str!=NULL);
char* ret = str;
while (*str != '\0')
{
str++;
}
return str - ret;
}
这里size_t等价于unsigned int，但是unsigned int 也有自己存在的问题。
关于size_t无符号整型的一个注意点
int main()
{
//但是size_t有缺点：两个无符号数相减结果仍为无符号数
if (strlen("abc") - strlen("abcdefg"))
{
printf("hehe\n");//恒成立
}
else
{
printf("haha\n");
}
return 0;
}
const介绍
//代码1
void test1()
{
int n = 10;
int m = 20;
int* p = &n;
*p = 20;//ok
p = &m; //ok
}
//代码2 const放在*左边
void test2()
{
int n = 10;
int m = 20;
const int* p = &n;
//等价于int const * p
*p = 20;//error
p = &m; //ok
}
//代码3 const放在*的右边
void test3()
{
int n = 10;
int m = 20;
int* const p = &n;
*p = 20; //ok
p = &m; //error
}
int main()
{
test1();
test2();
test3();
return 0;
}
结论：
const修饰指针变量的时候：
-
const如果放在*的左边，修饰的是指针指向的内容，保证指针指向的内容不能通过指针来改变。但是指针变量本身的内容可变。
-
const如果放在*的右边，修饰的是指针变量本身，保证了指针变量的内容不能修改，但是指针指向的内容，可以通过指针改变。
-
*的左右两边都有const，既修饰指针又修饰指针指向的内容，保证指针指向的内容不能通过指针来改变，同时指针变量本身也是不能改变的。
常见的编程错误
编译型错误
这种错误一般都是语法错误，直接看错误提示信息（双击），解决问题。或者凭借经验就可以搞定。相对来说简单。
如以下代码
int main()
{
int i = 10;
printf("%d\n",i);
return 0
}
程序运行后，报如下错误
链接型错误
看错误提示信息，主要在代码中找到错误信息中的标识符，然后定位问题所在。一般是标识符名不存在或者拼写错误。
看下图代码，只是声明了函数，但是没有函数实现，这就是链接错误。
对于链接错误，我们一般都是直接搜索错误变量的名字。
运行时错误
借助调试，逐步定位问题。这种错误最难找到。
本章完。