指针数组的使用方法

① 指针数组的创建和用法

创建：
（1）声明一个数组，声明时用常量表达式指定数组维数，然后可以用数组名访问数组元素。
（2）声明一个变长数组，声明时用变量表达式指定数组维数，然后用数组名来访问数组元素。
（3）声明一个指针，调用malloc()，然后使用该指针来访问数组元素。malloc接受一个参数：所需内存字节数。然后malloc()找到可用内存中一个大小合适的块。内存是匿名的；也就是说，malloc()分配了内存，但没有为它指定名字。然而，它却可以返回那块内存第一个字节的地址。因此，可以把那个地址赋值给一个指针变量，并使用该指针来访问那块内存。因为char代表一个字节，所以传统上曾将malloc()定义为指向char的指针类型。然而，ANSI
C标准使用了一个新类型：指向void的指针。这一类型被用作“通用指针”。函数malloc()可用来返回数组指针、结构指针等等，因此一般需要把返回值的类型指派为适当的类型。如果malloc()找不到所需的空间，它将返回空指针。我们使用malloc()来创建一个数组，可以在程序运行时使用malloc()请求一个存储块，另外还需要一个指针来存放该块在内存中的位置。例如，考虑以下代码：

double * ptd;
ptd = (double
*)malloc(30*sizeof(double));

使用第二种或第三种方法可以做一些用普通的数组声明做不到的事；创建一个动态数组(dynamic
array)，即一个在程序运行时才分配内存并可在程序运行时选择大小的数组。例如，假定n是一个整数变量。在C99之前，不能这样做：

double item[n]; /*如果n是一个变量，C99之前不允许这样做*/

然而，即使在C99之前的编译器中，也可以这样做：
ptd=(double
*)malloc(n*sizeof(double));

变长数组VLA和malloc的用法有两点区别。一个区别在于VLA是自动存储的。自动存储的结果之一就是VLA所用内存空间在运行完定义部分之后会自动释放。因此不必使用free()。另一方面，使用由malloc()创建的数组不必局限在一个函数中。例如，函数可以创建一个数组并返回指针，供调用该函数的函数访问。接着，后者可以在它结束时调用free()。free()可以使用不同于malloc()指针的指针变量；必须一致的是指针中存储的位置。

用法：
//注意指针数组和数组指针分别是如何指向二维数组的
#include
<stdio.h>
main()
{

static int m[3][4]={0,1,2,3,4,5,6,7,8,9,10,11};

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

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("] ",*(*(p+i)+j));

}

printf("\n");

}

printf("\n");

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

{

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

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

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

printf("= ",*(*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("= ",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("= ",*(q[0]+j+4*i));

}

printf("\n");

}

printf("\n");
}

② C语言 指针数组的使用

int**a可以表达一个二维数组。为什么呢？

你可以这么理解*p[3]表达的是一个数组指针，这个指针p[0]表示的是数组存的第一个地址。而数组实际上是一串连续地址的块。每一个小块存着一个内容。每次访问数组时，你为什么可以用数组名+下标访问呢？//比如a[i]；

实际上就是访问*a+i;*这个符号可以表示你存的是变量的地址。而数组地址的第一位为int类型变量存的地址(你可以直接使用数组的地址加上单位变量的空间的大小去访问下个元素)。在这个程序中int*p[3]表示可以存三个int类型的地址。而p正好把二维数组的三个一维数组的开头的int类型变量的地址给存起来了。

给你举个例子

实际上p[i]与 *（p+i）是表达的是同一个意思。只不过只有数组可以定义一个连续的空间

（数组的第一个地址是随机的其他的是连续的。）单独用指针的话会随机分配的

数组的指针可以存三个地址。当然可以访问二维数组了。

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

指针的数组和整型的数组是指一个数组，其中每一个元素是指针类型；
数组的指针是指一个数组的首元素的地；
参考实例应用如下：
//注意指针数组和数组指针分别是如何指向二维数组的；
#include <stdio.h>
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");

}

④ 数组指针怎么使用

可以这样来
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
char *d[4];
d[0]=malloc(1*sizeof(char));
strcpy(d[0],"web");
printf("%s",d[0]);
return 0;
}
此时*d[]为一个指向指针的指针
d[0]=malloc(1*sizeof(char));
此句话的意思是，分配1个字节的内存空间给d[0]，也就意味着d这个数组的第一个元素[0]内保存的是一个1字节空间的地址，因为d[0]指向一个地址！

你可以这样理解
对于普通的数组(例如 char d[4];)，在内存中是这样的
变量:内存地址:内容
d[0]:0x400000h:'w'
d[1]:0x400001h:'e'
d[2]:0x400002h:'b'
d[3]:0x400003h:'\0'
而在此处 char *d[4]; *d[0] = malloc(1*sizeof(char));，是这样的'
d[0]:0x400000h:0x400100h
d[1]:0x400001h:0x400101h
d[2]:0x400002h:0x400102h
d[3]:0x400003h:0x400103h
而在内存0x400100h处
才保存着"web\0"

不好意思，我上面说错了，应该是
d[0]:0x400000h:0x400100h
d[1]:0x400001h:NULL
d[2]:0x400002h:NULL
d[3]:0x400003h:NULL
而在内存0x400100h处
0x400100h:'w'
0x400101h:'e'
0x400102h:'b'
0x400103h:'\0'

对应的，你的代码执行后，内存变量应该是这样的
d[0]:0x400000h:0x400100h
d[1]:0x400001h:0x400104h
d[2]:0x400002h:0x400108h
d[3]:0x400003h:NULL
在内存0x400100处:
0x400100h:'w'
0x400101h:'e'
0x400102h:'b'
0x400103h:'\0'
0x400104h:随机字符
......
0x400108h:随机字符

以上内存地址是以字节方式内存对齐的，用一些编译器编译后可能地址会有些问题(比如d[0]到d[1]不止差了4，可能是8)，但总体框架就是这样！

⑤ 指针数组怎么使用

在C语言和C++等语言中，数组元素全为同一类指针变量的数组称为指针数组，指针数组中的元素都必须具有相同的存储类型、指向相同数据类型的指针变量。指针数组比较适合用来指向若干个字符串，使字符串处理更加方便、灵活。一维指针数组的定义形式为：“类型名 *数组标识符[数组长度]”。

⑥ c＋＋指针数组怎么用

指针数组，是指一个数组里面装着指针；

一下是指针数组的使用案例：

#include "stdafx.h"

#include <iostream>

using namespace std;

int _tmain(int argc, _TCHAR* argv[])

{

int *ptr[5]; //指针数组

int p = 5, p2 = 8, *page, *page2;

page = &p;

page2 = &p2;

ptr[0] = &p;

ptr[1] = page2;

cout << *ptr[0] << endl;

cout << *page << endl;

cout << *ptr[1] << endl;

return 0;

}

运行结果：

⑦ 指针数组函数的用法

请参考：
#include <stdio.h>

const int fun1(int a,int b)
{
return a+b;
};
const int fun2(int a,int b)
{
return a-b;
};

typedef const int (* Fun)(int a,int b); //把 int 返回值 两个int参数的函数定义成Fun函数指针类型

int main()
{
Fun f[2]={fun1,fun2}; //形式相同的函数指针数组,方便函数的统一管理
int temp[2];
/*
int i;
for(i=0;i<2;i++)
temp[i]=f[i](1,1);
*/
temp[0]=f[0](3,6);
temp[1]=f[1](7,4);
printf("%d %d\n",temp[0],temp[1]);
return 0;
}

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

二维数组和指针⑴ 用指针表示二维数组元素。
要用指针处理二维数组，首先要解决从存储的角度对二维数组的认识问题。我们知道，一个二维数组在计算机中存储时，是按照先行后列的顺序依次存储的，当把每一行看作一个整体，即视为一个大的数组元素时，这个存储的二维数组也就变成了一个一维数组了。而每个大数组元素对应二维数组的一行，我们就称之为行数组元素，显然每个行数组元素都是一个一维数组

下面我们讨论指针和二维数组元素的对应关系，清楚了二者之间的关系，就能用指针处理二维数组了。
设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<a[0]+12;p++)
if( 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}};
int 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<4;j++)
if( (p+i4+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,返回的是数组的总空间