数组、指针

数组：

数组类型声明的一般形式为：  数组类型    标识符  [ 常量表达式1 ] [ 常量表达式2 ]；

存储方式：行优先存储

初始化细节：当指定的初值个数小于数组大小时，剩下的数组元素会被赋零。

                    若定义时没有指定任何一个元素的初值。

                           静态生存期：全被赋零；动态生存期：初值不确定

          数组也可以声明为常量。每个元素都被当做常量看待。声明为常量的数组，必须给定初值

1. 使用数组名传递参数时，传递的是地址；数组作为函数参数：当把数组作为参数时，一般不指定数组第一维的大小，即使指定，也会被忽略
2. 对象数组        声明形式： 类名   数组名 [ 常量表达式 ]

                              建立某个类的对象数组，在设计构造函数时要充分考虑到数组元素初始化时的需要

                              当各元素对象的初值要求为相同的值时，应在类中定义默认构造函数；

                              当各元素对象的初值要求为不同的值时，需要定义形参（无默认值）的构造函数

   

---

指针：

• 指针定义：

1. 1. 一种重要的数据类型。可以方面、灵活而有效地组织和表示复杂的数据结构。动态内存分配和管理也离不开指针
   2. 内存分配：具有静态生存期的变量在程序开始运行之前就已经被分配了内存空间；具有动态生存期的变量，是在程序运行时遇到变量声明语句时被分配内存空间

• 指针变量：

1. 1. 通过变量名可以存取变量的内容
   2. 指针变量是用于存放内存单元地址的 
   3. "*" 指针运算符，也称解析，表示获取指针所指向变量的值：一元操作符      出现在声明语句中：表示声明的是指针

          "&"取地址运算符，一元操作符                                                                 出现在声明语句中：表示声明的是引用

     4.  数组名称：实际上就是一个不能被赋值的指针，即指针常量

         1) 声明指向常量的指针：此时不能通过指针来改变所指对象的值  ，但指针本身可以改变，可以指向另外的对象

                       eg： const int *p = &a;

         2)声明指针类型的常量，这时，指针本身的值不能被改变

                       eg： int * const p = &a;

         3) void 类型指针：可以存储任何类型的对象指针（换言之，任何类型的指针都可以赋值给 void 类型的指针变量） 

                       void 指针：一般只在指针所指向的数据类型不确定时使用

• 指针运算：

          算数运算、关系运算、赋值运算

          关系运算：指向相同类型数据的指针之间进行的关系运算

                          如果两个相同类型的指针相等，就表示这两个指针是指向同一个地址

                          指针变量可以和整数0进行比较，0专门用于表示空指针 : 也就是一个不指向任何有效地址的指针

                                 eg：int *p;          p = 0;

                          空指针也可以用NULL    eg： int *p = NULL;

                          NULL 是一个在很多头文件中有定义的宏，被定义为 0

           习惯： 如果不便于用一个有效地址给一个指针变量赋初值，那么应当用0为它的初值，从而避免指向不确定地址指针的出现

• 数组与指针

1. 1. 用指针处理数组元素

                         void  f（int p[]）,  void  f(int  p[3]) ,   void  f(int  *p)          三者等价

               2.   指针数组：一个数组的每个元素都是指针变量（每个元素必须是同一类型的指针）

                           声明： 数据类型  * 数组名 [下标表达式]  eg： int * pa[3];          pa [i][j] 等价于 *（pa[i] + j）表示其中元素

                    指针数组的每个元素都是一个指针，必须先赋值后引用；声明数组后，对指针元素赋初值必不可少

                    指针数组 区别于 二维数组：二维数组  int array[3][3];    指针数组： int * pa[3];

                                        pa[i]的值需要通过读取指针数组pa的第 i 个元素才能得到

                                        而array[i]的值是通过二维数组array的首地址计算得到的，内存中，没有一个指针数组存储array[i]的值

                                        （直观的说，二维数组：借用首地址可以访问其任意元素：存储时连续的）

                                         （指针数组：每个指针地址对应一个数组的起始位置：存储可能是不连续的）

                     尽管两者有本质区别，但二者具有相同的访问形式。 可以把二维数组当作指针数组来访问， eg： *（*（array+i) + j） == array[i][j];

•  指针作为函数参数

                               C++语法支持：函数的参数：基本类型的变量，对象名，数组名，或引用，指针

                         指针作为函数形参三作用：

1. 1. 1. 1. 使实参和形参指针指向共同的内存空间，以达到参数双向传递的目的，即通过在被调函数中直接处理主调函数中的数据而将函数的处理结果返回主调者（c++引用实现）
         2. 减少函数调用时参数传递的开销。（c++中有时可以通过引用实现，有时还是需要使用指针）
         3. 通过指向函数的指针传递函数代码的首地址

                              习惯：1） 不需要通过指针改变指针所指向对象的内容，应在参数表中声明指向常量的指针

                                        2） 当某个函数以指针或引用作为形参都可以达到同样目的，使用引用会使程序的可读性更好

•   指针型函数

                         当一个函数的返回值是指针类型时，这个函数就是指针型函数

                         使用指针型函数的目的：函数调用结束时把大量的数据从被调函数返回到主调函数中。而通常非指针函数结束后，只能返回一个变量或者对象

                              定义形式：  数据类型  * 函数名（参数表）

                              {

                                   函数体

                              }

•  指向函数的指针

                         函数名：表示函数的代码在内存中的起始地址。在表示代码起始地址的同时，也包括函数的返回值类型和参数的个数、类型、排列次序等

                         函数指针：专门用来存放函数代码首地址的变量

                         声明一个函数指针，需说明函数的返回值、形式参数列表、其一般语法如下：

                                数据类型 （*函数指针名）（形参表）    （定义比较繁琐，如果需多次定义，使用typedef）  typedef：可以很方便地为复杂类型起别名

                         函数指针使用前赋值：

                              函数指针名 = 函数名

• 对象指针

1. 1. 对象指针的一般概念

                    对象指针：用于存放对象地址的变量
                    对象占据空间：只是用于存放数据成员的，函数成员不在每一个对象中存储副本

                    声明对象指针的一般语法形式为：

                               类名  * 对象指针名；

                    访问对象成员的语法形式：

                              对象指针名->成员名 ==（等价于） （*对象指针名）.成员名

                    对象指针，可以访问到对象的公有成员

                    好处： 可以解决，前向引用声明时，在提供一个完整的类定义之前，不能定义该类的对象；我们只需定义一个对象指针就OK了

            2.  this 指针

                   概念： ！！  隐含于每一个类的非静态成员函数中的特殊指针（包括构造函数和析构函数）

                   详解： 用于指向正在被成员函数操作的对象

                              this指针实际上是类成员函数的一个 隐含参数。在调用类的成员函数时，目的对象的地址会自动作为该参数的值，传递给被调用的成员函数

                         这样被调函数就能够通过this指针来访问目的对象的数据成员。

                              this 是一个指针常量；对于常成员函数，this同时又是指向常量的指针（常指针类型）

                              在成员函数中，可以使用 *this来标识正在调用该函数的对象

                            （每次对成员函数的调用都存在一个目的对象，this指针明确指出了成员函数当前所操作的数据所属的对象。实际过程中，this指针是成员函数的一个隐含形参，

                               当通过一个对象调用成员函数时，系统先将该对象的地址通过该参数传递给成员函数，成员函数对对象的数据成员进行操作时，就隐含使用了this指针

                      提示：     当局部作用域中声明了与类成员同名的标识符，对该标识符的直接引用代表的是局部作用域中所声明的标识符，这时，为了访问该类成员，可以通过this指针

           3. 指向类的非静态成员的指针（用起来很复杂，以后要好好注意啊 ）

                 类的成员自身 : 是一些变量、函数、或者对象等。因此，也可直接将它们的地址存放到一个指针变量中，这样，指针直接指向对象的成员（可通过指针访问对象成员）

                  声明的一般形式：

                        类型说明符    类名 : : *指针名；       // 声明指向数据成员的指针

                        类型说明符   （类名 : : *指针名） （参数表）；   // 声明指向函数成员的指针

                赋值语句：

                     1）    指针名 = &类名 : : 数据成员名；

                              注意：对类成员取地址，要遵守访问权限的约定

                              说明：类的定义只确定各个数据成员的类型、所占内存大小以及它们的相对位置，在定义时不为数据成员分配具体地址

                                        因此上述赋值，只是说明了被赋值的指针是专门用于指向哪个数据成员，同时，在指针中存放数据成员在类中的相对位置（即相对于起始地址的地址偏移量）

                              所以， 访问数据成员时，要结合起始地址+偏移量

                                       对象名.*类成员指针名

                                       对象指针名->*类成员指针名

                   2）     指针名 = &类名 : : 函数成员名

                             注意  被常成员函数赋值的指针，声明时，明确写出const关键字

                              调用：

                              （对象名.* 类成员指针名）（参数表）

                              （对象指针名->*类成员指针名）（参数表）

                              说明：成员函数指针的声明、赋值和使用过程中的返回值类型、函数参数表一定要相互匹配

         4. 指向类的静态成员的指针

                

               对类的静态成员的访问是不依赖于对象的，因此可以用普通的指针来访问静态成员

               对静态成员数据：    类型说明符  * 指针名 = &类名 : : 类的静态成员数据

               对静态函数成员：    声明： 类型说明符 （*指针名）（参数表）

                                             赋值： 指针名 = 类名 : :  静态成员

                                             调用： 指针名（）