指针数组，数组指针与二维数组剖析

int *p[3]与int (*p)[3]的区别
*p[3]这个是一个指针数组，它所代表的意思是数组中的每一个元素都是一个指针变量，而(*p)[3]，p是一个指针变量，表示指向一个含有3个整型元素的一维数组。

复制代码代码如下:

int i,j;
    int a[2][3]={3,4,5,6,7,8}; //
    int *p[3] ;  //表示一个数组，数组中的元素是指针类型，一共有三个元素
    int (*q)[3]; //是一个指针，指向一个含有三个int型的数组(q+1)会跳三个数组元素

    //把第一行三个元素地址存放在p指针数组中
    for( i=0;i<3;++i)
        p[i]=&a[0][i];

    //输出指针数组中地址所对应值
    for( j=0;j<3;++j)
        cout<< *p[j]<<" ";//输出结果为：3,4,5
    cout<<endl;

    q=a;//把数组a开始地址赋给指向一维数组q；
    for(i=0;i<2;i++)
        for(j=0;j<3;j++)
            cout<< *(*(q+i)+j)<<" "; //输出数组中元素

    system("pause");

参考《c++ primer》
严格的将，c++中没有多维数组，通常所指的多维数组其实就是数组的数组，比如int arry[3][4];表示一个长度为3的数组，数组中的每个元素是一个长度为4的数组。在使用多维数组时，记住这一点有利于理解其应用。

下面来讲讲多维数组与指针的关系。与普通数组一样，使用多维数组时，实际上将其自动转换为指向该数组第一个元素的指针。也就是说，数组的名字是一个指向该数组中第一个元素的指针，在一维数组中，arry==&arry[0]，这两个地址是一样的。在二维数组中，数组名称指向第一个元素，第一个元素是一个长度为4的数组。我们定义一个指向长度为4的数组的指针 int (*p)[4]，然后可以将二维数组的首地址赋值给它，p=arry。这样是可以进行赋值的。这里同样满足arry==&arry[0]。

知道了二维数组名字与指针的关系，那么我们在进行二维数组传参的时候就会好理解很多，以前二维数组传参是一直让人头疼的问题。这里我们还是将二维数组名字作为实参来传递，在接受函数的形参中，我们只需要定义一个指向具体长度为数组的指针即可，比如我们这里使用 int (*p)[4]来接受arry这样的参数。下面给出代码实例。

复制代码代码如下:

#include<iostream>
#include<stdlib.h>
using namespace std;

//数组名字是一个指向数组首元素的指针，这里我们定义一个指向数组的指针来接受arry
//r表示二位数组的行数，c表示二维数组的列数。
void PrintArry(int (*arry)[4],int r,int c)
{
    for(int i=0;i<r;i++)
    {
        for(int j=0;j<c;j++)
        {
            cout<<arry[i][j]<<" ";
        }
        cout<<endl;
    }
}

void main()
{
    int arry[3][4]={{1,2,8,9},{2,4,9,12},{4,7,10,13}};
    PrintArry(arry,3,4);//等价于PrintArry(&arry[0],3,4);
    system("pause");
}

上述一个简单的打印二维数组的简单例子，重点是二维数组的传参。

更优化的方法
在上述示例中，形参必须指明这个arry指针是指向一个长度为多少的数组，如int (*arry)[4]必须指明为4，有一定的局限性，那么有没有更好的方法呢。答案是有的。考虑到二维数组在内存中占据连续的空间这一个特性，我们可以用以为数组来表达二位数组。将上述PrintArry方法进行改写，改写结果如下：

复制代码代码如下:

#include<iostream>
#include<stdlib.h>
using namespace std;

//传入数组的指针，二维数组的行数与列数
void PrintArry2(int *arry,int r,int c)
{
    for(int i=0;i<r*c;i++)
    {
        cout<<arry[i]<<" ";
    }
    cout<<endl;
}

void main()
{
    int arry[4][4]={{1,2,8,9},{2,4,9,12},{4,7,10,13},{6,8,11,15}};
    PrintArry2(&arry[0][0],4,4);//传入数组中的第一个数组中的第一个元素的地址

    system("pause");
}

直接用程序说明：

#include<stdio.h>void main(){    char **p,a[6][8];    p = a;    printf（"\n"）;}

编译，然后就会发现通不过，报错：错误 1 error C2440: “=”: 无法从“char [6][8]”转换为“char **” 

于是乎，我看了下《C专家编程》里10.5节—使用指针向函数传递一个多维数组。

方法一，函数是 void fun(int arr[2][3]); 这种方法只能处理2行3列的int型数组。

方法二，可以省略第一维的长度。函数是 void fun(int arr[][3]);这种方式虽然限制宽松了一些，但是还是只能处理每行是3个整数长度的数组。

　　　　或者写成这种形式 void fun(int (*arr)[3]);这是一个数组指针或者叫行指针，arr和*先结合使得arr成为一个指针，这个指针指向具有3个

　　　　int类型数据的数组。

方法三，创建一个一维数组，数组中的元素是指向其他东西的指针，也即二级指针。函数是 int fun(int **arr);这种方法可以动态处理各行各列不一样长度的数据。

注意：只有把二维数组改成一个指向向量的指针数组的前提下才可以这么做！比如下面的程序可以正常输出abc：

#include <iostream> using namespace std; void test(char **ptr) {     cout << *ptr << endl; }  int main() {     char *p[3] = {"abc", "def", "ghi"};     test(p);     return 0; }

在《C专家编程》10.3节的小启发里讲的很透彻：（以下这段文字及对比一定要认真分析！）

数组和指针参数是如何被编译器修改的？

“数组名被改写成一个指针参数”规则并不是递归定义的。数组的数组会被改写成“数组的指针”，而不是“指针的指针”：

实参                                                      所匹配的形参

数组的数组          char c[8][10];                 char (*)[10];          数组指针

指针数组             char *c[10];                   char **c;               指针的指针

数组指针(行指针)  char (*c)[10];                 char (*c)[10];        不改变

指针的指针           char **c;                       char **c;               不改变

下面再看一个网友的一段分析相当给力的代码：

#include "stdafx.h" #include <iostream> using namespace std;  int _tmain(int argc, _TCHAR* argv[]) {     int arr1[3];     int arr2[3];     int arr3[3];     int * ptr;     // ptr1是一个指向 int [3] 的指针，即ptr1的类型和&arr1的类型是一样的，注意：arr1指向的内存区域定长     int ptr1[3][3]={{1,2,3},{1,2,3},{1,2,3}};     // ptr2是一个指向 int * 的指针，即ptr2的类型和&ptr是一样的，注意：ptr指向的内存区域不定长     int * ptr2[3]={arr1,arr2,arr3};     // ptr3是一个指向 int [3] 的指针，即ptr3的类型和&arr1的类型是一样的，注意：arr1指向的内存区域定长     int(* ptr3)[3]=&arr1;     ptr3=ptr1; // 没错，他们的类型相同  // ptr3=ptr2;//error 无法从“int *[3]”转换为“int (*)[3]  // ptr4是一个指向 int * 的指针，即ptr4的类型和&ptr是一样的，注意：ptr指向的内存区域不定长     int ** ptr4;     //ptr4=&arr1; //error 无法从“int (*)[3]”转换为“int **     ptr4=ptr2; // 没错，他们的类型相同  //ptr4=ptr3; // error 无法从“int (*)[3]”转换为“int **     return 0; }

</pre><pre id="best-answer-content" class="reply-text mb10" name="code" style="white-space: pre-wrap; word-wrap: break-word; color: rgb(51, 51, 51); font-size: 14px; widows: 1; margin-top: 0px; margin-bottom: 10px; padding: 0px; zoom: 1; line-height: 22px; background-color: rgb(255, 252, 246);"><span style="font-family: 'Microsoft YaHei';">最简单的理解方式就是，假设你是编译器，你要看看自己是否能够合理的解释这些语句？</span>

<span style="font-family: 'Microsoft YaHei';">练习1：</span>

<span style="font-family: 'Microsoft YaHei';">char array[5][10];</span>

<span style="font-family: 'Microsoft YaHei';">char (*p)[10] = array; </span>

<span style="font-family: 'Microsoft YaHei';">// ok，先确定运算符的优先级： () function call > [] > *，*p被括号包裹，p先于*结合，所以p是一个指针；指向长度为10的char数组那么array和p的步长是相同的，p+1会向前进10*sizeof(char)=10bytes，array[1]也是同理 </span>

<span style="font-family: 'Microsoft YaHei';"></span>

<span style="font-family: 'Microsoft YaHei';"></span><pre id="best-answer-content" class="reply-text mb10" name="code" style="white-space: pre-wrap; word-wrap: break-word; margin-top: 0px; margin-bottom: 10px; padding: 0px; zoom: 1; background-color: rgb(255, 252, 246);">练习:2：

<span style="font-family: 'Microsoft YaHei';">char **p = array;</span>

<span style="font-family: 'Microsoft YaHei';">// error，p是一个指向char指针的指针，所以p的步长是多少哪？sizeof(char*)=4bytes，所以你就不能指望编译器不报错 </span>

<span style="font-family: 'Microsoft YaHei';"></span>

<span style="font-family: 'Microsoft YaHei';">练习3：</span>

<span style="font-family: 'Microsoft YaHei';">char* array2[3]; </span>

<span style="font-family: 'Microsoft YaHei';">char **ptr = array2;</span>

<span style="font-family: 'Microsoft YaHei';">// ok，大家的步长都是sizeof(char*)=4bytes</span><span style="font-family: 'Microsoft YaHei';">，另外需要说明的是array2 与 &array2都是同一地址，但是意义不同；array2相当于&array2[0]，所以array2 + 1 代表指向下一个元素array2[1];   &array2 + 1，代表指向array2整个数组之后的地址，也就是说步长是整个数组！</span>

</pre></div><div style="color:rgb(51,51,51); font-family:Arial; font-size:14px; line-height:26px"><span style="font-family:微软雅黑; line-height:24px; background-color:rgb(242,242,242)"></span><pre id="best-answer-content" class="reply-text mb10" name="code" style="white-space: pre-wrap; word-wrap: break-word; margin-top: 0px; margin-bottom: 10px; padding: 0px; zoom: 1; line-height: 22px; background-color: rgb(255, 252, 246);">转载两篇文章：

-----------------------------------------------------------------------------

C/C++数组名与指针区别深入探索

引言

　　指针是C/C++语言的特色，而数组名与指针有太多的相似，甚至很多时候，数组名可以作为指针使用。于是乎，很多程序设计者就被搞糊涂了。而许多的大学老师，他们在C语言的教学过程中也错误得给学生讲解："数组名就是指针"。很幸运，我的大学老师就是其中之一。时至今日，我日复一日地进行着C/C++项目的开发，而身边还一直充满这样的程序员，他们保留着"数组名就是指针"的误解。

　　想必这种误解的根源在于国内某著名的C程序设计教程。如果这篇文章能够纠正许多中国程序员对数组名和指针的误解，笔者就不甚欣慰了。借此文，笔者站在无数对知识如饥似渴的中国程序员之中，深深寄希望于国内的计算机图书编写者们，能以"深入探索"的思维方式和精益求精的认真态度来对待图书编写工作，但愿市面上多一些融入作者思考结晶的心血之作！

　　魔幻数组名

　　请看程序（本文程序在WIN32平台下编译）：

1. #include <iostream.h>
2. int main(int argc, char* argv[])
3. {
4. 　char str[10];
5. 　char *pStr = str;
6. 　cout << sizeof(str) << endl;
7. 　cout << sizeof(pStr) << endl;
8. 　return 0;
9. }
　　1、数组名不是指针

　　我们先来推翻"数组名就是指针"的说法，用反证法。

　　证明　数组名不是指针

　　假设：数组名是指针；

　　则：pStr和str都是指针；

　　因为：在WIN32平台下，指针长度为4；

　　所以：第6行和第7行的输出都应该为4；

　　实际情况是：第6行输出10，第7行输出4；

　　所以：假设不成立，数组名不是指针

　　2、数组名神似指针

　　上面我们已经证明了数组名的确不是指针，但是我们再看看程序的第5行。该行程序将数组名直接赋值给指针，这显得数组名又的确是个指针！

　　我们还可以发现数组名显得像指针的例子：

1. #include <string.h>
2. #include <iostream.h>
3. int main(int argc, char* argv[])
4. {
5. 　char str1[10] = "I Love U";
6. 　char str2[10]; 
7. 　strcpy(str2,str1);
8. 　cout << "string array 1: " << str1 << endl;
9. 　cout << "string array 2: " << str2 << endl;
10.　 return 0;
11. }
　　标准C库函数strcpy的函数原形中能接纳的两个参数都为char型指针，而我们在调用中传给它的却是两个数组名！函数输出：

string array 1: I Love U
string array 2: I Love U
　　数组名再一次显得像指针！

　　既然数组名不是指针，而为什么到处都把数组名当指针用？于是乎，许多程序员得出这样的结论：数组名（主）是（谓）不是指针的指针（宾）。

　　整个一魔鬼。

　　揭密数组名

　　现在到揭露数组名本质的时候了，先给出三个结论：

　　(1)数组名的内涵在于其指代实体是一种数据结构，这种数据结构就是数组；

　　(2)数组名的外延在于其可以转换为指向其指代实体的指针，而且是一个指针常量；

　　(3)指向数组的指针则是另外一种变量类型（在WIN32平台下，长度为4），仅仅意味着数组的存放地址！

　　1、数组名指代一种数据结构：数组

　　现在可以解释为什么第1个程序第6行的输出为10的问题，根据结论1，数组名str的内涵为一种数据结构，即一个长度为10的char型数组，所以sizeof(str)的结果为这个数据结构占据的内存大小：10字节。

　　再看：

1. int intArray[10];
2. cout << sizeof(intArray) ;
　　第2行的输出结果为40（整型数组占据的内存空间大小）。

　　如果C/C++程序可以这样写：

1. int[10] intArray;
2. cout << sizeof(intArray) ;
　　我们就都明白了，intArray定义为int[10]这种数据结构的一个实例，可惜啊，C/C++目前并不支持这种定义方式。

　　2、数组名可作为指针常量

　　根据结论2，数组名可以转换为指向其指代实体的指针，所以程序1中的第5行数组名直接赋值给指针，程序2第7行直接将数组名作为指针形参都可成立。

　　下面的程序成立吗？

1. int intArray[10];
2. intArray++;
　　读者可以编译之，发现编译出错。原因在于，虽然数组名可以转换为指向其指代实体的指针，但是它只能被看作一个指针常量，不能被修改。 

　　而指针，不管是指向结构体、数组还是基本数据类型的指针，都不包含原始数据结构的内涵，在WIN32平台下，sizeof操作的结果都是4。
顺便纠正一下许多程序员的另一个误解。许多程序员以为sizeof是一个函数，而实际上，它是一个操作符，不过其使用方式看起来的确太像一个函数了。语句sizeof(int)就可以说明sizeof的确不是一个函数，因为函数接纳形参（一个变量），世界上没有一个C/C++函数接纳一个数据类型（如int）为"形参"。

　　3、数据名可能失去其数据结构内涵 

　　到这里似乎数组名魔幻问题已经宣告圆满解决，但是平静的湖面上却再次掀起波浪。请看下面一段程序：

1. #include <iostream.h>
2. void arrayTest(char str[])
3. {
4. 　cout << sizeof(str) << endl;
5. }
6. int main(int argc, char* argv[])
7. {
8. 　char str1[10] = "I Love U";
9. 　arrayTest(str1); 
10.　 return 0;
11. }
　　程序的输出结果为4。不可能吧？

　　一个可怕的数字，前面已经提到其为指针的长度!

　　结论1指出，数据名内涵为数组这种数据结构，在arrayTest函数体内，str是数组名，那为什么sizeof的结果却是指针的长度？这是因为：

　　(1)数组名作为函数形参时，在函数体内，其失去了本身的内涵，仅仅只是一个指针；

　　(2)很遗憾，在失去其内涵的同时，它还失去了其常量特性，可以作自增、自减等操作，可以被修改。

　　所以，数据名作为函数形参时，其全面沦落为一个普通指针！它的贵族身份被剥夺，成了一个地地道道的只拥有4个字节的平民。

二维数组可以用指向数组的指针代替，而指针数组才可以用指向指针的指针代替。

#include<iostream>
using namespace std;

void main()

{
char *a[]={"Hello","the","World"};

char **pa=a;

pa++;

cout<<*pa;
}

类型确定的数组，元素的类型和元素的个数是确定的；
数组退化为对应的指针，元素的类型保持一致；
所谓的二维数组只是数组的数组。
因此二维数组不能退化为二级指针，而只能退化为指向一维数组的指针

#include<iostream.h> 
void main()

{ 

 inta[2][3];

 int**p=a;

}  请问为什么是错误的？？（请不要说数组名是一个指针这个我知道，我想知道为什么不能用二级指针指向二维数组）

   其实这个数组与指针的问题，要写的话，一句话，两句话是将不清楚的。首先数组和指针的概念你没分清楚，数组的本质你没搞清楚。这是导致问题出现的根源。  int x[5]; 这个定义里面，我们说定义了一个数组x，此数组有5个数组元素，元素的类型为int类型。首先要问的是，x到底为什么东西? 我知道，在谭浩强的书上面说x是数组名，x代表了数组第一个元素的首地址。没错，x确实是数组的名字，x的值也确实是第一个数组元素的地址值。注意这里我们说x代表的值与数组第一个元素的地址值相等，但是并不是说他们的类型是一样的。那么x的类型到底是什么呢? 有人说就是int * 类型。有如下语句可以做证：

                         int *p=x; //这句话是正确的。 

    x的类型真是int *吗，我们说不是，因为下面的语句是不正确的： 

                         int a=10; x=&a; // int *类型的变量时可以接受值的。

   所以x不是int*  那么我们可以猜测x的类型是不是 int *const呢。也就是说x是一个地址值不可以改变的指针。这句话貌似有点正确。但是请大家看看下面的例子：

                         int x[5]={0}; int a=sizeof(x); // a的值到底是多少?

   实际上这里a的值是5*4=20 我这里使用的编译器是VC++ 6.0 int类型数据占用4个字节空间，所以这里的道的是整个数组占用的字节数。 我们不是说x的类型是iint * const类型的吗，也就是x应该是一个指针类型，应该是4个字节的啊，为什么sizeof出来时整个数组占用的字节数呢。例如  sizeof(int *)这个的结果就是4。所以有此可以看出，x的类型并不是int*,也不是int * const。  i

   int x[5];中的x到底是什么呢，我们说x是数组，此数组有5个元素，并且每个元素都是int类型。 我们有一个识别数据类型的规律例如：  int x; //x类型为int 

       int *x;//x类型为int * 

       int **x;//x类型为int ** 

       int (*x)[10];//x类型为int(*)[10]实际上是指向数组的指针 

       int (*x)(int ,int);//x的类型为int(*)(int,int)实际上是指向函数的指针  

   由此可以看出，一个符号是什么数据类型，我们只要在其定义的表达式中去掉符号本身，剩下的就是符号的类型了。照此推断，int x[5];中x的类型应该是 int [5]这个类型，可以看出此类型并不是int *类型。  那么int x[5];中的x可以这样赋值: int *p=x; 为什么呢，只能说这里面将x的类型隐式转换为了int *类型。所以这里是可以赋值的，因为进行了类型转换。 再请看下面的例子：  void function(int x[5]) {   cout<<sizeof(x)<<endl; //这里输出4 }  为什么会输出4，而不是4*5呢，可以看出上面的函数形参实际上类型是int*，并不是数组类型，所以我们在定义函数的时候，下面的都是与上面等价的：  

void function(int x[])//元素个数是多少可以省略 {   cout<<sizeof(x)<<endl; //这里输出4 }  void function(int *x) //直接写成指针变量也没错 {   cout<<sizeof(x)<<endl; //这里输出4 }  

   他们都是等价的。 

   那么我们看一个类似的问题： int x[5]; int **p=&x; //为什么会报错？ 因为类型不匹配。  p的类型是int **,而&x的类型却不是int **。 &x的类型实际上是int(*)[5]，因为去的是x的地址，也就是说这个地址是数组的地址，并不是指向数组第一个元素的指针的指针(也就是二维指针)，而是整个数组的地址。所以我们可以改成下面的： int (*p)[5]=&x;//这就对了。 

   指向数组的指针，和指向数组元素的指针有什么不同？  我们说对于一个指针变量，要几点是我们必须注意的，例如int *p;我们要注意的是，p的类型是int*，p占用的空间4个字节，p指向的数据类型是int。p指向的数据类型占用4个字节。所以对于指针变量，我们要明白指针变量本身是占用空间的，本身是有类型的，其次指针变量所指向的空间是有类型的，是有空间的。  那么int *p; char *p1; 对于指针变量来说p,p1里面都放的是地址值，说白了就是一个数值，他们都占用4个字节的空间，但是他们的类型不一样，p里面的地址指向的是int类型的数据，p1指向的是char类型的数据，这主要体现在p++与p1++中他们在内存中移动的字节数是不一样的，我们假设int占4个字节，char占1个字节。那么对于p来说向前移动了4个字节，p1来说移动了一个字节。这就是他们的类型不同，导致运算过程中的不同。 int x[5]; 

     int (*p3)[5]; 此时p3指向数组x，那么p3++实际上向前移动了多少呢，可以算出移动了4*5个字节。也就是p3指向的是一个数组，是整个数组，所以p3移动的时候是将一个数组当做一个整体来看待的。所以向前移动了一整个数组的距离。  再看你的问题之前，我们来看一个类似的问题：  

      int a[2][3]; int**p=&a; //这里我用&a来赋值行不行呢。是不行的。  这里为什么是错误的，原因就是因为&a的类型不是int**类型。所以类型不兼容，导致不能赋值，同时这两种类型是不可以相互转换的。 那么&a到底是一个什么样的类型呢。 我们说&a去的是整个数组的地址，那么&a自然就是指向整个数组的指针了。 int (*p)[2][3]=&a; 此时这样赋值才是正确的。如果我们要用a直接赋值，那该定义一个什么样的变量来接受它呢，首先要明白，数组名代表的地址类型是指向数组的第一个元素的指针，例如：  int a[10]; int *p=a; 实际上这里与 int *p=&a[0];是等价的。因为指向a[0]的指针类型就是int*类型。  那么&a的是去数组的地址，其类型是指向数组的指针，而不是指向数组第一个元素的指针，整个是要区别的，他们的类型就不一样。 int(*p)[10]=&a;  所以说这里的a和&a绝对不是同一个东西，虽然本质上他们的地址值是一样的，但是他们的类型不一样。就决定他们代表不同的意义。  那么刚刚说了对于下面的例子： int a[2][3]; int (*p)[2][3]=&a;//我们可以定义这样的一个变量p来接受&a的值。  那么我们要接受a应该定义一个什么样的变量呢。a[2][3]是一个二维数组，可以看成是这样的a是一个数组，具有两个元素，分别为a[0],a[1]其中这两个元素的值a[0],a[1]他们的值又是一个具有3个元素的数组。此时我们可以将a[0],a[1]看成是数组名，那么a[0][0]就是数组a[0]的第0个元素了。对应关系如下： a[0] ---->  a[0][0],a[0][1],a[0][2] a[1] ---->  a[1][0],a[1][1],a[1][2]  那么a到底是什么，其实a数组有两个元素，a[0],a[1]，那么a的值自然就是其第一个元素的地址了，也就是&a[0]了。这是一个什么类型？  我们知道如果我们将a[0]看成一个整体，例如我们用A来代替a[0],那么A[0],A[1]就相当于a[0][0],a[0][1] 。 此时A就是一个int类型的数组，&A，的类型实际上就是 int(*p)[3]这个类型。  所以下面的代码也是正确的：    int a[2][3];  int(*p)[3]=a; //所以对于你的问题，可以这样子。。 

转载地址：

http://www.jb51.net/article/41108.htm

http://www.cnblogs.com/stoneJin/archive/2011/09/21/2184211.html

http://blog.csdn.net/thinkinwm/article/details/8112962

http://col1.blog.163.com/blog/static/1909775192012514111830946/