C++数组，指针，引用以及三者的复合类型

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种：

	数组	指针	引用
数组的数组	数组的数组的数组	数组的数组的指针	数组的数组的引用
数组的指针	数组的指针的数组	数组的指针的指针	数组的指针的引用
数组的引用
指针的数组	指针的数组的数组	指针的数组的指针	指针的数组的引用
指针的指针	指针的指针的数组	指针的指针的指针	指针的指针的引用
指针的引用