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.使用快捷键

C语言基础-实用调试技巧_第1张图片
最常使用的几个快捷键:

F5
启动调试,经常用来直接调到下一个断点处。

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

F10
逐过程,通常用来处理一个过程,一个过程可以是一次函数调用,或者是一条语句。(不进入函数)

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

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

ctrl+shift+F9
取消所有断点

shift+F11
跳出过程

设置条件断点:
右击断点,选择“条件”
C语言基础-实用调试技巧_第2张图片
设置条件C语言基础-实用调试技巧_第3张图片
那么当i=5时,才会跳到断点处。

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

在调试开始之后,查看变量的值。

1.查看临时变量的值
查看局部变量
C语言基础-实用调试技巧_第4张图片

C语言基础-实用调试技巧_第5张图片
2.查看内存信息
C语言基础-实用调试技巧_第6张图片
C语言基础-实用调试技巧_第7张图片
3.查看监视信息

C语言基础-实用调试技巧_第8张图片
C语言基础-实用调试技巧_第9张图片
4.查看调用堆栈
通过调用堆栈,可以清晰的反应函数的调用关系以及当前调用所处的位置。
C语言基础-实用调试技巧_第10张图片
C语言基础-实用调试技巧_第11张图片
C语言基础-实用调试技巧_第12张图片
C语言基础-实用调试技巧_第13张图片
5.查看汇编信息
C语言基础-实用调试技巧_第14张图片
C语言基础-实用调试技巧_第15张图片
6.查看寄存器信息
查看当前运行环境的寄存器的使用信息。
C语言基础-实用调试技巧_第16张图片
C语言基础-实用调试技巧_第17张图片

调试实例

求 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;
}

调试代码:
C语言基础-实用调试技巧_第18张图片
当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;
}

代码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;
}

运行程序,我们发现,程序进入死循环,这是为什么呢?我们调试代码
C语言基础-实用调试技巧_第19张图片
此时i=12,F10,单步调试,然后我们发现,当arr[12] = 0后,i变成了0,这是为什么呢?
C语言基础-实用调试技巧_第20张图片
我们查看变量i的地址,以及arr[12]的地址
C语言基础-实用调试技巧_第21张图片
我们发现,&i = &arr[12],这是为什么呢?

1.数组arr和变量i是局部变量,局部变量在栈上面开辟空间的;
2.栈区的使用习惯是:先使用高地址处的空间,再使用低地址处的空间;
3.数组元素的地址随着下标的增长由低到高变化,随着数组元素下标的增大,数组越界,可能会造成死循环。

在VS2019编译器下,这段代码先创建了变量i,那么i的地址要比arr[9]的地址要大,所以随着数组元素下标的增大,数组越界,会找到i所在的那块空间,只是在VS2019编译器下,i和arr[9]之间间隔了两个整型元素。对于不同的编译器,i和arr[9]之间间隔是不同的。

C语言基础-实用调试技巧_第22张图片
怎么解决?我们在访问数组的时候,不要越界访问。

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

对于优秀的代码,具有以下特点:

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

常见的调试技巧:

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

strcpy函数模拟实现

下面我们通过模拟实现strcpy函数,来演示一下优秀的代码

strcpy :字符串拷贝,包括字符串结束标志’\0’。
C语言基础-实用调试技巧_第23张图片
版本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 == 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函数的几个注意点:

  1. 分析参数的设计(命名,类型),返回值类型的设计
  2. 对空指针解引用的危害。
  3. assert的使用
  4. 参数部分 const 的使用
  5. 字符串结束标志是’\0’,源字符串一定要有’\0’
  6. 目标空间要大于源字符串
  7. 目标空间必须可修改
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
}
//代码2   const放在*左边
void test2()
{	
	int n = 10;
	int m = 20;
	const int* p = &n;
	//等价于int const * p
	*p = 20;//error
	p = &m; //ok
}
//代码3  const放在*的右边
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修饰指针变量的时候:

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

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

  3. *的左右两边都有const,既修饰指针又修饰指针指向的内容,保证指针指向的内容不能通过指针来改变,同时指针变量本身也是不能改变的。

常见的编程错误

编译型错误

这种错误一般都是语法错误,直接看错误提示信息(双击),解决问题。或者凭借经验就可以搞定。相对来说简单。

如以下代码

int main()
{
	int i = 10;
	printf("%d\n",i);
	return 0
}

程序运行后,报如下错误
C语言基础-实用调试技巧_第24张图片

链接型错误

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

看下图代码,只是声明了函数,但是没有函数实现,这就是链接错误。
C语言基础-实用调试技巧_第25张图片
对于链接错误,我们一般都是直接搜索错误变量的名字。

运行时错误

借助调试,逐步定位问题。这种错误最难找到。

C语言基础-实用调试技巧_第26张图片
本章完。

你可能感兴趣的:(C语言基础,c语言)