【C语言】高阶指针（1）

本节为高阶指针，即对C语言指针的一些拓展和应用。首先，我们来介绍回顾一下 指针的概念和基本用法。

1. 指针就是个变量，用来存放地址，地址唯一标识一块内存空间。
2. 指针的大小是固定的4/8个字节（32位平台/64位平台）。

地址是物理的电线产生的，在32位平台下，由32个0/1组成的二进制序列，把这个二进制序列作为地址，32个bit位才能存储这个地址。也就是需要4个字节才能存储，所以在32位系统下指针变量的大小就是4个字节。
在64位平台下，由64个0/1组成的二进制序列，把这个二进制序列作为地址，64个bit位才能存储这个地址。也就是需要8个字节才能存储，所以在64位系统下指针变量的大小就是8个字节。

3. 指针是有类型的，指针的类型决定了指针的±整数的步长，指针解引用操作的时候的权限。

一. 字符指针

在这里我们分为字符指针和字符串指针来分别介绍。

1. 字符指针较为简单，以下代码为其基本用法：

int main()
{
char ch = 'w';
char *pc = &ch;
*pc = 'w';//既可直接对ch赋值，也可通过其地址pc间接赋值
return 0;
}

2. 字符串指针
   先给出一段代码：

int main()
{
const char* pstr = "hello bit.";
printf("%s\n", pstr);
return 0;
}

对于这份代码，要注意：C语言中是没有字符串类型的，C语言中字符串的本质为数组，那么此处 pstr实际指向了字符串 hello bit. 的首元素（即字符’ h '），并非指向了整个字符串。

那么，这样创建出来的字符串数组*pstr和 pstr[ ]有什么区别呢 ?
话不多说，看例子：

#include <stdio.h>
int main()
{
char str1[] = "hello bit.";
char str2[] = "hello bit.";
const char *str3 = "hello bit.";
const char *str4 = "hello bit.";
if(str1 ==str2)
printf("str1 and str2 are same\n");
else
printf("str1 and str2 are not same\n");
if(str3 ==str4)
printf("str3 and str4 are same\n");
else
printf("str3 and str4 are not same\n");
return 0;
}

大家可以试着判断一下，以下为运行结果：

这个结果告诉我们，虽然 *pstr 和 pstr[ ] 都可以用来创建字符串数组，但还是有所区别的，其区别在于：
pstr[ ] 每定义一次都会开辟一个新的内存空间；
*pstr 重复定义多次只会开辟一次内存空间，多个指针指向同一个内存空间。

二. 指针数组

指针数组，是一个存放指针的数组，注意，指针数组是数组，而不是指针！

举个例子：

int* arr1[10]; //整形指针的数组
char *arr2[4]; //一级字符指针的数组
char **arr3[5];//二级字符指针的数组

三. 数组指针

1. 数组指针和指针数组的区分

数组指针是指针，是指向数组的指针。
下面，我们对指针数组和数组指针做出区分。
先给出一组例子，大家可以试着判断：

int *p1[10];
int (*p2)[10];

在这组例子中，p1是指针数组，p2是数组指针，这是因为 [ ] 和*同作为操作符， [ ] 的优先级更高，因此p1和 [10] 优先结合，形成数组；而p2和*优先结合，形成指针。

2. &数组名VS数组名

我们先给出一个数组，以此为例展开分析：

int arr[10];

我们知道arr为数组名，数组名表示数组首元素的地址。（两个例外：sizeof(arr)，&arr，此处arr皆表示整个数组。）
那&arr是什么呢？
我们先看一组例子：

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

以下为运行结果：

由此可见，数组名和&数组名打印的地址是一样的。那他们又有什么区别呢？
我们再给一组例子：

#include <stdio.h>
int main()
{
int arr[10] = { 0 };
printf("arr = %d\n", arr);
printf("&arr= %d\n", &arr);
printf("arr+1 = %d\n", arr+1);
printf("&arr+1= %d\n", &arr+1);
return 0;
}

运行结果如下：

从这组例子中，我们不难发现，差别主要在+1，arr+1跳过4个字节，即一个整形变量（数组元素）的长度，&arr+1跳过40个字节，即十个整形变量（整个数组）的长度。
实际上：&arr表示的是数组的地址，而不是数组首元素的地址。
本例中 &arr 的类型是： int(*)[10] ，是一种数组指针类型。

3. 数组指针的使用

举两个例子：

#include <stdio.h>
int main()
{
int arr[10] = {1,2,3,4,5,6,7,8,9,0};
int (*p)[10] = &arr;//把数组arr的地址赋值给数组指针变量p
//但是我们一般很少这样写代码
return 0;
}

在第一个例子中，将&arr存入p中，需要我们正确定义p的类型，即int (*)[10]，否则在VS2022中会报warning。

#include <stdio.h>
void print_arr2(int (*arr)[5], int row, int col)
{
 int i = 0;
 for(i=0; i<row; i++)
 {
   for(j=0; j<col; j++)
   {
    printf("%d ", arr[i][j]);
   }
   printf("\n");
 }
}
int main()
{
int arr[3][5] = {1,2,3,4,5,6,7,8,9,10};
//数组名arr，表示首元素的地址
//但是二维数组的首元素是二维数组的第一行
//所以这里传递的arr，其实相当于第一行的地址，是一维数组的地址
print_arr2(arr, 3, 5);
return 0;
}

在第二个例子中，我们是演示了数组指针作为形参接收二维数组数组名的一个功能，也许没那么实用，但最起码要见到能理解吧。

下面，我们来看一个例子，加深一下我们对数组指针和指针数组的理解：

int (*parr3[10])[5];

这是什么呢？数组指针？指针数组？
可以用以下方法来理解这个声明：

1. 从变量名 parr3 开始，分析它的类型。

2. 我们最先遇到了带有 [] 的标识符，那就意味着 parr3是一个数组 (Array)。

3. 接下来，我们看到了 *，这个符号说明数组中的每个元素是一个指针 (Pointer)。

4. 继续往后看，我们再次遇到了 []，这意味着每个指针指向的对象是一个数组。

5. 最后，我们看到了 int，这表示指向的数组的元素类型是整型。

综上所述，int (*parr3[10])[5] 可以解释为一个包含 10 个指针的数组，每个指针指向一个长度为 5 的整型数组。简单的说就是功能相当于int parr3[10][5]。（实际运用时由于编译器的规定，在传参等操作时可能会报warning）

那么，不妨再看看这些：

int (*parr3)[10][5];
int *(parr3[10][5]);

第一个呢，是parr3和*先结合，再和[10][5]相结合，实质上为一个指向二维数组的指针。
第二个呢，是parr3和[10][5]先结合，再与*结合，实质上是一个二维指针数组。

四. 数组传参和指针传参

在写代码的时候难免要把【数组】或者【指针】传给函数，那函数的参数该如何设计呢？

1.一维数组传参

我们来看一些例子（附注释讲解）：

#include <stdio.h>
//传过来的数组名实质上是一个指针，但程序设定上为了更加简便，允许使用数组来接收
void test(int arr[])//ok?       ok
{}
void test(int arr[10])//ok？    ok
{}
void test(int *arr)//ok?        ok        数组名本质上就是数组首元素的地址
{}
void test2(int *arr[20])//ok?   ok
{}
void test2(int **arr2)//ok?    ok       
//传过来的arr2是数组首元素的地址，但数组元素就是指针，那传来的便是指针的地址,故可以用二级指针来接收
{}
int main()
{
int arr[10] = {0};
int *arr2[20] = {0};
test(arr);
test2(arr2);
}

2.二维数组传参

我们同样来看一组例子（附代码讲解）：

void test(int arr[3][5])//ok？     ok
{}
void test(int arr[][])//ok？      not ok，不允许省略二维数组的列
{}
void test(int arr[][5])//ok？     ok
{}
void test(int *arr)//ok？         not ok，指针类型不匹配
{}
void test(int* arr[5])//ok？      not ok，这是指针数组，是数组，且和主函数中数组类型不一致
{}
void test(int (*arr)[5])//ok？    ok，数组指针
{}
void test(int **arr)//ok？        not ok，类型不匹配
{}
int main()
{
int arr[3][5] = {0};
test(arr);
}

3.一级指针传参

#include <stdio.h>
void print(int *p, int sz)
{
  int i = 0;
  for(i=0; i<sz; i++)
  {
   printf("%d\n", *(p+i));
  }
}
int main()
{
int arr[10] = {1,2,3,4,5,6,7,8,9};
int *p = arr;
int sz = sizeof(arr)/sizeof(arr[0]);
print(p, sz);
return 0;
}

这部分较为简单，就是一级指针传一级指针即可。

4.二级指针传参

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

这一部分也较为简单，就是二级指针传二级指针即可。

总结一下：讲了这么多，传参过程其实也没那么复杂，只需记住，形参和实参类型匹配即可，此外，为了简便，C语言中允许用对应的数组来接收数组名形参，但不允许用数组名来接收非数组名的指针。

五. 函数指针

之前讲了数组指针，数组指针就是指向数组的指针；
同理，函数指针便是指向函数的指针。

我们先看一段代码作为铺垫：

#include <stdio.h>
void test()
{
	printf("hehe\n");
}
int main()
{
	printf("%p\n", test);
	printf("%p\n", &test);
	printf("%p\n", *test);

	return 0;
}

对应结果如下：

在这段代码中，我们可以发现，test和&test和*test打印的地址是一样的，这点和数组类似，可以参照上面进行理解。

得到test的地址，那我们当如何保存函数的地址，下面我们看代码：

void test()
{
printf("hehe\n");
}
//下面pfun1和pfun2哪个有能力存放test函数的地址？
void (*pfun1)();
void *pfun2();

能给存储地址，就要求pfun1或者pfun2是指针，那哪个是指针？ 答案是：

pfun1可以存放。pfun1先和*结合，说明pfun1是指针，指针指向的是一个函数，指向的函数无参数，返回值类型为void；
pfun2和()结合为函数，返回值类型为void *。

然后，我们再来看一个应用：

int Add(int x, int y)
{
	return x + y;
}
int main()
{
	int(*pf)(int, int) = &Add;
	int m = (*pf)(4, 5);//Add
	int n= pf(4, 5);   //&Add
	int q = (*Add)(4, 5);//*Add

	printf("%d\n", m);
	printf("%d\n", n);
	printf("%d\n", q);
	return 0;
}

这段代码中，pf就是我们所说的函数指针，这段代码也说明了函数名也是一个指针，并且用Add,&Add,*Add都可以实现调用。

最后，我们来阅读两段有趣的代码：

//代码1
(*(void (*)())0)();
//代码2
void (*signal(int , void(*)(int)))(int);

小伙伴们看懂了吗？
好吧，我承认这两条代码很恶心，既然这样，那我们就一点一点慢慢分析吧！

//代码1
(*(void (*)())0)();

这段代码看起来只能从0下手了，0可以视作为地址编号为0x00000000的指针，和(void (*)())结合，转化为该类型的指针，再与*结合，解引用。
这段代码的实际意义就是：调用0地址处的函数。

//代码2
void (*signal(int , void(*)(int)))(int);

这段代码，我们来分析一下：

1. 从函数名 signal 开始，我们知道这是一个函数声明。

2. 接下来看到 (int, void(*)(int))，这表明函数 signal 接受两个参数：一个是 int 类型，另一个是指向一个函数的指针，该函数的参数是 int 类型并返回 void。

3. 继续往后看，我们看到了 (*signal(...))，这表示函数 signal 返回的是一个指针。

4. 最后，看到 ()(int)，这表示指针指向的函数接受 int 类型的参数，并返回 void。

综上所述，void (*signal(int, void(*)(int)))(int) 可以解释为 signal 是一个函数，它接受一个 int 类型的参数和一个指向函数的指针，并返回一个指向接受 int 类型参数并返回 void 类型的函数的指针。

代码2太复杂，我们可以用typedef给出简化：

typedef void(*pfun_t)(int);
pfun_t signal(int, pfun_t);

文章写到这里就结束了，如果有错误，还请各位大佬斧正！