实用调试技巧

最新推荐文章于 2024-10-09 10:07:13 发布

「已注销」

最新推荐文章于 2024-10-09 10:07:13 发布

阅读量512

点赞数 5

分类专栏：知识总结文章标签： c++ 经验分享 c#

原文链接：https://www.bilibili.com/video/BV1oi4y1g7CF?spm_id_from=333.999.0.0

版权

知识总结专栏收录该内容

20 篇文章 8 订阅

订阅专栏

1. 调试是什么？有多重要？

1.1 调试是什么？

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

1.2 调试的基本步骤

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

2. Debug 和 Release 的介绍

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

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

#include <stdio.h>
#include <stdlib.h>
int main()
{
	int i = 0;
	for (i = 0; i < 100; i++)
	{
		printf("%d ", i);
	}
	system("pause");
	return 0;
}

上述代码在 Debug环境的结果展示：

上述代码在 Release 环境的结果展示：

调试就是在 Debug版本 的环境中，找代码中 潜伏的问题 的一个过程。

那编译器进行了那些优化呢？

如下代码：

#include <stdio.h>

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

如果是 debug 模式去编译，x86环境下会死循环。

如果是release模式去编译，程序不会报错。

它们之间的区别就是因为优化导致的。

debug 和 release模式的比较：

总结：

Release 版本会将内存分布的结构进行优化，从而影响到了程序执行的结构。

3. windows 环境调试介绍

3.1 调试环境准备

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

3.2 学会快捷键

最常使用的几个快捷键：

F5 – （经常和 F9 配合使用）

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

F9 –

创建断点和取消断点的重要作用，可以在程序的任意位置设置断点。

这样就可以使得程序在想要的位置随意停止执行，继而一步步执行下去。

F10

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

F11

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

CTRL + F5

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

更多快捷键

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

查看临时变量的值

在调试开始之后，用于观察变量的值。

查看内存信息

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

查看调用堆栈

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

查看汇编信息

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

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

(2) 第二种方式：

可以转到汇编代码。

查看寄存器信息

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

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

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

4. 一些调试的实例

4.1 实例一

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

int main()
{
	int i = 0;
	int sum = 0;  // 保存最终结果
	int n = 0;
	int ret = 1; // 保存 n 的阶乘
	scanf("%d", &n); // 3   1!+2!+3! = 1+2+6=9
	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。

解决办法：

首先推测问题出现的原因。初步确定问题可能的原因最好。
实际上手调试很有必要。
调试的时候我们心里有数。

4.2 实例二

出自于**《C 陷阱和缺陷》**

#include <stdio.h>
int main()
{
    int i = 0;
    int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
    // VC6.0 环境下  <=10  就死循环了
    // gcc 编译器 <=11 就死循环了
    // vs2019     <=12  死循环 
    // 因为内存布局的位置不同
    for(i=0; i<=12; i++)
   {
        arr[i] = 0;
        printf("hehe\n");
   }
    return 0;
}

总结： 如果将循环判断条件改成i<12 则不会进入死循环，直接报栈被破坏的错误，而i<=12时报错是因为程序忙着在循环上，没有机会报错。

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

5.1 优秀的代码：

代码运行正常
bug很少
效率高
可读性高
可维护性高
注释清晰
文档齐全

常见的 coding 技巧：

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

5.2 示范：

模拟实现库函数：strcpy

// 6分

// dest  是指向目标空间的
// src   是指向源字符串的
void my_strcpy(char* dest, char* src)
{
	while (*src != '\0')
	{
		*dest = *src;
		dest++;
		src++;
	}
	*dest = *src; // '\0'
}
int main()
{
	// strcpy
	// 字符串拷贝
	char arr1[] = "###################";
	char arr2[] = "bit";
	my_strcpy(arr1, arr2);
	printf("%s\n", arr1);
	return 0;
}

优化后代码：

// 7分
void my_strcpy(char* dest, char* src)
{
    // 1. 拷贝字符
    // 2. 遇到\0循环停止
	while (*dest++ = *src++)
	{
		;
	}
}



// Null -- \0
// null -- \0
// NULL -- 空指针

// 如果用 if 判断某个条件的 正确性，会将错误隐瞒  -- 输出原来的字符串
//void my_strcpy(char* dest, char* src)
//{
//	if (dest != NULL && src != NULL)
//	{
//		while (*dest++ = *src++)
//		{
//			;
//		}
//	}
//	
//}


// 8分
void my_strcpy(char* dest, char* src)
{
	assert(dest != NULL); // 断言（宏） -- release 版本可以优化掉
	assert(src != NULL); // 更容易理解
    // assert(src);
    // assert(dest && src);


	while (*dest++ = *src++)
	{
		;
	}

}

// 9分
void my_strcpy(char* dest, const char* src)
{
	assert(dest != NULL); // 断言
	assert(src != NULL);  // 断言	

	while (*dest++ = *src++)
	{
		;
	}
}

// 10 分
#include <stdio.h>
#include <assert.h>
char* my_strcpy(char* dest, const char* src)
{
	assert(dest != NULL); // 断言
	assert(src != NULL);  // 断言
	char* ret = dest;
    
	// 把 src 指向的字符串拷贝到 dest 指向的空间，包含 '\0'字符
	while (*dest++ = *src++)
	{
		;
	}
	return ret;
}
int main()
{
	// strcpy
	// 字符串拷贝
	// 1
	//char arr1[] = "###################";
	//char arr2[] = "bit";

	// 2  -- 错误写法  -- arr2没有'\0'，循环不会停止
	// 	   源字符串中一定要有\0
	//char arr1[] = "###################";
	//char arr2[] = { 'a','b','c' };

	// 3   -- 目标空间必须足够大
	//char arr1[3] = { 0 };
	//char arr2[] = "abcdef";

	// 4  -- 目标空间必须可修改
	char* arr1 = "xxxxxxxxx"; // 常量字符串，是放在常量区的，是不能修改的
	// const char* arr1 = "xxxxxxxxx"; //严谨的写法
	char arr2[] = "abcdef";
	
	// 链式访问
	printf("%s\n", my_strcpy(arr1, arr2));
	return 0;
}

注意：

分析参数的设计（命名，类型），返回值类型的设计。
野指针，空指针的危害。
assert的使用，assert的作用。
参数部分 const 的使用，const修饰指针的作用。
注释的添加。

5.3 const 的作用

int main()
{
	const int num = 10; // num 是常变量
    //int* p = &num;
    //*p = 20; // 会报警告！！！
    //printf("%d\n",num); // 20
    
    
	int n = 100;
	// const int* p = &num; // 等价于 int const* p = &num;
	// // *p = 20;   // error      
    // // const 放在指针变量的 * 左边时，修饰的是 *p，也就是说：不能通过 p 来改变 *P （num）的值。
	// p = &n;


	//int* const p = &num; 
	//*p = 20;  
	// //p = &n;     // error       
    // // const 放在指针变量的 * 右边时，修饰的是指针变量 p 本身，p不能被改变。

	const int* const p = &num;
	// *p = 20;    // error
	// p = &n;     // error
	printf("%d\n", num);  // 10
	return 0;
}

结论：

const 修饰指针变量的时候：

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

**注：**介绍《高质量C/C++编程》一书中最后章节试卷中有关 strcpy 模拟实现的题目。

练习：

模拟实现一个strlen函数。

#include <assert.h>
int my_strlen(const char* str) 
// 将返回类型改成unsigned 更合适    
// 但是也有问题 sizeof("adc") - sizeof("dsafsafsaf") 永远大于0
{
	assert(str != NULL); // 断言指针  -- 保证指针的有效性。
    int count = 0;
	while (*str != '\0')
	{
		count++;
		str++;
	}
	return count;
}

int main()
{
	char arr[] = "abcdef";
	int len = my_strlen(arr);
	printf("%d\n", len);
	return 0;
}