野指针

野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）

指针未初始化

int main()
{
 int *p;//局部变量指针未初始化，默认为随机值
    *p = 20;
 return 0;
}

指针越界访问

int main()
{
    int arr[10] = {0};
    int *p = arr;
    int i = 0;
    for(i=0; i<=11; i++)
   {
        //当指针指向的范围超出数组arr的范围时，p就是野指针
        *(p++) = i;//先使用指针p，使用时进行解引用，对内容进行赋值，再进行++
   }
    return 0;
}

指针指向的空间释放

int* test()
{
    int n=10;
    int *p=&n;//进入test函数开辟空间
    return p;//离开时空间释放，n的空间没有了
}
int main()
{
    int *i=p;//即便有地址也找不到对象，便成了野指针
    printf("%d",*i);//err
    return 0;
}

如何规避野指针

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

指针运算

指针+-整数

上文已经提及，不再赘述

指针-指针

两个指针指向同一个数组中的（可能不同）元素，它们的差就是两个元素之间的元素个数+1

int a[5];
int* p;
int* q;
p = &a[1]; // 第二个元素
q = &a[3]; // 第四个元素

这里 q - p 等于 2 （从 p 指向的元素往后数两个，就是 q 指向的元素）

如果两个指针不是指向同一个数组中的元素，结果是未定义的（the behavior is undefined）

指针的关系运算

1. px > py 表示 px 指向的存储地址是否大于 py 指向的地址
2. px == py 表示 px 和 py 是否指向同一个存储单元
3. px == 0 和 px != 0 表示 px 是否为空指针

对于指针比较

for(vp = &values[N_VALUES]; vp > &values[0];)//用指针从后初始化数组
{
    *--vp = 0;
}
//优化
for(vp = &values[N_VALUES-1]; vp >= &values[0];vp--)
{
    *vp = 0;
}

• 标准规定：

允许指向数组元素的指针与指向数组最后一个元素后面的那个内存位置的指针比较

但是不允许与指向第一个元素之前的那个内存位置的指针进行比较

指针和数组

之前我们可以通过下标访问数组元素

学习了指针之后，我们可以通过指针访问数组的元素

在数组中，数组名即为该数组的首地址，结合上面指针和整数的加减，可以实现指针访问数组元素

int arr[10] = {1,2,3,4,5,6,7,8,9,0};
int *p = arr;//p存放的是数组首元素的地址

p+i 其实计算的是数组 arr 下标为i的地址

int main()
{
 int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
 int *p = arr; //指针存放数组首元素的地址
 int sz = sizeof(arr) / sizeof(arr[0]);
 int i = 0;
 for (i = 0; i<sz; i++)
 {
 printf("%d ", *(p + i));
 }
 return 0;
}

二级指针

指针变量也是变量，是变量就有地址

而指针变量的地址存放在二级指针里（指向指针的指针）

int a =100;
int *p1 = &a;
int **p2 = &p1;

C语言不限制指针的级数，每增加一级指针，在定义指针变量时就得增加一个星号*

使用及运算

• *ppa 通过对ppa中的地址进行解引用，这样找到的是 pa ， *ppa 其实访问的就是 pa

int b = 20;
*ppa = &b;//等价于 pa = &b;

• **ppa 先通过 *ppa 找到 pa ,然后对 pa 进行解引用操作： *pa ，那找到的是 a

1. **ppa = 30;
2. //等价于*pa = 30;
3. //等价于a = 30;

指针数组

指针数组是存放指针的数组

1. int arr1[5];
2. char arr2[6];
3. int* arr3[5];