##野指针

野指针[概念：野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）]
一、野指针成因
1. 指针未初始化
int main()
{
int* p;
//p没有初始化，就意味着没有明确的指向
//一个局部变量不初始化的化，放的是随机值：0xcccccccc
//
*p = 10;//非法访问内存了，这里的p就是野指针
return 0;
}
2. 指针越界访问
int main()
{
int arr[10] = { 0 };
int* p = arr;//&arr[0]
return 0;
}


int* test()
{
int a = 10;
return &a;
}
int main()
{
int*p = test();
if (p != NULL)
{
printf("%d\n", *p);//
}
return 0;
}

3. 指针指向的空间释放

二、如何规避野指针
1. 指针初始化
2. 小心指针越界
3. 指针指向空间释放即使置NULL
4. 避免返回局部变量的地址
5. 指针使用之前检查有效性

三、指针运算
1.指针+整数
#define N_VALUES 5
float values[N_VALUES];
float *vp;
//指针+-整数；指针的关系运算
for (vp = &values[0]; vp < &values[N_VALUES];)
{
*vp++ = 0;
}
int main()
{
int arr[10] = {0};
int i = 0;
int sz = sizeof(arr) / sizeof(arr[0]);
//数组下标的写法
//for (i = 0; i < sz; i++)
//{
// arr[i] = 1;
//}

int* p = arr;
for (i = 0; i < sz; i++)
{
*p = 1;
p++;
}
return 0;
}


2.指针-指针
int my_strlen(char *s)
{
char *p = s;
while(*p != '\0' )
p++;
return p-s;
}


int main()
{
int arr[10] = { 0 };
printf("%d\n", &arr[9] - &arr[0]);
return 0;
}

PS：指针-指针得到的是指针和指针之间元素的个数
不是所有的指针都能相减
指向同一块空间的2个指针才能相减


（1）
int my_strlen(char* str)
{
int count = 0;
while (*str != '\0')
{
count++;
str++;
}
return count;
}
//（2）递归的版本

//（3） 指针-指针
int my_strlen(char* str)
{
char* start = str;
while (*str != '\0')
{
str++;
}
return (str - start);
}

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

3. 指针的关系运算
for(vp = &values[N_VALUES]; vp > &values[0];)
{
*--vp = 0;
}
代码简化，这将代码修改如下:
for(vp = &values[N_VALUES-1]; vp >= &values[0];vp--)
{
*vp = 0;
}
实际在绝大部分的编译器上是可以顺利完成任务

标准规定:
允许指向数组元素的指针与指向数组最后一个元素后面的那个内存位置的指针比较，但是不允许与指向第一个元素之前的那个内存位置的指针进行比较