#include<stdio.h>int main()
{//输入有n个阶乘int n = 0;scanf("%d", &n);//循环 求 1！+2！+3！ ...+ n! int ret = 1;int i = 0;int sum = 0;//存放阶乘的累加和for (i = 1; i <= n; i++){int j = 0;//实现求i的阶乘for (j = 1; j <= i; j++){ret *= j;}sum += ret;}//输出结果printf("%d\n", sum);return 0;
}

如果我们输入3，想输出9，但实际输出15。

why？

分析：推测循环出错了，第一次调试在第二个循环处打断点，一步步调试监视变量的变化。

但是没有发现是哪里错了，第二次调试在断点处右击设置断点条件快速调试到错误处，符合断点条件就停止，再F10观察具体原因。

 实例二：

#include <stdio.h>
int main()
{int i = 0;//数组下标界限0~9int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };for (i = 0; i <= 12; i++){//数组下标为10~12时数组越界arr[i] = 0;printf("hehe\n");}return 0;
}

数组越界应该是程序错误，不执行但是我们运行后发现程序死循环了。

why？

我们F10调试起来观察变量。

在调试的时候，我们发现每一次i的值都和arr[12]的值一样，当arr[12]=0时，i也变成0了，所以死循环。

那arr[12]和i是不是地址一样？我们调试观察之后确实是一样的。 

图解：

在i和arr数组中间恰好就是2个整形吗？

答：不一定，该代码只是在VS2019 X86环境下实验的结果。

        如果是VC6.0——i和arr之间没有多余的空间，gcc——i和arr之间有一个整形空间。 

        所以说平时我们写代码要注意不数组越界了。

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

6.1优秀的代码：

①代码运行正常

②bug很少

③效率高

④可读性高(如良好的代码风格，函数名、变量名见名知意等)

⑤可维护性高

⑥注释清晰

⑦文档齐全

常见的coding技巧：

①使用assert

②尽量使用const

③养成良好的编码风格

④添加必要的注释

⑤避免编码的陷阱

6.2示范

模拟实现库函数strcpy：

strcpy：

1.函数原型：

2.函数功能：

3.函数参数： 

 4.函数的返回类型：

代码1：模拟实现strcpy

分析：

#include<stdio.h>
#include<string.h>//自定义strcpy//代码1
void my_strcpy(char* dest, const char* src)
{//拷贝'\0'之前的字符while (*src != '\0'){*dest = *src;dest++;src++;}//拷贝'\0'*dest = *src;
}
int main()
{//将arr2中的字符串拷贝在arr1char arr1[20] = "#############";char arr2[] = "hello";//调用库函数实现//strcpy(arr1, arr2);//调用自定义函数实现my_strcpy(arr1, arr2);//打印拷贝后的arr1printf("%s\n", arr1);return 0;
}

代码2：优化函数体

#include<stdio.h>
#include<assert.h>//自定义strcpy//代码2
void my_strcpy(char* dest, const char* src)
{//优化1：使用指针之前一定要检查是否有效，如果无效就报错//assert--断言// assert中可以放一个表达式，表达式结果为假就报错，为真就啥事都不发生，正常运行//assert的头文件是assert.h//assert其实在release版本中被优化调了assert(dest && src);//断言指针的有效性//优化2：使代码简化//*dest++ = *src++;//等价于//*dest = *src;//dest++;src++;while (*dest++ = *src++)//'\0'的ASCII码值就是0，所以拷贝到'\0'停止{;}
}
int main()
{//将p中的字符串拷贝在arr1char arr1[20] = "#############";char* p = NULL;//调用自定义函数实现my_strcpy(arr1, p);//打印拷贝后的arr1printf("%s\n", arr1);return 0;
}

程序结果：

代码3：优化函数的形参

如下代码我们程序不报错，但是没有成功完成我们想要的拷贝：

#include<stdio.h>
#include<assert.h>void my_strcpy(char* dest, char* src)
{assert(dest && src);//断言指针的有效性while(*src++ = *dest++)//程序员喝酒，写反了这样我们没有实现拷贝的目的{;}//将src所指向内容拷贝到dest所指向数组
}int main()
{char arr[20] = "#############";char arr1[20] = "hello";my_strcpy(arr, arr1);printf("%s\n", arr);return 0;
}

 该怎么避免出现这种错误呢？

我们先来学习const的作用：

#include <stdio.h>void test()
{//代码1//定义两个整型变量int n = 10;int m = 20;//没有const修饰int* p = &n;//可以通过指针变量p将指针所指向的内容n的值改成20？*p = 20;//ok//可以修改指针变量本身？p = &m; //ok
}
void test1()
{//代码2const int num = 10;//num = 20;//err,因为num被const修饰，所以不能修改//但是通过指针变量p，num能被修改了(p就像卖票的黄牛一样)int* p = &num;*p = 20;
}
void test2()
{//代码3int n = 10;int m = 20;//const放在*的左边const int* p = &n;//也可写成：int const* p = &n;//*p = 20;//err,因为const修饰的指针p指向的内容，所以不能通过指针来修改p = &m; //ok，因为const只修饰的是指针p指向的内容，所以指针变量本身可以修改
}
void test3()
{//代码4int n = 10;int m = 20;//const放在*的右边int* const p = &n;*p = 20; //ok，因为const只修饰的是指针变量本身，所以指针指向的内容可以通过指针改变//p = &m;  //err,因为const修饰的是指针变量本身，所以指针变量本身不能被修改
}
int main()
{//测试无cosnt的test();//测试const修饰变量test1();//测试const放在*的左边test2();//测试const放在*的右边test3();return 0;
}

结论：

const修饰指针变量的时候：

1.const如果放在*的左边，const修饰的是指针指向的内容，保证指针指向的内容不能通过指针来改变；但是指针变量本身可以修改。

2.const如果放在*的右边，const修饰的是指针变量本身，保证指针变量本身的内容不能被修改；但是指针指向的内容，可以通过指针来改变。

3.const就像法律，不能被修改。

学习了const的作用，我们来修改刚在代码的问题，可以运行但是没有完成拷贝，是因为*dest++和*src++写反了，因为src所指向的内容不变。所以我们可以在把第二个形参改成const int* src,用const修饰指针指向的内容，这样的话如果不小心将*dest++和*src++写反直接就编译错误，不会运行成功，很快就发现代码的错误了。

#include<stdio.h>
#include<assert.h>void my_strcpy(char* dest,const char* src)
{assert(dest && src);//断言指针的有效性while (*src++ = *dest++)//程序员喝酒，写反了这样我们没有实现拷贝的目的{;}//将src所指向内容拷贝到dest所指向数组
}int main()
{char arr[20] = "#############";char arr1[20] = "hello";my_strcpy(arr, arr1);printf("%s\n", arr);return 0;
}

如下图：

代码4：优化函数的返回类型（最终的优化版本）

#include<stdio.h>
#include<assert.h>//库函数strcpy的返回值是目的地的起始地址
char* my_strcpy(char* dest,const char* src)
{assert(dest && src);//断言指针的有效性char* ret = dest;//存放目的地的起始地址while (*dest++ = *src++){;}//将src所指向内容拷贝到dest所指向数组return ret;
}int main()
{char arr[20] = "#############";char arr1[20] = "hello";//优点：链式访问（有返回值才可以）printf("%s\n", my_strcpy(arr, arr1));return 0;
}

 运行结果：

 练习：模拟strlen

#include<stdio.h>
#include<assert.h>//size_t是unsigned int的别名，因为长度没有负数
size_t my_strlen(const char* str)
{assert(str != NULL);//断言指针的有效性size_t count = 0;//计数while (*str++){count++;}return count;
}int main()
{char arr[] = "abcdef";printf("%d\n", my_strlen(arr));return 0;
}

 7.编程常见的错误

7.1编译型错误（语法错误）

直接看错误提示信息（双击锁定），解决问题。或者凭借经验就可以搞定，相对来说简单。

7.2链接型错误

        看错误提示信息，主要在代码中找到错误信息中的标识符，然后定位问题所在。一般是标识符名不存在或者拼写错误。