初阶C语言(9)-VS的实用调试技巧

什么是bug

计算机程序错误就叫bug，也称为缺陷 、臭虫
第一次被发现的导致计算机错误的飞蛾，也是第一个计算机程序错误。

调试

所有发生的事情都一定有迹可循，如果问心无愧，就不需要掩盖也就没有迹象了，如果问心有愧， 就必然需要掩盖，那就一定会有迹象，迹象越多就越容易顺藤而上，这就是推理的途径。顺着这条途径顺流而下就是犯罪，逆流而上，就是真相。
一名优秀的程序员是一名出色的侦探，每一次调试都是尝试破案的过程。
如果每次写程序报错了，就随便猜想是哪里出错了，这样是没有科学依据的。我们要拒绝迷信式调试！

调试是什么

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

调试的基本步骤

●发现程序错误的存在 （程序员本身->测试人员->用户）
●以隔离、消除等方式对错误进行定位
●确定错误产生的原因
●提出纠正错误的解决办法
●对程序错误予以改正，重新测试

Debug和Release

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

由于Release对程序进行了优化，所以同一个程序的Debug版本和Release版本运行结果可能会有差异

Windows环境调试介绍

调试环境的准备

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

学会快捷键

以下为最常使用的几个快捷键:

F5

启动调试，经常用来直接跳到下一个断点处。没断点拦住它的话，就一口气干完了

F9

• 创建断点和取消断点
• 断点的可以在程序的任意位置设置断点，使得程序在这个位置断开
• 这样就可以使得程序在想要的位置随意停止执行，继而一步步执行下去。搭配F5使用，在已知bug可能出现的位置的时候，就能避免F10一个个按，大大提高了效率。
• 鼠标右击断点，里面可以设置条件断点，输入条件表达式从而精准定位到某次循环，提高效率

F10

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

F11

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

CTRL+F5

开始执行不调试，如果你想让程序直接运行起来而不调试就可以直接使用。（设置了断点也不管，一口气干完，谁也拦不住）

如果以上快捷键按起来不生效，则需要按Fn-辅助功能键然后配合以上快捷键使用。
如果不想按Fn，就按Fn+Esc关闭辅助功能键。就可以直接按快捷键了

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

以下这些窗口都必须在程序按了F10或F11然后才可以在调试的窗口里面找到

查看临时变量的值：在调试开始之后，用于观察内存信息

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

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

ps：栈=堆栈，堆！=栈

查看汇编信息

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

第一种方式：右击鼠标，选择【转到反汇编】：

第二种方式：在调试-窗口里面找到反汇编

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

多多动手，尝试调试，才能有进步

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

一些调试的实例

实现代码1：求 1！+2！+3！ …+ n! ；不考虑溢出。给出一个错误代码，我们对它进行调试分析

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

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。
为什么呢？
我们按F10一步步的走，最后发现是ret和我们的预期值不同。
为什么呢？
是因为ret每次被使用完之后没有清空，按上次的继续相乘，那么程序必然就会错误了调试技巧
总结以下几点：
1.首先推测问题出现的原因。
2.初步确定问题可能的原因。
3.实际上手调试很有必要。
4.调试的时候我们心里有数。

实例2：

1 2 3 4 5 6 7 8 9 10 11 12

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

这个程序按理来说，越界访问了，应该是会报错的，为什么这里程序执行的结果确是无限打印hehe呢？我们通过F9，然后给断点设置条件，观察它后面越界的时候到底发生了什么。
然后发现，arr[10]被改成了0，arr[11]也被改成了0,到arr[12]的时候，arr[12]被改成0，同时i也被改成0了，我们此时发现arr[12]和i的地址是相同的。i被改成0，然后循环执行到12的时候，又被改成0，这就是死循环的原因。

为什么呢？

说明

我们知道，i和arr都是局部变量，局部变量放在栈区(注意区分数据结构的栈)，而栈区的内存使用习惯是：先使用高地址空间，再使用低地址空间。
i先创建，所以i放在高地址，而arr后创建，放在低地址，数组的地址是随下标的大小正比例变化的。
倘若arr[12]刚好就和i重合，那么我们改变arr[12]就改变了i。

如果在Release版本运行又会如何呢？

程序没有进入死循环了，为什么？我们知道，如果要造成死循环的话，i的地址是比数组地址要高的。我们观察在Debug版本的地址情况：

debug

我们发现，i的地址确实比arr[9]高。如果在release版本呢？

release

arr[9]的地址明显比i的地址高，所以程序就不会进入死循环了
这也就是release对程序进行的优化

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

优秀的代码

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

常见的coding技巧

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

示范模拟实现strcmp

模拟实现strcpy函数，把src指向的内容拷贝放进dest指向的空间中
从本质上讲，希望dest指向的内容被修改，src指向的内容不被修改。
然后返回目标空间的起始地址
我们先把代码写出来，然后对它进行逐步的优化：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

#include char* my_strcpy(char* dest,char* src)     char* ret = dest;     while (*src != '\0')     {         *dest = *src;         dest++;         src++;     }     *dest = *src;//把src中'\0'放到dest中去     return ret; int main() {     char arr[20] = "*****************";     char arr2[10] = "hellow";     //strcpy  1.目标的起始地址 2.源空间的起始地址3.返回目标的起始地址     printf("%s", my_strcpy(arr, arr2));//因为my_strcpy返回的是arr的起始地址，所以可以进行链式访问-用函数的返回值作为参数     return 0; }

对my_strcpy函数进行优化

1 2 3 4 5 6 7 8

char* my_strcpy(char* dest,char* src)     char* ret = dest;     while (*src != '\0')     {         *dest++= *src++;//dest++和src++可以直接放在指针这里，因为满足先使用后自增     }     *dest = *src;     return ret;

我们还可以再优化

1 2 3 4 5 6 7

char* my_strcpy(char* dest,char* src)     char* ret = dest;     while (*dest++ = *src++)     {         ;//循环部分的值如果为\0，则停止循环，不然就一直执行自增然后赋值，这样的代码就是最优的最简的;即copy到\0的时候，循环就停止了     }     return ret;

我们还要考虑空指针的问题，野指针是非法访问的，必然会导致程序出错。怎么办呢？这里引入一个新的定义：assert-断言，利用断言对代码进行优化

1 2 3 4 5 6 7 8 9

char* my_strcpy(char* dest,char* src)    assert(dest != NULL);    assert(src != NULL);     char* ret = dest;     while (*dest++ = *src++)     {         ;//循环部分的值如果为\0，则停止循环，不然就一直执行自增然后赋值，这样的代码就是最优的最简的;即copy到\0的时候，循环就停止了     }     return ret;

当我们传入的值为空指针NULL的时候，断言就把具体出错的行号给报出来了

asset

断言assert,头文件assert.h。类似于IF，为真则什么都不发生，为假则把错误信息的位置报出来，断言是这个好东西！不止用于指针。

我们希望dest指向的内容被修改，src指向的内容不被修改。就要对src进行保护，在*左边加上const就可以保护*src不能被解引用。于是完整代码如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

#include #include char* my_strcpy(char* dest, const  char* src)//给char*src加上const，就可以及时发现错误，对src进行保护 {     assert(src!=NULL);     assert(dest != NULL);     char* ret = dest;     while (*dest++ = *src++)     {        ;     }     return ret; } int main() {     char arr[20] = "*****************";     char arr2[10] = "hellow";     printf("%s", my_strcpy(NULL, arr2));     return 0; }

这样的代码，简洁明了，赏心悦目。我们要多向大师学习，不要模仿那些代码风格差的语法书，不断进步，才会慢慢变成大牛

const的作用

接下来重点讲解const，常考！看代码：

1 2 3 4 5 6 7 8

#include int main() {     int num = 10;     int* p = #     *p = 20;     printf("%d",num); }

这串代码我们已经很熟悉了吧，就是指针变量p解引用访问num嘛。程序输出结果为20。
如果我们用const修饰int num会怎么样呢？

1 2 3 4 5 6 7 8 9

#include int main() {      const int num = 10; //num=20//err      int* p = #     *p = 20;     printf("%d",num); }

const修饰了num，num就是常变量了，按理来说不能修改了，我们此时输入num=20就会报错-表达式必须是可修改的左值，可见const确实生效了。而为什么程序的输出结果是20呢？
是因为指针通过对内存操作强制访问了num，就好比你把教室的门关了，但还可以跳窗户进去。可我们使用const的本意就是让num不被修改，而指针可以通过解引用来改变常变量,这是一种危险操作。所以我们要给指针加上const。
给指针加const大概有以下三种情况：

①const 如果放在*的左边(常量指针)：

1 2 3 4 5

int n=10; const int* p = # //这种写法等价于int const *p //*p = 10; err p=&n//OK

const 如果放在*的左边。修饰的是*p，修饰的是指针指向的内容，保证指针指向的内容是不能通过*p来改变的，即此时再用*p=20;就会报错了。
*p不能改变了，但p这个指针变量存的地址仍然可以存入n的地址，也就是说，当const放在*的左边的时候，指针变量不能改变指向对象的内容，但可以改变指针变量指向的对象

②const 如果放在*的右边(常指针)：

1 2 3 4

int n=10; int*const p = # *p = 20;//OK //p=&n;err

const 如果放在*的右边，修饰的是p，表示指针变量p不能被改变，但可以改变指针变量指向对象的内容，即*p可以改变。

③如果有两个const，既在*左边也在*右边呢？

1 2 3 4

int n=10; const int*const p = # //*p = 20;err //p=&n;err

第一个const修饰*p，第二个const修饰 p，所以p和p都不能改变了。

简记：左定值，右定向。

扩展：有关于const修饰指针的一些资料

• const int* p与int const* p等同
• const int* p的含义是：p是指向常量整形的指针
• int* const p的含义是p是指向int的常量指针
• 常量指针：const在* 左边，表示不能通过指针来改变变量的值
• 常指针：const在* 右边，表示指针是一个常量，不能改变指针的指向，但是可以改变指针所指向变量的值
• 常指针不可以指向常量
• 常量指针可以指向常量和非常量

对const进行深入了解后，接下来我们尝试写出一个优质的模拟实现strlen函数

首先我们就考虑要不要const，assert

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

//健壮性，鲁棒性 #include #include //size_t - unsigned int size_t my_strlen(const char*p)//const提升了健壮性 {     size_t  count=0;     //assert(p != NULL);也可以写成     assert(p);     while (*p != '\0')     {         p++;         count++;     }     return count; } int main() {     char arr[] = "123456";     printf("%d",my_strlen(arr));     return 0; }

编程常见的错误

●编译型错误：语法错误，双击错误信息就可以定位位置
●链接型错误：看错误提示信息，主要在代码中找到错误信息中的标识符，然后定位问题所在。一般是标识符名不存在或者拼写错误
●运行时错误：借助调试，逐步定位问题。最难搞。

总结：

做一个有心人，积累排错经验。
本章完，祝好。如果再也不能见到你，也祝你早安午安，还有晚安。