1. 字符指针
2. 数组指针
3. 指针数组
4. 数组传参和指针传参
5. 函数指针
6. 函数指针数组
7. 指向函数指针数组的指针
8. 回调函数
9. 指针和数组面试题的解析
指针的主题，我们在初级阶段的《指针》章节已经接触过了，
我们知道了指针的概念：
1. 指针就是个变量，用来存放地址，地址唯一标识一块内存空间。
2. 指针的大小是固定的4/8个字节（32位平台/64位平台）。
3. 指针是有类型，指针的类型决定了指针的+-整数的步长，指针解引用操作的时候的权限。
4. 指针的运算。
字符指针
在指针的类型中我们知道有一种指针类型为字符指针 char* ;
int main()
{
char ch = 'w';
char *pc = &ch;
*pc = 'w';
return 0;
}
这里char ch='w'就是把w赋值给ch这个字符型变量，所以在取地址的时候，我们用char* 来接收才是最好的。
不要与下面的代码混淆了
int main()
{
const char* pstr = "hello bit.";//这里是把一个字符串放到pstr指针变量里了吗？ printf("%s\n", pstr);
return 0;
}
这个第一行代码，这个字符串在赋值给pstr时其实存的是起始地址(也就是h这个字符的地址)，而我们%s打印输出的是字符串，也就是说，printf这串代码在执行的时候会去寻找从pstr这个指向的地址的空间的字符数据并打印。
上面代码的意思是把一个常量字符串的首字符 h 的地址存放到指针变量 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;
}思考一下？
为什么会这样呢？
这里str3和str4指向的是一个同一个常量字符串。C/C++会把常量字符串存储到单独的一个内存区域. 当 几个指针，指向同一个字符串的时候，他们实际会指向同一块内存。但是用相同的常量字符串去初始化 不同的数组的时候就会开辟出不同的内存块。所以str1和str2不同，str3和str4不相同。
我们再来看一看小伙伴容易错的部分：
#include <stdio.h>
int main()
{
char ch = 'w';
char* chx = &ch;
char* c = "hello boy";
*chx = 'c';
*c = 'w';
return 0;
}
那我们想一想怎么可以改呢？
我们可以用一个数组去接受这个字符串，然后利用这个数组去改存的字符串的值
指针数组
int* arr1[10]; //整形指针的数组
char *arr2[4]; //一级字符指针的数组
char **arr3[5];//二级字符指针的数组
那什么是指针数组呢，就是有个数组，里面的元素存放的都是相同类型地址。
图例
类型可以是整形地址，字符地址等等，也可以是结构体地址
例子1：
#include <stdio.h>
int main()
{
char* ch[4] = { "hello","world","baby","sas" };
for (int i = 0;i < 4;i++)
{
printf("%s ", ch[i]);
}
return 0;
} 
那么就有人问了？初始化arr的{“hello”, “world”, “baby, “sas”};的是什么鬼？
这四个不是什么鬼，他们也存在在内存中，只是跟arr这个变量不在同一段空间，它们被分配在只读数据区，数组arr[4]的四个指针元素，分别存放着这四个字符串的首地址，想象一下，从栈区有四只无形的手指向数据区的空间。arr+1会跳过四个字节，。也就是一个指针的大小
例子2：
#include <stdio.h>
int main()
{
int arr1[] = { 0,1 };//整形数组
int arr2[] = { 2,1 };//整形数组
int arr3[] = { 3,1 };//整形数组
int* arr[3] = { arr1,arr2,arr3 };
int j = 0;
for (int i = 0;i < 3;i++)
{
printf("%d ", arr[i][j]);
}
return 0;
}
arr[0]这个指向的arr这个数组的第一个元素（arr1整个数组）的地址，而arr[0][0]，这个指向的是arr
这个数组的第一个元素（arr1数组）的首元素地址的值所以打印 0 2 3
&数组名VS数组名
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 = %p\n", arr);
printf("&arr= %p\n", &arr);
printf("arr+1 = %p\n", arr+1);
printf("&arr+1= %p\n", &arr+1);
return 0;
} 
&arr+1是跳过整个数组，&arr指向的是数组首元素地址，但是本质是取出整个数组，arr+1，是跳过一个int类型的数据。
数组指针的使用
什么是数组指针
数组指针指向的是整个数组。
既然数组指针指向的是数组，那数组指针中存放的应该是数组的地址。
#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;
}
一般这样用
#include <stdio.h>
void print_arr1(int arr[3][5], int row, int col)
{
int i = 0;
int j = 0;
for (i = 0; i < row; i++)
{
for (j = 0; j < col; j++)
{
printf("%d ", arr[i][j]);
}
printf("\n");
}
}
void print_arr2(int(*arr)[5], int row, int col)
{
int i = 0;
int j = 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 };
print_arr1(arr, 3, 5);
//数组名arr，表示首元素的地址
//但是二维数组的首元素是二维数组的第一行
//所以这里传递的arr，其实相当于第一行的地址，是一维数组的地址
//可以数组指针来接收
print_arr2(arr, 3, 5);
return 0;
}char (*pa)[4];
如果指针数组和数组指针这俩个变量名称一样就会是这样：char *pa[4]和char (*pa)[4]，原来指针数组和数组指针的形成的根本原因就是运算符的优先级问题，所以定义变量是一定要注意这个问题，否则定义变量会有根本性差别！
pa是一个指针指向一个char [4]的数组，每个数组元素是一个char类型的变量，所以我们不妨可以写成：char[4] (*pa);这样就可以直观的看出pa的指向的类型，不过在编辑器中不要这么写，因为编译器根本不认识，这样写只是帮助我们理解。
既然pa是一个指针，存放一个数组的地址，那么在我们定义一个数组时，数组名称就是这个数组的首地址，那么这二者有什么区别和联系呢？
上面验证过，
那我们再来看个例子
数组参数、指针参数
在写代码的时候难免要把【数组】或者【指针】传给函数，那函数的参数该如何设计呢？
例题:
#include <stdio.h>
void test(int arr[])//ok?
{}
void test(int arr[10])//ok?
{}
void test(int* arr)//ok?
{}
void test2(int* arr[20])//ok?
{}
void test2(int** arr)//ok?
{}
int main()
{
int arr[10] = { 0 };
int* arr2[20] = { 0 };
test(arr);
test2(arr2);
return 0;
}
第一行代码中，为什么没有定义数组大小也可以？
在用数组名作函数参数的时候，不是进行值的传送，即不是把实参数组的每一个元素的值都赋予形参数组的各个元素。因为实际上形参数组并不存在， 编译器不会形参数组分配内存。所以在形参接收时不用定义下标，只用知道是上面数据类型即可
那么数组在传参时是用上面传的呢？
用的是数组名，数组名就是首元素地址，所以形参实际接收到的是一个地址
二维数组传参
void test(int arr[3][5])//ok？
{}
void test(int arr[][])//ok？
{}
void test(int arr[][5])//ok？
{}
//总结：二维数组传参，函数形参的设计只能省略第一个[]的数字。
//因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。
//这样才方便运算。
void test(int* arr)//ok？
{}
void test(int* arr[5])//ok？
{}
void test(int(*arr)[5])//ok？
{}
void test(int** arr)//ok？
{}
int main()
{
int arr[3][5] = { 0 };
test(arr);
} 
先看一下，再修改
一级指针传参
#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]);
//一级指针p，传给函数
print(p, sz);//传过去，形参用一级指针接收
return 0;
}
当一个函数的参数部分为一级指针的时候，函数能接收什么参数？
比如
void test1(int *p)
{}
为什么第三个可以，因为一维数组的数组名是数组首元素地址。小伙伴们不要与二维数组名搞混哈！！！
二级指针传参
#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;
}
当函数的参数为二级指针的时候，可以接收什么参数?
#include <stdio.h>
void test(char** p)
{}
int main()
{
char c = 'b';
char* pc = &c;
char** ppc = &pc;
char* arr[10];
test(&pc);
test(ppc);
test(arr);//Ok?
return 0;
}
函数指针 （与指针函数比较绕）
#include <stdio.h>
void test()
{
printf("hehe\n");
}
int main()
{
printf("%p\n", test);
printf("%p\n", &test);
return 0;
}输出的是两个地址，这两个地址是 test 函数的地址。
对于函数来说，函数名和取地址函数名两个都是函数的地址
那我们的函数的地址要想保存起来，怎么保存？ 下面我们看代码：
void test()
{
printf("hehe\n");
} //下面pfun1和pfun2哪个有能力存放test函数的地址？
void (*pfun1)();
void *pfun2();
首先，能给存储地址，就要求pfun1或者pfun2是指针，那哪个是指针？ 答案是：
pfun1可以存放。pfun1先和*结合，说明pfun1是指针，指针指向的是一个函数，指向的函数无参 数，返回值类型为void。
我们再来看看函数指针怎么定义和初始化的，因为我们知道函数名和取地址函数名都是函数的地址
也就是说:
函数名==取地址函数名那么我们接下来就进入如何定义和初始化
这四种定义和初始化都是可以的。
//代码1
(*(void (*)())0)();
//代码2
void (*signal(int, void(*)(int)))(int);代码2待搞
指针函数
顾名思义，它的本质是一个函数，不过它的返回值是一个指针。跟指针数组类似
ret *func(args, ...);
其中，func是一个函数，args是形参列表，ret *作为一个整体，是 func函数的返回值，是一个指针的形式。
下面举一个具体的实例来做说明
# include <stdio.h>
# include <stdlib.h>
int * func_sum(int n)
{
if (n < 0)
{
printf("error:n must be > 0\n");
exit(-1);
}
static int sum = 0;
int *p = ∑
for (int i = 0; i < n; i++)
{
sum += i;
}
return p;
}
int main(void)
{
int num = 0;
printf("please input one number:");
scanf("%d", &num);
int *p = func_sum(num);
printf("sum:%d\n", *p);
return 0;
}
那我们再来看看这个代码:
# include <stdio.h>
# include <stdlib.h>
int * func_sum(int n)
{
if (n < 0)
{
printf("error:n must be > 0\n");
exit(-1);
}
int sum = 0;
int *p = ∑
for (int i = 0; i < n; i++)
{
sum += i;
}
return p;
}
int main(void)
{
int num = 0;
printf("please input one number:");
scanf("%d", &num);
int *p = func_sum(num);
printf("sum:%d\n", *p);
return 0;
}
这里我们没有加static int sum，当我们除func_sum这个函数时，操作系统会把这个函数内的变量和数据还给操作系统，虽然可能结果对了，但是也可能会被改掉了；
函数指针数组
int *arr[10];//数组的每个元素是int*,这个是指针数组
那要把函数的地址存到一个数组中，那这个数组就叫函数指针数组，那函数指针的数组如何定义呢？
int (*parr1[10])(int int);int *parr2[10]();int (*)() parr3[10];
答案是：parr1
parr1 先和 [] 结合，说明 parr1是数组，数组的内容是什么呢？
int (*parr1)[10](int, int);
//含有10个元素的数组，每个元素为函数指针
//且函数指针指向的函数参数为int、int，返回值为int。double (*parr2)[5](int, char);
//含有5个元素的数组，每个元素为函数指针
//且函数指针指向的函数参数为int、char，返回值为double。
那我们知道函数指针数组的用处吗？
可不要小看这个函数指针数组的用处。
第一段代码
#include <stdio.h>
int add(int a, int b) {
return a + b;
}
int sub(int a, int b) {
return a - b;
}
int mul(int a, int b) {
return a * b;
}
int div(int a, int b) {
return a / b;
}
int main()
{
int x, y;
int input = 1;
int ret = 0;
do
{
printf("*************************\n");
printf(" 1:add 2:sub \n");
printf(" 3:mul 4:div \n");
printf("*************************\n");
printf("请选择：");
scanf("%d", &input);
switch (input)
{
case 1:
printf("输入操作数：");
scanf("%d %d", &x, &y);
ret = add(x, y);
printf("ret = %d\n", ret);
break;
case 2:
printf("输入操作数：");
scanf("%d %d", &x, &y);
ret = sub(x, y);
printf("ret = %d\n", ret);
break;
case 3:
printf("输入操作数：");
scanf("%d %d", &x, &y);
ret = mul(x, y);
printf("ret = %d\n", ret);
break;
case 4:
printf("输入操作数：");
scanf("%d %d", &x, &y);
ret = div(x, y);
printf("ret = %d\n", ret);
break;
case 0:
printf("退出程序\n");
break;
default:
printf("选择错误\n");
break;
}
} while (input);
return 0; }
第二段代码
#include <stdio.h>
int add(int a, int b) {
return a + b;
}
int sub(int a, int b) {
return a - b;
}
int mul(int a, int b) {
return a * b;
}
int div(int a, int b) {
return a / b;
}
int main()
{
int x = 0;
int y = 0;
int input = 1;
int ret = 0;
int(*p[5])(int x, int y) = { 0, add, sub, mul, div };
do
{
printf("*************************\n");
printf(" 1:add 2:sub \n");
printf(" 3:mul 4:div \n");
printf("*************************\n");
printf("请选择：");
scanf("%d", &input);
if (input<=4 && input>=1)
{
scanf("%d%d", &x, &y);
printf("%d\n",p[input](x, y));
}
} while (input);
return 0;
}
那我们来验证一下是否等价
显然是等价的
指向函数指针数组的指针
指向函数指针数组的指针是一个 指针指针指向一个 数组 ，数组的元素都是 函数指针
void test ( const char* str ){printf ( "%s\n" , str );}int main (){// 函数指针 pfunvoid ( * pfun )( const char* ) = test ;// 函数指针的数组 pfunArrvoid ( * pfunArr [ 5 ])( const char* str );pfunArr [ 0 ] = test ;// 指向函数指针数组 pfunArr 的指针 ppfunArrvoid ( * ( * ppfunArr )[ 5 ])( const char* ) = & pfunArr ;return 0 ;}
回调函数
我们来看看qsort函数#include <stdio.h>//qosrt 函数的使用者得实现一个比较函数int int_cmp ( const void * p1 , const void * p2 ){return ( * ( int * ) p1 - * ( int * ) p2 );}int main (){int arr [] = { 1 , 3 , 5 , 7 , 9 , 2 , 4 , 6 , 8 , 0 };int i = 0 ;qsort ( arr , sizeof ( arr ) / sizeof ( arr [ 0 ]), sizeof ( int ), int_cmp );for ( i = 0 ; i < sizeof ( arr ) / sizeof ( arr [ 0 ]); i ++ ){printf ( "%d " , arr [ i ]);}printf ( "\n" );return 0 ;}
#include <stdio.h>
int int_cmp(const void* p1, const void* p2) {
return (*(int*)p1 - *(int*)p2);
}
void _swap(void* p1, void* p2, int size) {
int i = 0;
for (i = 0; i < size; i++)
{
char tmp = *((char*)p1 + i);
*((char*)p1 + i) = *((char*)p2 + i);
*((char*)p2 + i) = tmp;
}
}
void bubble(void* base, int count, int size, int(*cmp)(void*, void*))
{
int i = 0;
int j = 0;
for (i = 0; i < count - 1; i++)
{
for (j = 0; j < count - i - 1; j++)
{
if (cmp((char*)base + j * size, (char*)base + (j + 1) * size) > 0)
{
_swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
}
}
}
}
int main()
{
int arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
//char *arr[] = {"aaaa","dddd","cccc","bbbb"};
int i = 0;
bubble(arr, sizeof(arr) / sizeof(arr[0]), sizeof(int), int_cmp);
for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
{
printf("%d ", arr[i]);
}
printf("\n");
return 0;
}