指针数组，二维数组，函数指针，指针函数，结构体

指针数组和二维数组 

指针数组:  指针数组传参二级指针和长度 

二维数组：二维数组传参数组指针和长度

#include<stdio.h>
#include<string.h>
int InputArray(char (*p)[32],int len)
{
    for(int i=0;i<len;i++)
    {
        gets(p[i]);
    }
}
int OutputArray(char (*p)[32],int len)
{
    for(int i=0;i<len;i++)
    {
        puts(p[i]);
    }
}
int OutputArray2(char **pp,int len)
{
    for(int i=0;i<len;i++)
    {
        printf("%s\n",pp[i]);
    }
}
/*对原二维字符串数组冒泡排序，改变字符串数组里各字符串的存储顺序*/
void BubbleSort1(char (*p)[32],int len)
{
    int i=0;
    int j=0;
    char t[32]={0};
    for(i=0;i<len-1;i++)
    {
        for(j=0;j<len-1-i;j++)
        {
            if(strcmp(p[j],p[j+1])>0)
            {
                strcpy(t,p[j]);  //p[j]存放的是字符串
                strcpy(p[j],p[j+1]);
                strcpy(p[j+1],t);
            }
        }
    }
}
/*对指针数组冒泡排序，改变指针数组里面存放的字符串首地址的顺序*/
void BubbleSort2(char **pp,int len)
{
    int i=0;
    int j=0;
    char *t=NULL;
    for(i=0;i<len-1;i++)
    {
        for(j=0;j<len-1-i;j++)
        {
            if(strcmp(pp[j],pp[j+1])>0)
            {
                t=pp[j];   //pp[j]存放的是字符串的首地址
                pp[j]=pp[j+1];
                pp[j+1]=t;
            }
        }
    }
}
int main()
{
    char str[5][32]={0};
    char *p[5]={str[0],str[1],str[2],str[3],str[4]};

    InputArray(str,5);
    BubbleSort1(str,5);
    BubbleSort2(p,5);
    printf("=================\n");
    OutputArray(str,5);
    printf("=================\n");
    OutputArray2(p,5);
    return 0;
}

函数指针和指针函数

指针函数

指针函数是函数,函数的返回值是指针 
    int *fun(int x, int y);

#include<stdio.h>
char * Mystrcpy(char *pstr,const char *dst)
{
    char *ph=pstr;
    while(*dst!='\0')
    {
        *pstr=*dst;
        pstr++;
        dst++;
    }
    *pstr=='\0';
    return ph; //返回值是pstr的首地址
}
int main()
{
    char str[20]={0};
    char dst[20]={0};
    Mystrcpy(dst,Mystrcpy(str,"hello world"));
    puts(str);
    puts(dst);
    return 0;
}

函数指针

 函数指针是指针,指针指向一个函数 
    int (*p)(int, int);

#include<stdio.h>
int Add(int a,int b)
{
    return a+b;
}
int Sub(int a,int b)
{
    return a-b; 
}
int caculate(int num1,int num2,int (*p)(int,int))
{                                    //当输入+运算时，函数指针p就指向Add函数的首地址
    return p(num1,num2);  //p指向Add函数，传入参数num1和num2
}
int main()
{
    int num1=0;
    int num2=0;
    char op=0;
    int (*p)(int,int)=NULL;
    scanf("%d%c%d",&num1,&op,&num2);

    switch(op)
    {
        case '+':
           p=Add;break;
        case '-':
           p=Sub;break;
    }
    printf("re=%d\n",p(num1,num2));

    if('+'==op)
    {
        printf("%d\n",caculate(num1,num2,Add)); 
    }
    else if('-'==op)
    {
        printf("%d\n",caculate(num1,num2,Sub));
    }
}

  注意：
        指针函数不能返回局部变量的地址,当函数结束时，局部变量申请的内存空间就被回收了

结构体 

1.结构体类型的定义：
        struct 结构体名 
        {
            数据类型1 成员变量1;
            数据类型2 成员变量2;
            数据类型3 成员变量3;
            ...
        }; 

（1） .定义了一个student的结构体，成员变量有name,age,sex三种

struct student
{
  char name[32];
   int age;
   char sex;
};

（2）.结构体定义时的嵌套使用，struct datetime 结构体嵌套了struct mtime和struct  mdate两个结构体

struct mtime
{
    int hour;
    int min;
    int sec;
};
struct mdate
{
    int year;
    int mon;
    int day;
};
struct datetime
{
    struct mdate m;
    struct mtime t;
};

2.结构体变量的定义：
        数据类型 变量名;    

    例子：struct student st;

3.结构体变量的初始化：

全部初始化：

             struct student s = {"zhangsan", 'm', 19, 100};

              struct datetime dt={{2024,7,25},{16,34,25}};

局部初始化：

             struct student s = {

                         .name = "zhangsan",

                         .score = 100,

                        };

                struct datetime dt2={

                   .m={

                          .year=2024,

                          .mon=7, },

                  };

4.结构体成员的访问： 结构体访问成员变量最终的类型由成员变量的类型决定

（1）. :结构体变量类型访问成员变量

               printf("姓名：%s\n",s.name);

                printf("性别：%c\n",s.sex);

                printf("年龄：%d\n",s.age);

          

（2）-> :结构体指针类型访问成员变量

                struct student* sp; sp=&s;

                 printf("姓名:%s\n",sp->name);

                 

                struct datetime *p=&dt;

                 printf("%02d:%02d:%02d\n",p->t.hour,p->t.min,p->t.sec);