初阶C语言(9)-VS的实用调试技巧-CFANZ编程社区

什么是bug

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

调试

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

调试是什么

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

调试的基本步骤

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

Debug和Release

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

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

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

Debug和Release如何设置

Windows环境调试介绍

调试环境的准备

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

学会快捷键

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

快捷键

F10

F11

CTRL+F5

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

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

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

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

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

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

ps：栈=堆栈，堆！=栈

调用堆栈

查看汇编信息

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

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

反汇编

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

反汇编

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

寄存器

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

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

一些调试的实例

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

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：

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

}

这个程序按理来说，越界访问了，应该是会报错的，为什么这里程序执行的结果确是无限打印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技巧

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

示范模拟实现strcmp

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

#include <stdio.h>

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函数进行优化

char* my_strcpy(char* dest,char* src)

char* ret = dest;

while (*src != '\0')

{

*dest++= *src++;//dest++和src++可以直接放在指针这里，因为满足先使用后自增

}

*dest = *src;

return ret;

我们还可以再优化

char* my_strcpy(char* dest,char* src)

char* ret = dest;

while (*dest++ = *src++)

{

;//循环部分的值如果为\0，则停止循环，不然就一直执行自增然后赋值，这样的代码就是最优的最简的;即copy到\0的时候，循环就停止了

}

return ret;

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

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不能被使用。于是完整代码如下：

#include <stdio.h>

#include<assert.h>

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，常考！看代码：

#include <stdio.h>

int main()

{

int num = 10;

int* p = &num;

*p = 20;

printf("%d",num);

}

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

#include <stdio.h>

int main()

{

const int num = 10;

//num=20//err

int* p = &num;

*p = 20;

printf("%d",num);

}

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

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

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 如果放在*的右边(常指针)：

int n=10;

int*const p = #

*p = 20;//OK

//p=&n;err

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

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

int n=10;

const int*const p = #

//*p = 20;err

//p=&n;err

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

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

（1） const int* p与int const* p等同
（2） const int* p的含义是p是指向常量整形的指针
（3） int* const p的含义是p是指向int的常量指针
（4）常量指针：const在* 前面，表示不能通过指针来改变变量的值
（5）常指针：const在* 后面，表示指针是一个常量，不能改变指针的指向，但是可以改变指针所指向变量的值
（6）常指针不可以指向常量
（7）常量指针可以指向常量和非常量

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

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