Linux C语言学习day9：指针与函数

【1】数组指针
    1.概念：本质是个指针，指向数组的指针称之为数组指针。
    2.定义格式：
        [存储类型]   [数据类型]   （*数组指针名）[大小];
          （auto）       int        (*p)[大小];
        大小：列下标 
        p指向的是二维数组的行
    3.应用
        数组指针指向二维数组    
        int a[2][3] = {1,2,3,4,5,6};
        int (*p)[3] = a;        
        
         p           行地址
        *p           列地址
        *(p+i)+j     元素地址
        *(*(p+i)+j)  元素值          
        
        访问数组元素a[i][j]的值：
        直接访问：  a[i][j]  *(a[i]+j)   *(*(a+i)+j)
        间接访问：  p[i][j]  *(p[i]+j)   *(*(p+i)+j)
        访问数组元素a[i][j]的地址：
        直接访问：  &a[i][j]    a[i]+j   *(a+i)+j
        间接访问：  &p[i][j]    p[i]+j   *(p+i)+j
        
    指针的大小：
        int (*p)[2];   //4
        int (*p)[4];   //4
        sizeof（p） = 4字节
        本质还是个指针。

【2】指针数组
     1.概念：本质上是个数组，用于保存指针的数组称之为指针数组。
     2.定义格式：
        [存储类型]   [数据类型]   *指针数组名[大小];
         （auto）       int           *p[5];         
     3.应用：
       1）用于保存变量的地址
          int a = 10;
          int b = 20;
          int c = 20;
          int *p[3] = {&a,&b,&c};
          通过指针数组访问c的值：
              *p[2]    *(*(p+2))
          通过指针数组访问c的地址：
               p[2]      *(p+2)
      推导过程：
        p    => &p[0] => &(&a)
        p+1  => &p[1] => &(&b) 
        p+2  => &p[2] => &(&c)
 
         *p      => p[0] => &a
        *(p+1)  => p[1] => &b 
        *(p+2)  => p[2] => &c
            
         **p        => a
        *(*(p+1))  => b 
        *(*(p+2))  => c
        
       2）用于保存二维数组的列地址，及每行首个元素的地址。    
        int a[2][3] = {1,2,3,4,5,6};
        int *p[2] = {&a[0][0],&a[1][0]};     
        
        通过指针数组访问二维数组的元素值： a[1][2]
         p[1][2]   *(p[1]+2)    *(*(p+1)+2)
         
        通过指针数组访问二维数组的元素地址： a[1][2]
         &p[1][2]    p[1]+2       *(p+1)+2
        
    注：p代表的数组的首个元素的地址，而数组中首个元素是列地址，所以p代表的是二维数组的行地址。
        
        3）用于保存字符串。
           char *p[3] = {“hello”,"world","hqyj"};
        
        打印world这个字符串：
           printf("%s\n",p[1]);
        打印'o'这个字符串：
           printf("%c\n",p[1][1]);
           printf("%c\n",*(p[1]+1));         
           printf("%c\n",*(*(p+1)+1));
           
        4）用于命令行传参
           指针数组就在我们身边！
           #include<stdio.h>
            int main(int argc, const char *argv[])
            {
                printf("%s  %s\n",argv[0],argv[1]);
                return 0;
            }                                           
            argv就是一个指针数组，用于保存执行代码时命令行的字符串。
            argc是个整型变量， 用于保存命令行传递的参数个数。
           
【3】二级指针
    概念：本质上就是指针，指向指针的指针称为二级指针，
    二级指针变量中保存的是一级指针的地址。    
    定义格式：
        [存储类型]   [数据类型]   **二级指针名;
          （auto）      int         **p;
    应用：
         int  a = 10;
         int *p = &a;
         int **q = &p;    
          
         打印a的值10：
            a   *p    **q 
         打印a的地址：
            &a   p     *q     
         打印p的地址：
                &p      q             
   
【4】函数
    1.概念：具有特定功能的代码模块
    2.作用：减少代码的重复使用    
    3.格式：
           int         main(int argc, const char *argv[])
        //返回值类型   函数名（形参）
        {                                                
            return 0;
            //return 返回值;            
        }
    4.分类：
      1）有参有返回值
         int add(int a,int b)
         {
            return a+b;
         }
      2)有参无返回值
         void add(int a,int b)
         {
            printf("%d\n",a+b);
         }
      3)无参无返回值
         void func(void)
         {
            printf("关门\n");
         }
    5.函数调用
        形参：形式参数，只是规定一种参数形式，不占用内存空间。
        实参：实际参数，实际传递给函数的数据，占用内存空间。
      
        1）有参有返回值
           定义和函数返回值同种类型的变量来接收函数返回值。
           返回值类型 变量 = 函数名(实参);
                int     a  =  add(1,2);
        2)有参无返回值
            函数名(实参);
        3)无参无返回值
            函数名();
    6.函数声明
        在主函数之上或.h文件中进行函数声明。
        声明格式： 返回值类型 函数名(形参);