调试-初阶完结！

实用调试技巧

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

1. 什么是bug?

第一次被发现的导致计算机错误的是一只飞蛾，也是第一个计算机程序错误。

2.调试是什么 ? 有多重要 ?

所有发生的事情都一定有迹可循，如果问心无愧，就不需要掩盖也就没有迹象了，
如果问心有愧就必然需要掩盖，那就一定会有迹象，迹象越多就越容易顺藤而上，这就是推理的途径。
顺着这条途径顺流而下就是犯罪，逆流而上，就是真相。
一名优秀的程序员是一名出色的侦探。

2.1 调试是什么 ?

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

2.2 调试的基本步骤

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

2.3 Debug和Release的介绍

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

F10调试

3. Windows环境调试介绍

3.1 调试环境的准备

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

3.2 学会快捷键

最常使用的几个快捷键:
F5：
启动调试，经常用来直接跳到下一个（逻辑）断点处(配合F9使用)

F9：
创建断点和取消断点
断点的重要作用，可以在程序的任意位置设置断点。
这样就可以使得程序在想要的位置随意停止执行，继而一步步执行下去。

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

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

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

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

3.3.1 查看临时变量的值
在调试开始之后，用于观察变量的值。

调试开始后，窗口中才能看到一些选项

一般用监视
arr，10（看函数中数组的多个元素）

3.3.2 查看内存信息
再调试开始之后，用于观察内存信息。

调试--->窗口--->内存

内存数据，以二进制存入，显示的时候是十六进制，方便看。

3.3.3 查看调用堆栈

void  test2()
{
    printf("hehe\n");
}

void test1()
{
    test2();
}

void test()
{
    test1();
}

int main()
{
    test();
    return 0;
}

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

很好的反馈了函数如何调用的

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

3.3.4 查看汇编信息

在调试开始后可以：

1. 右击鼠标，选择转到反汇编

2. 调试--->窗口--->转到反汇编

3.3.5 查看寄存器信息

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

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

4. 多多动手，多多练习调试

5. 一些调试的实例

5.1 实例一

实现代码：求1！ + 2 + 3！ + ... + n！;不考虑溢出。

int main()
{
    //n!
    int n = 0;
    scanf("%d", &n);
    int i = 0;
    int ret = 1;
    int sum = 0;
    for (i = 1; i <= n; i++)//产生1~n的数字
    {
        ret = ret * i;//累计乘在一起
        sum = sum + ret;
    }
    printf("%d", sum);
    return 0;
}

5.2 实例二

int main()
{
    int i = 0;
    int arr[10] = { 0,1,2,3,4,5,6,7,8,9 };
    for (i = 0; i <= 12; i++)
    {
        arr[i] = 0;
        printf("hehe\n");
    }
    return 0;
}
研究程序死循环的原因
i每次到12的时候都会变成0，因为恰好i和arr[12]在同一个内存空间上
改变arr[12]就是改变i，改变i就是改变arr[i]

int i = 0;
int arr[10] = { 0,1,2,3,4,5,6,7,8,9 };
都是局部数据，放在内存的栈区的，

栈区    
堆区      
静态区

把栈区单独拿出来看：

高地址
i(arr[12])
arr[11]
arr[10]
arr[9]
arr[8]
arr[7]
arr[6]
arr[5]
arr[4]
arr[3]
arr[2]
arr[1]
arr[0]
...
低地址

1. 栈区内存的使用习惯是先使用高地址处的空间，再使用低地址处的空问。
2. 数组随着下标的增长地址是由低到高变化的。
3. 如果i和arr之间有适当的空间，利用数组的越界操作就可能会覆盖到i，就可能会导致死循环出现的。

6. 如何写出好(易于调试)的代码。

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

常见的coding技巧 :
1.使用assert
2.尽量使用const
3.养成良好的编码风格
添加必要的注释
5.避免编码的陷阱。

6.2 示例
模拟库函数strcpy

strcpy 字符串拷贝
strcpy（char*目标空间地址，const char*原数据地址）

#include <string.h>
int main()
{
    char arr1[20] = { 0 };
    char arr2[] = "hello";
    strcpy(arr1, arr2);
    printf("%s\n", arr1);
    return 0;
}
strcpy在拷贝字符串的时候，会把源字符串中的\0也拷贝过去。

现在模拟实现：

void my_strcpy(char* dest, char* src)
{
    while (*src != '\0')
    {
        *dest = *src;
        dest++;
        src++;
    }
    *dest = *src;//上面还没把\0拷贝过来，这一步拷贝过来了
}

优化版本：
void my_strcpy(char* dest, char* src)
{
    while (*dest++ = *src++)//'\0'的阿斯克码为0
    {
        ;
    }
}

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

但是别人如果不小心，传了个空指针过去，
char* p = NULL;
my_strcpy(arr1, P)
那my_strcpy函数内部对空指针解引用很危险，
那我们可以用assert

#include <assert.h>
void my_strcpy(char* dest, const char* src)
{
    //断言
    assert(str != NULL);
    assert(dest != NULL);
    while (*dest++ = *src++)//'\0'的阿斯克码为0
    {
        ;
    }
}

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

1. assert 宏简介
assert 宏定义于 <assert.h>（C 语言）或者 <cassert>（C++ 语言）头文件中。其作用是在程序运行期间对特定条件进行检查，
若条件不成立（也就是条件表达式的值为 false），程序就会终止运行，
并且会输出一条包含具体出错位置（文件名和行号）的错误信息。这对于调试程序、快速定位问题十分有帮助。

2. 代码解释
assert(str != NULL); 这行代码检查 str 指针是否为 NULL。
若 str 为 NULL，那就意味着它没有指向有效的内存地址，此时条件 str != NULL 为 false，
assert 宏会触发断言失败，程序会终止运行并输出错误信息。
若 str 不为 NULL，也就是它指向了有效的内存地址，那么条件 str != NULL 为 true，assert 宏不会产生任何作用，程序会继续正常执行。

万一还有人在my_strcpy(arr1, arr2);中把arr1和arr2的位置写反了

所以就可以用const修饰常变量，是这个变量不能够被修改
void my_strcpy(char* dest, const char* src)，
让strcpy（char* 目标空间地址，const char* 原数据地址）
原始数据不能够被改变

const修饰的常变量，不能修改

int main()
{
    const int num = 10;
    num = 20;
    return 0;
}

强行改:

int main()
{
    const int num = 10;
    int* p = &num;
    *p = 20;
    return 0;
}

但是如果，const int* p = &num;又不能改了

这叫const修饰指针：
1. const放在*的左边
const int* p = &num;或者int const* p = &num;
const修饰*p，意思是p指向的对象不能通过p来改变了，但是p变量本身的值可以改变，可以把p改成别的值，如p=&n；

2. const 放在*的右边
int* const p = &num;
p = &n;//err
*p=0；//ok
const 放在 * 的右边意思是p指向的对象是可以通过p来改变的，但是不能修改p变量本身的值

总的来说，const放在*左边修饰的是*p，p指向的对象。
const放在* 右边修饰的是p变量本身。

void my_strcpy(char* dest, const char* src)
其实这个应该是
char* my_strcpy(char* dest, const char* src)
是为了实现链式访问，这个函数的返回值就可以作为其它函数的参数
strcpy函数返回的是目标空间的起始地址

char* my_strcpy(char* dest, const char* src)
{
    char* ret = dest;
    //断言
    assert(str != NULL);
    assert(dest != NULL);
    while (*dest++ = *src++)//'\0'的阿斯克码为0
    {
        ;
    }
    return ret;
}

7.编程常见的错误

7.1 编译型错误(语法错误)
直接看错误提示信息(双击)，解决问题。或者凭借经验就可以搞定。相对来说简单。

7.2 链接型错误
看错误提示信息，主要在代码中找到错误信息中的标识符，然后定位问题所在。一般是标识符名不存在或者拼写错误。
test.c--->编译--->连接--->可执行程序

7.3 运行时错误
借助调试，逐步定位问题。

初阶完！