C语言/指针与数组&指针与函数

对初学者来说，C语言里比较绕的应该就是指针数组/数组指针、指针函数/函数指针了，当然指针也是C语言里面比较难的部分了。

下面我就简单介绍一下指针与数组和函数的组合之间的区别：

函数：

   —— 可以代替大量重复项代码的功能模块 

格式：

    <数据类型><函数名> （形式参数）  注意：<数据类型>可以是基本数据类型，也可是构造数据类型

   ｛

         函数体                            <函数名>满足标识符命名三大规则

     ｝

                                           <参数>格式类似于变量的定义（int a），多个参数之间用“，”分隔

                                                                                                    

                                           函数体表示函数的功能实现

<数据类型> ：代表了函数的返回值：返回函数的执行状态；返回函数中的变量值；返回函数中的变量地址

<函数名>：代表函数的地址

（参数）：代表函数需要的数据

｛｝：代表函数的范围，也称函数的作用域

 

函数声明：

       末有“；”告诉系统以识别函数

       被调函数在主函数之前，则不需要声明

 

函数调用：

       格式：<函数名>（实际参数）

 

main函数是整个程序的入口；函数名不能改；被操作系统调用，返回值返回给操作系统

 

函数原型：char *gets（char *s）

头文件：#include<stdio.h>

链接库：无

功能：从标准输入流中读取字符串放入指针s指向的缓存区中

参数：s：缓存区的指针

返回值：成功 返回s //失败   返回NULL

 

数组：

 

一维数组：一组数据类相同，且在内存上连续存储的数据的集合

 

    格式：  <存储类型><数据类型><数组名>[数组长度]

    注意：<数据类型>可以是基本数据类型，也可是构造数据类型

 

    数组的初始化：全部初始化；部分初始化；省略数组长度的初始化（a[]={11,12,13,14}）      

    数组元素的调用：<数组名>[数组的下标]

                

二维数组：          

    格式： <存储类型><数据类型><数组名>[行数][列数]

 

    注意：省略类型初始化（与鼠族在内存上的存储有关，按行存储）

                         int a[][4]  √

                         int a[3][]  X  //列号不能省略

                         int a[3][4] √

          数组元素调用： <数组名>[行下标][列下标]；

 

指针：

         地址：内存以字节为单位，每个字节都对应一个编号，而每个编号代表一个地址

         指针：就是地址

         指针变量：保存了指针常量（地址常量）的变量

         格式： <存储类型><数据类型>  *<指针变量名>：

         eg： Int *p=&a；    p ===>  int*    表示指针的类型

              *p===> int      表示指针指向的空间的类型

              * ——>作用为完成指向

 

指针的运算：        

算术运算：

   p++/p-- ：表示指针向地址大/小端偏移一个单位（指针指向空间类型的大小）

   p+n/p-n

   p-q：若为正数，则p靠近大端

        若为负数，则p靠近小端

        若为0，则p、q指向同一块内存

        p-q 结果代表两个地址之间相差几个单位

  

指针的修饰：  

         1、const(不可改，常量) >>>>看const修饰的对象

 

               int * const p；指针指向空间不可改，但指向空间的内容可改

               int const *p；指针指向空间可改，但指向空间的内容不可改

               const int *p；指针指向空间可改，但指向空间的内容不可改

               const int *const p；指针指向空间和内容都不可改

               const 和 int 可换顺序 

          2、void（空）         

               void *p；表示指针指向空间不确定

函数的调用:

        //printf("&a = %p,&b=%p",&a,&b); //取地址

 

        格式:<函数名>[实际参数]

        1）值传参

            传递的是变量的复制体，不影响变量本身

        2）地址传参

             传递的是变量本身，操作影响变量的结果

             [ 地址常量 &a 用地址变量指针 *x接收]

        3）一维数组传参

            int fun（int *p，int num） ；

            int fun（int p[ ]，int num）；

        4）二维数组传参

             int fun(int(*p)[n],int m,int n);

             int fun(int p[][n],int m,int n);

 

指针与数组AND函数

指针与数组：  

    指针数组：用于存储指针的数组，即数组元素都是指针

    数组指针：指向数组的指针

 

       1） 数组指针 : 本质是指针，指向类型是数组

           A、数组指针与一维数组

              int a[4]；

              int（*p）[4] = &a； // 数组指针指向数组整体 p+1 地址偏移4*4=24

                                 //[4]表示指针指向右4个元素的数组

变量与数据类型的关系：

int a = 5；   ===>>int

int *p = &a; ===>>int *

 

int a[6] ;      ===>>int [6]  a;===>INTint a;===>int [6];===>> INT //构造类型

int [6] *p = &a;===>>INT *p = &a;===>>int (*p)[6];  [ ]与p结合的优先级高于*与p结合的优先级，（*p）[ ]称为指向数组的指针  

                         

           B、数组指针与二维数组

                 int a[2][3];

                 int（*p）[3] = a；

 

        2）指针数组 :本质是数组，数组元素是指针

          

            A、指针数组与一维数组

                 int a[3]；

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

        

            B、指针数组与二维数组  

                 int a[2][3]；

                 int * p[2] = { a[0],a[1] };

 

指针与函数：        

           A、指针函数：本质是函数，返回值是指针 

                int * fun（intx，int y）；

                static 解决局部变量返回问题 

                malloc动态申请//free（）释放

  

栈区变量  //动态 ,自动释放

static// 静态变量

malloc/free(C语言)

new/delete(C++)

     

          B、函数指针：本质是指针，指向函数 

                 int  fun（int x，inty）；

                int (*p) (int ,int )=fun;                   

 函数指针数组   ===>>int （*p[4]）（int，int）==（add，sub，mul，div）；