数组指针和指针数组

先看一下基本的形式,我们从这里起步!

--------------指针----------------
int a=10;
int *p=&a;

-------------指针的指针-----------
int b=20;
int *p=&b;
int **p2p=&p;

-------------简单数组-----------------
int c[10];//整数数组，含有10个整数元素
          file://也就是说每一个元素都是整数
         
--------------指针数组--------------------
int *p[10];//指针数组，含有10个指针元素
            file://也就是说每一个元素都是指针
           
--------------数组指针--------------------
int (*p)[10];//数组指针，这个指针可以用来指向
             file://含有10个元素的整数数组

 

先看一段程序。
#include <iostream>
#include <typeinfo>
using namespace std;
int main()
{
 int vInt=10;
 int arr[2]={10,20};
 
 int *p=&vInt;
 int **p2p=&p;
 
 int *parr[2]={&vInt,&vInt};
 int (*p2arr)[2]=&arr;

 cout<<"Declaration [int vInt=10] type=="<<typeid(vInt).name()<<endl;
 cout<<"Declaration [arr[2]={10,20}] type=="<<typeid(arr).name()<<endl;
 cout<<"Declaration [int *p=&vInt] type=="<<typeid(p).name()<<endl;
 cout<<"Declaration [int **p2p=&p] type=="<<typeid(p2p).name()<<endl;
 cout<<"Declaration [int *parr[2]={&vInt,&vInt}] type=="<<typeid(parr).name()<<endl;
 cout<<"Declaration [int (*p2arr)[2]=&arr] type=="<<typeid(p2arr).name()<<endl;

 return 0;
}

运行的结果如下：(我在前面加了行号#XX)
#01 Declaration [int vInt=10] type==int
#02 Declaration [arr[2]={10,20}] type==int *
#03 Declaration [int *p=&vInt] type==int *
#04 Declaration [int **p2p=&p] type==int * *
#05 Declaration [int *parr[2]={&vInt,&vInt}] type==int **
#06 Declaration [int (*p2arr)[2]=&arr] type==int (*)[2]

 

--------#02：数组------------

现在看#02,想到了什么没有呀？在编译器看来数组只是相对应类型的指针类型。
当我们把数组传递给函数作为参数的时候，传递的是指针，所以我们可以利用
参数来修改数组元素。这个转化是编译器自动完成的。

void f(int[]);
int a[2]={10,20};
f(a);//这行等价于编译器完成的函数转化f(int *p)

也就是说这里编译器自动完成了int[]类型到int *的转化，
注意是编译器完成的，也可以说是语言本身实现的，我们
对此只有接受的份了。

-------#05：指针数组---------------

指针数组的编译器内部表示也是对应类型的指针。

------#06：数组指针----------------
数组指针的编译器内部表示就是有一点特别了。
编译器(或者说是语言本身)有数组指针这个内部表示。
由于c++语言的类型严格检查的语言（当然还有一些是存在隐式类型转化的）

 

 

 

下面到底哪个是数组指针，哪个是指针数组呢：
A)
int *p1[10];
B)
int (*p2)[10];

 

“[]”的优先级比“*”要高。p1 先与“[]”结合，构成一个数组的定义，数组名为p1，int *修饰的是数组的内容，即数组的每个元素。那现在我们清楚，这是一个数组，其包含10 个指向int 类型数据的指针，即指针数组。至于p2 就更好理解了，在这里“（）”的优先级比“[]”高，“*”号和p2 构成一个指针的定义，指针变量名为p2，int 修饰的是数组的内容，即数组的每个元素。数组在这里并没有名字，是个匿名数组。那现在我们清楚p2 是一个指针，它指向一个包含10 个int 类型数据的数组，即数组指针。

int (*)[10] p2-----也许应该这么定义数组指针
这里有个有意思的话题值得探讨一下：平时我们定义指针不都是在数据类型后面加上指针变量名么？这个指针p2 的定义怎么不是按照这个语法来定义的呢？也许我们应该这样来定义p2：
     int (*)[10] p2;
int (*)[10]是指针类型，p2 是指针变量。这样看起来的确不错，不过就是样子有些别扭。其实数组指针的原型确实就是这样子的，只不过为了方便与好看把指针变量p2 前移了而已。你私下完全可以这么理解这点。

实例：

通过上面的分析，相信你已经明白数组和指针的访问方式了，下面再看这个例子：
main()
{
   int a[5]={1,2,3,4,5};
   int *ptr=(int *)(&a+1);
   printf("%d,%d",*(a+1),*(ptr-1));
}
打印出来的值为多少呢? 这里主要是考查关于指针加减操作的理解。

对指针进行加1 操作，得到的是下一个元素的地址，而不是原有地址值直接加1。所以，一个类型为T 的指针的移动，以sizeof(T) 为移动单位。因此，对上题来说，a 是一个一维数组，数组中有5 个元素； ptr 是一个int 型的指针。

&a + 1: 取数组a 的首地址，该地址的值加上sizeof(a) 的值，即&a + 5*sizeof(int)，也就是下一个数组的首地址，显然当前指针已经越过了数组的界限。

(int *)(&a+1): 则是把上一步计算出来的地址，强制转换为int * 类型，赋值给ptr。

*(a+1): a,&a 的值是一样的，但意思不一样，a 是数组首元素的首地址，也就是a[0]的首地址，&a 是数组的首地址，a+1 是数组下一元素的首地址，即a[1]的首地址,&a+1 是下一个数组的首地址。所以输出2*(ptr-1): 因为ptr 是指向a[5]，并且ptr 是int * 类型，所以*(ptr-1) 是指向a[4] ，输出5。