C指针难点解析

序言

学习 C 语言的指针既简单又有趣。通过指针，可以简化一些 C 编程任务的执行，还有一些任务，如动态内存分配，没有指针是无法执行的。所以，想要成为一名优秀的 C 程序员，学习指针是很有必要的。

内存地址

在了解c指针之前，我们先来了解下内存地址。计算机程序运行时的数据一般保存在内存（ram）中，为了存取内存中的数据，系统会对内存进行编址，然后程序就可以按地址存取数据。c语言中，每一个变量都有一个内存位置，每一个内存位置都定义了可使用连字号（&）运算符访问的地址，它表示了在内存中的一个地址。请看下面的实例，它将输出定义的变量地址：

#include <stdio.h>
int main ()
{
   int  var1;
   printf("var1 变量的地址： %p\n", &var1  );
   return 0;
}

运行结果是：var1 变量的地址： 0x7fff5cc109d4

什么是指针？

指针是一个变量，其值为另一个变量的地址，即指针变量的值就是上面说的内存地址。所有指针的值的实际数据类型，不管是整型、浮点型、字符型，还是其他的数据类型，都是一样的，都是一个代表内存地址的长的十六进制数。访问指针变量中可用地址的值是通过使用一元运算符 *来返回位于操作数所指定地址的变量的值。

#include <stdio.h>
int main ()
{
   int  var = 20;   /* 实际变量的声明 */
   int  *ip;        /* 指针变量的声明 */
   ip = &var;  /* 在指针变量中存储 var 的地址 */
   printf("Address of var variable: %p\n", &var  );
   /* 在指针变量中存储的地址 */
   printf("Address stored in ip variable: %p\n", ip );
   /* 使用指针访问值 */
   printf("Value of *ip variable: %d\n", *ip );
   return 0;
}

运行结果是：

Address of var variable: bffd8b3c
Address stored in ip variable: bffd8b3c
Value of *ip variable: 20

指向指针的指针

现在我们了解了内存地址、指针以及它们之间的相互关系之后，下面看看指针当中的一些难点：指向指针的指针。指向指针的指针是一种多级间接寻址的形式，或者说是一个指针链。通常，一个指针包含一个变量的地址。当我们定义一个指向指针的指针时，第一个指针包含了第二个指针的地址，第二个指针指向包含实际值的地址。

示例如下：

#include <stdio.h>
int main ()
{
   int  var;
   int  *ptr;
   int  **pptr;
   var = 3000;
   /* 获取 var 的地址 */
   ptr = &var;
   /* 使用运算符 & 获取 ptr 的地址 */
   pptr = &ptr;
   /* 使用 pptr 获取值 */
   printf("Value of var = %d\n", var );
   printf("Value available at *ptr = %d\n", *ptr );
   printf("Value available at **pptr = %d\n", **pptr);
   return 0;
}

运行结果是：

Value of var = 3000
Value available at *ptr = 3000
Value available at **pptr = 3000

传递指针给函数

C 语言允许传递指针给函数，只需要简单地声明函数参数为指针类型即可。例如：

#include <stdio.h>
#include <time.h>
void getSeconds(unsigned long *par);
int main ()
{
   unsigned long sec;
   getSeconds( &sec );
   /* 输出实际值 */
   printf("Number of seconds: %ld\n", sec );
   return 0;
}

void getSeconds(unsigned long *par)
{
   /* 获取当前的秒数 */
   *par = time( NULL );
   return;
}

运行结果是：Number of seconds :129445046

从函数返回指针

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

#include <stdio.h>
#include <time.h>
#include <stdlib.h> 
/* 要生成和返回随机数的函数 */
int * getRandom( )
{
   static int  r[10];
   int i;
   /* 设置种子 */
   srand( (unsigned)time( NULL ) );
   for ( i = 0; i < 10; ++i)
   {
      r[i] = rand();
      printf("%d\n", r[i] );
   }
   return r;
}
 
/* 要调用上面定义函数的主函数 */
int main ()
{
   /* 一个指向整数的指针 */
   int *p;
   int i;
   p = getRandom();
   for ( i = 0; i < 10; i++ )
   {
       printf("*(p + [%d]) : %d\n", i, *(p + i) );
   }
   return 0;
}

运行结果是：

1523198053
1187214107
1108300978
430494959
1421301276
930971084
123250484
106932140
1604461820
149169022
*(p + [0]) : 1523198053
*(p + [1]) : 1187214107
*(p + [2]) : 1108300978
*(p + [3]) : 430494959
*(p + [4]) : 1421301276
*(p + [5]) : 930971084
*(p + [6]) : 123250484
*(p + [7]) : 106932140
*(p + [8]) : 1604461820
*(p + [9]) : 149169022

函数指针

函数指针是指向函数的指针变量。通常我们说的指针变量是指向一个整型、字符型或数组等变量，而函数指针是指向函数。函数指针可以像一般函数一样，用于调用函数、传递参数。

函数指针变量的声明：

typedef int (*fun_ptr)(int,int); // 声明一个指向参数和返回值都为int的函数指针类型

以下实例声明了函数指针变量 p，指向函数 max：

#include <stdio.h>
int max(int x, int y)
{
    return x > y ? x : y;
}
int main(void)
{
    /* p 是函数指针 */
    int (* p)(int, int) = & max; // &可以省略，这里和一般的整型指针有点不一样，赋值整型指针必须有&符号
    int a, b, c, d;
    printf("请输入三个数字:");
    scanf("%d %d %d", & a, & b, & c);
    /* 与直接调用函数等价，d = max(max(a, b), c) */
    d = p(p(a, b), c); 
    printf("最大的数字是: %d\n", d);
    return 0;
}

 运行结果是：

请输入三个数字:1 2 3
最大的数字是: 3

函数指针变量可以作为某个函数的参数来使用的，回调函数就是一个通过函数指针调用的函数。简单讲：回调函数是由别人的函数执行时调用你实现的函数。示例：

实例中 populate_array 函数定义了三个参数，其中第三个参数是函数的指针，通过该函数来设置数组的值。实例中我们定义了回调函数 getNextRandomValue，它返回一个随机值，它作为一个函数指针传递给 populate_array 函数。populate_array 将调用 10 次回调函数，并将回调函数的返回值赋值给数组。

#include <stdlib.h>  
#include <stdio.h>
// 回调函数
void populate_array(int *array, size_t arraySize, int (*getNextValue)(void))
{
    for (size_t i=0; i<arraySize; i++)
        array[i] = getNextValue();
}
// 获取随机值
int getNextRandomValue(void)
{
    return rand();
}
int main(void)
{
    int myarray[10];
    populate_array(myarray, 10, getNextRandomValue);
    for(int i = 0; i < 10; i++) {
        printf("%d ", myarray[i]);
    }
    printf("\n");
    return 0;
}

运行结果是：

16807 282475249 1622650073 984943658 1144108930 470211272 101027544 1457850878 1458777923 2007237709 

总结：

1. 指针指向变量的地址，即指针的值是另一个变量的地址。
2. 指针也是变量，所以指针它也有自己的地址，指针自己的地址和它指向的地址是两个不一样的地址。
3. 获取指针指向的地址不需要带*号。
4. 获取指针指向的地址所存取的值需要带*号。
5. 可以有多级指针。
6. 调用函数指针不需要带*号，和一般的基类指针操作不一样。
7. 函数指针是指向函数的指针变量，函数指针可以作为某个函数的参数。