指针数组和二维数组,指针数组是2维数组吗

指针数组和二维数组,指针数组是2维数组吗详细介绍

本文目录一览： 指针数组是2维数组吗

指针数组的是几维的，要看怎么声明了，跟普通的数组一样，只是他们的元素是指针，声明的时候，前面多了个*号。
比如：
int *p[3],a[2];//p是一维的指针数组，a是一维的数组
int *p[3][2],a[2][3];//p是二维的指针数组，a是二维的数组
有二维有一维，多维也可以，只是每个单元格里面存的是指针罢了
2维和指针数组是两回事
指针数组可以看成指针的一维数组
数组的维数要看[]的个数
a[i] 一维
a[i][j] 二维
不是，完全不是，指针数组就是一个容纳指针的顺序存储结构，无他。
coid *p[];
*p[n]是一维数组，*p[][n]是二维数组（其中[]中的数可写可不写，因为[]代表行指针，[n]一定要写，因为[n]代表列指针）。
OK？
不是。
指针是指针，数组是数组。它们用法很相似，但逻辑上并不是一体，从面象对象角度看，两者区别极大。
只从使用上说，指针很容易发生内存违规，而数组有限。
指针是栈操作，而数组是堆操作。
所以指针数组也不是2维数组。

请问二级指针，二维数组，数组指针的区别

//解答如下二级指针：指向指针的指针，它存放的是一级指针的地址。int *p;int **q;q = &p; //把一级指针p的地址赋值给二级指针q。二维数组：int arr[4][5]; //定义了一个4行5列的数组数组指针：指向数组的指针。int arr[4][5];int (*p)[5]; //指针p是指向数组的指针,你可以理解为指针p是二维数组的行指针。p=arr;还有一种就是指针数组，即数组元素都是指针变量int *p[5];int **q;q=p; //二级指针q指向了指针数组p的首元素，它的首元素是指针p[0]。

C语言中二维数组名是不是可以看作指针数组名？

例如：
二维数组名是一个指针，但是说它是常量的意思是它本身不可更改：如你定义int a[34][3]，a确实是个指针，*a指向数组中第一个整数；但是你不能通过a++操作使在此操作后a指向数组中第二个整数，而普通指针(int a[12];int *b=a;b 就是普通指针)可以这么操作的，所以说它是“指针常量”；
二维数组的名称就是指针的指针， 对于一维数组，它的数组名，就是它存放内存的首地址
不可以，二维数组要看做“数组的数组”。
（以如下定义为例：int a[4]; int * p;）
给你个对于指针和数组的正确理解吧：
定义的不同：C 里，指针和数组是不同的类型，不要把数组名看做“常指针”。所以 sizeof(a) 和 sizeof(p) 值是不同的。
容易被混淆的原因：a. 都有基础类型。b. 数组（或者叫数组名）可以默认转化为指针，值为数组首地址。这就像 int 可以默认转化为 double 一样。
操作：除声明外，中括号操作符仅用于指针，如 p[0]，p[5] 等。当使用 a 时，要看做 (int*)a 。比如 a[0] 要看做 ((int*)a)[0] ， *a 要看成 *(int*)a 。（除 sizeof 以及类似操作以外）
所谓的“二维数组”，“二级指针”，“指针数组”，以及“数组指针”的理解应该为：
基础类型为数组的数组，
基础类型为指针的指针，
基础类型为指针的数组，
基础类型为数组的指针。
比如二维数组定义为 int b[3][4]; ，可以看做：
typedef int A[4];
A b[3];
其它类推。
不知道表述清楚了没，有疑问加评论吧。

请教C++二维数组和指针的简单问题。

1.设有int a[3][2] ={1,2,3,4,5,6}, (*p)[2]=a1;则*(*(p+2)+1)的值是__1__。
答案6
问题：有人说，p是含有两个元素的一维数组，怎么是含有两个元素呢？
然后请解释一下(*p)[2]=a1，*(*(p+2)+1和求解过程
int a[3][2] ={1,2,3,4,5,6},严格表示应该为：
int a[3][2] ={
{1,2}, //a[0]
{3,4}, //a[1]
{5,6} //a[2]
}, 三组数，每组两个
int (*p)[2]=a1的正确写法为：int (*p)[2]=a[0] ; p是指针，其所指向的地址中的数据类型为“两个int”，即p指向的地址中的数据可以看成是 “一个含有两个元素的数组" 。这样描述，你应该可以看的懂。
p+0 ------->a[0]
p+1 ------->a[1]
p+2-------->a[2]
*(p+2) 指向a[2][0]的地址
*(p+2)+1指向a[2][1]的地址
*（*(p+2)+1）就是a[2][1]的值 = 6
2,.
有二维字符数组char s[4][6]={"zhang","gao","tang","wang"},执行程序cout<<*s[2],屏幕上显示 ( )。
A gao B tang C g D t 答案B
问题：*s[2]是什么呢？ 怎么求出来是s[0][2]的值呢？？
s[0]指向"zhang"
s[1]指向"gao"
s[2]指向"tang"
s[3]指向"wang"
*s[2]就是指s[2]的第一个数值 t，所以答案应该是D
首先要先搞明白指针是什么
然后要搞明白数组名是什么
再搞清楚数组与指针的关系
然后再去研究多维数组的概念
再去研究多维数组与指针的关系
最后再研究数组指针的概念
1、(*p)[2]是个数组指针，p是个指针，指向一个2个元素的一维数组，关于数组指针你可以去百度一下，这里也不怎么说的清楚，*(*(p+2)+1就等价于p[2][1],也就是求a[2][1]
2、答案不是B，应该是D，*s[2]等价于s[2][0]，也就等价于*(*(s+2))，同样等价于*(*s+12)，如果输出为B，应该cout<
<s[2]，或者*(s+2)，就是说cout一个地址或指针，才会输出整个字符串
第一个不完整吧。

2，你可以看一下二维数组的初始化，s[i](i=0,1,2,3)都是char*类型的指针。

第一个题盲点实在是太多了。p的定义呢？a1又是什么？

第二题

主要是明白*s[2]这个是什么。其实有两个操作符，一个是解引用操作符*；另外一个是下标操作符[]。查一下优先级吧。应该先是下标操作所以*s[2]变成了*(s[2])。

那么s[2]是什么呢？其实由定义char s[4][6]可以明白。s中存放的是指向字符串的指针。s[2]是一个指针，指向一个字符串。由下标是2，指向的是"tang"这个字符串。对这个字符串解引用可得第一个字符t。答案是错误的，应该是D

int main(int argc, char *argv[]){ char s[4][6]={"zhang","gao","tang","wang"}; cout<<*s[2]<
<endl; cout<<s[2]<<endl; cout<<(*s)[2]<<endl; return 0;}

</s[2]，或者*(s+2)，就是说cout一个地址或指针，才会输出整个字符串

C语言指针指向一维数组与二维数组？

(三)应该报错的：error: cannot convert ‘double (*)[3]’ to ‘double*’ in initialization.
先回答(2)：其实（二）和（三）一个意思，都不正确。(三)在你那里不报错估计是编译器环境的原因。
对于问题(1)，在于能否正确理解二维数组名的含义。
二维数组名data表示第0行的地址；*data表示data[0][0]的地址；而**data才表示data[0][0]的值。
可以看一下该博文：二维数组中数组名与其指针的关系
3和2是一样的，也是会报错的。
可以使用行指针double （*p）[3]=data;指向数组第0行，也就是我们平常理解的第一行。
访问方式，假设data是i行j列，*(*(p+i)+j)就是第i行j列的元素值，也就是data[i][j]的值。
也可以使用列指针double *p = data[0]指向第0行0列，访问方式如下：

数组指针的指向一维数组和二维数组的区别

一、指向一维数组的指针变量设一维数组为a[n]定义方法：*指针变量名即*P这个p一般指向的一维数组的首地址，即p=a，或者p=&a[0]；p,a,&a[0]均指向同一单元，它们是数组a的首地址，也是0号元素a[0]的首地址。p+1,a+1,&a[1]均指向1号元素a[1]。类推可知a+i,a+i,&a[i]。例子：main(){　　inta[5],i,*pa;　　pa=a;　　for(i=0;i<5;i++){　　*pa=i;　　pa++;　　}　　pa=a;　　for(i=0;i<5;i++){　　printf(a[%d]=%d\n,i,*pa);　　pa++;　　}　　}　　二、指向二维数组的指针变量设一维数组为a[m][n]定义方法：(*指针变量名)[长度]即（*P）[n]“长度”表示二维数组分解为多个一维数组时，一维数组的长度，也就是二维数组的列数。1、多维数组有关概念注意a[0]，a[1]，a[2]表示的都是对应那行的数组首地址，和数组名，而不是一个元素多维数组地址的表示方法　　设有整型二维数组a[3][4]如下：　　0123　　4567　　891011　　设数组a的首地址为1000，各下标变量的首地址及其值如图所示。在第四章中介绍过，C语言允许把一个二维数组分解为多个一维数组来处理。因此数组a可分解为三个一维数组，即a[0]，a[1]，a[2]。每一个一维数组又含有四个元素。例如a[0]数组，含有a[0][0]，a[0][1]，a[0][2]，a[0][3]四个元素。数组及数组元素的地址表示如下：a是二维数组名，也是二维数组0行的首地址，等于1000。a[0]是第一个一维数组的数组名和首地址，因此也为1000。*(a+0)或*a是与a[0]等效的，它表示一维数组a[0]0号元素的首地址。也为1000。&a[0][0]是二维数组a的0行0列元素首地址，同样是1000。因此，a，a[0]，*(a+0)，*a，&a[0][0]是相等的。同理，a+1是二维数组1行的首地址，等于1008。a[1]是第二个一维数组的数组名和首地址，因此也为1008。&a[1][0]是二维数组a的1行0列元素地址，也是1008。因此a+1,a[1],*(a+1),&a[1][0]是等同的。由此可得出：a+i，a[i]，*(a+i)，&a[i][0]是等同的。此外，&a[i]和a[i]也是等同的。因为在二维数组中不能把&a[i]理解为元素a[i]的地址，不存在元素a[i]。　　C语言规定，它是一种地址计算方法，表示数组a第i行首地址。由此，我们得出：a[i]，&a[i]，*(a+i)和a+i也都是等同的。另外，a[0]也可以看成是a[0]+0是一维数组a[0]的0号元素的首地址，而a[0]+1则是a[0]的1号元素首地址，由此可得出a[i]+j则是一维数组a[i]的j号元素首地址，它等于&a[i][j]。由a[i]=*(a+i)得a[i]+j=*(a+i)+j，由于*(a+i)+j是二维数组a的i行j列元素的首地址。该元素的值等于*(*(a+i)+j)。

比较用指针数组处理多个字符串与用二维字符数组处理多个字符串的优缺点

指针数组内存利用率更高，字符窜长度不用相同，但是内存分配是动态的，速度比较慢；
2维数组内存是在栈上分配的，速度较快，但占用空间较大。
用指针数组可以更方便，举个例子给你，假如你要到某栋单元房找一个叫李四的人，他住在A#408;
如果你用的是二维数组的话，你应该是A[8][8],而用指针数组*A[8],你要找他，就要用到循环，for();
如果是二维数组你要找多少回，你自己可以想象，而且当你找到A了，你是不是每次都还要回到A[k][0]来找408呢？如果是用指针数组的话，你只要找到了*A就找到了他的第一个地址变量，这时候你就可以直接去找408，而不用在回到A[k][0]去了，这里的k指的是A在数组里的下标，其实指针数组只是比二维数组处理数据起来方便，要是用不好就会让指针指错地方，我建议能用二维数组解决的尽量不要用指针数组。最后建议你去看看清华大学出版社出版的谭浩强老师的c语言教程，那里有很详细的说明，也可以，看看数据结构。回答的不好，希望见谅，希望能对你有所帮助

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

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];

指针必须指向指针类型的值，否则编译器会提示出错。

int**p =a的效果为：*p=&a[0],或p=&(&a[0]))，但你要注意，&a[0]是a[0]的地址，而不是一个变量或常量，你问他地址，把它赋给p，编译器也不知道给你什么值啊

类型不匹配，一个是双重指针，一个是指针。

int **p=(int **)a;就可以了

类型不匹配，a 不是 int ** 类型的 ，虽然一维数组的数组名是一个指针 ，但是二维数组却不同 ，因为它所指向的东西是有大小的 ，举例来说 ，你这个 a 他是 int[2][3] 类型的 ， 编译器需要知道要操作的单元的大小，就是说如果你用 p++; 的话编译器要能知道移动多少个字节，所以说可以改为：

int (*p)[3] = a ;

这样的话 p 所指向的每个数据单元大小便明确了
</x;++i)

c＋＋指针数组怎么用，还有指针数组和数组指针

名字可能拗口一点。增加一个”的“就好理解了：”指针的数组“和”数组的指针“。
”指针的数组“和”整型的数组“类似，就是指一个数组，其中每一个元素是指针类型。从数组中取出一个元素（指针）后，再根据这个元素(指针)的指向地址，对实际的内存空间进行操作。
”数组的指针“，就是指一个数组的首元素的地址，数组中保存的元素不知道是什么类型（整型、浮点型、指针型都有可能）。
这个 你主要看后面两个字，指针数组是数组，每一个元素是指针，而数组指针，是指针，是指向数组的指针
指针的数组和整型的数组是指一个数组，其中每一个元素是指针类型；
数组的指针是指一个数组的首元素的地；
参考实例应用如下：
//注意指针数组和数组指针分别是如何指向二维数组的；
#include

main()

{

static int m[3][4]={0,1,2,3,4,5,6,7,8,9,10,11};/* 定义二维数组m并初始化*/

int (*p)[4];//数组指针 p是指针，指向一维数组,每个一维数组有4个int元素

int i,j;

int *q[3];//指针数组 q是数组，数组元素是指针，3个int指针

p=m; //p是指针，可以直接指向二维数组

printf("--数组指针输出元素--/n");

for(i=0;i<3;i++)/*输出二维数组中各个元素的数值*/

{

for(j=0;j<4;j++)

{

printf("%3d ",*(*(p+i)+j));

}

printf("/n");

}

printf("/n");

for(i=0;i<3;i++,p++)//p可看成是行指针

{

printf("%3d ",**p);//每一行的第一个元素

printf("%3d ",*(*p+1));//每一行的第二个元素

printf("%3d ",*(*p+2));//每一行的第三个元素

printf("%3d ",*(*p+3));//每一行的第四个元素

printf("/n");

}

printf("/n");

printf("--指针数组输出元素--/n");

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

q[i]=m[i];//q是数组，元素q[i]是指针

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

{

for(j=0;j<4;j++)

{

printf("%3d ",q[i][j]);//q[i][j]可换成*(q[i]+j)

}

printf("/n");

}

printf("/n");

q[0]=m[0];

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

{

for(j=0;j<4;j++)

{

printf("%3d ",*(q[0]+j+4*i));

}

printf("/n");

}

printf("/n");

}

一维一级指针数组实际上都是二维数组

不对。它就是一维数组，每个元素都是指针！这些指针元素要是都分别指向了一些一维数组，似乎有点像二维数组了，但实质也不是：二维数组的元素在内存中是连续存放的，而一维指针数组的指针元素指向的一维数组之间在内存中完全可以不连续存放。且，一维指针数组的指针元素也完全可以只指向一个变量，没有规定一定要指向一维数组。所以，建议不要把指针和数组必然联系起来，尽管用指针可以操作数组，数组也可以用指针寻址方法来操作，但指针就是指针，数组就是数组，它们并不是一回事。供参考。