二维数组详解

二维数组指针

 概括的说，指针其实就是可变数组的首地址，说是可变数组，是
指其包含内容的数量的可变的，并且是可动态申请和释放的，从而充
分节约宝贵的内存资源。我一向喜欢一维数组，除非万不得已，我一
般是不用二维数组的，多维的则更是很少涉足了。因为一维简单，容
易理解，而用指针指向的多维数组就具有相当的复杂性了，也因此更
具有讨论的必要。
    闲话少说，这里我就以三个二维数组的比较来展开讨论：
    (1)、int **Ptr;
    (2)、int *Ptr[ 5 ];
    (3)、int ( *Ptr )[ 5 ];
    以上三例都是整数的二维数组，都可以用形如 Ptr[ 1 ][ 1 ] 的
方式访问其内容；但它们的差别却是很大的。下面我从四个方面对它们
进行讨论：
    一、内容：
       它们本身都是指针，它们的最终内容都是整数。注意我这里说
的是最终内容，而不是中间内容，比如你写 Ptr[ 0 ]，对于三者来说，
其内容都是一个整数指针，即 int *；Ptr[ 1 ][ 1  ] 这样的形式才
是其最终内容。
    二、意义：
       (1)、int **Ptr 表示指向"一群"指向整数的指针的指针。
       (2)、int *Ptr[ 5 ] 表示指向 5 个指向整数的指针的指针。
       (3)、int ( *Ptr )[ 5 ] 表示指向"一群"指向 5 个整数数
组的指针的指针。
    三、所占空间：
       (1)、int **Ptr 和 (3)、int ( *Ptr )[ 5 ] 一样，在32位平
台里，都是4字节，即一个指针。
       但 (2)、int *Ptr[ 5 ] 不同，它是 5 个指针，它占5 * 4 = 20
个字节的内存空间。
    四、用法：
       (1)、int **Ptr 
       因为是指针的指针，需要两次内存分配才能使用其最终内容。首
先，Ptr = ( int ** )new int *[ 5 ]；这样分配好了以后，它和(2)的
意义相同了；然后要分别对 5 个指针进行内存分配，例如：
  Ptr[ 0 ] = new int[ 20 ];
  它表示为第 0 个指针分配 20 个整数，分配好以后， Ptr[ 0 ] 为指
向 20 个整数的数组。这时可以使用下标用法 Ptr[ 0 ][ 0 ] 到
Ptr[ 0 ][ 19 ] 了。
      如果没有第一次内存分配，该 Ptr 是个"野"指针，是不能使用
的，如果没有第二次内存分配，则 Ptr[ 0 ] 等也是个"野"指针，也
是不能用的。当然，用它指向某个已经定义的地址则是允许的，那是另外
的用法（类似于"借鸡生蛋"的做法），这里不作讨论（下同）。
      (2)、int *Ptr[ 5 ]
      这样定义的话，编译器已经为它分配了 5 个指针的空间，这相当
于(1)中的第一次内存分配。根据对(1)的讨论可知，显然要对其进行一次
内存分配的。否则就是"野"指针。
      (3)、int ( *Ptr )[ 5 ]
      这种定义我觉得很费解，不是不懂，而是觉得理解起来特别吃力，
也许是我不太习惯这样的定义吧。怎么描述它呢？它的意义是"一群"
指针，每个指针都是指向一个 5 个整数的数组。如果想分配 k 个指针，
这样写： Ptr = ( int ( * )[ 5 ] ) new int[ sizeof( int ) * 5 * k ]。
这是一次性的内存分配。分配好以后，Ptr 指向一片连续的地址空间，
其中 Ptr[ 0 ] 指向第 0 个 5 个整数数组的首地址，Ptr[ 1 ] 指向第
1 个 5 个整数数组的首地址。
   综上所述，我觉得可以这样理解它们：
   int ** Ptr <==> int Ptr[ x ][ y ];
   int *Ptr[ 5 ] <==> int Ptr[ 5 ][ x ];
   int ( *Ptr )[ 5 ] <==> int Ptr[ x ][ 5 ];
   这里 x 和 y 是表示若干的意思。

 

问题：cannot convert from 'double [10][10]' to 'double ** '
例如：double arry[5][10] = {0};        double** pp;

           pp=arry;

           直接的赋值会提示错误：cannot convert from 'double [10][10]' to 'double ** '

解决方法：

          double arry[5][10] = {0};        double (*p)[5];

         

          for(int i=0;i<5;i++)

                p[i]= arry[i];

          这样既可解决问题。

 

分析参考如下（转载）：

一个函数形如：
void f(float **p){
/* 想要在函数体中按二维数组的方式访问*/
    p[1][1] = 0;//c++用vc编译ok，运行出错（非法访问）
}

float **p; //其实这里的p并不是一个二位数组的指针，只不过是一个指向指针的指针
像你这样访问肯定是会出问题的。

例如：
float a[2][2]={0，1，2，3};
float **p=(float**)a;//强制将二维数组指针转为指向指针的指针
则此时

p[0]=0;

p[1]=1;

p[2]=2;

p[3]=3;

而

p[0][0]=*(*(p+0)+0)=**p；

p[0][1]=*(*(p+0)+1)；

对于p[0][0]：由于*p=0; ====> **p=*(0);引用地址为零的内存，必然是错误的。

对于p[0][1]=*(*p+1)====>*(4),引用了非法内存

同样，对于p[1][0]=*(1)，p[1][1]=*(5),均引用了非法内存

所以说，二位数组并不能简单的转换成指向指针的指针。

正确的指向二维数组的指针应该是:

float a[5][10];

float (*p)[10];//只需要定义为指向第二维的指针，忽略第一维

p=a;

p[0][1]=a[0][1];

二级指针和二维数组并不等价。

二级指针是一个指向指针的指针
而二维数组其实就是一个指针，char a[3][4]； a是指向整个二维数组的首地址。它相当于(char *)[n],并不是char **;

所以不能直接：t=a;
要这样：t = (char **)a;

我们知道char array[]=”abcdef”; array是数组的首地址,
那么在二维数组中array当然也是数组的首地址,
看看这个定义char Array[][3] ={“ab“,“cd“,“ef“};
怎么知道的呢?定义这样一个数组,在vc调试窗口中
我们看到:
Array ---------0x64324234
|------Array[0]---0x64324234 “ab“
|------Array[1]---0x64324337 “cd“
|------Array[2]---0x6432433A “ef”
已经很明白了,实际编译器是这样实现二维数组的,实际上Array是“一维指针数组“的首地址,其中每一个元素指针都对应一个字符串,那么好我们来看看是否可以这样来使用Array二维数组.
char **pArray = Array;编译器提示出错,怎么办呢?加个(char **)试试,仍然出错,设断看一下pArray的值和Array的值是相等的,但我们是否可以象使用Array那样来同样输出字符串呢?很明显是不行的,编译器不会把pArray+i处理成pArray+i*3寻找到第i个指针的地址,而只是简单的加了一个i.这说明编译器只做了很简单的将地址值赋给了pArray,而它实际没有任何意义.我们不能用它来访问任何数据.很奇怪吗?
再来看看这样定义char *p[] = {“ab“, “cd“, “ef“};定义了一个指针数组.char **sp = p;这样的用法经常看到,为什么这样就可以使用sp来访问字符串了呢,的确编译器在编译的时候识别出了sp是一个指向一维数组的指针的指针,那么我们就可以把它做为数组名来操纵整个数组了.