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

指针数组是存放指针的数组，实质上是数组。数组指针是指向数组的指针，实质上是指针。

1.1指针数组

比如int* arr[10];这里怎么理解，这里的arr[10 ]就是数组，数组中存放的是int类型的指针。

用例子来说：

#include <stdio.h>
int main()
{
  char* arr[3] = { "zhangsan","lisi","wangwu" };
  int i = 0;
  for (i = 0; i < 3; i++)
  {
    printf("%s\n", arr[i]);
  }
  return 0;
}

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

1.2数组指针

比如int (*arr)[10];这里的意思是arr是个指针，这个指针指向一个数组，数组中有十个元素，每个元素都是int类型。这里可以借用int *arr;类比，这里的意思是指向整型的指针变量arr。

这里需要注意的是&arr和arr,认识到这个数组指针，这里对其再次解读。

这里的&arr的类型是int (*)[10];是一个数组指针类型，其他的是整型指针类型，所以&arr+1跳过的是整个数组。

打印一维数组元素：

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

打印二维数组：

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

再来看看这个是什么鬼？

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

这个是什么东西？

首先它可拆分为两个int (* )[5]和parr[10]，这里的意思是 parr是存放数组指针的数组。

2.数组参数和指针参数

2.1一维数组传参

int arr[10] = {0};

可以用int arr[]和int arr[10]和int *arr接收。

int *arr[10] = {0};

这里的arr可以用int *arr[10] 和int **arr接收。

2.2二维数组传参

int arr[3][5] = {0};

这里的arr可以用int arr[3][5]和int arr[][5]和int (*arr)[5]接收，其他的都不行。

2.3一级指针传参

void test(int *p){}

2.4二级指针传参

void test(int **ptr){}

这里的int **ptr可以用二级指针和&一级指针和指针数组传参。

3.函数指针

这里的函数名就是函数的地址。

这里用这个Add来写一下函数指针，void (*padd)(int x,int y);这个就是函数指针，首先把padd和void ( * )(int x,int y)分开，首先是一个指针，这个指针的类型是函数，指向函数，这个函数的参数是x和y，返回值是void。

上述代码改进

int Add(int x, int y)
{
  return x + y;
}
int main()
{
  int a = 10;
  int b = 20;
  int (*padd)(int x,int y) = &Add;
  int ret = padd(3,5); 
  printf("%d\n", ret);
  return 0;
}
//结果是8

下面来看看这个代码是什么意思？

(* ( void( * )( ) )0 )( );

解释：void( * )( )是函数指针类型，把0强制类型转换为函数指针类型，调用0地址处的函数。这里这个代码也可以写成( void( * )( ) )0 ( );

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

解释：上述代码是函数声明，声明的函数叫做signal，函数的第一个参数是int类型，第二个参数是函数指针类型，该函数指针指向的函数参数是int,返回类型是void，signal函数的返回类型也是一个函数指针，该函数指针指向的函数参数是int,返回类型是void。

4. 函数指针数组

比如：int (*p[3])(int x,int y);这里p是指数组，p中存放的是函数指针。

#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;
  //函数指针数组
  int(*p[5])(int x, int y) = { 0, add, sub, mul, div }; 
  while (input)
  {
    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))
    {
      printf("输入操作数：");
      scanf("%d %d", &x, &y);
      ret = (*p[input])(x, y);
      //ret = p[input](x,y);
    }
    else
      printf("输入有误\n");
    printf("ret = %d\n", ret);
  }
  return 0;
}

5. 指向函数指针数组的指针

函数指针数组：int (*p[3])(int x,int y);

指向函数指针数组的指针：int ( * (*p)[3])(int x,int y);

6. 回调函数

回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。

上述模拟计算器可以这样来写（利用回调函数）：

#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;
}
void menu()
{
  printf("***************************\n");
  printf("***** 1.add    2. sub  ****\n");
  printf("***** 3.mul    4. div  ****\n");
  printf("***** 0.exit           ****\n");
  printf("***************************\n");
}
void calc(int (*p)(int, int))
{
  int x = 0;
  int y = 0;
  int ret = 0;
  printf("请输入2个操作数:>");
  scanf("%d %d", &x, &y);
  //回调函数
  ret = p(x, y);
  printf("%d\n", ret);
}
int main()
{
  int input = 0;
  do
  {
    menu();
    printf("请选择:>");
    scanf("%d", &input);    
    switch (input)
    {
    case 1:
      calc(Add);
      break;
    case 2: 
      calc(Sub);
      break;
    case 3:
      calc(Mul);
      break;
    case 4:
      calc(Div);
      break;
    case 0:
      printf("退出计算器\n");
      break;
    default:
      printf("选择错误\n");
      break;
    }
  } while (input);
}

6.1.qsort库函数

初步了解：

再次理解：

qsort库函数可以对任意类型数据进行排序，其原理类似于快速排序。

base：待排序数组的起始地址

num:待排序数据的元素个数

size:待排序数组的元素的大小

int (* compare)(const void*,const void*): 比较两个元素的大小的函数指针

6.1.1 qsort库函数排序整型数组

int compare(const void* a, const void* b)
{
  return *(int*)a - *(int*)b;
}
void print(int arr[], int sz)
{
  int i = 0;
  for (i = 0; i < sz; i++)
  {
    printf("%d ", arr[i]);
  }
}
int main()
{
  int arr[5] = { 2,3,4,1,5 };
  int sz = sizeof(arr) / sizeof(arr[0]);
  qsort(arr, sz, sizeof(int), compare);
  print(arr, sz);
  return 0;
}

6.1.2 qsort库函数排序结构体数据

6.1.2.1 按照名字大小来排序

struct stu
{
  char name[20];
  int age;
};
int cmp_by_name(const void* a, const void* b)
{
  return strcmp(((struct stu*)a)->name, ((struct stu*)b)->name);
}
void print(struct stu s[], int sz)
{
  int i = 0;
  for (i = 0; i < sz; i++)
  {
    printf("%s\n", s[i].name);
  }
}
int main()
{
  struct stu s[] = { {"zhangsan",20},{"lisi",55},{"wangwu",40} };
  int sz = sizeof(s) / sizeof(s[0]);
  //按照名字比较
  qsort(s, sz, sizeof(s[0]), cmp_by_name);
  print(s, sz);
  return 0;
}

6.1.2.2 按照年龄来排序

struct stu
{
  char name[20];
  int age;
};
int cmp_by_age(const void* a, const void* b)
{
  return (((struct stu*)a)->age - ((struct stu*)b)->age);
}
void print(struct stu s[], int sz)
{
  int i = 0;
  for (i = 0; i < sz; i++)
  {
    printf("%d\n", s[i].age);
  }
}
int main()
{
  struct stu s[] = { {"zhangsan",20},{"lisi",55},{"wangwu",40} };
  int sz = sizeof(s) / sizeof(s[0]);
  //按照年龄比较
  qsort(s, sz, sizeof(s[0]), cmp_by_age);
  print(s, sz);
  return 0;
}

6.2 实现冒泡排序对任意类型的排序

6.2.1 对整型排序

int cmp_int(const void* e1, const void* e2)
{
  return (*(int*)e1 - *(int*)e2);
}
void Swap(char* buf1, char* buf2, int size)
{
  int i = 0;
  for (i = 0; i < size; i++)
  {
    char tmp = *buf1;
    *buf1 = *buf2;
    *buf2 = tmp;
    buf1++;
    buf2++;
  }
}
void bubble_sort(void* base, int sz, int size, int (*cmp)(const void* a,const void* b))
{
  int i = 0;
  for (i = 0; i < sz - 1; i++)
  {
    int j = 0;
    for (j = 0; j < sz - 1 - i; j++)
    {
      if (cmp((char*)base + j * size, (char*)base + (j + 1) * size)> 0)
      {
        //交换
        Swap((char*)base + j * size, (char*)base + (j + 1) * size,size);
      }
    }
  }
}
void print(int arr[], int sz)
{
  int i = 0;
  for (i = 0; i < sz; i++)
  {
    printf("%d ", arr[i]);
  }
}
int main()
{
  int arr[] = { 2,1,3,7,5,9,6,8,0,4 };
  int sz = sizeof(arr) / sizeof(arr[0]);
  bubble_sort(arr, sz, sizeof(arr[0]),cmp_int);
  print(arr, sz);
  return 0;
}

6.2.2 对结构体排序

6.2.2.1 按照年龄进行排序

struct stu
{
  char name[20];
  int age;
};
int cmp_by_age(const void* a, const void* b)
{
  return (((struct stu*)a)->age - ((struct stu*)b)->age);
}
void Swap(char* buf1, char* buf2, int size)
{
  int i = 0;
  for (i = 0; i < size; i++)
  {
    char tmp = *buf1;
    *buf1 = *buf2;
    *buf2 = tmp;
    buf1++;
    buf2++;
  }
}
void bubble_sort(void* base, int sz, int size, int (*cmp)(const void* a, const void* b))
{
  int i = 0;
  for (i = 0; i < sz - 1; i++)
  {
    int j = 0;
    for (j = 0; j < sz - 1 - i; j++)
    {
      if (cmp((char*)base + j * size, (char*)base + (j + 1) * size) > 0)
      {
        //交换
        Swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
      }
    }
  }
}
void print(struct stu s[], int sz)
{
  int i = 0;
  for (i = 0; i < sz; i++)
  {
    printf("%d ", s[i].age);
  }
}
int main()
{
  struct stu s[] = { {"zhangsan",20},{"lisi",55},{"wangwu",40} };
  int sz = sizeof(s) / sizeof(s[0]);
  //按照年龄比较
  qsort(s, sz, sizeof(s[0]), cmp_by_age);
  print(s, sz);
  return 0;
}

6.2.2.2 按照名字排序

struct stu
{
  char name[20];
  int age;
};
int cmp_by_name(const void* a, const void* b)
{
  return strcmp(((struct stu*)a)->name, ((struct stu*)b)->name);
}
void Swap(char* buf1, char* buf2, int size)
{
  int i = 0;
  for (i = 0; i < size; i++)
  {
    char tmp = *buf1;
    *buf1 = *buf2;
    *buf2 = tmp;
    buf1++;
    buf2++;
  }
}
void bubble_sort(void* base, int sz, int size, int (*cmp)(const void* a, const void* b))
{
  int i = 0;
  for (i = 0; i < sz - 1; i++)
  {
    int j = 0;
    for (j = 0; j < sz - 1 - i; j++)
    {
      if (cmp((char*)base + j * size, (char*)base + (j + 1) * size) > 0)
      {
        //交换
        Swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
      }
    }
  }
}
void print(struct stu s[], int sz)
{
  int i = 0;
  for (i = 0; i < sz; i++)
  {
    printf("%s ", s[i].name);
  }
}
int main()
{
  struct stu s[] = { {"zhangsan",20},{"lisi",55},{"wangwu",40} };
  int sz = sizeof(s) / sizeof(s[0]);
  //按照年龄比较
  qsort(s, sz, sizeof(s[0]), cmp_by_name);
  print(s, sz);
  return 0;
}

c语言分层理解（c语言指针（下））