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语言指针（下））

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

1.1指针数组

1.2数组指针

2.数组参数和指针参数

2.1一维数组传参

2.2二维数组传参

2.3一级指针传参

2.4二级指针传参

3.函数指针

4. 函数指针数组

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

6. 回调函数

6.1.qsort库函数

6.1.1 qsort库函数排序整型数组

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

6.1.2.1 按照名字大小来排序

6.1.2.2 按照年龄来排序

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

6.2.1 对整型排序

6.2.2 对结构体排序

6.2.2.1 按照年龄进行排序

6.2.2.2 按照名字排序

热门文章

最新文章

相关课程

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

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

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

1.1指针数组

1.2数组指针

2.数组参数和指针参数

2.1一维数组传参

2.2二维数组传参

2.3一级指针传参

2.4二级指针传参

3.函数指针

4. 函数指针数组

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

6. 回调函数

6.1.qsort库函数

6.1.1 qsort库函数排序整型数组

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

6.1.2.1 按照名字大小来排序

6.1.2.2 按照年龄来排序

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

6.2.1 对整型排序

6.2.2 对结构体排序

6.2.2.1 按照年龄进行排序

6.2.2.2 按照名字排序

热门文章

最新文章

相关课程

相关电子书