学习 C 语言的指针既简单又有趣。通过指针，可以简化一些 C 编程任务的执行，还有一些任务，如动态内存分配，没有指针是无法执行的。所以，想要成为一名优秀的 C 程序员，学习指针是很有必要的。 正如您所知道的，每一个变量都有一个内存位置，每一个内存位置都定义了可使用&运算符访问的地址，它表示了在内存中的一个地址。

  1. #include <stdio.h>
  3. int main ()
  4. {
  5.     int var_runoob = 10;
  6.     int *p;              // 定义指针变量
  7.     p = &var_runoob;
  9.    printf("var_runoob 变量的地址： %p\n", p);
  10.    return 0;
  11. }
  13. /* 
  14. var_runoob 变量的地址： 0x7ffee41de628 
  15. */

image.png
通过上面的实例，我们了解了什么是内存地址以及如何访问它。接下来让我们看看什么是指针

什么是指针？

指针也就是内存地址，指针变量是用来存放内存地址的变量。就像其他变量或常量一样，您必须在使用指针存储其他变量地址之前，对其进行声明。指针变量声明的一般形式为：

  1. type *var-name;

在这里，type是指针的基类型，它必须是一个有效的 C 数据类型，var-name是指针变量的名称。用来声明指针的星号 * 与乘法中使用的星号是相同的。但是，在这个语句中，星号是用来指定一个变量是指针。以下是有效的指针声明：

  1. int    *ip;    // 一个整型的指针
  2. double *dp;    // 一个 double 型的指针
  3. float  *fp;    // 一个浮点型的指针
  4. char   *ch;    // 一个字符型的指针

所有实际数据类型，不管是整型、浮点型、字符型，还是其他的数据类型，对应指针的值的类型都是一样的，都是一个代表内存地址的长的十六进制数。
不同数据类型的指针之间唯一的不同是，指针所指向的变量或常量的数据类型不同。

如何使用指针？

使用指针时会频繁进行以下几个操作：定义一个指针变量、把变量地址赋值给指针、访问指针变量中可用地址的值。这些是通过使用一元运算符 * 来返回位于操作数所指定地址的变量的值。下面的实例涉及到了这些操作：

  1. #include <stdio.h>
  3. int main ()
  4. {
  5.    int  var = 20;  // 实际变量的声明
  6.    int  *ip;       // 指针变量的声明
  7.    ip = &var;      // 在指针变量中存储 var 的地址
  9.    printf("var 变量的地址: %p\n", &var  );
  10.    printf("ip 变量存储的地址: %p\n", ip );  // 在指针变量中存储的地址
  11.    printf("*ip 变量的值: %d\n", *ip );     // 使用指针访问值
  13.    return 0;
  14. }
  16. /* 
  17. var 变量的地址: 0x7ffeeb19c628
  18. ip 变量存储的地址: 0x7ffeeb19c628
  19. *ip 变量的值: 20 
  20. */

C 中的 NULL 指针

在变量声明的时候，如果没有确切的地址可以赋值，为指针变量赋一个 NULL 值是一个良好的编程习惯。赋为 NULL 值的指针被称为空指针。
NULL 指针是一个定义在标准库中的值为零的常量。请看下面的程序：

  1. #include <stdio.h>
  3. int main ()
  4. {
  5.    int  *ptr = NULL;
  6.    printf("ptr 的地址是 %p\n", ptr  );
  8.    return 0;
  9. }
  11. /* 
  12. ptr 的地址是 0x0 
  13. */

在大多数的操作系统上，程序不允许访问地址为 0 的内存，因为该内存是操作系统保留的。然而，内存地址 0 有特别重要的意义，它表明该指针不指向一个可访问的内存位置。但按照惯例，如果指针包含空值（零值），则假定它不指向任何东西。
如需检查一个空指针，您可以使用 if 语句，如下所示：

  1. if(ptr)     // 如果 p 非空，则完成
  2. if(!ptr)    // 如果 p 为空，则完成

C 指针详解

在 C 中，有很多指针相关的概念，这些概念都很简单，但是都很重要。下面列出了 C 程序员必须清楚的一些与指针相关的重要概念：

概念 描述
指针的算术运算 可以对指针进行四种算术运算：++、—、+、-
指针数组 可以定义用来存储指针的数组。
指向指针的指针 C 允许指向指针的指针。
传递指针给函数 通过引用或地址传递参数，使传递的参数在调用函数中被改变。
从函数返回指针 C 允许函数返回指针到局部变量、静态变量和动态内存分配。

指针的算术运算

C 指针是一个用数值表示的地址。因此，您可以对指针执行算术运算。可以对指针进行四种算术运算：
++
—
+
-
假设ptr是一个指向地址 1000 的整型指针，是一个 32 位的整数，让我们对该指针执行下列的算术运算：

  1. ptr++

在执行完上述的运算之后，ptr将指向位置 1004，因为 ptr 每增加一次，它都将指向下一个整数位置，即当前位置往后移 4 字节。这个运算会在不影响内存位置中实际值的情况下，移动指针到下一个内存位置。如果ptr指向一个地址为 1000 的字符，上面的运算会导致指针指向位置 1001，因为下一个字符位置是在 1001。
我们概括一下：

  • 指针的每一次递增，它其实会指向下一个元素的存储单元。
  • 指针的每一次递减，它都会指向前一个元素的存储单元。
  • 指针在递增和递减时跳跃的字节数取决于指针所指向变量数据类型长度，比如 int 就是 4 个字节 ```c

    include

int main() { int arr[8] = {0,1,2}; int p = arr; printf(“arr是%p\n”, arr); //0x7ffee7c03600 printf(“&arr[0]是%p\n”, &arr[0]); //0x7ffee7c03600 printf(“p是%p\n”, p); //0x7ffee7c03600 printf(“sizeof(arr)是%lu\n”, sizeof(arr)); // 对数组名称进行sizeof计算的结果是数组里所有存储区的总大小 printf(“p是%d\n”, p); printf(“(p+1)是%d\n”, (p+1)); printf(“(p+2)是%d\n”, *(p+2)); return 0; }

/ arr是0x7ffee7c03600 &arr[0]是0x7ffee7c03600 p是0x7ffee7c03600 sizeof(arr)是32 p是0 (p+1)是1 (p+2)是2 */

  2. <a name="LMzIz"></a>
  3. #### 递增一个指针
  4. 我们喜欢在程序中使用指针代替数组，因为变量指针可以递增，而数组不能递增，数组可以看成一个指针常量。下面的程序递增变量指针，以便顺序访问数组中的每一个元素：
  5. ```c
  6. #include <stdio.h>
  8. const int MAX = 3;
  10. int main ()
  11. {
  12.    int  var[] = {10, 100, 1000};
  13.    int  i, *ptr;
  14.     //ptr = &var;  //warning: incompatible pointer types assigning to 'int *' from 'int (*)[3]' [-Wincompatible-pointer-types]
  15.     //ptr = var;   // 指针中的数组地址，默认是第一个
  16.     ptr = &var[0]; // 指针中第一一个元素的地址
  18.    for ( i = 0; i < MAX; i++)
  19.    {
  20.       printf("存储地址：var[%d] = %p\n", i, ptr );
  21.       printf("存储值：var[%d] = %d\n", i, *ptr );
  22.       ptr++;  // 指向下一个位置
  23.    }
  24.    return 0;
  25. }
  27. /* 
  28. 存储地址：var[0] = 0x7ffee475861c
  29. 存储值：var[0] = 10
  30. 存储地址：var[1] = 0x7ffee4758620
  31. 存储值：var[1] = 100
  32. 存储地址：var[2] = 0x7ffee4758624
  33. 存储值：var[2] = 1000
  34. */

递减一个指针

同样地，对指针进行递减运算，即把值减去其数据类型的字节数，如下所示：

  1. #include <stdio.h>
  3. const int MAX = 3;
  5. int main ()
  6. {
  7.    int  var[] = {10, 100, 1000};
  8.    int  i, *ptr;
  9.    ptr = &var[MAX-1]; // 指针中最后一个元素的地址
  11.    for ( i = MAX; i > 0; i--)
  12.    {
  13.       printf("存储地址：var[%d] = %p\n", i-1, ptr );
  14.       printf("存储值：var[%d] = %d\n", i-1, *ptr );
  15.       ptr--;  // 指向下一个位置
  16.    }
  17.    return 0;
  18. }
  20. /* 
  21. 存储地址：var[2] = 0x7ffee00e9624
  22. 存储值：var[2] = 1000
  23. 存储地址：var[1] = 0x7ffee00e9620
  24. 存储值：var[1] = 100
  25. 存储地址：var[0] = 0x7ffee00e961c
  26. 存储值：var[0] = 10 
  27. */

指针的比较

指针可以用关系运算符进行比较，如 ==、< 和 >。如果 p1 和 p2 指向两个相关的变量，比如同一个数组中的不同元素，则可对 p1 和 p2 进行大小比较。
下面的程序修改了上面的实例，只要变量指针所指向的地址小于或等于数组的最后一个元素的地址 &var[MAX - 1]，则把变量指针进行递增：

  1. #include <stdio.h>
  3. const int MAX = 3;
  4. int main ()
  5. {
  6.    int  var[] = {10, 100, 1000};
  7.    int  i, *ptr;
  8.    ptr = var;   // 指针中第一个元素的地址 
  9.    i = 0;
  10.    while ( ptr <= &var[MAX - 1] )
  11.    {
  13.      //printf("存储地址：var[%d] = %x\n", i, (unsigned int)ptr );
  14.       printf("存储地址：var[%d] = %p\n", i, ptr );
  15.       printf("存储值：var[%d] = %d\n", i, *ptr );
  16.       ptr++;   // 指向上一个位置
  17.       i++;
  18.    }
  19.    return 0;
  20. }
  22. /* 
  23. 存储地址：var[0] = 0x7ffee992e61c
  24. 存储值：var[0] = 10
  25. 存储地址：var[1] = 0x7ffee992e620
  26. 存储值：var[1] = 100
  27. 存储地址：var[2] = 0x7ffee992e624
  28. 存储值：var[2] = 1000 
  29. */

指针数组

在我们讲解指针数组的概念之前，先让我们来看一个实例，它用到了一个由 3 个整数组成的数组：

  1. #include <stdio.h>
  3. const int MAX = 3;
  4. int main ()
  5. {
  6.    int  var[] = {10, 100, 200};
  7.    int i;
  9.    for (i = 0; i < MAX; i++)
  10.    {
  11.       printf("Value of var[%d] = %d\n", i, var[i] );
  12.    }
  13.    return 0;
  14. }
  16. /* 
  17. Value of var[0] = 10
  18. Value of var[1] = 100
  19. Value of var[2] = 200 
  20. */

可能有一种情况，我们想要让数组存储指向 int 或 char 或其他数据类型的指针。下面是一个指向整数的指针数组的声明：

  1. int *ptr[MAX];

在这里，把ptr声明为一个数组，由 MAX 个整数指针组成。因此，ptr 中的每个元素，都是一个指向 int 值的指针。下面的实例用到了三个整数，它们将存储在一个指针数组中，如下所示：

  1. #include <stdio.h>
  3. const int MAX = 3;
  5. int main ()
  6. {
  7.    int  var[] = {10, 100, 200};
  8.    int i, *ptr[MAX];
  10.    for ( i = 0; i < MAX; i++)
  11.    {
  12.       ptr[i] = &var[i]; // 赋值为整数的地址
  13.    }
  15.    for ( i = 0; i < MAX; i++)
  16.    {
  17.    *ptr[i] = i;
  18.    }
  20.    for ( i = 0; i < MAX; i++)
  21.    {
  22.       printf("Value of var[%d] = %d\n", i, *ptr[i] );
  23.    }
  24.    return 0;
  25. }
  27. /* 
  28. Value of var[0] = 0
  29. Value of var[1] = 1
  30. Value of var[2] = 2
  31. */

您也可以用一个指向字符的指针数组来存储一个字符串列表，如下：

  1. #include <stdio.h>
  3. const int MAX = 4;
  4. int main ()
  5. {
  6.    const char *names[] = {
  7.                    "Zara Ali",
  8.                    "Hina Ali",
  9.                    "Nuha Ali",
  10.                    "Sara Ali",
  11.    };
  12.    int i = 0;
  14.    for ( i = 0; i < MAX; i++)
  15.    {
  16.       printf("Value of names[%d] = %s\n", i, names[i] );
  17.    }
  18.    return 0;
  19. }
  21. /* 
  22. Value of names[0] = Zara Ali
  23. Value of names[1] = Hina Ali
  24. Value of names[2] = Nuha Ali
  25. Value of names[3] = Sara Ali 
  26. */

指向指针的指针

指向指针的指针是一种多级间接寻址的形式，或者说是一个指针链。通常，一个指针包含一个变量的地址。当我们定义一个指向指针的指针时，第一个指针包含了第二个指针的地址，第二个指针指向包含实际值的位置。
image.png
一个指向指针的指针变量必须如下声明，即在变量名前放置两个星号。例如，下面声明了一个指向 int 类型指针的指针：

  1. int **var;

当一个目标值被一个指针间接指向到另一个指针时，访问这个值需要使用两个星号运算符，如下面实例所示：
image.png

  1. #include <stdio.h>
  3. int main ()
  4. {
  5.    int  v;
  6.    int  *Pt1;
  7.    int  **Pt2;
  8.    v = 100;
  9.    Pt1 = &v;     // 获取 v 的地址
  10.    Pt2 = &Pt1;   // 使用运算符 & 获取 Pt1 的地址
  12.    printf("var = %d\n", v );
  13.    printf("Pt1 = %p\n", Pt1 );
  14.    printf("*Pt1 = %d\n", *Pt1 );
  15.    printf("Pt2 = %p\n", Pt2 );
  16.    printf("**Pt2 = %d\n", **Pt2);
  18.    return 0;
  19. }
  21. /* 
  22. var = 100
  23. Pt1 = 0x7ffee56ca628
  24. *Pt1 = 100
  25. Pt2 = 0x7ffee56ca620
  26. **Pt2 = 100 
  27. */

传递指针给函数

C 语言允许您传递指针给函数，只需要简单地声明函数参数为指针类型即可。
下面的实例中，我们传递一个无符号的 long 型指针给函数，并在函数内改变这个值：

  1. #include <stdio.h>
  2. #include <time.h>
  4. void getSeconds(unsigned long *par);
  6. int main ()
  7. {
  8.    unsigned long sec;
  9.    getSeconds( &sec );
  10.    printf("Number of seconds: %ld\n", sec );    // 输出实际值
  11.    return 0;
  12. }
  14. void getSeconds(unsigned long *par)
  15. {
  16.    *par = time( NULL );  // 获取当前的秒数
  17.    return;
  18. }
  20. /* 
  21. Number of seconds: 1621335112 
  22. */

能接受指针作为参数的函数，也能接受数组作为参数，如下所示：

  1. #include <stdio.h>
  3. double getAverage(int *arr, int size); // 函数声明 
  5. int main ()
  6. {
  7.    int balance[5] = {1000, 2, 3, 17, 50};
  8.    double avg;
  9.    avg = getAverage( balance, 5 );  // 传递一个指向数组的指针作为参数
  10.    printf("Average value is: %f\n", avg ); // 输出返回值 
  11.    return 0;
  12. }
  14. double getAverage(int *arr, int size)
  15. {
  16.   int i, sum = 0;      
  17.   double avg;          
  19.   for (i = 0; i < size; ++i)
  20.   {
  21.     sum += arr[i];
  22.   }
  24.   avg = (double)sum / size;
  25.   return avg;
  26. }
  28. /* 
  29. Average value is: 214.400000 
  30. */

从函数返回指针

我们已经了解了 C 语言中如何从函数返回数组，类似地，C 允许您从函数返回指针。为了做到这点，您必须声明一个返回指针的函数，如下所示：

  1. int * myFunction(){ }

另外，C 语言不支持在调用函数时返回局部变量的地址，除非定义局部变量为static变量。
现在，让我们来看下面的函数，它会生成 10 个随机数，并使用表示指针的数组名（即第一个数组元素的地址）来返回它们，具体如下

  1. #include <stdio.h>
  2. #include <time.h>
  3. #include <stdlib.h> 
  5. // 要生成和返回随机数的函数
  6. int * getRandom( )
  7. {
  8.    static int  r[10];
  9.    int i;
  10.    srand( (unsigned)time( NULL ) );  // 设置种子
  11.    for ( i = 0; i < 10; ++i) 
  12.    {
  13.       r[i] = rand() %100;
  14.       printf("%d\n", r[i] );
  15.    }
  16.    return r;
  17. }
  20. int main ()
  21. {
  22.    int *p;   // 一个指向整数的指针
  23.    int i;
  24.    p = getRandom();
  25.    for ( i = 0; i < 10; i++ )
  26.    {
  27.        printf("*(p + [%d]) : %d\n", i, *(p + i) );
  28.    }
  29.    return 0;
  30. }
  32. /* 
  33. 92
  34. 63
  35. 62
  36. 35
  37. 86
  38. 6
  39. 26
  40. 78
  41. 98
  42. 35
  43. *(p + [0]) : 92
  44. *(p + [1]) : 63
  45. *(p + [2]) : 62
  46. *(p + [3]) : 35
  47. *(p + [4]) : 86
  48. *(p + [5]) : 6
  49. *(p + [6]) : 26
  50. *(p + [7]) : 78
  51. *(p + [8]) : 98
  52. *(p + [9]) : 35 
  53. */

请看下面的实例，它将输出定义的变量地址：

  1. #include <stdio.h>
  3. int main(int argc, char const *argv[])
  4. {
  5.   unsigned int data[] = {1987013737, 1970239845};
  6.   char *p = (char *)&data;
  7.   int i = 0;
  8.   printf("%lu\n", sizeof(data));
  9.   printf("%p\n", data);
  10.   while (i++ < sizeof(data))
  11.   {
  12.     printf("%c", *p++);
  13.   }
  14.   printf("\n");
  15.   return 0;
  16. }
  18. /* 
  19. 8
  20. 0x7ffeecdcd620
  21. iloveyou 
  22. */