数组指针函数结构体之间的关系

最新推荐文章于 2024-07-24 17:44:32 发布

IT·程猿

最新推荐文章于 2024-07-24 17:44:32 发布

阅读量37

点赞数

文章标签：物联网 c++ c#

本文链接：https://blog.csdn.net/qq_45436880/article/details/134465051

版权

文章目录

一、以数组为核心：
二、以指针为核心：
三、以函数为核心：
四、以结构体为核心:

* 以数组为核心：
   * 数组与数组之间的关系 ---> 多维数组
       int arr[5];
       int brr[3][5];    ——————二维数组包含：3 个 int [5] 类型的数组       如果是指针的话时int （*）[5]    （加1）移位 int [5] 个字节，
                       二维数组是指向二维数组的首元素地址，也是第一个一维数组首元素地址，解引用得出一维数组的地址，指向一维数组的首元素地址
       int crr[7][3][5];

   * 数组与指针之间的关系
       指针存在数组里面
           int arr[5]; //数组里面存入int 类型
   =====
   要求：往数组中存入 short *
       short *     arr[5]; // 还是个数组，保存了指针的数组：指针数组

   * 数组与函数之间的关系
       数组中存放的都是函数指针

       例子：
           void fun1(int a){}
           void fun2(int a){}
           void fun3(int a){}
           fun1: void (*)(int) 类型

           void (*arr[8])(int) = {fun1,fun2,fun3};

           void (* )(int) arr[8]
           函数指针数组
           arr[1](5); // fun2(5)


   * 数组与结构体之间的关系
       *数组中保存的都是结构体
           struct point {int x; int y;};

           struct point sp = {1,2};

           struct point arr[8] = {{1,2},{3,4},{5,6},{7,8},{9,10}}; //结构体数组
           arr[0].x ---> 1
           arr[4].y ---> 10
============================================\
总结：
   数组与数组：多维数组
   数组与指针: 指针数组
   数组与函数：函数指针数组
   数组与结构体：结构体数组

二、以指针为核心：

* 指针与数组之间的关系：
         一个指针指向数组 （该指针是 数组的地址 ）
         int arr[10];
         &arr : 类型？？ int (*)[10]  // 数组指针 ： 是一个指针，指向数组的指针（数组的地址）
         
===========区别
指针数组：是一个数组，里面保存的都是指针的数组
    例子： 保存都是 short * 
        short * arr[10];     arr:指针数组 
        
数组指针：是一个指针，指向数组的指针（数组的地址）
    short arr[7];
    &arr :  short (*)[7]   // 数组指针类型
    
    
int *arr[10];    // 指针数组
int (*arr)[10]  ;  // 数组指针 

======
int *arr[10];  
&arr :  int *  (*)[10]  // 指针数组 指针 ： 
++++++=====
        
    * 指针与指针之间的关系
        * 一个指针是 另外一个指针的 地址  :   多级指针 
            int *p;
            &p  --->   int **
            
            例子：
                int a = 10;
                int *p = &a;
                int **pp = &p;
                int ***ppp = &pp;
                int ****pppp = &ppp;
            
    
    * 指针与函数之间的关系:
        * 一个指针 指向一个 函数 (函数的地址)----》 函数指针  
        ........
        
        
    * 指针与结构体之间的关系 
        * 一个指针 指向 结构体（结构体的地址） ---》 结构体指针 
            struct point{int x; int y;}
            
            struct point sp;
            &sp :  struct point *  //结构体指针类型 
            
=========================
指针总结：
    * 指针与数组 ：  数组指针  
    * 指针与指针 ：  多级指针  
    * 指针与函数 ：  函数指针 
    * 指针与结构体： 结构体指针

三、以函数为核心：

   *姿势：
       返回值类型函数名(形参)
       {
           函数体;
           return 返回值;
       }

   ===
   函数与数组：
       * 数组传参：
           short * arr[10]; // arr是什么类型 short **
           fun(arr)
           ==================
               fun(short **p)
               fun(short *p[])
               fun(short *p[10])

       * 数组作为函数体：
           fun(void)
           {
               short *arr[10];
           }

       * 数组作为返回值       //即返回的是元素类型的值
           short ** fun(void)
           {
               static short *arr[10];
               return arr;
           }

======
int xx(short s){return 0;}

xx : int (*)(short) 类型

int (*arr[10])(short) = {xx};

int (*)(short) arr[10]; //这是分析

arr: 数组类型： int (* [10])(short)       函数指针数组指针
   指针类型： int (**)(short)

int (*arr[10])(short);
fun(arr);

=================
   fun(int (**p)(short))           函数指针指针

=================================
函数为核心：
   *函数与指针之间的关系：
       * 指针作为形参
           short ***p;
           fun(p);
           ==============
               fun(short ***xx){}


       * 指针作为函数体
           fun(void)
           {
               int **p;
           }
       * 指针作为返回值
           int ***fun(void)
           {
               int ***p;
               int a = 10l;
               return p;
           }

================
void fun(int a)
{
   //return;
}
==> 调用： fun(11);

float fun2(double a)
{
   return 12.5f;
}
===>调用： float f = fun2(25.6);

====> *&a ===> a
void fun3(int *p)
{
   *p = 30;
}
--> 函数调用：
   int a;
   fun(&a); // 给a赋值了30

int b;
scanf("%d",&b);


=========
函数与函数之间的关系：
   * 函数作为形参 ====》回调函数
       void fun(void){}
       xx(fun);
       =============
       xx(void (*p)(void)){p();}

   * 函数作为函数体 :
       void xx(void){}

       void fun(void)
       {
           xx(); // 函数调用
       }


   * 函数作为返回值
       int xx(short s, char c){}

       int (*fun(void))(short,char)
       {
           return xx;
       }

=========
写一个函数：
   形参是函数指针(返回值是 int 形参是 short char)
   返回值函数指针(返回值是 void 形参是 int )

   void (*fun))(int)    void （*fun） (int) (int (*p)(short,char))
   {

   }


=========================================

void (*fun(int (*p)(short,char)))(int)

char * (*)(char *) (*)[3] pf;
typedef char * (*)(char *) xx ;
xx (*)[3] pf;

============
int(*(*func)(int *))[5] ;
int(*)[5] (*)(int *) func;

typedef int(*)[5] xx;
xx (*)(int *) func;

==========================================
函数与结构体之间：
   * 结构体作为形参
       struct point{int x; int y;};
       struct point sp;
       fun(sp);
       =============
               fun(struct point sp){}

   * 结构体作为函数体
       fun(void)
       {
           struct point sp;
       }

   * 结构体作为返回值
       struct point fun(void)
       {
           struct point sp;
           return sp;
       }

四、以结构体为核心

* 姿势：
       struct [标签]
       {
           成员;
           成员;
           成员;
       };

   =====
   结构体与数组：
       struct xx{
           char name[20];
       };

   =====
   结构体与指针：
       struct xx{
           char *p;
           struct xx *pp;
       };

   =====
   结构体与函数：
       void fun(int a){}

       struct xx{
           void (*p)(int);
       };
       struct xx sx;
       sx.p = fun;
       sx.p(10);

   =====
   结构体与结构体：
       struct xx{int x;int y;};

       struct yy{
           struct xx sx;
       };
       struct yy sy;
       sy.sx.x = 10;
       sy.sx.y = 20;