4.4、C语言复杂表达式和指针高级应用

4.4.1 指针数组与数组指针

4.4.1.1、字面意思来理解指针数组与数组指针（分清楚主语和修饰语）

(1)指针数组的实质是一个数组，这个数组中存储的内容全部是指针变量。

(2)数组指针的实质是一个指针，这个指针指向的是一个数组。

4.4.1.2、分析指针数组与数组指针的表达式

(1)int *p[5]; int (*p)[5];    int *(p[5]);

(2)一般规律：int *p;(p是一个指针)； int p[5];(p是一个数组)

总结：我们在定义一个符号时，关键在于：首先要搞清楚你定义的符号是谁（第一步：找核心）；其次再来看谁跟核心最近、谁跟核心结合（第二步：找结合）；以后继续向外扩展（第三步：继续向外结合直到整个符号完）。

(3)如果核心和*结合，表示核心是指针；如果核心和[]结合，表示核心是数组；如果核心和()结合，表示核心是函数。

(4)用一般规律来分析3个符号：

第一个：int *p[5]; 核心是p，p是一个数组，数组有5个元素大，数组中的元素都是指针，指针指向的元素类型是int类型的；整个符号是一个指针数组。

第二个，int (*p)[5];

核心是p，p是一个指针，指针指向一个数组，数组有5个元素，数组中存的元素是int类型； 总结一下整个符号的意义就是数组指针。

第三个，int *(p[5]);

解析方法和结论和第一个相同，()在这里是可有可无的。

注意：符号的优先级到底有什么用？其实是决定当2个符号一起作用的时候决定哪个符号先运算，哪个符号后运算。

遇到优先级问题怎么办？第一，查优先级表；第二，自己记住（全部记住都成神了，人只要记住[] . ->这几个优先级比较好即可）。

4.4.1.3、总结1：优先级和结合性是分析符号意义的关键

(1)在分析C语言问题时不要胡乱去猜测规律，不要总觉得c语言无从捉摸，从已知的规律出发按照既定的规则去做即可。

4.4.1.4、总结2：学会逐层剥离的分析方法

(1)找到核心后从内到外逐层的进行结合，结合之后可以把已经结合的部分当成一个整体，再去和整体外面的继续进行结合。

4.4.1.5、总结3：基础理论和原则是关键，没有无缘无故的规则

总结：我们在定义一个符号时，关键在于要搞清楚你定义的符号是谁（第一步：找核心）；其次再来看谁跟核心最近，谁跟核心结合（第二步：找结合）：以后继续向外扩展。

4.4.2 。函数指针与typedef

4.4.2.1、函数指针的实质（还是指针变量）

(1)函数指针的实质还是指针，还是指针变量。本身占4字节（在32位系统中，所有的指针都是4字节）

(2)函数指针、数组指针、普通指针之间并没有本质区别，区别在于指针指向的东西是个什么玩意。

(3)函数的实质是一段代码，这一段代码在内存中是连续分布的（一个函数的大括号括起来的所有语句将来编译出来生成的可执行程序是连续的），所以对于函数来说很关键的就是函数中的第一句代码的地址，这个地址就是所谓的函数地址，在C语言中用函数名这个符号来表示。

(4)结合函数的实质，函数指针其实就是一个普通变量，这个普通变量的类型是函数指针变量类型，它的值就是某个函数的地址（也就是它的函数名这个符号在编译器中对应的值）

4.4.2.2、函数指针的书写和分析方法

(1)C语言本身是强类型语言（每一个变量都有自己的变量类型），编译器可以帮我们做严格的类型检查。

(2)所有的指针变量类型其实本质都是一样的，但是为什么在C语言中要去区分它们，写法不一样呢（譬如int类型指针就写作int *p; 数组指针就写作int (*p)[5]，函数指针就得写得更复杂）

(3)假设我们有个函数是：void func(void); 对应的函数指针：void (*p)(void); 类型是：void (*)(void);

(4)函数名和数组名最大的区别就是：函数名做右值时加不加&效果和意义都是一样的；但是数组名做右值时加不加&意义就不一样。

(5)写一个复杂的函数指针的实例：譬如函数是strcpy函数（char *strcpy(char *dest, const char *src);），对应的函数指针是：char *(*pFunc)(char *dest, const char *src);

4.4.2.3、typedef关键字的用法

(1)typedef是C语言中一个关键字，作用是用来定义（或者叫重命名类型）

(2)C语言中的类型一共有2种：一种是编译器定义的原生类型（基础数据类型，如int、double之类的）；第二种是用户自定义类型，不是语言自带的是程序员自己定义的（譬如数组类型、结构体类型、函数类型·····）。

(3)我们今天讲的数组指针、指针数组、函数指针等都属于用户自定义类型。

(4)有时候自定义类型太长了，用起来不方便，所以用typedef给它重命名一个短点的名字。

(5)注意：typedef是给类型重命名，也就是说typedef加工出来的都是类型，而不是变量。

4.4.2.4、总结：函数指针的分析方法也是源于优先级与逐层剥离的基本理论

（1）函数指针，数组指针，普通变量之间没有什么本质区别，区别在于指针指向的东西是个什么玩意。

（2）C语言中函数编译出来生成的可执行程序是连续的，函数中第一句代码的地址就是函数的地址，用函数名表示函数这段代码的首地址。

 (3) 函数指针的表示：普通函数：void  func（void）对应的函数指针：void （*p） void。举例一个比较复杂的函数char* (*pFunc)(char *, const char *)就等于char* strcpy(char * ,const char *).。 函数指针数组（这是一个数组，数组里面存放的是指针，指针指向的是函数） （见4.4.3_1func_pointer_array.c）    函数名和数组名最大的区别是：函数名做右值时加不加&效果和意义都是一样的。但是数组名就不一样了数组名a表示数组首元素的首地址（ 元素指针 ），&a表示整个数组的首地址（ 数组指针 ），学习要注意归纳总结。

    (4) Typedef关键字的用法：用来定义或者重命名类型的，typedef加工出来的都是类型（数据模板）（不占内存），而不是变量（实在的数据）（占内

存）。

#include <stdio.h>

#include <string.h>

void func1(void)

{

    

    printf("test for function pointer.\n");

}

//重命名了一种类型，这个新类型名字叫pType，类型是：char* (*)(char *, const char *);

typedef char* (*pType)(char *, const char *);

//这是一个函数指针数组//5个这样类型函数指针

//typedef char* (*pType[5])(char *, const char *);    pType[5]首先这是一个数组，前面有一个*表示这是一个指针数组：里面存放5个char类型的地址，再外面是一个（）表明是一个函数，这个函数的返回值是char*，函数的参数是。。。。

//函数指针数组指针

//typedef char* (*(*pType)[5])(char *, const char *);  //逐层剥离，优先级的思想来分析问题。

int main(void)

{

    char* (*p1) (char *, const char *);

    pType p3;

    printf("func1 = %p\n", func1);    //实践证明：函数名加不加& ，效果是一样的，但是数组名就不一样的。

    printf("&func1 = %p\n", &func1);

    p3 = p1;

    

    

/*

    char a[5] = {0};

    char* (*pFunc) (char *, const char *);   //首先先解析（*pFunc）这是一个指针变量，

    pFunc = strcpy;

    pFunc(a,"abc");

    printf("a = %s.\n",a);

    

    /*

    void (*pFunc)(void);

    pFunc = func1;      //左边是一个函数指针变量，右边是一个函数名，代表这个函数的代码块的首地址。

    pFunc();          //用函数指针来解引用以调用该函数

    */

    

    /*

    int *p;

    int a[5];

    

    p = a;

    

    //p = &a;     //类型不匹配，p是int *元素指针,  &a是int(*p)[5];这是一个数组指针

    

    int (*p1)[5] ;     //这是一个数组指针的类型。p1就指向这个数组，这个数组里面有5个int*类型的元素，所以p1是数组指针，指向这个数组的首地址

    p1 = &a;              //&a是a这个指针变量指向整个数组的首地址

*/

    return 0;

}

函数指针数组：

/******************       函数指针数组     *** *********/

#include <stdio.h>

double add(double a,double b)

{

    return a+b;

}

double sub(double a,double b)

{

    return a-b;

}

double mul(double a,double b)

{

    return a*b;

}

double div(double a,double b)

{

    return a/b;

}

//函数指针数组:本质上这是一个数组，数组里面存放的是各个函数的函数名，就是首地址。

double (*oper_func[4])(double,double) = {    //使用的时候直接数组名，数组下标，然后传参

    add,sub,mul,div                           //数组和函数的组合使用，数组的元素是数组名，即指针。

};

int main(int argc,const char* argv[])

{

    int oper = 0;

    int op1 = 5;

    int op2 = 8;

    int result = oper_func[oper](op1,op2);   //使用方法类似数组，直接用下标访问数组中的元素。

    printf("result = %d\n",result);

    

    return 0;

}

4.4.3、函数指针实战

、用函数指针调用执行函数：

第一：当程序出现段错误时，第一步先定位段错误。定位方法是在可疑处加打印信息。

第二：linux中命令行是默认行缓冲的，当我们程序printf输出的时候，linux不会一个字一个字的输出我们的内容，而是将其缓冲起来放在缓冲区等第一行准备完了再一次性把一行全部输出出来（为了效率）。Linux判断一行有没有完的依据是换行符'\n'，也就是说如果没有遇到缓存区满，程序终止或者\n你是无法看见内容输出的，调试的时候一定要加\n。

第三：对于scanf函数，我们用户在输入内容时结尾都会以\n结尾，但是程序中scanf的时候都不会去接收最后的\n，导致这个回车符还存留在标准输入中，下次再scanf时就会被拿出来，这就导致你真正想拿的那个数反而没机会拿，导致错误。

#include <stdio.h>

typedef int (*pFunc)(int, int);       //pFunc表示int (*)(int,int) 这个类型的函数

int add(int a, int b);

int sub(int a, int b);

int multiply(int a, int b);

int divide(int a, int b);

int main(void)

{

    pFunc p1=NULL;   //让这个函数指针指向一个NULL，初始化函数指针

    

    char c = 0;

    int a= 0,b=0,result=0;

    printf("请输入要操作的2个整数：\n");

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

                          // while(1);   //这是打个结的作用

    printf("请输入操作类型：+ | - | * | /\n");  //行缓冲。加个\n可以判断是不是这行的问题。

    do{

        scanf("%c", &c);

      }

      while((c == '\n') || (c == '\r'));

      //加一句调试

      //printf("a = %d,b = %d, c = %d.\n", a, b,c);

    

    

    switch(c)                   //类似多态。在这里判断到底使用哪一个函数。将这个函数的地址赋给指针p1

    {

        case '+':

        p1 = add;

        break;

        

        case '-':

        p1 = sub;

        break;

        

        case '*':

        p1 = multiply;

        break;

        

        case '/':

        p1 = divide;

        break;

        

        default:

        p1 = NULL;

        break;

    }

    

    result = p1(a,b);   //函数指针指向不同的函数，来实现同一个调用实现不同结果。

    printf("%d %c %d = %d.\n", a,c,b,result);

    return 0;            //将不同函数的首地址赋给指针p1，来选用不同函数。

}

int add(int a, int b)

{

    return a+b;

}

int sub(int a, int b)

{

    return a-b;

}

int multiply(int a, int b)

{

    return a*b;

}

int divide(int a, int b)

{

    return a/b;

}

结构体内嵌函数指针实现分层。

4.4.4.函数指针实战2

主题：结构体内嵌函数指针实现分层

(1)程序为什么要分层？因为复杂程序东西太多一个人搞不定，需要更多人协同工作，于是乎就要分工。要分工先分层，分层之后各个层次由不同的人完成，然后再彼此调用组合共同工作。

(2)本程序要完成一个计算器，我们设计了2个层次：上层是framework.c，实现应用程序框架；下层是cal.c，实现计算器。实际工作时cal.c是直接完成工作的，但是cal.c中的关键部分是调用的framework.c中的函数来完成的。

(3)先写framework.c，由一个人来完成。这个人在framework.c中需要完成计算器的业务逻辑，并且把相应的接口写在对应的头文件中发出来，将来别的层次的人用这个头文件来协同工作。

(4)另一个人来完成cal.c，实现具体的计算器；这个人需要framework层的工作人员提供头文件来工作（但是不需要framework.c）

//framework.c，这是一个框架层。

#include "cal.h"

/*

框架，等待传入结构体的首地址，返回函数的计算结果。

*/

//计算器函数

int calculator(const struct cal_t *p1)//在里面不去改变它，用const，结构体指针效率高。

{

    return p1->p(p1->a,p1->b);//调用结构体里面的函数。

    

}

#ifndef __CAL_H__           //防止头文件被重复包含

#define __CAL_H__      

typedef int (*pFunc)(int ,int);   //函数指针，这是一个函数类型，返回值为int，函数名为*pFunc

//结构体是用来做计算器的，计算器工作时需要计算原材料

struct cal_t

{

    int a;

    int b;

    pFunc p;//函数指针，p所指向的就是那个函数的类型。int (*)(int ,int)。

    //用来实现面向对象，相当于类里面的方法。结构体内嵌指针。

};

int calculator(const struct cal_t *p);    //    经过测试是可有可无的。

#endif

#include "cal.h"

#include <stdio.h>

int add(int a, int b)

{

    return a+b;

}

int sub(int a, int b)

{

    return a-b;

}

int multiply(int a, int b)

{

    return a*b;

}

int divide(int a, int b)

{

    return a/b;

}

int main(void)

{

    int ret = 0;

    struct cal_t myCal;   //定义一个结构体myCal

    myCal.a = 12;

    myCal.b = 4;

    myCal.p = add;  //将函数的第一句代码的地址赋给结构体指针p，这个p就是那个函数。

    

    ret = calculator(&myCal);  //将这个结构体地址传进去

    printf("ret = %d.\n",ret);

    

    return 0;

}

(5)总结：

第一：本节和上节实际完成的是同一个习题，但是采用了不同的程序架构。

第二：对于简单问题来说，上节的不分层反而容易理解，反而简单；本节的分层代码不好理解，看起来有点把简单问题复杂化的意思。原因在于我们这个问题本身确实是简单问题，而简单问题就应该用简单方法处理。我们为什么明知错误还要这样做？目的是向大家演示这种分层的写代码的思路和方法。

第三：分层写代码的思路是：有多个层次结合来完成任务，每个层次专注各自不同的领域和任务；不同层次之间用头文件来交互。

第四：分层之后上层为下层提供服务，上层写的代码是为了在下层中被调用。

第五：上层注重业务逻辑，与我们最终的目标相直接关联，而没有具体干活的函数。

第六：下层注重实际干活的函数，注重为上层填充变量，并且将变量传递给上层中的函数（其实就是调用上层提供的接口函数）来完成任务。

第七：下层代码中其实核心是一个结构体变量（譬如本例中的struct cal_t），写下层代码的逻辑其实很简单：第一步先定义结构体变量；第二步填充结构体

变量；第三步调用上层写好的接口函数，把结构体变量传给它既可。

4.4.5、再论typedef

4.4.5.1、C语言的2种类型：内建类型与用户自定义类型

(1)内建类型ADT、自定义类型UDT

4.4.5.2、typedef定义（或者叫重命名）类型而不是变量

(1)类型是一个数据模板，变量是一个实在的数据。类型是不占内存的，而变量是占内存的。

(2)面向对象的语言中：类型就是类class，变量就是对象。

4.4.5.3、typedef与#define宏的区别(一个是类型，还有一个是原地展开的文本替换。)

typedef char *pChar;   pChar p3,p4  展开char *p3, char *p4;

#define pChar char *    pChar p1,p2  展开char *p1, char p2;

4.4.5.4、typedef与结构体

(1)结构体在使用时都是先定义结构体类型，再用结构体类型去定义变量。

(2)C语言语法规定，结构体类型使用时必须是struct 结构体类型名 结构体变量名;这样的方式来定义变量。

(3)使用typedef一次定义2个类型，分别是结构体变量类型，和结构体变量指针类型。

4.4.5.5、typedef与const

(1)typedef int *PINT;    const PINT p2; 相当于是int *const p2;

(2)typedef int *PINT;    PINT const p2; 相当于是int *const p2;

(3)如果确实想得到const int *p;这种效果，只能typedef const int *CPINT; CPINT p1;

4.4.5.6、使用typedef的重要意义（2个：简化类型、创造平台无关类型）

(1)简化类型的描述。

char *(*)(char *, char *);        typedef char *(*pFunc)(char *, char *);   

(2)很多编程体系下，人们倾向于不使用int、double等C语言内建类型，因为这些类型本身和平台是相关的（譬如int在16位机器上是16位的，在32位机器上就是32位的）。为了解决这个问题，很多程序使用自定义的中间类型来做缓冲。譬如linux内核中大量使用了这种技术.

内核中先定义：typedef int size_t; 然后在特定的编码需要下用size_t来替代int（譬如可能还有typedef int len_t）

(3)STM32的库中全部使用了自定义类型，譬如typedef volatile unsigned int vu32;

（1）C语言中的两种类型：内建类型（ADT）与用户自定义类型（UDT）。

（2）typedef与宏定义#define的区别： typedef  char* pChzr（pChzr表示一个类型，这个类型是char*类型的）；    #define pChar char*

（3）使用typedef一次定义2个类型，分别是结构体变量类型，和结构体变量指针类型。

typedef struct teacher

{

    char name[20];

    int age;

    int mager;

}teacher, * pTeacher;  //这个指针指向结构体变量。

（4）typedef  int *  const PINT（和typedef   const  int *CPINT; 的区别，一个是不能更改指针，一个是不能更改指针指向的那个数。）；  typedef int *PINT定义的，然后 const  PINT  p2； 相当于是int  *const  p2；。。或者 PINT  const  p2中的const（不管位置在哪）都是在修饰那个指针不可变，指针指向的可变, 因为typedef是一个类型，所以const直接修饰指针 。 如果想得到const  int *p；这种效果，只能typedef  const  int *CPINT ,   CPINT p1;

#include <stdio.h>

/*

//先定义结构体类型。

struct student     

{

    char name[20];

    int age;

};

*/

typedef struct student       //要么使用struct student 来定义变量，要么使用student_t来定义

{

    char name[20];

    int age;

}student_t;

//一次定义了两个类型：

//第一个是结构体类型，有两个名字：struct teacher,teacher

//第二个是结构体指针类型，有两个名字：struct teacher *, pTeacher

typedef struct teacher

{

    char name[20];

    int age;

    int mager;

}teacher, * pTeacher;//分别定义两个类型，一个是结构体变量类型，一个是结构体变量指针类型。

typedef int *PINT;  //PINT代表的是int *。。因为PINT是一个类型，const无论放在哪，修饰的都是这个指针。

typedef const int *CPINT;

int main(void)

{

    int a = 23;

    int b = 44;

    

    CPINT p = &a;

//    *p = 33;        //不能改变指针指向的那个数。

    p = &b;

    

/*

    PINT p1 = &a;

    

    PINT const p3 = &a;        //指针不能被修改。

    

    *p3 = 33;

    printf("*p3 = %d.\n",*p3);

    p3 = &b;

/*    

    

    const PINT p2 = &a;   //是不是 const int *p2 = &a(不是);p2 = &b（这才是const修饰的内容）;

    *p2 = 33;

    printf("*p2 = %d.\n",*p2);

    

    /*

    struct student *pS1;     //结构体指针

    

    teacher t1;

    t1.age = 23;

    pTeacher p1 = &t1;

    printf("teacher age = %d.\n",p1->age);//结构体的引用指向结构体中的属性，通过地址来操作结构体里面的元素。

    

    /*

    struct student s1;   //struct studnet是类型，s1是变量。

    s1.age = 12;

    

    student_t s2;

    */

    return 0;

}

4.4.6、二重指针

4.4.6.二重指针

4.4.6.1、二重指针与普通一重指针的区别

(1)本质上来说，二重指针和一重指针的本质都是指针变量，指针变量的本质就是变量。

(2)一重指针变量和二重指针变量本身都占4字节内存空间，

4.4.6.2、二重指针的本质

(1)二重指针本质上也是指针变量，和普通指针的差别就是它指向的变量类型必须是个一重指针。二重指针其实也是一种数据类型，编译器在编译时会根据二重指针的数据类型来做静态类型检查，一旦发现运算时数据类型不匹配编译器就会报错。

(2)C语言中如果没有二重指针行不行？其实是可以的。一重指针完全可以做二重指针做的事情，之所以要发明二重指针（函数指针、数组指针），就是为了让编译器了解这个指针被定义时定义它的程序员希望这个指针被用来指向什么东西（定义指针时用数据类型来标记，譬如int *p，就表示p要指向int型数据），编译器知道指针类型之后可以帮我们做静态类型检查。编译器的这种静态类型检查可以辅助程序员发现一些隐含性的编程错误，这是C语言给程序员提供的一种编译时的查错机制。

(3)为什么C语言需要发明二重指针？原因和发明函数指针、数组指针、结构体指针等一样的。

4.4.6.3、二重指针的用法

(1)二重指针指向一重指针的地址

(2)二重指针指向指针数组的

(3)实践编程中二重指针用的比较少，大部分时候就是和指针数组纠结起来用的。

(4)实践编程中有时在函数传参时为了通过函数内部改变外部的一个指针变量，会传这个指针变量的地址（也就是二重指针）进去

4.4.6.4、二重指针与数组指针

(1)二重指针、数组指针、结构体指针、一重指针、普通变量的本质都是相同的，都是变量。

(2)所有的指针变量本质都是相同的，都是4个字节，都是用来指向别的东西的，不同类型的指针变量只是可以指向的（编译器允许你指向的）变量类型不同。

(3)二重指针就是：指针数组

#include <stdio.h>

void func(int **p)  //二重指针指向的是一个一重指针的地址。所以传参的时候对普通一重地址，还要再取一下地址。

{

    *p = 0x12345678;//*p指向的是int *，重新赋值  。。改变这个指针变量的地址

}

//地址的地址应当理解为：int **p   、、p这个指针指向的值存储的就是*P的地址。（从里面往外面剥）

int main(void)

{

    int a = 4;

    int *p = NULL;   //定义的时候初始化，这样可以防止出错，因为运行时，NULL是会报错的，而未初始化的情况下，这个值是随机的，分配在栈上，可能报错，也可能不报错。

    p = &a;

    printf("p = %p.\n",p);   //地址

    func(&p);//***主要在这里，这里不仅是一个指针，还要再取一个地址。为什么要这样传参。这个指针指向的值是前面指针的地址

    printf("p = %p.\n",p);   //这里p已经不指向a了。

    //*p = 23;  //因为此时的p指向了0x12345678，但是这个地址是不允许访问的。

    

    

    int *p1[5];  //这是一个指针数组，数组里面是int *指针，p1代表首元素的首地址

    int *p2;     

    int **p3;   //这是一个二重指针，p3指向int *的类型的地址，p3的那块地址所指向的常量，存储着*p3的地址。  

    

    p3 = p1;   //因为p1指向int *，，p3也指向int *，两个类型相匹配。

    

    

/*    

    char a;

    char **p1;   //二重指针   p1指向的是一个char *类型的指针。p1指向的地址所存储的值是*p1的地址

    char *p2;   //一重指针   ，，char *类型表示指针指向的变量是char类型。p2指向的是一个char

    //二者的指针大小都是4字节

    

    p2 = &a;  //这是可以的，p2是char *,,&a也是char *.

//    p1 = &a;  //p1是char **类型的，这个指针指向的变量是char *类型的。行不通的。编译器的静态类型检查过不了。

    */

    

    return 0;

}

4.4.7、二维数组

4.4.7.1、二维数组的内存映像

(1)一维数组在内存中是连续分布的多个内存单元组成的，而二维数组在内存中也是连续分布的多个内存单元组成的。

(1)从内存角度来看，一维数组和二维数组没有本质差别。

(2)二维数组int a[2][5]和一维数组int b[10]其实没有任何本质差别。我们可以把两者的同一单元的对应关系写下来。

a[0][0]     a[0][1]   a[0][4]     a[1][0]    a[1][1]      a[1][4]   

b[0]     b[1]       b[4]         b[5]        b[6]      b[9]

(3)既然二维数组都可以用一维数组来表示，那二维数组存在的意义和价值在哪里？明确告诉大家：二维数组a和一维数组b在内存使用效率、访问效率上是完全一样的（或者说差异是忽略不计的）。在某种情况下用二维数组而不用一维数组，原因在于二维数组好理解、代码好写、利于组织。

(4)总结：我们使用二维数组（C语言提供二维数组），并不是必须，而是一种简化编程的方式。想一下，一维数组的出现其实也不是必然的，也是为了简化编程。

4.4.7.2、哪个是第一维哪个是第二维？

(1)二维数组int a[2][5]中，2是第一维，5是第二维。

(2)结合内存映像来理解二维数组的第一维和第二维的意义。首先第一维是最外面一层的数组，所以int a[2][5]这个数组有2个元素；其中每一个元素又是一个含有5个元素的一维数组（这个数组就是第二维）。

(3)总结：二维数组的第一维是最外部的那一层，第一维本身是个数组，这个数组中存储的元素也是个一维数组；二维数组的第二维是里面的那一层，第二维本身是个一维数组，数组中存的元素是普通元素，第二维这个一维数组本身作为元素存储在第一维的二维数组中。

4.4.7.3、二维数组的下标式访问和指针式访问

(1)回顾：一维数组的两种访问方式。以int b[10]为例, int *p = b;。

b[0] 等同于 *(p+0);   b[9] 等同于 *(p+9);  b[i] 等同于 *(p+i)

(2)二维数组的两种访问方式：以int a[2][5]为例，(合适类型的)p = a;

a[0][0]等同于*(*(p+0)+0);     a[i][j]等同于 *(*(p+i)+j)

4.4.7.4、二维数组的应用和更多维数组

(1)最简单情况，有10个学生成绩要统计；如果这10个学生没有差别的一组，就用b[10]；如果这10个学生天然就分为2组，每组5个，就适合用int a[2][5]来管理。

(2)最常用情况：一维数组用来表示直线，二维数组用来描述平面。数学上，用平面直角坐标系来比拟二维数组就很好理解了。

(3)三维数组和三维坐标系来比拟理解。三维数组其实就是立体空间。

(4)四维数组也是可以存在的，但是数学上有意义，现在空间中没有对应（因为人类生存的宇宙是三维的）。

总结：一般常用最多就到二维数组，三维数组除了做一些特殊与数学运算有关的之外基本用不到。（四轴飞行器中运算飞行器角度、姿态时就要用到三维数组）

a[0]（一维）[0]（二维）：二维数组的第一维是最外部的那一层，第一维本身是个数组，这个数组中存储的元素也是一个一维数组；二维数组的第二维是里面的那一层，第二维本身是个一维数组，数组中存的元素是普通元素，第二维这个一维数组本身作为元素存储在第一维的二维数组中。a[0][0]二维数组指针式访问*(*(a+0)+0)。a是二维数组的数组名，作为右值表示二维数组第一维的数组的首元素首地址，等同于&a[0]；

4.4.8二维数组的运算和指针。

（1）二维数组的数组名表示二维数组的第一维数组中首元素（也就是第二维的数组）的首地址。

（2）二维数组的数组名a等同于&a[0]、、用数组指针来指向二维数组的数组名是类型匹配的。

（3）指针指向二维数组的第一维：  用int  *p来指向二维数组的第一维a[i]

（4）指针指向二维数组的第二维：  二维数组的第二维就是普通变量，不能用指针类型和它相互赋值了。（2）除非int  *p = &a[i][j]；；类似指针指向二维数组的第一维。。    

 总结：二维数组和指针的纠葛：1:、数组中各个符号的含义。2：数组的指针式访问，尤其是二维数组的指针式访问。二维数组和数组指针的匹配问题。譬如  int (*p1)[5] ;     p1 = &a[0]  ;匹配。    *(*(p1+1)+4)) = p1[1][4]；

#include <stdio.h>

int main(void)

{

    int a[2][5] = {{1,2,3,4,5},{6,7,8,9,10}};//数组名代表二维数组的第一维首元素的首地址，与数组指针匹配。&a[0]

    

    //int *p = NULL;

    //p = a;

    printf("a[1][3] = %d.\n",a[1][3]);

    printf("a[1][3] = %d.\n",*(*(a+1)+3));

    

    int (*p3)[5];   //数组指针，首先这是一个指针，指针指向的是一个数组。数组里面5个int类型元素

    p3 = a;          //这样的类型能和二维数组匹配。只有数组指针才能和二维数组的数组名相等。

    //p3是一个指向数组的指针，这个数组里面有5个元素，元素是int类型的。

    //a是二维数组的数组名，作为右值表示二维数组第一维的数组的首元素首地址，等同于&a[0]；

    

    p3 = &a[0];  //因为这是一个数组指针，所以可以这样赋值

    printf("a[1][3] = %d.\n",*(*(a+1)+3));

    

    

    //这是指针指向二维数组的第一维

    //int *p4 = &a[0];     //不可以的,类型不匹配。

    int *p4 = a[0];  //a[0]表示二维数组的第一维的第一个元素，相当于是

                      //第二维整体数组的数组名，数组名又表示数组首元素

                      //首地址，因此a[0]等同于&a[0][0];

    int *p5 = &a[0][0];   //指向二维数组中第一维数组的首元素的首地址

    printf("a[0][4] = %d.\n",*(p4+4));

    

    //只能一维一维的指向。

    int *p6 = a[1];    //应该等同于&a[1][0]，即二维数组的第二维的首元素的地址

    int *p7 = &a[1][0];

    int (*p10) [5];

    p10 = &a[0];//通过指针来操作数组

    printf("a[1][4] = %d.\n",*(*(p10+1)+4));

    printf("a[1][0] = %d.\n",(*(p6+1)+0));

    

    

    

    return 0;

}