c++二维数组和二级指针

Posted 2023-05-02

#include <iostream.h>
void main()

int a[2][3];
int**p=a;


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

类型不匹配，a 不是 int ** 类型的 ，虽然一维数组的数组名是一个指针 ，但是二维数组却不同 ，因为它所指向的东西是有大小的 ，举例来说 ，你这个 a 他是 int[2][3] 类型的 ， 编译器需要知道要操作的单元的大小，就是说如果你用 p++; 的话编译器要能知道移动多少个字节，所以说可以改为：
int (*p)[3] = a ;
这样的话 p 所指向的每个数据单元大小便明确了 参考技术A char x[3]，此x是什么类型？答曰：char[3]类型，即此类型的变量内存组织形式为三个连续的char变量，sizeof(a)值为3，这就是一维数组，其实写char[3] x这种更合适。C语言里没有二维数组，或者说是由一维数组实现的。a[2][3]即是存储两个char[3]类型的元素（不是指针，之前说错了），承接上面说的，定义成char[3] a[2]更合适。如果char a[3]这样定义的a可以退化成指针char *的话，那么char[3] a[2]中的a就应该退化成char (*)[3]，事实也是如此。
char ** 与char (*)[3]，类型差得还是比较远的(编译器认为)，当然强制转换的话任何指针都是可以互相转换的。 强制转换的话，二级指针可以指向二维数组，但注意不要越。甚至一维指针也是可以的，如
int a[2][3] = 1,2,3,4,5,6;
int i=0;
int * p = (int *)a;
for(;i<6;++i)
printf("%d",*(p++));
绝对正确打印123456，因为二维数组实际上也是一段连续的内存，即int a[2][3]在内存上完全等价于int a[6]，如果首地址相同的话。
PS：
动态申请二维数组方法如下：
char **p;
int x,y;//程序运行时初始化
...
p = new (char *)[x];
for(i = 0;i<x;++i)
p[i] = new char[y]; 参考技术B 指针必须指向指针类型的值，否则编译器会提示出错。
int**p =a的效果为：*p=&a[0],或p=&(&a[0]))，但你要注意，&a[0]是a[0]的地址，而不是一个变量或常量，你问他地址，把它赋给p，编译器也不知道给你什么值啊 参考技术C 类型不匹配，一个是双重指针，一个是指针。

int **p=(int **)a;就可以了 参考技术D 本来不想写什么的，但是看看，我觉得都没有我想要的答案，于是我向楼主推荐我的拙见。其实这个数组与指针的问题，要写的话，一句话，两句话是讲不清楚的。

首先数组和指针的概念你没分清楚，数组的本质你没搞清楚。这是导致问题出现的根源。

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的类型是int * const类型的吗，也就是x应该是一个指针类型，应该是4个字节的啊，为什么sizeof出来是整个数组占用的字节数呢。例如

sizeof(int *)这个的结果就是4。所以由此可以看出，x的类型并不是int*,也不是int * const。

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就是一个具有3个int类型元素的数组，&A的类型实际上就是 int(*p)[3]这个类型。

所以下面的代码也是正确的：

int a[2][3];
int(*p)[3]=a; //所以对于你的问题，可以这样子。。

明白了吗？

二维数组和二级指针关系浅析

　　昨天写了关于一级指针的见解，即二级数组的用法和二级指针差不多，关于数组指针和指针数组这两个是不同的概念，这一点我们一定要清楚；

　　数组指针我们可以理解为指向数组的指针，就是一个指针；

　　指针数组则可以理解为数组里存的是指针，即每个储存空间上储存的是指针变量；这里储存了多个指针

　　一个数组可以这样定义 char a[3];分配了3个字节的内存

　　二维数组可以这样定义 char b[3][3];分配了3*3 即9个字节的内存

　　我们知道一维数组和一级指针的用法差不多，那么二级指针有和二级指针有什么关系呢？

{

　　char a[3][3];定义一个二维数组

　　//二维数组我们可以理解为它是由一维数组组成，比如这个二维数组可以看成是由三个一维数组构成，而每个一维数组里分配了三个字节的空间

　　//每个一维数组都分配了一个头地址a[0]是第一个数组的地址，a[1]是第二个a[2]是第三个，下标是从0开始的；

　　int i = 0;

　　char b[3];//定义一个一维数组

　　char *c;//定义一个一级指针

　　//我们知道可以直接将数组的头地址直接赋给一级指针，那么我们可不可以也将二维数组的头地址赋给一个指针呢？于是便有了数组指针，即指向数组的指针

　　char *d[3];//定义一个数组指针，指针指向的空间只有3个字节，这是一个二级指针

　　c = b;//将指针指向一维数组

　　d = a;//将数组指针指向二维数组

　　printf("%d\n",sizeof(*d));//算出b所指向空间所分配的内存大小即3和数组指针的分配有关，如char *d[5] 则为5

　　//我们可以通过指针往数组里copy数据

　　for(i = 0 ; i  < 3 ; i++)

　　{

　　　　strcpy((b+i),"aa");

　　}

 

//通过指针来

　　for(i = 0 ; i < 3; i++)

　　{

　　　　printf("%s\n",(b+i));//b+i 每次会向后移动三个字节

　　}　

 

//通过数组来

for(i = 0 ; i < 3; i++)

　　{

　　　　printf("%s\n",a[i]);//a[i] 每次会向后移动三个字节

　　}　

　　

}

　　写到这里我想大家应该可以明白二维数组是可以用二级指针来表示的；当然这里我们还是不明白为什么二维数组可以和二级指针的用法 一样，这一点我们以后再说，总之现在我们可以了解二维数组可以像二级指针一样使用，它们的用法是差不多的；