指针数组和数组指针的用法,指针数组和数组指针（行指针）有什么区别？

指针数组和数组指针的用法,指针数组和数组指针（行指针）有什么区别？详细介绍

本文目录一览： 指针数组和数组指针的区别

指针数组是数组，它的元素是指针；而数组指针是指针，可以用来指向数组。
如：
int a,b,c;
//ptarr是指针数组，它有3个元素，每个元素都是指针，分别保存了a、b、c的地址
int *ptarr[]={&a,&b,&c};
再如：
int arr[]={1,2,3};
//arrpt是数组指针，它可以指向一个具有3个int型元素的数组，现在它指向数组arr
int (*arrpt)[3]=&arr;

二维数组与指针、指针数组、数组指针的用法

二维数组和指针⑴ 用指针表示二维数组元素。 要用指针处理二维数组，首先要解决从存储的角度对二维数组的认识问题。我们知道，一个二维数组在计算机中存储时，是按照先行后列的顺序依次存储的，当把每一行看作一个整体，即视为一个大的数组元素时，这个存储的二维数组也就变成了一个一维数组了。而每个大数组元素对应二维数组的一行，我们就称之为行数组元素，显然每个行数组元素都是一个一维数组
下面我们讨论指针和二维数组元素的对应关系，清楚了二者之间的关系，就能用指针处理二维数组了。 设p是指向二维数组a[m][n]的指针变量，则有：
int* p=a[0];//此时P是指向一维数组的指针。P++后，p指向 a[0][1]。
如果定义int (*p1)[n];p1=a;p1++后，p1指向a[1][0];
则p+j将指向a[0]数组中的元素a[0][j]。 由于a[0]、a[1]┅a[M-1]等各个行数组依次连续存储，则对于a数组中的任一元素a[i][j]，指针的一般形式如下： p+i N+j 相应的如果用p1来表示，则为 (p1+i)+j 元素a[i][j]相应的指针表示为： ( p+i N+j) 相应的如果用p1来表示，则为 ( (p1+i)+j) 同样，a[i][j]也可使用指针下标法表示，如下： p[i N+j] 例如，有如下定义： int a[3][4]={{10,20,30,40,},{50,60,70,80},{90,91,92,93}}; 则数组a有3个元素，分别为a[0]、a[1]、a[2]。而每个元素都是一个一维数组，各包含4个元素，如a[1]的4个元素是a[1][0]、a[1][1]、a[1]2]、a[1][3]。 若有： int p=a[0]; 则数组a的元素a[1][2]对应的指针为：p+1 4+2 元素a[1][2]也就可以表示为：( p+1 4+2) 用下标表示法，a[1][2]表示为：p[1 4+2] 特别说明： 对上述二维数组a，虽然a[0]、a都是数组首地址，但二者指向的对象不同，a[0]是一维数组的名字，它指向的是a[0]数组的首元素，对其进行“ ”运算，得到的是一个数组元素值，即a[0]数组首元素值，因此， a[0]与a[0][0]是同一个值；而a是一个二维数组的名字，它指向的是它所属元素的首元素，它的每一个元素都是一个行数组，因此，它的指针移动单位是“行”，所以a+i指向的是第i个行数组，即指向a[i]。对a进行“ ”运算，得到的是一维数组a[0]的首地址，即 a与a[0]是同一个值。当用int p;定义指针p时，p的指向是一个int型数据，而不是一个地址，因此，用a[0]对p赋值是正确的，而用a对p赋值是错误的。这一点请读者务必注意。 ⑵ 用二维数组名作地址表示数组元素。 另外，由上述说明，我们还可以得到二维数组元素的一种表示方法： 对于二维数组a，其a[0]数组由a指向，a[1]数组则由a+1指向，a[2]数组由a+2指向，以此类推。因此， a与a[0]等价、 (a+1)与a[1]等价、 (a+2)与a[2]等价，┅，即对于a[i]数组，由*(a+i)指向。由此，对于数组元素a[i][j]，用数组名a的表示形式为： ( (a+i)+j) 指向该元素的指针为： *(a+i)+j 数组名虽然是数组的地址，但它和指向数组的指针变量不完全相同。
第一，指针变量的值可以改变，即它可以随时指向不同的数组或同类型变量，而数组名自它定义时起就确定下来，不能通过赋值的方式使该数组名指向另外一个数组。
第二，数组名是指针，类型是指向元素类型的指针，但值是指针常量，声明数组时编译器会为声明所指定的元素数量保留内存空间。数组指针是指向数组的指针，声明指针变量时编译器只为指针本身保留内存空间。
例4 求二维数组元素的最大值。
该问题只需对数组元素遍历，即可求解。因此，可以通过顺序移动数组指针的方法实现。 main() { int a[3][4]={{3,17,8,11},{66,7,8,19},{12,88,7,16}}; int p,max; for(p=a[0],max= p;p

max) max= p; printf("MAX=%d/n",max); } 执行结果： MAX=88 这个程序的主要算法都是在for语句中实现的：p是一个int型指针变量；p=a[0]是置数组的首元素地址为指针初值；max= p将数组的首元素值a[0][0]作为最大值初值；p
<a[0]+12是将指针的变化范围限制在12个元素的位置内；p++使得每比较一个元素后，指针后移一个元素位置。 例5 求二维数组元素的最大值，并确定最大值元素所在的行和列。 本例较之上例有更进一步的要求，需要在比较的过程中，把较大值元素的位置记录下来，显然仅用上述指针移动方法是不行的，需要使用能提供行列数据的指针表示方法。 main() { int a[3][4]="{{3,17,8,11},{66,7,8,19},{12,88,7,16}};" p="a[0],max,i,j,row,col;" max="a[0][0];" row="col=0;" for(i="0;i<3;i++)" for(j="0;j
max) { max= (p+i 4+j); row=i; col=j; } printf("a[%d][%d]=%d/n",row,col,max); } 程序运行结果： a[2][1]=88 ⑶ 行数组指针 在上面的说明中我们已经知道，二维数组名是指向行的，它不能对如下说明的指针变量p直接赋值： int a[3][4]={{10,11,12,13},{20,21,22,23},{30,31,32,33}}, p; 其原因就是p与a的对象性质不同，或者说二者不是同一级指针。C语言可以通过定义行数组指针的方法，使得一个指针变量与二维数组名具有相同的性质。行数组指针的定义方法如下： 数据类型 ( 指针变量名)[二维数组列数]； 例如，对上述a数组，行数组指针定义如下： int ( p)[4]; 它表示，数组 p有4个int型元素，分别为( p)[0]、( p)[1]、( p)[2]、( p)[3] ，亦即p指向的是有4个int型元素的一维数组，即p为行指针

此时，可用如下方式对指针p赋值：

p=a;

(4)指针数组的定义

指针数组是指每个元素中存放的是指针。定义为 int *p[4];sizeof(p)=16,返回的是数组的总空间

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");

}

数组指针和指针数组的区别

数组指针，是指向数组的指针。通常所说的数组指针，只是一个指针，他只能存放一个地址。一般用于多维数组。
举例说明，假设有一个四行五列的二维数组A，C语言认为它是由四个五元素的一维数组首尾相连组成的。当定义一个数组指针P时，让p指向二维数组的首地址，其实他指的也是第一个一维数组的首元素地址，当执行P+1之后，P就指向了第二个一维数组的首元素地址，或者p再+2以后就指向了第四个一维数组数组的首元素地址。
int a[4][5]={{1,2,3,4,5},{6,7,8,9,10}}
(*p)[5]=a;
则*(*(p+1)+1)代表第二行的第二个元素7。
指针数组是由若干指针组成的数组，它是一组指针，而不是一个指针。它和普通的数组一模一样，只是它存放的是指针，也就是地址，而不是元素的值。
如：
int a=2,b=3,c=5;
int*p[3];
p[0]=&a;
p[1]=&b;
p[2]=&c;
则*p[1],*p[2]分别代表3和5。
有什么问题请留言。

指针数组和数组指针的区别

1、性质不同
指针数组：首先它是一个数组，数组的元素都是指针，它是“储存指针的数组”的简称。数组指针：首先它是一个指针，它指向一个数组，它是“指向数组的指针”的简称。
2、字节不同
数组占多少个字节由数组本身的大小决定，每一个元素都是一个指针，在32位系统下任何类型的指针永远是占4个字节。
数组指针在32位系统下任何类型的指针永远是占4个字节，至于它指向的数组占多少字节，不知道，具体要看数组大小。
3、表示方法不同
指针数组：数组a中的元素都为int型指针；数组指针：指向数组a的指针。
4、变量不同
指针数组：指针数组可以说成是”指针的数组”，这个变量是一个数组。
数组指针：数组指针可以说成是”数组的指针”，这个变量是一个指针。

c语言指针，指向数组的指针、指向指针数组的指针、指向数组的指针的指针，分别如何定义？

2. 那么，如何声明一个指针， 这个指针也是指向数组的，数组有n个元素，每个元素不是int，而是指针int*；
指针数组，int *arrayInt[n];
指向这个数组的指针 int *(*p)[n];
3. 又如何声明一个指针，它指向另一个指针，这“另一个指针”指向一个数组，数组元素是int
数组 int array[n];
int **p;
2, int *(*p)[n];其中： int *[n];是一个指针数组，(*p)是它的指针
3 int (**p)[n];其中：int [n]是普通int数组，(**p)是它的二级指针
解答：
1. 如何声明一个指针，这个指针是指向整个数组的，数组有n个元素，每个元素是int，不是int (*p)[n]，而是最简单的int*p；
2. 如何声明一个指针，这个指针也是指向数组的，数组有n个元素，每个元素不是int，而是指针int*；这个指针是int**p；
3. 又如何声明一个指针，它指向另一个指针，这“另一个指针”指向一个数组，数组元素是int；这个指针仍然是int**p。

指针数组和数组指针（行指针）有什么区别？

指针数组：一个数组元素是指针 int *ptr_array[10]
数组指针：数组的指针 int (*p)[10];
前者一个数组，而后者只是一个指针。
一个数组的 元素值 为指针 则是指针数组. 指针数组是一组有序的指针的集合。指针数组的所有元素都必须是具有相同存储类型和指向相同数据类型的指针变量
指针数组说明的一般形式为：类型说明符 *数组名[数组长度]
其中类型说明符为指针值所指向的变量的类型。例如：int *pa[3]
所谓数组的指针是指数组的起始地址，数组元素的指针是数组元素的地址。
指针数组是数组，数组里存放的是指针
数组指针是指针，指向了数组。
指针数组是指每个元素都为指针变量的数组，本质是数组。
数组指针是指向数组的指针，是一个指针变量，本质是变量。
数组指针（行指针）全称是二维数组的指针，只能操作二维数组，又因为操作二维数组是以行为单位，所以又名行指针，如(*a)[3]是指一个每行有3个元素的二维数组，即3列，行数未定
指针数组是一个数组里面的所有元素都为指针，如*a[3]是将*a[0]、*a[1]、*a[2]这三个指针打包用数组存放，相当于3个指针

指针数组和指针是一样的吗？

正确的。
数组指针是指向数组地址的指针，其本质为指针；指针数组是数组元素为指针的数组(例如 int *p[4],定义了p[0]，p[1]，p[2]，p[3]三个指针)，其本质为数组。数组指针的使用在某些情况下与指针数组很相似，要注意区别。
p是一个指针变量，它指向包含4个int元素的一维数组，此时p的增量以它所指向的一维数组长度为单位。
*(p+i)是一维数组a[i][0]的地址;*(p+2)+3表示a[2][3]地址（第一行为0行，第一列为0列），*（*(p+2)+3）表示a[2][3]的值。
扩展资料：
对指针进行初始化或赋值只能使用以下四种类型的值:
1. 0 值常量表达式，例如,在编译时可获得 0 值的整型 const对象或字面值常量 0。
2. 类型匹配的对象的地址。
3. 另一对象末的下一地址。
4. 同类型的另一个有效指针。
参考资料：
百度百科-指针数组

指针数组和数组指针的区别有哪些？

指针数组和数组指针的区别主要有以下几点：
1、数组名不可以改变，而指向数组的指针是可以改变的。字符串指针指向的字符串中的字符是不能改变的，而字符数组中的字符是可以改变的。求数组长度时，借用数组名可求得数组长度，而借用指针却得不到数组长度。
2、数组名的指向不可以改变，而指向数组的指针是可以改变的。因为数组名的指向是不可以改变的，使用自增运算符自增就会改变其指向，这是不对的，数组名只能指向数组的开头。
3、指针数组是一个数组，数组的元素都是指针，数组占多少个字节由数组本身决定。数组指针是一个指针，它指向一个数组。在32位系统下永远是占4个字节，至于它指向的数组占多少字节。
4、字符串指针指向的字符串中的字符是不能改变的，而字符数组中的字符是可以改变的。指针数组本身就是个数组，只不过呢，它里面存放的数据类型不是int，也不是char这类基本类型，而是一个指针类型，说白了就是地址。
扩展资料：
对于指针数组，首先，它是一个数组，知道数组的元素是一个指针，换句话说，数组存储一个指针。此外，数组本身的字节数由数组本身决定；
数组指针，首先它是一个指针，数组指针的指针数组，也就是说，它是一个指针指向一个数组，唯一可以确定的是它是4个字节在32位系统中，但多少字节是指向一个数组，这不是确定的，它取决于情况。