一个函数形如：
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是一个指向一维数组的指针的指针,那么我们就可以把它做为数组名来操纵整个数组了.
-----------------------------------------------------------------------------------------------------------------------------------
看如下例子：
#include <stdio.h>
int main(void)
{
int array[2][2] = {12, 15, 51, 54};
int **ptr = array; //错误
int **ptr = &array; //错误
int **ptr = &array[0][0]; //错误
....
return 0;
}
错误在哪呢？
关于指针的说明：
0） 指针只能指向一维数组。
1） C/C++标准中并没有 array[m][n] 这样的表达//array为指针变量；
2） 不能用一维指针或二维指针直接指向二维数组。如果要让一维指针指向二维数组，则我们必需告诉指针所指向的数组的最后一维包含多少个元素，即告诉指针我们将传递一个二维数组的首地址给指针。如上面的例子，应该这样来定义指针：int (*p)[4]；这样就可以用p=mat了；这是不是和我们上面说的"指针只能指向一维数组"相矛盾呢？不是的。其实指针指向的还是一维数组：这时我们是将每行当成一个元素！！指针即所谓的行指针。
3） 如果没有告诉指针所指向的数组是二维的（即定义行指针），显然指针不能接收二维数组名传来的地址，即p=mat的两边地址的类型不同，左边是一维的，右边是二维的。但是如果我们将二维数组看成是一维数组，那么这个一维数组的首地址是：mat[0]，所以我们可以用p=mat[0];这样指针对二维数组的引用将完全按照一维数组的引用方式来调用。
来自：http://wenda.tianya.cn/wenda/thread?tid=441b3214f83b083f
我们知道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[i]那样来同样输出字符串呢?很明显是不行的,编译器不会把
pArray+i处理成pArray+i*3寻找到第i个指针的地址,而只是简单的加了一个i.这说明编译器只做了很简单的将地址值赋给
了pArray,而它实际没有任何意义.我们不能用它来访问任何数据.很奇怪吗?
再来看看这样定义char *p[] = {“ab“, “cd“, “ef“};定义了一个指针数组.char **sp = p;这样的用法经常看到,为什么这样
就可以使用sp[i]来访问字符串了呢,的确编译器在编译的时候识别出了sp是一个指向一维数组的指针的
指针,那么我们就可以把它做为数组名来操纵整个数组了,c神奇的地方或者说精华的地方就在这里了,希望
这篇文章对那些对指针或二级指针有疑惑的朋友能够有所帮助,这也是我blog里的第一篇文章,呵呵.
来自：http://www.wangchao.net.cn/bbsdetail_59198.html
---------------------------------------------------------------------------------------------------------------
本来不想写什么的，但是看看，我觉得都没有我想要的答案，于是我像楼主推荐我的拙见。其实这个数组与指针的问题，要写的话，一句话，两句话是将不清楚的。
首先数组和指针的概念你没分清楚，数组的本质你没搞清楚。这是导致问题出现的根源。
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。
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; //所以对于你的问题，可以这样子。。
明白了吗？
-----------------------------------------------------------------------------
简单地说说，数组与指针的区别吧
int a[5];//组数a，a代表数组首地址，记住，是地址
int *p;//p，有一个四字节的空间，其中的内容是地址
a = 5;//错误，因为a没有存储空间，它就是一个地址而已
p = 0x1234;//OK,p有存储空间
当数组与指针声明于函数参数时，
void fun(int a[]);
void fun(int* p);//p和a一个意思
--------------------------------------------------
无论是二维，还是一维在内存中都是一样的，都是从低到高的地址序列
我认为函数应该这样定义
void fun(char *p, int rows,int lines)//p是二维数组的地址（也就是第一个元素的地址）
//rows是行，lines是列
在 fun()中，要自己编算法把它还原成二维数组
调用时可以这样
char a[2][2];
void main()
{
fun((char *)a,2,2);
//fun(&a[0][0],2,2);
}
如果fun()函数传递的二维数组大小是固定的，可以这样声名
char fun(char a[5][5])
{
return a[3][3];
}
void main()
{
char a[5][5];
fun(a);
}
原则是：静态的申请数组时，必须给定数组的大小
----------------------------------------------------------
转为1维的 双参数
void fnct ( double *p,int row, int col )
{
for(int i=0;i <row*col;i++)
{
cout < <p[i] < <endl;
}
}
int main()
{
double A[3][2] = { {1},{2},{3} };
fnct((double *)A,3,2);
return 0;
}
------------------------------------------------------------
1维通用接口
void a(int *, int, int);
int main(void)
{
int c[2][5], b[6][8];
......
a((int*)c, 2, 5); //使用数组c
.........
a((int*)b, 6, 8); //使用数组b
....
return 0;
}
void a(int *cpSource, int iRow, int iColumn)
{
int **cpTemp, i;
cpTemp = (int**)malloc(iRow*sizeof(int*));
for(i=0; i<iRow; ++i) cpTemp[i] = cpSource+i*iColumn;
cpTemp[i][j] = ...... //然后就可以cpTemp[i][j]这种形式使用了
/*释放*/
for(i=0; i<iRow; ++i) free(cpTemp[i]);
free(cpTemp);
return;
}
================================================
1维 单参数
const int N = 4;
void Fun1(int (*a)[N])
{
}
void Fun2(int a[][N])
{
}
int main()
{
int a[N][N];
Fun1(a);
Fun2(a);
}
1928
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
