前言

• C语言中指针可以说是最接近计算机的一种表达方式了，他是C语言中最难也最重要的一块，这就需要我们细心去学去体会指针的每一步效果，相信大家刚学指针时会有些许困惑，本章我们就来看看指针的初阶把。

1.指针是什么？

• 指针是一个值为内存地址的变量；
• 指针提供一种以符号的形式使用地址的方法。因为计算机的硬件指令非常依赖地址，指针在某种程度上把程序员想要传达的指令以更接近机器的方式表达。因此，使用指针的程序更有效率。
• 通俗来说，指针就是指针变量，他能存放一个地址。也可以说，指针就是地址。

2.指针和指针类型

首先我们得知道，内存中的地址是连续存放的，每一个内存单元占一个字节。在32位机器中，有32跟地址线，也就是说，cpu的寻址能力为2的32次方个地址，64为机器与32位机器大同小异，只不过64位的寻址能力更强了。

由于32位机器每一次的寻址为32个比特位，也就是4个字节，所以指针变量的大小为4个字节。也就是说，在32位机器中，无论一个指针变量为何种类型，他的大小都是4个字节。在64位当中我们也很容易就可以推出，指针变量的大小为8个字节，这是基于机器来确定的。

下面基于64位系统看看上述效果：

#include <stdio.h>
int main()
{
  int a = 10;
  int* a1 = &a;
  char* a2 = (char*) & a;
  short* a3 = (short*) & a;
  printf("%zd\n", sizeof(a1));
  printf("%zd\n", sizeof(a2));
  printf("%zd\n", sizeof(a3));
  return 0;
}

很明显，在64位系统中，何种类型的指针他的大小都是8个字节。

2.1.声明指针

int a = 10;
  int* pa = &a;

• a的值为10，&a为a的地址；
• int* pa表示pa是一个指针变量，int*表示pa是一个整型的指针变量；
• 经过上述操作，pa里面存放了a的地址；
• 这样我们便声明了一个指向a地址的指针变量pa。

我们分别将a的地址和pa打印出来，可以发现两个地址是一样的：

2.2.指针类型

• 指针类型有int等类型，与定义一个变量使用的类型相同，那么指针类型对指针有什么作用呢？

• 指针的类型决定了指针向前或者向后走一步有多大；
• 比如一个int类型的指针，int的大小为4个字节，当指针加一时，指针在内存中跳过4个字节；
• 同样的，一个char类型的指针，char的大小为1个字节，当指针加一时，指针在内存中跳过1个字节；
• 总的来说，指针的类型提供了一个指针在内存中移动的视角，理解指针的类型可以使我们更精确的使用指针来改变某个值。

例如：我们用一个char类型的指针来修改int类型数组里面的值

#include <stdio.h>
int main()
{
  int arr[5] = { 1,2,3,4,5 };
  char* parr = (char*)arr;
  int i = 0;
  for (i = 0; i < 8; i++)
  {
    *(parr + i) = 0;
  }
  for (i = 0; i < 5; i++)
  {
    printf("%d ", arr[i]);
  }
  return 0;
}

运行结果：0 0 3 4 5

我们可以看到，数组arr的前面两个元素被改成了0，这是因为：parr是一个指向arr的char类型的指针，每当parr + 1时，指向arr首元素的地址跳一个字节，也就是说移动一个内存单元，而arr是一个整型的数组，它里面每个元素占四个字节，所以当parr移动7次后他才指向arr第三个元素的地址，当然，arr前面的两个元素被改为0。

想要更明确的看到类型指针的作用，建议大家运用调试并查看内存的方法，这样效果会更加的明显，更能加深对指针类型的理解。

3.野指针

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

3.1.野指针的成因

3.1.1.指针未初始化

例如：

#include <stdio.h>
int main()
{
  int* p; // 这里没有给一个初始地址（局部变量指针未初始化，默认为随机值）
  *p = 20; // 不知道修改了那一块内存
  return 0;
}

3.1.2.指针越界访问

• 指针越界访问的问题一般出现在指针与数组的结合运用当中：

#include <stdio.h>
int main()
{
    int arr[10] = {0};
    int *p = arr;
    int i = 0;
    for(i=0; i<=11; i++)
   {
        *(p++) = i;
   }
    return 0;
}

• 当指针指向的范围超出数组arr的范围时，p就是野指针

3.1.3.指针指向的空间释放（不具体展开）

• 解释：当你用指针指向一块空间后，这块空间在程序中中途释放了，而你指向这块空间的指针他还是指向这块空间，其地址没变，只不过说指针指向的这块空间它由原有确定的值变成不确定了，指针也变成了一个悬垂指针。

这个现象在函数调用时会发生，例如：

#include <stdio.h>
int* test()
{
  int a = 10;
  return &a;
}
int main()
{
  int *p = test();
  printf("%d\n", *p);
  return 0;
}

这里a的值在函数调用完后就被释放了，也就是说指针变量p最后指向a的那块空间是一个不确定的值。

3.2.如何规避野指针

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

4.指针运算

4.1.指针±整数

• 指针加减整数在数组中有很明显的效果，下面以一段代码来说明：

#include <stdio.h>
#define value 5
int main()
{
  int arr[value] = { 0 }; // arr里有五个元素，全初始化0
  int* parr;
  int i = 0;
  for (parr = arr; parr < &arr[value]; i++) // arr是数组名，为首元素地址，这里先将首元素地址交给指针变量parr
  {
    *parr++ = i; // 指针从第一个元素开始++找到数组每一个元素的地址并将数组arr里的元素改变；
  }
  for (i = 0; i < value; i++)
  {
    printf("%d ", arr[i]); // 打印改变后的arr
  }
  return 0;
}

4.2.指针减指针

• 指针减指针的前提是：两个指针要指向同一块空间；
• 指针减指针的绝对值得到的是两个指针之间的元素个数。

例如：

#include <stdio.h>
int main()
{
  int arr[5] = { 1,2,3,4,5 };
  int* parr1 = arr;  // parr1指向的是arr首元素的地址
  int* parr2 = &arr[5];  // parr2指向的是(arr[4] = 5)后面那一个元素的地址
  int sum = parr2 - parr1; // parr2 - parr1 得到的是整个arr数组的元素的个数 也是parr2与parr1 之间的元素个数
  printf("%d", sum); // 5
  //  如果parr2指向的是 &arr[4] 这个地址，那么结果为 4 
  return 0;
}

4.3.指针的关系运算

我们看这两段代码：

#include <stdio.h>
int main()
{
  int arr[5] = { 0 };
  int* parr;
  for (parr = &arr[5]; parr > arr;)
  {
    *--parr = 0;
  }
  return 0;
}

将代码简化后：

#include <stdio.h>
int main()
{
  int arr[5] = { 0 };
  int* parr;
  for (parr = &arr[4]; parr >= arr; parr--)
  {
    *parr = 0;
  }
  return 0;
}

我们想象代码的运行过程和结果，第一段代码是用比数组地址大的地址来进行比较，而第二段代码最后是用比数组地址小的地址来进行比较，实际在绝大部分的编译器上是可以顺利完成任务的，然而我们还是应该避免第二种的写法，因为标准并不保证它可行。

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

5.指针和数组

我们先来看一个例子：

#include <stdio.h>
int main()
{
  int arr[5] = { 1,2,3,4,5 };
  int* p = &arr[0];
  printf("%p\n", p);
  printf("%p\n", arr);
  return 0;
}

• 通过上面的展示，我们不难看出，数组名其实就是数组首元素的地址，那么据此我们结合前面所说知识就可以运用指针对数组进行一系列的访问。
• 指针能有效地处理数组，数组表示法其实就是在变相地使用指针。

例（1）：我们用指针来打印一个数组的元素：

#include <stdio.h>
int main()
{
  int arr[5] = { 1,2,3,4,5 };
  int* parr = arr; // arr为数组名是首元素地址，这里将首元素地址交给指针变量parr
  int i = 0;
  int sz = sizeof(arr) / sizeof(arr[0]);
  for (i = 0; i < sz; i++)
  {
    printf("%d ", *(parr + i)); // 由首元素地址开始访问数组的每个元素地址并解引用操作打印
  }
  return 0;
}

运行结果为：

输出： 1 2 3 4 5

例（2）：我们用指针来修改一个数组里的元素：

#include <stdio.h>
int main()
{
  int arr[5] = { 0 };
  int* p = arr;
  int i = 0;
  int sz = sizeof(arr) / sizeof(arr[0]);
  for (i = 0; i < sz; i++)
  {
    *(p + i) = (i + 1);
  }
  for (i = 0; i < sz; i++)
  {
    printf("%d ", arr[i]);
  }
  return 0;
}

运行结果：

输出：1 2 3 4 5

总结

• 指针我们不仅要学会，并且能够灵活的运用，这需要我们的基础知识与编程思维共同作用。
• 本章只是指针初阶的一部分知识，但其已经为我们的指针打下了坚实的基础。学无止境，勇往直前！