---

一、字符指针

在指针的类型中我们都知道有一种指针类型为字符指针，即char*

下面举个例子：

#include <stdio.h>

int main() 
{
    char* ps = "abcdef";
    printf("%s\n", ps);
    return 0;
}

运行结果：

上述例子中很容易理解成把字符串“abcdef”放到字符指针ps里，但是本质上是把字符串的首字符的地址放到ps中。用%s打印字符串只需要知道字符串的首地址。

下面看一道面试题：

#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;
}

运行结果：

上述面试题中，str3和str4指向的是一个同一常量的字符串，会单独存储到同一个内存区域中，所以他们指向同一个字符串的时候，他们实际是指向同一个内存区域。但是用相同的常量字符串去初始化不同数组就会开辟不同的空间，所以str1和str2不同，str3和str4相同。

---

二、数组指针

2.1、数组指针的定义

数组指针是指针还是数组呢？ 当然，是指针，指向数组的指针，存放的是数组的地址

我们都知道：
整型指针：指向整型的指针，是存放整型变量的地址，即int* p
字符指针：指向字符的指针，是存放字符变量的地址，即char* ch
下面我们来看看什么是数组指针：

int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int (*pa)[10] = &arr;

pa先和*结合，说明pa是一个指针变量，然后指向一个大小为10个整型的数组，所以pa是一个指针，指向一个数组

---

2.2、&数组名和数组名

对于下面的数组：

int arr[10];

arr和&arr怎么分别呢？
我们先看一段代码：

#include <stdio.h>

int main() 
{
    int arr[10] = { 0 };
    printf("%p\n", arr);
    printf("%p\n", arr + 1);
    printf("%p\n", &arr[0]);
    printf("%p\n", &arr[0] + 1);
    printf("%p\n", &arr);
    printf("%p\n", &arr + 1);
    return 0;
}

运行结果：

上述代码中，arr和arr[0]、&arr的地址都是相同的，但是他们都加1呢？
加1后，arr和arr[0]还是相同的，他们都表示的是首元素跳过一个整型，下一个元素的地址。
而&arr则与arr的差值是40，表示的是跳过了整个数组。
综上所述：&arr表示的是整个数组的地址，而不是数组首元素的地址。

---

2.3、数组指针的使用

先举个例子：

#include <stdio.h>

int main() 
{
    int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
    int sz = sizeof(arr) / sizeof(arr[0]);
    int(*p)[10] = &arr;
    for (int i = 0; i < sz; i++)
    {
        printf("%d ", (*p)[i]);
    }
    return 0;
}

上述代码中，把数组arr的地址赋给数组指针变量p中，但是我们很少这样去写一维数组。

下面我们有数组指针来实现二维数组：

#include <stdio.h>
void print(int(*p)[5], int rol, int col)
{
    int i = 0;
    int j = 0;
    for (i = 0; i < rol; i++)
    {
        for (j = 0; j < col; 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} };
    print(arr, 3, 5);
    return 0;
}

运行结果：

上述代码中，由于二维数组的首元素就是二维数组的第一行，所以这里传的arr是二维数组的第一行，相当于一维数组的地址，可以用数组指针来接收。

我来看看下面代码表示什么意思：

int arr[5];
int* parr1[10];
int(*parr2)[10];
int(*parr3[10])[5];

第一个表示整型数组
第二个表示指针数组
第三个表示数组指针
第四个也是数组指针，其中*parr3[10]可看做指针数组，用来存放数组指针的数组

---

三、数组传参、指针传参

3.1、一维数组传参

我们看看下面传参那些是正确的：

#include <stdio.h>
void test(int arr[]) // true，形参是数组
{}
void test(int arr[10]) // true，形参是数组
{}
void test(int* arr[]) // true，形参是指针
{}
void test2(int* arr[20]) // true，形参是数组
{}
void test2(int** arr) // true，形参是指针
{}
int main() 
{
    int arr[10] = { 0 };
    int* arr2[20] = { 0 };
    test(arr);
    test2(arr2);
    return 0;
}

3.2、二维数组传参

我们看看下面传参那些是正确的：

#include <stdio.h>
void test(int arr[3][5]) // true 
{}
void test(int arr[][]) // error 行可以省略，列不可以省略
{}
void test(int arr[][5]) // true
{}
void test(int* arr) // error
{}
void test(int* arr[5]) // error
{}
void test(int(*arr)[5]) // true
{}
void test(int** arr) // error 二级指针接收的是一级指针的地址
{}
int main()
{
	int arr[3][5] = { 0 };
	test(arr);
}

3.3、一级指针传参

我们举个例子：

#include <stdio.h>
void print(int* p, int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", *(p + i));
	}
}
int main()
{
	int arr[10] = { 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;
}

如果当一个函数的参数部分为一级指针的时候，函数又能接收什么参数呢？

void print(int* p)

上述函数中，可接收以下参数：

int a=0;      int* ptr = &a;     int arr[10];   
print(&a);    print(ptr);        print(arr);

3.4、二级指针传参

看个例子：

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

如果当一个函数的参数部分为二级指针的时候，函数又能接收什么参数呢？

void test(int** ptr);

上述函数中，可接收以下参数：

int** ptr;        int* p2;       int* arr[10];
test(ptr);        test(&p2)      test(arr);

---

四、函数指针

函数指针是指向函数的指针

下面我们看一段代码：

#include <stdio.h>
int Add(int x, int y)
{
	return x + y;
}
int main()
{
	printf("%p\n", Add);
	printf("%p\n", &Add);
	return 0;
}

运行结果：

由上述结果可知Add和&Add都是函数的地址，那么我们应该怎样保存函数的地址呢？

#include <stdio.h>
int Add(int x, int y)
{
	return x + y;
}
int main()
{
	int (*pf)(int x, int y) = Add; // Add也可写成&Add
	int sum = (*pf)(3, 5);
	printf("%d", sum); // 8
	return 0;
}

上述代码中，pf是指针，指向的是一个函数，返回类型为int

我们看看下面两个代码：

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

上述代码中：
代码1：可把0当做一个函数的地址，把0直接强制转换成一个void(*)()的函数指针，然后去调用0地址处的函数。
代码2：是一次函数声明，声明的函数叫signal，signal函数的第一个参数是int类型，第二个参数是一个函数指针类型，该函数指针指向的函数参数是int类型，返回类型是void。signal函数的返回类型也是一个函数指针类型，该函数指针指向的函数参数是int，返回类型是void。

---

五、函数指针数组

函数指针数组是多个函数指针放在数组里

可写成：

int(*pfArr[4])(int int);

函数指针数组的用途是转移表。

举个例子（计算器）：

#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 x = 0;
	int y = 0;
	int input = 0;
	int ret = 0;
	int (*pfArr[5])(int, int) = { 0,Add,Sub,Mul,Div };
	do
	{
		printf("请选择：");
		scanf("%d", &input);
		if (input == 0)
		{
			printf("退出计算器\n");
		}
		else if (input >= 1 && input <= 4)
		{
			printf("请输入两个数字：");
			scanf("%d %d", &x, &y);
			ret = pfArr[input](x, y);
			printf("%d\n", ret);
		}
		else
		{
			printf("选择错误\n");
		}
	} while (input);
	return 0;
}

运行效果：

---

六、指向函数指针数组的指针

是一个指针，指针指向的是一个数组，数组元素都是函数指针

举个例子：

int(*pf)(int int); // 函数指针
int (*pfArr[4])(int int); // 函数指针数组
int (*(*ptr)[4])(int int) = &pfArr; // 指向函数指针数组的指针

---

七、回调函数

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

qsort函数的参数中就有一个函数指针，这个函数指针就是一个回调函数。
详解qsort函数

---

加深对指针的理解，可以看看：
指针的几个笔试题