C++数组，指针，引用以及三者的复合类型
这里省去了对这三者的单独介绍，仅仅介绍使用这三者组成的组合类型。
一、两两组合
这三者的两两组合有9种：
|
数组 |
指针 |
引用 |
|
|
数组 |
数组的数组 |
数组的指针 |
数组的引用 |
|
指针 |
指针的数组 |
指针的指针 |
指针的引用 |
|
引用 |
引用的数组 |
引用的指针 |
引用的引用 |
1、指针的指针、数组的数组、数组的指针、指针的数组
指针的指针（二维指针），数组的数组（二维数组），数组的指针和指针的数组这里就不介绍了，很多博客文章书籍都有详细的介绍。它们的形式是：
指针的指针： int** a = NULL;
数组的数组： int a[2][3] = {0};
数组的指针：int (*a)[10];//a指向有10个元素的int型数组
指针的数组：int *a[10];//a是一个数组，有10个元素，元素的类型是(int *)
下面才是讨论的主题，C++中引入“引用”类型的时候，事情有点复杂了。我在尝试使用一个指针数组的时候，发现以后会以引用的方式将该数组传入函数，第一次发现自己完全不会定义这三者的组合类型，找了一些资料，将这三者的复合类型总结成这篇文章。
2、数组的引用，引用的数组
引用与数组，引用与指针进行组合的时候，网上还是有一些介绍的，它们的形式是：
数组的引用：
int a[3] = {1,2,3};
int (&b)[3]=a;
和数组的指针是不是很相似？？所以引用的数组是不是也应该是以下这样的？
int h = 4;
int &c = h;
int &d = a[1];
int &e = a[1];
int &f[3] = {c,d,e};//error
但这是错误的，C++无法定义引用的数组，编译器不会通过。经典的解释（《C++ Primer》）是：引用不是对象。我自己的想法是：引用传递的不仅仅是值，还有变量的地址信息，多个引用指向的变量内存上不一定是连续的（如上例中的h和a[1]），不一定是不同的地址（如上例中的引用d和e指向同一个变量）；但是数组的元素地址必须是连续的。
太好了，下面就不会有由“引用的数组”组成的麻烦的复合类型了！！
3、指针的引用，引用的指针
指针的引用和引用的指针，对这两者的介绍也不少，
指针的引用：
int a = 0;
int * p = &a;
int* &b = p;
引用的指针：和引用的数组一样，没有这种东西，依然采用经典的解释：引用不是对象。
这样我们又去掉了一种组合，以后也不会有由“引用的指针”组成的复合类型了。
4、引用的引用
引用的引用，你当然可以这么做：
int a = 0；
int &b = a;
int &c = b;
但是不能定义这样的引用：
int a = 0;
int &&b = a;//error
int &(&b) = a;//error
（指针也不能这么干：int ** p = &&a;//error，不解释）
总之，忘了以上两种错误的方式：
第一种，g++给出的编译信息如下：
error: expected unqualified-id before ‘&&’ token
int &&p = a;
第二种，g++给出的编译信息如下：
error: cannot declare reference to ‘int&’, which is not a typedef or a template type argument
int &(&p) = a;
好了，这样我们进行三者组合的时候就可以去掉了9种中的3种。
我们先列出可以使用的两者组合：
|
数组 |
指针 |
引用 |
|
|
数组 |
数组的数组 |
数组的指针 |
数组的引用 |
|
指针 |
指针的数组 |
指针的指针 |
指针的引用 |
|
引用 |
二、三者的组合情况
1、指针的指针的指针、数组的数组的数组
|
数组 |
指针 |
引用 |
|
|
数组的数组 |
数组的数组的数组 |
数组的数组的指针 |
数组的数组的引用 |
|
数组的指针 |
数组的指针的数组 |
数组的指针的指针 |
数组的指针的引用 |
|
数组的引用 |
数组的引用的数组 |
数组的引用的指针 |
数组的引用的引用 |
|
指针的数组 |
指针的数组的数组 |
指针的数组的指针 |
指针的数组的引用 |
|
指针的指针 |
指针的指针的数组 |
指针的指针的指针 |
指针的指针的引用 |
|
指针的引用 |
指针的引用的数组 |
指针的引用的指针 |
指针的引用的引用 |
1、不存在的类型
数组的引用的数组，数组的引用的指针，数组的引用的引用，指针的引用的数组，指针的引用的指针，指针的引用的引用这些复合类型不存在，参考两两组合。
2、指针的指针的指针、数组的数组的数组
指针的指针的指针，数组的数组的数组：三维指针和数组，它们的形式分别为：
int *** p = NULL;
int a[2][4][3] = {0};
3、指针的指针的数组
指针的指针的数组：参考指针的数组，毕竟指针的指针也是指针，它的形式如下：
int ** a[2];//a是一个有两个元素的数组，元素的类型是int**
4、指针的指针的引用
指针的指针的引用：参考指针的引用，它的形式如下：
int **&b = a[0];
5、数组的数组的指针
数组的数组的指针：参考数组的指针，毕竟数组的数组也是数组，它的形式如下：
int (*p)[2][3] = NULL；// p是一个指针，指向一个2行3列元素为int型的数组。
6、数组的数组的引用
数组的数组的引用：参考数组的引用，和数组的数组的指针类似，形式如下：
int a[2][3] = {0};
int (&r)[2][3] = a;
7、数组的指针的数组
我读的程序不多，没见过有这么用的程序，我自然也没这么用过，不过依然不妨碍我们给出此类对象的定义：
指针的数组是这么定义的：
int *b[2] = {NULL,NULL};
其实写成这样也没问题：
int *(b)[2] = {NULL,NULL};
这个指针的数组中存放的指针指向int型，现在要改成指向int数组型，比如 int [2]，只要将b替换成一个int数组就可以了：
int *(b[2])[2] = {NULL,NULL};
好了，数组的指针的数组类型定义好了，这是一个存放两个指针的数组，这种指针指向有两个int型元素的数组。
我想以后如果你想定义“数组的指针的数组的指针的数组”的时候，也可以这样一步步代入来完成这种复合类型。
int *(*(a[2])[2])[2] = {NULL,NULL};
如果选择从数组的指针开始推导会挺困难的。我是没有推出来。
8、数组的指针的指针
数组的指针类型是这么定义的： int (*a)[2] = NULL;
也可以这么写：int (*(a))[2] = NULL;
所以如果想对a再次取地址，那么使用*a替换a,所以数组的指针的指针对象的定义是这样子的：
int (*(*a))[2] = NULL;
对比上一个数组的指针的数组，你可能会有如下的疑问：
指针的指针是这样的：int ** a = NULL;
根据数组的指针的数组的推导经验，数组的指针的指针应该这样得出：
int ** (a) = NULL;
int ** (a[2]) =NULL; //error
遗憾的是，编译不通过。我暂时不知道什么原因。
比较以上两种复合类型的推导，我们似乎没发现有什么很固定的规律。一切都是经验之谈。再等等，后面应该会看到规律。
9、指针的数组的数组
这个比较容易，因为指针的数组是这样的：int *a[2] = {NULL,NULL};
所以可以很容易就写出来：
int *a[2][2] = {0};
10、指针的数组的指针
指针的数组：int *a[2] = {0};
也即：int *(a)[2] = {0};
所以，指针的数组的指针：int *(*a)[2] = NULL;
规律我也不知道该怎么总结，不过我把我的经验写成一个例子应该比较好理解。
综合以上几种复合类型，我们就可以在c或者c++中组合出非常丧心病狂的复合类型，比如：数组的指针的指针的数组的数组的指针的数组的指针的指针
我的方法是这样的：
从右面数，找到第一个“数组”：
数组的指针的指针的数组的数组的指针的数组的指针的指针
什么样的数组？指针的数组
数组的指针的指针的数组的数组的指针的数组的指针的指针
所以先定义的一个指针的数组
int *(a)[2] = {0};
那么a是一个什么样的指针呢？数组的指针？还是数组的数组的指针？我们把所有的修饰型“数组”全部取完，所以是数组的数组的指针：
数组的指针的指针的数组的数组的指针的数组的指针的指针
int *(a[2][2])[2] = {0};
那么a这个数组的数组中存放的是什么呢？指针？指针的指针？我们把所有的修饰型“指针”全部取完，所以存放的是指针的指针：
数组的指针的指针的数组的数组的指针的数组的指针的指针
int *(**a[2][2])[2] = {0};
那么现在a是一个什么样的指针呢？数组的指针：
数组的指针的指针的数组的数组的指针的数组的指针的指针
int *(**(a[2])[2][2])[2] = {0};
好了，前半部分推完，还有后面一部分：
现在我们知道a是一个数组，我们还要取它的指针的指针呢：
数组的指针的指针的数组的数组的指针的数组的指针的指针
int *(**((**a)[2])[2][2])[2] = NULL;
完成！！！！
好吧我没测试这个写到底对不对。
这个已经够复杂了,但这还没在里面加入函数指针呢……
好了，下面终于到引用了
11、数组的指针的引用
很显然，先写出数组的指针，于是
int (*p)[2] = NULL;
该指针的引用，参考指针的引用，于是
int (*&r)[2] = p;
12、指针的数组的引用
很显然，先写出指针的数组，于是
int *p[2] = {0};
参考数组的引用，于是
int *(&r)[2] = p;//这个括号不能省
总结一下可用的三者组合的复合类型，共12种：
|
数组 |
指针 |
引用 |
|
|
数组的数组 |
数组的数组的数组 |
数组的数组的指针 |
数组的数组的引用 |
|
数组的指针 |
数组的指针的数组 |
数组的指针的指针 |
数组的指针的引用 |
|
数组的引用 |
|||
|
指针的数组 |
指针的数组的数组 |
指针的数组的指针 |
指针的数组的引用 |
|
指针的指针 |
指针的指针的数组 |
指针的指针的指针 |
指针的指针的引用 |
|
指针的引用 |