指针进阶（C语言）

前言：我们在前面学过了指针的一些简单知识。
1、指针就是一个变量，用来存放地址，地址唯一表示一块内存空间。
2、指针的大小是固定的4/8个字节（32位平台/64位平台）
3、指针是有类型，指针的类型决定了指针的±整数的步长，指针解引用操作的时候的权限。
4、指针运算
（如若记不太清，请点击

字符指针

对于了解字符指针，我们来看一个例子：

#include <stdio.h>
int main()
{
	char ch = 'w';
	char* pc = &ch;//pc是指向一个字符变量的指针
	char* p = "hello world";//"hello world"是一个常量字符串
	//上面的表达式的作用是将：常量字符串"hello world"的第一个字符的地址赋值给p
	printf("%c\n", *p);
	printf("%s\n", p);
	return 0;
}

在这段代码中，我们可以看到字符创建有两种方式：1、指向字符变量的指针。2、指向常量字符串的指针。但是我们需要注意的事，在面对指向常量字符串时，此时p指针指向的是第一个字符的地址，因此我们在打印整个字符串时，只需要给出地址即可，不需要解引用，因为*p是h，也就是第一个字符，并且p指向的内容是无法更改的，因为“hello world”是常量字符串，不能更改，类似*p=‘w’;这类代码无法实现。

指针数组

关于数组指针，我们原来曾经简单的介绍过，我们来看这样一个例子：

#include<stdio.h>
//指针数组
int main()
{
	char* arr1[5];//arr1是存放字符指针的数组
	int* arr2[4];//arr2是一个整型指针的数组
	int a = 10;
	int b = 20;
	int c = 30;
	int d = 40;
	int* arr3[4] = { &a,&b,&c,&d };
	int i = 0;
	for (i = 0; i < 4; i++)
	{
		printf("%d ", *(arr3[i]));
	}
	return 0;
}

我们创建了4个整型变量，并且将每个变量的地址按顺序取出存放进数组，此时这数组的类型就是整型指针数组。当我们打印时，对数组内容进行解引用，再按顺序打印出来就可以了。

数组指针

数组指针，顾名思义是指针，类型是数组类型的指针，那么我们如何定义一个数组指针呢？

#include<stdio.h>
int main()
{
	//int a = 10;
	//int* pi = &a;
	//char ch = 'w';
	//char* pc = &ch;
	int arr[10] = { 0 };
	int* p = arr;
	int (*parr)[10] = &arr;
	return 0;
}

我们定义一个arr[10]的int型数组，我们知道arr数组名表示的数组首元素的地址，首元素是int类型，因此我们定义p指针时是int*类型，而数组名取地址是整个数组，因此要存放到数组指针中，也就是int（*parr）[10]，此时可以将整个数组的地址存放入数组指针中去。
大家可能会问，这种数组指针的运用场景是什么？什么时候会用到呢？我们来看这样一个例子：

#include <stdio.h>
void print2(int (*p)[5], int r, int c)
{
	int i = 0;
	for (i = 0; i < r; i++)
	{
		int j = 0;
		for (j = 0; j < c; j++)
		{
			printf("%d ", (*(p+i)[j]);
		}
		printf("\n");
	}
}
int main()
{
	int arr[3][5] = { 1,2,3,4,5,2,3,4,5,6,3,4,5,6,7 };
	print2(arr, 3, 5); 
	return 0;
}

当我们打印一个二维数组时，如何打印呢？我们可以看到，我们将数组名arr传入函数中去，函数的参数定义为一个数组指针，为什么需要这样呢？我们知道，数组名是首元素的地址，那么在二维数组中数组名是不是首元素地址呢？是的，不过需要变通一下，在二维数组中，我们可以将二维数组看成一个一维数组的数组，以例题为例，我们可以将数组arr看成是一个三个元素的一位数组，而三个元素中分别表示一个数组。而数组名就可以理解为第0行数组的地址，那么此时传参是一个数组的地址，在函数定义时，我们就需要定义一个数组指针，所以接下来打印的过程中对p进行解引用表示第0行，然后用j变量访问这一行中每个元素。这种写法感觉好难理解，是的，那么就没有简单的写法了吗？当然有！

void print2(int arr[3][5], int r, int c)
{
	int i = 0;
	for (i = 0; i < r; i++)
	{
		int j = 0;
		for (j = 0; j < c; j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
}

我们将print2函数写成这种形式，直接将参数写成数组的形式，打印也是以数组的形式打印，我们发现也是可以实现的，而且更容易理解，所以对于数组指针，我们遇见的时候并不太多，但是也是需要了解学习的。

数组参数、指针参数

一维数组传参

我们来看这样一组例子：

#include <stdio.h>
void test(int arr[])
{

}
void test(int arr[10])
{

}
void test(int *p)
{

}
int main()
{
	int arr[10] = {0};
	test(arr);
	return 0;
}

我们在创建一个一维数组arr时，将一维数组调用函数，我们可以两种方式传参。第一种，参数部分创建类似数组（并不是真的创建了数组，用于理解），这样是语法所允许的，当然可以不用给出数组大小；第二种，传参传过去的是数组首元素的地址，因此我们用指针进行接收，因此参数创建可以使用指针。我们再看指针数组的传参。

#include <stdio.h>
void test2(int* *p)
{

}
void test2(int* arr[])
{

}
void test2(int *arr[10])
{

}
int main()
{
	int* arr[10] = { 0 };
	test2(arr);
	return 0;
}

同理，指针数组的传参跟整型数组传参类似，唯一需要注意的是第二种传参方式，在第二种传参过程中，数组中元素类型是指针类型，因此，传参首元素地址是二级指针，因此我们需要创建二级指针来接收一级指针。

二维数组传参

我们来看二维数组如何传参：

#include<stdio.h>
void test(int arr[3][5])
{

}
void test(int arr[][5])
{

}
void test(int (*p)[5])
{

}
int main()
{
	int arr[3][5] = { 0 };
	test(arr);
	return 0;
}

二维数组传参跟一维数组传参极其相似：同样是两种方式传参，但又需要注意的几点，第一种方式：在传参时，我们可以用数组接收，但是省略行和列时，需要要注意跟定义二维数组一样，是不能省略列的。第二种方法：用指针接收，我们需要注意的是二维数组的首元素不是第0行，第0列的元素。而是整个第0行，因此首元素的地址可以看作是一个一位数组的地址，因此我们需要创建数组指针接收，同时元素个数就是列数。

一级指针传参

我们来看一级指针如何传参

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

在这段代码中我们应用到了指针传参，我们可以看到，在一级指针传参的过程中，我们使用指针来接收的，当然我们也可以使用数组来接收，不过我们很少这样来进行传参，大家可以尝试一下。

二级指针传参

二级指针传参：

#include<stdio.h>
void test(int** ppa)
{

}
int main()
{
	int a = 10;
	int* pa = &a;
	int** ppa = &pa;
	test(ppa);
	return 0;
}

我们可以看到二级指针传参，就可以用二级指针来接收，并不需要过多复杂的操作。

函数指针

函数指针顾名思义，就是用来指向函数的指针，用来存放函数地址的。

#include<stdio.h>
int Add(int x, int y)
{
	return x + y;
}
int main()
{
	printf("%p", &Add);
	printf("%p", Add);
	int (*pf)(int, int) = &Add;//pf用来存放函数的地址-pf就是函数指针变量
	return 0;
}

在这段代码中，我们发现函数名Add和取地址函数&Add的效果是一样的，都是表示函数的地址，这一点是跟数组不一样的。我们如何定义一个函数指针来接收一个函数地址呢？其实跟数组指针类似，pf是指针名，先跟*结合，类型是函数，所以（int，int）分别表示int x和int y，返回类型是int，在最前面加上int。
那么，我们如何使用函数指针呢？

#include<stdio.h>
int Add(int x, int y)
{
	return x + y;
}
int main()
{
	int (*pf)(int, int) = &Add;
	//方法1
	int ret = Add(2, 3);
	printf("%d\n", ret);
	//方法2
	ret = (*pf)(4, 5);
	printf("%d\n",ret);
	return 0;
}

方法1，是我们经常使用的一种直接使用的方法，而方法2，也很好理解，pf是指向函数的指针，因此我们在解引用后直接就是函数，我们将参数传到函数就可以完成了。

函数指针数组

函数指针数组，是用来存放函数指针的数组，类型也就是函数指针。我们来看例子：

#include<stdio.h>
int Add(int x, int y)
{
	return x + y;
}
int Sub(int x, int y)
{
	return x - y;
}
int Mul(int x, int y)
{
	return x * y;
}
int Div(int x, int y)
{
	return x / y;
}
int main()
{
	int* arr[10];//整型指针数组
	int(*pf1)(int, int) = &Add;
	int(*pf2)(int, int) = &Sub;
	int(*pf3)(int, int) = &Mul;
	int(*pf4)(int, int) = &Div;
	int(*arr[4])(int, int) = { pf1,pf2,pf3,pf4 };
	return 0; 
}

我们定义了4个函数，分别是Add（），Sub（），Mul（），Div（），这四个函数的类型都是int 函数名（int，int），因此我们知道这四个函数指针的类型是int（*）(int,int)类型，那么函数指针数组的类型就是int(*\arr[4])(int, int)，从而将函数指针存放进数组里。

指向函数指针数组的指针

在理解指向函数指针数组的指针时，我们需要逐步往上分析，首先我们先看简单的，正好将前面的复习一下：
1、数组指针：

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

p指针指向的时arr数组，所以p叫做数组指针。
2、整型指针数组的指针

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

创建一个整型指针数组arr[10]，p指向这个数组，因此，p叫做指向整形指针数组的指针。
3、指向函数指针数组的指针

#include<stdio.h>
int Add(int x,int y)
{
	return x + y;
}
int main()
{
	int (*p)(int, int) = &Add;
	int(*parr[5])(int, int);
	int(*(*pparr)[5])(int, int)=&parr;
	return 0;
}

创建一个Add（）函数，p指针指向函数Add（），所以p指针叫函数指针，parr[5]是一个数组，存放类型int（*）（int,int）指针的数组，所以parr[5]，叫做函数指针数组，pparr是一个指针，指向parr的地址，所以叫做指向函数指针数组的指针。

回调函数

回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。

举个例子：

#include<stdio.h>
int Add(int x, int y)
{
	return x + y;
}

int Sub(int x, int y)
{
	return x - y;
}

void Calc(int (*pf)(int, int))
{
	int ret = pf(3, 5);
	printf("%d\n",ret);
}

int main()
{
	Calc(Add);
	Calc(Sub);
	return 0;
}

在这段代码中，我们创建一个Calc（）函数，我们将函数Add（）和Sub（）的地址传给了Calc（）函数，在Calc（）函数中，我们创建了函数指针，用函数指针来指向我们所需要调用的函数，所以我们说函数Calc（）通过函数指针调用的函数，因此Calc（）调用Add（）函数时，就叫做Add（）是Calc（）函数的回调函数；同样的，如果函数调用Sub（）函数，就叫做Sub（）函数是Calc（）函数的回调函数。
好了，关于指针进阶的知识涉及的还是比较深入的，我们在后面也会举一些例子和例题来更深入了解，希望这次的学习能够帮助到大家，如果有疑问或者错误，希望大家指出来，谢谢各位！