1 指针

1.1 简介

当初学C语言，指针是最头疼的地方，难以理解，不过时间长了就自然明白了
通过指针，可以简化一些 C 编程任务的执行，还有一些任务，如动态内存分配，没有指针是无法执行的。
每一个变量都有一个内存位置，每一个内存位置都定义了可使用 & 运算符访问的地址，它表示了在内存中的一个地址。
注意：用register修饰的变量是没法取到地址的，没有内存位置

1.2 什么是指针

1.2.1 定义

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

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

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

不同数据类型的指针之间唯一的不同是，指针所指向的变量或常量的数据类型不同。

1.2.2 指针表示

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

#include <stdio.h>int main ()
{int var_runoob = 10;int *p;              // 定义指针变量p = &var_runoob;printf("var_runoob 变量的地址： %p\n", p);return 0;
}结果：
var_runoob 变量的地址： 0x7ffeeaae08d8

1.2.3 为什么*p=&a不正确

int *p=&a是对的，但是*p=&a；却不对？
int *p=&a;这一句定义了一个变量p，p是一个指向int型的指针，即p的数据类型是int*，而&a的数据类型也是int*。这条语句可以分写为 int *p;p=&a;所以这一句没问题。
*p=&a; 这一句是对(*p)进行赋值操作，(*p)的数据类型是int型，而&a的数据类型是int*，两者类型不同，无法进行赋值，所以语句是错的。

*p=a和p=&a是正确的，*p=a的意思：将a的值赋给p指针指向的地址的值；p=&a的意思是：将a的地址赋给指针p；
区别：*p是一个值；p是一个地址；两者完全不相同，*代表着p指向的地址的值，简单来说就是取值；&是取地址符号，取的是地址；p是指针，可以理解为所指向的值的地址，*p就是取p指针指向的地址的值，&a就是取a的地址。

1.3 使用指针

1.3.1 简单使用

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

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

1.3.2 NULL 指针

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

#include <stdio.h> 
int main (){int  *ptr = NULL; printf("ptr 的地址是 %p\n", ptr  ); return 0;
}结果：
ptr 的地址是 0x0

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

如需检查一个空指针，可以使用 if 语句，如下所示：

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

1.3.3 指针算术运算

1.3.3.1 定义

C 指针是一个用数值表示的地址。因此，可以对指针执行算术运算。可以对指针进行四种算术运算：++、--、+、-

• 整型指针：假设 ptr 是一个指向地址 1000 的整型指针，是一个 32 位的整数，让我们对该指针执行下列的算术运算：ptr++，在执行完上述的运算之后，ptr 将指向位置 1004，因为 ptr 每增加一次，它都将指向下一个整数位置，即 当前位置往后移 4 字节。这个运算会在不影响内存位置中实际值的情况下，移动指针到下一个内存位置。

• 字符型指针：如果 ptr 指向一个地址为 1000 的字符，上面的运算会导致指针指向位置 1001，因为下一个字符位置是在 1001。

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

1.3.3.2 遍历数组：递增一个指针

我们喜欢在程序中使用指针代替数组，因为变量指针可以递增，而数组不能递增，数组可以看成一个指针常量。
下面的程序递增变量指针，以便顺序访问数组中的每一个元素：

#include <stdio.h> 
const int MAX = 3; 
int main ()
{int  var[] = {10, 100, 200};int  i, *ptr; /* 指针中的数组地址 */ptr = var;for ( i = 0; i < MAX; i++){ printf("存储地址：var[%d] = %p\n", i, ptr );printf("存储值：var[%d] = %d\n", i, *ptr ); /* 指向下一个位置 */ptr++;}return 0;
}结果：
存储地址：var[0] = e4a298cc
存储值：var[0] = 10
存储地址：var[1] = e4a298d0
存储值：var[1] = 100
存储地址：var[2] = e4a298d4
存储值：var[2] = 200

1.3.3.3 遍历数组：递减一个指针

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

#include <stdio.h> 
const int MAX = 3; 
int main ()
{int  var[] = {10, 100, 200};int  i, *ptr; /* 指针中最后一个元素的地址 */ptr = &var[MAX-1];for ( i = MAX; i > 0; i--){printf("存储地址：var[%d] = %p\n", i-1, ptr );printf("存储值：var[%d] = %d\n", i-1, *ptr );/* 指向下一个位置 */ptr--;}return 0;
}结果：
存储地址：var[2] = 518a0ae4
存储值：var[2] = 200
存储地址：var[1] = 518a0ae0
存储值：var[1] = 100
存储地址：var[0] = 518a0adc
存储值：var[0] = 10

1.3.3.4 指针的比较

指针可以用关系运算符进行比较，如 ==、< 和 >。如果 p1 和 p2 指向两个相关的变量，比如同一个数组中的不同元素，则可对 p1 和 p2 进行大小比较。

下面的程序修改了上面的实例，只要变量指针所指向的地址小于或等于数组的最后一个元素的地址 &var[MAX - 1]，则把变量指针进行递增：

#include <stdio.h> 
const int MAX = 3; 
int main ()
{int  var[] = {10, 100, 200};int  i, *ptr; /* 指针中第一个元素的地址 */ptr = var;i = 0;while ( ptr <= &var[MAX - 1] ){ printf("存储地址：var[%d] = %p\n", i, ptr );printf("存储值：var[%d] = %d\n", i, *ptr );/* 指向上一个位置 */ptr++;i++;}return 0;
}结果：
存储地址：var[0] = 0x7ffeee2368cc
存储值：var[0] = 10
存储地址：var[1] = 0x7ffeee2368d0
存储值：var[1] = 100
存储地址：var[2] = 0x7ffeee2368d4
存储值：var[2] = 200

1.3.4 指针数组

1.3.4.1 简单示例

先让我们来看一个实例，它用到了一个由 3 个整数组成的数组：

#include <stdio.h> 
const int MAX = 3; 
int main ()
{int  var[] = {10, 100, 200};int i; for (i = 0; i < MAX; i++){printf("Value of var[%d] = %d\n", i, var[i] );}return 0;
}结果：
Value of var[0] = 10
Value of var[1] = 100
Value of var[2] = 200

可能有一种情况，我们想要让数组存储指向 int 或 char 或其他数据类型的指针。这是一个指向整数的指针数组的声明：
int *ptr[MAX];
在这里，把 ptr 声明为一个数组，由 MAX 个整数指针组成。因此，ptr 中的每个元素，都是一个指向 int 值的指针。因此是由指针构成的数组

#include <stdio.h> 
const int MAX = 3; 
int main ()
{int  var[] = {10, 100, 200};int i, *ptr[MAX];for ( i = 0; i < MAX; i++) {ptr[i] = &var[i]; /* 赋值为整数的地址 */}for ( i = 0; i < MAX; i++){printf("Value of var[%d] = %d\n", i, *ptr[i] );}return 0;
}结果：
Value of var[0] = 10
Value of var[1] = 100
Value of var[2] = 200

指针数组和数组指针的区别：

• 指针数组，如：int *p[3]
  指针数组：指针数组可以说成是指针的数组，首先这个变量是一个数组。
  其次，指针修饰这个数组，意思是说这个数组的所有元素都是指针类型。
  在 32 位系统中，指针占四个字节
• 数组指针，如：int (*p)[3]
  数组指针：数组指针可以说成是数组的指针，首先这个变量是一个指针。
  其次，数组修饰这个指针，意思是说这个指针存放着一个数组的首地址，或者说这个指针指向一个数组的首地址

1.3.4.2 字符串指针数组问题

在C语言中，字符串数组可以用字符数组来表示。字符数组是由一系列字符组成的数组，每个字符占用一个字节的内存空间。字符串是以\0（空字符）结尾的字符数组，因此在定义字符串数组时需要预留一个字符位置来存储\0。

char str[10] = "hello"; // 定义一个长度为10的字符数组，存储字符串"hello"
char *str = "hello";// 使用 字符指针表示法：

在C语言中，char *str = "hello"; 和 char str[] = "hello"; 都可以用来表示字符串，但它们之间有一些区别：

• 存储方式：
  char *str = "hello";：str 是一个指针，它指向一个字符串字面量（string literal）“hello”。字符串字面量通常存储在程序的只读内存区域（如常量区），因此不能修改。str 变量本身存储在栈上。
  char str[] = "hello";：str 是一个字符数组，它的内容是字符串 “hello”。字符串的字符存储在栈上，因此可以修改。str 变量本身也存储在栈上。
• 可修改性：
  char *str = "hello";：由于 str 指向的是只读内存区域，所以不能修改字符串内容。例如，尝试修改字符串的操作（如 str[0] = 'H';）可能会导致程序崩溃。
  char str[] = "hello";：由于 str 是一个字符数组，存储在栈上，所以可以修改字符串内容。例如，可以执行 str[0] = 'H'; 操作。
• sizeof操作符的结果：
  char *str = "hello";：使用 sizeof(str) 时，将返回指针的大小（通常为4字节或8字节，取决于操作系统和编译器）。
  char str[] = "hello";：使用 sizeof(str) 时，将返回字符数组的大小，即6字节（包括字符串结尾的空字符’\0’）。

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

#include <stdio.h> 
const int MAX = 4;int main ()
{const char *names[] = {"Zara Ali","Hina Ali","Nuha Ali","Sara Ali",};int i = 0;for ( i = 0; i < MAX; i++){printf("Value of names[%d] = %s\n", i, names[i] );}return 0;
}结果：
Value of names[0] = Zara Ali
Value of names[1] = Hina Ali
Value of names[2] = Nuha Ali
Value of names[3] = Sara Ali

由于 字符串 是以字符数组的形式存储的，以空字符（'\0'）作为结束标志。所以当定义一个字符串指针数组 char *names[] 时，数组中的每个元素都是一个指向字符数组（字符串）的指针。
当 访问 names[i] 时，实际上是获取了指向字符串的指针。然而，C 语言中的字符串处理函数（如 printf）通常会自动处理指针，它们会根据指针所指向的地址，逐个字符地读取字符串，直到遇到空字符（'\0'）为止。因此，当使用这些函数时，它们会显示字符串的内容，而不是指针的地址。

#include <stdio.h>void main()
{char *names[] = {"Zara Ali","ASD"};char **m;m = names;// m = names[0];printf("Value of names = %p\n", names);printf("Value of m = %p\n", m );printf("Value of *m = %s\n", *m );char *n;n = *names;// m = names[0];printf("Value of n = %p\n", n );printf("Value of n = %s\n", n );printf("Value of *n = %c\n", *n ); 
}输出结果：
Value of names = 0061FF10
Value of m = 0061FF10
Value of *m = Zara Ali
Value of n = 00405064
Value of n = Zara Ali
Value of *n = Z

从上面例子中分析：
char *names[] = {"Zara Ali", "ASD"}; 定义了一个指针数组，数组中的每个元素都是一个指向字符数组（字符串）的指针。当使用 char *m; 时，定义了一个指向字符的指针。所以，m 的类型是 char *。
而 names 是一个指针数组，它的类型是 char **，因为它是一个指向指针的指针。而数组名在大多数情况下会被解释为指向数组第一个元素的指针，所以 不能将 names 直接赋值给 m ，因为类型不同。
但是，你可以将 names 数组中的某个元素（即一个指向字符串的指针）赋值给 m，例如：m = names[0]; // 或者 m = *names;
这样，m 就指向了字符串 “Zara Ali”。
当使用 n = *names 时，相当于把字符串指针数组的第一个元素给了n，即"Zara Ali"，当在使用 *n 时，就指向了字符串的第一个元素即字符：Z

1.3.5 指向数组的指针

数组名是一个指向数组中第一个元素的常量指针。因此，在下面的声明中：
double balance[50];
balance 是一个指向 &balance[0] 的指针，即数组 balance 的第一个元素的地址。因此，下面的程序片段把 p 赋值为 balance 的第一个元素的地址：

double *p;
double balance[10];
p = balance;

使用数组名作为常量指针是合法的，反之亦然。因此，*(balance + 4) 是一种访问 balance[4] 数据的合法方式。

一旦把第一个元素的地址存储在 p 中，就可以使用 *p、*(p+1)、*(p+2) 等来访问数组元素。

#include <stdio.h>int main ()
{/* 带有 5 个元素的整型数组 */double balance[5] = {1000.0, 2.0, 3.4, 17.0, 50.0};double *p;int i; p = balance; /* 输出数组中每个元素的值 */printf( "使用指针的数组值\n");for ( i = 0; i < 5; i++ ){printf("*(p + %d) : %f\n",  i, *(p + i) );} printf( "使用 balance 作为地址的数组值\n");for ( i = 0; i < 5; i++ ){printf("*(balance + %d) : %f\n",  i, *(balance + i) );} return 0;
}结果：
使用指针的数组值
*(p + 0) : 1000.000000
*(p + 1) : 2.000000
*(p + 2) : 3.400000
*(p + 3) : 17.000000
*(p + 4) : 50.000000
使用 balance 作为地址的数组值
*(balance + 0) : 1000.000000
*(balance + 1) : 2.000000
*(balance + 2) : 3.400000
*(balance + 3) : 17.000000
*(balance + 4) : 50.000000

在上面的实例中，p 是一个指向 double 型的指针，这意味着它可以存储一个 double 类型的变量。一旦我们有了 p 中的地址，*p 将给出存储在 p 中相应地址的值

1.3.6 指向指针的指针

指向指针的指针是一种多级间接寻址的形式，或者说是一个指针链。通常，一个指针包含一个变量的地址。当我们定义一个指向指针的指针时，第一个指针包含了第二个指针的地址，第二个指针指向包含实际值的位置。

一个指向指针的指针变量必须如下声明，即在变量名前放置两个星号。例如，下面声明了一个指向 int 类型指针的指针：
int **var;
当一个目标值被一个指针间接指向到另一个指针时，访问这个值需要使用两个星号运算符，如下面实例所示：

#include <stdio.h> 
int main ()
{int  V;int  *Pt1;int  **Pt2;V = 100;/* 获取 V 的地址 */Pt1 = &V;/* 使用运算符 & 获取 Pt1 的地址 */Pt2 = &Pt1;/* 使用 pptr 获取值 */printf("var = %d\n", V );printf("Pt1 = %p\n", Pt1 );printf("*Pt1 = %d\n", *Pt1 );printf("Pt2 = %p\n", Pt2 );printf("**Pt2 = %d\n", **Pt2);return 0;
}结果：
var = 100
Pt1 = 0x7ffee2d5e8d8
*Pt1 = 100
Pt2 = 0x7ffee2d5e8d0
**Pt2 = 100

1.4 函数和指针关系

1.4.1 传递指针给函数

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

下面的实例中，我们传递一个无符号的 long 型指针给函数，并在函数内改变这个值：

#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 :1294450468

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

#include <stdio.h>/* 函数声明 */
double getAverage(int *arr, int size);int main ()
{/* 带有 5 个元素的整型数组  */int balance[5] = {1000, 2, 3, 17, 50};double avg;/* 传递一个指向数组的指针作为参数 */avg = getAverage( balance, 5 ) ;/* 输出返回值  */printf("Average value is: %f\n", avg );return 0;
}double getAverage(int *arr, int size)
{int    i, sum = 0;      double avg;          for (i = 0; i < size; ++i){sum += arr[i];}avg = (double)sum / size;return avg;
}结果：
Average value is: 214.40000

1.4.2 从函数返回指针

类似地，C 允许从函数返回指针。为了做到这点，必须声明一个返回指针的函数，如下所示：

int * myFunction()
{
.
.
.
}

另外，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

1.4.3 函数指针

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

函数指针变量的声明：

int (*fun_ptr)(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

1.4.4 回调函数

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

实例中 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];/* getNextRandomValue 不能加括号，否则无法编译，因为加上括号之后相当于传入此参数时传入了 int , 而不是函数指针*/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