c语言（12）—指针（2）函数指针、二级指针、指针数组和数组指针

一、函数指针

是指针，指针指向一个函数

e.g. 思路：要将一个数组元素递减排序，先写出主函数，以及用指针写出两个被调函数（接收和打印）的程序，然后写一个冒泡排序的被调函数，函数中需要定义一个指针，一个数组长度，和一个函数指针，再写一个判断数组元素是否倒序的被调函数，在冒泡排序的if语句中引用函数指针，这个函数指针就指向用来判断的被调函数，最终在主函数中引用冒泡排序的函数是，第三个参量使用用来判断的被调函数的函数名，最终完成打印

  1 #include <stdio.h>                                                              
  2 
  3 int InputArray(int *parry, int len)
  4 {
  5     int i = 0;
  6 
  7     for(i = 0; i < len; i++)
  8     {
  9         scanf("%d", &parry[i]);
 10     }
 11 
 12     return 0;
 13 }
 14 
 15 int Outputarray(int *parry, int len)
 16 {
 17     int i = 0;
 18 
 19     for(i = 0;i < len; i++)
 20     {
 21         printf("%d ", parry[i]);
 22     }
 23 
 24     printf("\n");
 25 
 26     return 0;
 27 }
 28 
 29 int Desc(int num1, int num2)
 30 {
 31     if(num1 < num2)
 32     {
 33         return 1;
 34     }
 35 
 36     return 0;
 37 }
 38 
 39 int SortArray(int *parry, int len, int (*pfun)(int, int))
 40 {
 41     int j = 0;
 42     int i = 0;
 43     int tmp = 0;
 44 
 45     for(j = 0; j < len - 1; j++)
 46     {
 47         for(i = 0; i < len - 1- j; i++)
 48         {
 49             if(pfun(parry[i], parry[i + 1]))
 50             {
 51                 tmp = parry[i];
 52                 parry[i] = parry[i + 1];
 53                 parry[i + 1] = tmp;
 54             }
 55         }
 56     }
 57 
 58     return 0;
 59 }
 60 int main(void)
 61 {
 62     int a[5] = {0};
 63 
 64     InputArray(a, 5);
 65     SortArray(a, 5, Desc);
 66     Outputarray(a, 5);
 67 
 68     return 0;
 69 }

二、二级指针

1.二级指针是指向一级指针变量的指针

int **q;
定义一个指针变量q，占8个字节空间，指向一个指针变量空间，即指向一级指针变量的指针，也就是二级指针

e.g. 思路：在主函数中定义一个指针，取指针的地址传入被调函数，也就是二级指针，对二级指针取星并传入字符串，这时传入的是字符串的首位地址，最终在主函数中可以打印出传入字符

#include <stdio.h>
  
int fun(char **pptmp)
{
    *pptmp = "hello world";

    return 0;                                                                   
}

int main(void)
{
    char *p = NULL;
 
    fun(&p);
 
    printf("p = %s\n", p);

    return 0;
}

2. 使用场景：

（1）函数体内部想修改函数体外部指针变量值的时候，需要传指针变量的地址即二级指针

（2） 指针数组传参，数组的数组名是指向数组第一个元素的指针，第一个元素是指针，所以数组名为指向指针的指针即二级指针

三、指针数组和数组指针

1.指针数组：是数组，数组的每个元素是指针

char *pstr[5];

注：存放字符串使用字符型数组，操作字符串使用指针

       存放字符串数组使用字符型二维数组，操作字符串数组使用指针数组

e.g. 思路：定义一个二维数组和一个指针数组，指针数组内的元素为二维数组中元素的地址；再对二维数组进行接收，用冒泡排序对数组元素进行排序（此时交换的是指针数组内的元素，也就是二维数组元素的地址，这样可以大大减少运算量），最终再打印指针数组地址对应的元素，这个过程中二维数组的元素不改变，改变的是它对应的地址

  1 #include <stdio.h>                                                              
  2 #include <string.h>
  3 
  4 int main(void)
  5 {
  6     int i = 0;
  7     int j = 0;
  8     char str [5][32] = {0};
  9     char *pstr[5] = {str[0], str[1], str[2], str[3], str[4]};
 10     char *ptmp = NULL;
 11 
 12     for(i = 0; i < 5; i++)
 13     {
 14         gets(str[i]);
 15     }
 16 
 17     for(j = 0; i < 4; j++)
 18     {
 19         for(i = 0; i < 4 - j; i++)
 20         {
 21             if(strcmp(pstr[i], pstr[i + 1]) > 0)
 22             {
 23                 ptmp = pstr[i];
 24                 pstr[i] = pstr[i + 1];
 25                 pstr[i + 1] = ptmp;
 26             }
 27         }
 28     }
 29 
 30     for(i = 0; i < 5; i++)
 31     {
 32         printf("pstr[%d] = %s\n", i, pstr[i]);
 33     }
 34 
 35     for(i = 0; i < 5; i++)
 36     {
 37         printf("str[%d] = %s\n", i, str[i]);
 38     }
 39 
 40     return 0;
 41 
 42 }                        

2.数组指针：是指针，指针指向整个数组

（1）对一维数组数组名&：值不变，类型升级为指向整个数组的指针

         对指针数组*：值不变，类型降级为指向数组第一个元素的指针

int a[5] = {1, 2, 3, 4, 5};
a == &a[0]
a == int *

（2）二维数组和指针的关系：数组的数组名是指向数组第一行元素的数组指针

int a[2][3] = {1, 2, 3, 4, 5, 6};

int *p = NULL;

int (*q)[3] = NULL;

p = &a[0][0];

p = a[0];

p = *a;

q = a;

a:指向数组第一行元素的数组指针 int (*)[3]

a[0]:指向a[0][0]的指针 int *

a[1]:指向a[1][0]的指针 int *

访问数组第m行第n列元素的方式：
a[m][n]   *(a[m]+n)   *(*(a+m)+n)   *(p+m*N+n)   *(*(q+m)+n)   *(q[m]+n)   q[m][n]