C语言基础|C语言基础-实用调试技巧 C语言基础|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; }

【C语言基础|C语言基础-实用调试技巧】代码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 int main() { int i = 0; int arr[10] = { 1,2,3,4,5,6,7,8,9,10 }; for (i = 0; i <= 12; i++) { arr[i] = 0; printf("hehe\n"); } return 0; }

运行程序，我们发现，程序进入死循环，这是为什么呢？我们调试代码

文章图片

此时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 =https://www.it610.com/article/= 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 } //代码2const放在*左边 void test2() { int n = 10; int m = 20; const int* p = &n; //等价于int const * p *p = 20; //error p = &m; //ok } //代码3const放在*的右边 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修饰指针变量的时候：