出现红色的点之后，右击红色的点，会出现条件，然后设置条件，会直接到达需要仔细观察的地方
F10
逐过程，通常用来处理一个过程，一个过程可以是一次函数调用，或者是一条语句。
F11
逐语句，就是每次都执行一条语句，但是这个快捷键可以使我们的执行逻辑进入调用的函数内部（这是最常用的）。

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

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

3.3.1?查看临时变量的值

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

f10->调试->窗口->监视? （监视1、2、3、4?都是一样的。没有区别）? ?

f10->调试->窗口->局部变量

3.3.2?查看内存信息

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

f10->调试->窗口->内存（内存1、2、3、4?也都是一样的）

3.3.3?查看调用堆栈

f10->调试->窗口->调用堆栈（可以看出哪一个函数调用哪一个函数）

3.3.4?查看汇编信息

（1）f10->调试->窗口->反汇编（2）右键->转到反汇编

3.3.5?查看寄存器信息

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

四?一些调试的实例

代码展示：

#include <stdio.h>
int main()
{
	int i = 0;
	int arr[10] = { 0 };
	for (i = 0; i <= 12; i++)
	{
		arr[i] = 0;
		printf("liu");
	}
	return 0;
}

调试结果：死循环打印?liu

编译器会报错：索引“12”超出了“0”至“9”的有效范围(对于可能在堆栈中分配的缓冲区“arr”)?

代码理解：这个代码在vs编译器里仍然可以调试，在我们调试的过程中，发现越界访问arr[12]，正好是i所在的地址，在for循环里面，把arr[12]的值改成0，就相当于把i的值改成0，所以这个代码会出现?

（1）i和arr是局部变量，局部变量是放在栈上的，栈区上的使用习惯是，先使用高地址处的地址，再使用低地址处的地址。?数组随着下标的增长，地址是从高到低变化。（?上面这个代码是故意为之的）

（2）如果i和arr之间的空间合适的话（这个根据编译器的不同，中间的空间也会有所不同），就有可能会使arr越界访问到i，造成循环变量i的改变，造成死循环。

五?如何写出好（易与调试）的代码

5.1?优秀的代码

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

常见的coding技巧：

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

5.2?示范

模拟实现库函数：strcpy (string copy) （字符串拷贝）

（1）strcpy?库函数效果

代码展示：

#include <stdio.h>
int main()
{
	char arr1[20] = { 0 };
	char arr2[] = "hello";
	strcpy(arr1, arr2);
	printf("%s", arr1);
	return 0;
}

?strcpy(a,b)是把b拷贝到a里面

（2）模拟实现strcpy

代码1展示：

#include <stdio.h>
void my_strcpy(char* a, char* b)
{
	while (*b != '\0')
	{
		*a = *b;
		a++;
		b++;
	}
	*a = *b;
}

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

但是，这个代码并不是最优的代码。

代码2展示：

知识点：assert （断言），头文件是<assert.h> ,在下面下的函数里面，断言不是空指针，assert(a != UNLL),如果a是空指针的话，就会报错，如果不是空指针的话就会正常运行。assert(a）也可以，两个的话assert（a && b）

报错代码展示：

#include <stdio.h>
#include <assert.h>
void my_strcpy(char* a, char* b)
{
	assert(a != NULL);
	assert(b != NULL);
	while (*b != '\0')
	{
		*a = *b;
		a++;
		b++;
	}
	*a = *b;
}

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

?正常代码展示：

#include <stdio.h>
#include <assert.h>
void my_strcpy(char* a, char* b)
{
	assert(a != NULL);
	assert(b != NULL);
	while (*b != '\0')
	{
		*a = *b;
		a++;
		b++;
	}
	*a = *b;
}

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

?代码3展示：

'\0'的ASCII代码为0.

#include <stdio.h>
#include <assert.h>
void my_strcpy(char* a, char* b)
{
	assert(a && b);
	while (*a++ = *b++)
	{
        ；
	}
}

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

?不用前置++的原因是，前置++?的话，第一个字母，就无法拷贝，前置++，什么都没有打印的原因是，char是字符类型，0对应的ASCII值是'\0',打印的结果?是字符串，字符串遇见'\0'又是停止，所以什么也没有打印。

代码4展示：

#include <stdio.h>
#include <assert.h>
char* my_strcpy(char* a, char* b)
{
	assert(a && b);
	char* ret = a;
	while (*a++ = *b++)
	{
		;
	}
	return ret;
}

int main()
{
	char arr1[20] = { 0 };
	char arr2[] = "hello";
	/*my_strcpy(arr1, arr2);
	printf("%s", arr1);*/
	printf("%s\n", my_strcpy(arr1, arr2));//函数的链式访问
	return 0;
}

?这个是为了与strcpy更加像。

代码5展示:

为了避免出现把*a++ = *b++，这两个数写反，引入const这个常量，可以避免指针变量指向的内容被修改，如果出现错误，那么这个代码就无法运行起来，就会更简单的检查出代码的bug.

#include <stdio.h>
#include <assert.h>
char* my_strcpy(char* a, const char* b)
{
	assert(a && b);
	char* ret = a;
	while (*a++ = *b++)
	{
		;
	}
	return ret;
}

int main()
{
	char arr1[20] = { 0 };
	char arr2[] = "hello";
	/*my_strcpy(arr1, arr2);
	printf("%s", arr1);*/
	printf("%s\n", my_strcpy(arr1, arr2));//函数的链式访问
	return 0;
}

?（3）模拟实现strlen

代码展示:

#include <stdio.h>
#include <assert.h>
int my_strlen(const char* m)
{
	assert(m != NULL);
	int n = 0;
	while (*m != '\0')
	{
		n++;
		m++;
	}
	return n;
}
int main()
{
	char arr[] = "abcdef";
	int len = 0;
	len = my_strlen(arr);
	printf("%d", len);
	return 0;
}

（1）有assert （2）有注意指针是否为空指针?

5.3?const的作用

const可以修饰变量，也就是在我初识C语言（1）中讲的const修饰的常变量（感兴趣的友友们可以浅看一下下）?。

const也可以修饰指针变量，const修饰指针变量的时候：

1. const 如果放在 * 的左边，修饰的是指针指向的内容，保证指针指向的内容不能通过指针来改

变。但是指针变量本身的内容可变。

2. const 如果放在 * 的右边，修饰的是指针变量本身，保证了指针变量的内容不能修改，但是指

针指向的内容，可以通过指针改变。

3.const即在*左边又在*右边，那么指针变量本身和指针指向的内容都不能够改变。

?代码1展示：

#include <stdio.h>
int main()
{
	const int a = 10;//
	//a = 20;//这里a的值不能改变为20.
	int* pa = &a;
	*pa = 20;
	printf("%d", a);
	return 0;//本来a的值是不能改变的，但是通过取地址就可以，但是这是一种违规操作。
}

?为了用取地址的方法也不能改变a的值，加上了const，变成了const int* pa = &a.

代码2展示：

#include <stdio.h>
int main()
{
	const int a = 10;//
	//a = 20;//这里a的值不能改变为20.
	int b = 20;
	const int* pa = &a;//const在这里修饰的是指针指向的内容*pa,，指针指向的内容不能通过指针来改变
	// 但是可以改变pa的内容，pa本来存放的是a地址，现在也可以改变为存放b的地址。
	printf("%d", a);
	return 0;
}

?代码展示：

#include <stdio.h>
int main()
{
	const int a = 10;
	int* const pa = &a;//const在这里修饰的是指针本身pa,，指针本身的内容不能改变，但是指针指向的内容可以改变
	*pa = 20;
	printf("%d", a);
	return 0;
}

?const?int?a = 10,这个代码a通过指针是可以改变的。