c语言之指针数组函数（精选8篇）
写一个函数，用于比较两个字符串的比较(string_compare).
程序分析：
(1)主要思想：传入两个字符串后，比较这两个字符串中的每个元素，如果第一次比较就不相等，就不要让它进入到下面的比较中，这样一来，将它返回一个相减的值(即：两数组中开始不相等的那两个元素相减，返回值(int类型)，是ASCII码值相减)。进入比较的过程中时，相等就返回0;其他情况都返回那个相减的值。
(2)主要方式：定义指针数组，并对其初始化。然后照上面的思想，进行代码的实现。
代码如下：
1 预备概念和结论
本文把指向具体元素的指针称为点指针;把指向包含n个具体元素一维数组的指针称为行指针。
int*p表示声明p是指向具体元素的指针, 为点的指针。
int (*pointer) [4]表示声明pointer是一个含4个具体元素一维数组的指针, 为行指针。
在C语言中, 地址可以认为是一个指针, 见下例:
运行结果如下:
&a是a的地址, aPtr是指向a变量的指针, 两者输出结果一致;&a+1和aPtr+1输出结果一致;*&a和*aPtr输出结果一致。
从结果看, 如果把&a视为一个指针, 一个指向变量a的指针, 那么很好解释&a和aPtr等价, &a+1和aPtr+1等价, *&a和a P t r等价, 因此他们输出结果分别一致。
地址就是指针, 该结论是理解数组和指针关系的基础。
2 一维数组
假设有:
(1) 数组名称就是地址和指针。
一维数组名称a r r a y代表数组中首元素 (array[0]) 的地址, p=array是把首元素地址赋给p。根据“地址就是指针”, array实际上就是一个指针, 一个指向首元素的指针, p=array也可以认为是把一个指针赋给另一个指针, 使得p跟array一样指向首元素。
p=array和p=&array[0]等价。&array[0]表示array[0]的地址, p=&array[0]是把首元素array[0]的地址赋给指针p, 使得p指向首元素。根据“地址就是指针”, &array[0]实际就是一个指针, 一个指向首元素的指针, 因此, p=&array[0]也可以认为是把一个指针赋给另一个指针, 使得p跟&array[0]一样指向首元素。因此两者是等价的。
(2) 一维数组名称是点指针。
一维数组名称a r r a y表示一个指针常量, 该指针指向首元素 (第0号元素, 为具体的元素) , 因此一维数组名称a r r a y是点指针。因为array为点指针, 那么array+1指向的是数组中第1号元素。
(3) *array跟array[0]等价, * (array+1) 和array[1]等价。
由于a r r a y为指向首元素的点指针, 那么*array表示该指针指向的元素 (首元素) , 而在一维数组中, array[0]表示首元素, 因此*array跟array[0]等价。
由于a r r a y表示指向首元素的点指针, 那么array+1指向下一个点 (即下一个具体元素) 。因此, * (array+1) 和array[1]等价, 其他依次类推。
3 二维数组
假设定义一个二维数组如下:
int a[3][4]={{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}, {13, 14, 15, 16}}。
(1) 把二维数组a视为一维数组, 其元素为a[0], a[1]和a[2], 其中a[0], a[1]和a[2]分别是包含4个具体元素的一维数组 (见图1) 。这里面包含两个信息。
(1) 把a作为一维数组来理解, 那么名称a就是一个指针, 指针a指向的是a[0], a+1指向的是a[1], a+2指向的是a[2]。由于a[0], a[1]和a[2]并不是具体的元素, 而是包含4个具体元素的一维数组。因此a和a+1, a+2分别是行指针。
(2) a[0], a[1]和a[2]并不是具体的元素, 而是包含4个具体元素的一维数组。因此把a[0], a[1]和a[2]作为一维数组名称来使用。
一维数组名称就是一个指针, 其指向该数组的首元素。本文把指向具体元素的指针称为点的指针, 因此a[0], a[1], a[2]就是指向该数组中首元素的指针, 为点的指针。
(2) a[0]+1指向的是第0行第1列元素, a[1]+2指向的是第1行第2列元素。
由于a[0]表示指向第0行数组的首元素 (第0列元素) , 为点的指针, a[0]+1表示把该指针移动1个位置, 即指向该数组中的第1列元素, 即指向的是第0行第1列元素;同样, 由于a[1]表示指向第1行数组的首元素 (第0列元素) , 为点的指针, a[1]+2表示把该指针移动2个位置, 即指向该数组中的第2列元素, 即指向的是第1行第2列元素;
点指针为具体指向某个元素的指针, * (a[0]+2) 表示第0行第2列元素。
(3) a[1]+2和* (a+1) +2等价。
把a看成是一个含有3个元素的一维数组。采用下标法访问元素, 即a[0], a[1]和a[2];采用指针法访问元素, 如*a, * (a+1) 和* (a+2) 等。因此a[1]和* (a+1) 等价, 所以a[1]+2和* (a+1) +2等价。
a[1]+2和* (a+1) +2都表示指向第1行第2列元素的指针, 因此* (a[1]+2) 和* (* (a+1) +2) 均表示该指针指向的元素。
(4) *a和a输出值一样, 类型不一样。
测试如下的程序, 观察*a和a的输出值:
测试表明*a和a输出的值一样。a代表0行首地址, *a其代表第0行第0列的地址, 因此两者的输出值是一样的, 但是两者的类型不一样。
a是行指针, 其代表0行首地址。a[0]和*a是点的指针 (a[0]和*a等价) , 其代表第0行第0列的地址。因此a和*a输出的值一样, 但是前者是行指针, 后者是点指针。
进一步测试如下程序, 该例的目的是输入二维数组a的行和列的下标, 把相应位置的元素输出:
发现以上程序通不过编译, 错误在于指针类型不匹配。p是点指针, 而a是二维数组名, 表示一个行指针常量, 显然把个行指针常量赋给一个点指针, 类型上不一致。因此, 修改如下:
发现以上程序通过编译, 功能满足要求。int (*p) [4]表示p为一个指针变量, 它指向包含4个整型元素的一维数组, 为行指针, 因此p和a类型一致。
如果采用点指针来完成上述程序的功能, 可以把程序修改为:
*a其代表第0行第0列的地址, 根据地址就是指针, *a就是第0行第0列的元素的指针, 为点指针。p=*a实现把p指向第0行第0列的元素, 亦为点指针。本例子是采用点移动的方法, 找到相应行和列的元素。
同样, 函数调用就是把实参赋给形参。如果指针作为函数参数, 必须分清形参和实参的类型并判别两者类型是否一致。数组名的本质就是指针, 因此数组名作函数参数, 实质就是指针作为函数参数, 同样遵守以上的规则。
4 结语
综上所述, 在数组和指针关系中, 有如下三个主要结论。
(1) 地址就是指针。
(2) 数组名称是既表示地址, 又表示指针。一维数组名称是点指针, 二维数组名称是行指针。
(3) 假设有array[n][m], 二维数组array认为是包含array[0], array[1], array[2]…array[n-1]等n个元素的一维数组, 而这n个元素分别是包含了m个具体元素的一维数组, array[0], array[1], array[2]…array[n-1]等可以视为一维数组名称。
参考文献
[1] (美) 阿霍, 赵建华[译].编译原理 (第2版) [M].机械工业出版社, 2009, 1.
[2]张素琴.编译原理 (第2版) [M].清华大学出版社, 2005, 2.
[3]严蔚敏, 吴伟民.数据结构 (C语言版) [M].清华大学出版社, 1997, 4.
关键词：数组；元素；数据；类型
中图分类号：TP313文献标识码：A文章编号：1007-9599 (2010) 16-0000-02
Elements of the Array in C-language
Zhang Kexing
（Foreign Language Teachers College of Taiyuan University,Taiyuan030012,China）
Abstract:The array is the most commonly used programming data st-
ructure.Array can be divided into array of values（integer group,real array）,a character array and pointer array and the array of structures.
This array will be examples of various types were analyzed and explained.
Keywords:Array;Element;Data;Type
一、引言
數组是相互关联的一批数据的序列，序列中的数据称为数组的元素，可按照排列顺序编号，起始编号一般为0，前后两个数据的编号有差异，通过编号可以唯一指定数组中的数据成员。数组中的元素可以是基本类型，也可以是构造类型。按照数组元素的不同可将数组分为数值数组、字符数组、指针数组、结构数组。
二、数值数组
数值数组是指数组元素是整型、实型、及其相关类型的数据，简单说，就是元素是数字的数组。
例1：
main（）
{
int i，a[10]；
for（i=0；i<=9；i++）
a[i]=i；
for（i=9；i>=0；i--）
printf（"%d "，a[i]）；
}
在该例中，第一个for语句给数组a中的10个元素赋值为整形数据0-9，赋值以后数组中数据如下：
第二个for语句将数组a中的10个数字反序输出，即9、8、7、6、5、4、3、2、1、0
数值数组是数组中使用率最高的数组，需要注意的是一个数组中的数据必须是同一种类型的数据，
{int a[3]；
a[0]=3；
a[1]=2.5；
a[2]=3.0；}
是不合法的。
三、字符数组
C语言没有专门定义字符串数据类型（如其他语言中的string），它用以' '结尾的字符数组来表示一个逻辑意义上的字符串。
字符数组主要有两种用途，（1）存储字符串，（2）存储字符或字符变量。这两个是不同的，刚开始接触时很容易混淆。下面进一步分析这两者的不同。
首先初始化时不同，用于存储字符串，例如：char str[]="Hello"； 用于存储字符或字符变量，例如：char Chars[]={‘H‘‘e‘，‘1‘‘1‘，‘o‘}。这两者的存储方式是一样的，但是存储内容稍微有所不同，那就是第一种情况会在结尾加上‘ ’，存储情况类似于{‘H‘‘e‘，‘1‘‘1‘，‘o‘，‘ ‘}，存储空间会比第二种情况大一点，但是这个存在空间并不被计算进字符串（其实只是字符数组）变量中。
C语言中提供的字符串操作函数其实是针对于结尾是‘ ‘的字符数组进行的。输出函数printf中的输出参数%s也是针对于结尾是‘ ‘的字符数组。
另外，还有一种方法可以定义字符串（其实也是字符数组），声明如下：
char * string = "this is a point charArray."；字符指针指向字符数据的第一个字符的位置。
最后，有两点特别说明。
（1）字符串常量给出的是地址值。如
char *p， s[10]；
p="hello"；//正确
（2）不能用赋值语句给字符数组整体赋一串字符，例：
char str[10]；
str = "abc"；//错误
例2：
char c[10]={‘c’， ‘’， ‘p’， ‘r’， ‘o’， ‘g’， ‘r’， ‘a’，’m’}；
赋值后数组元素如下：
四、指针数组
在C语言中，一个数组的元素值为指针则是指针数组。 指针数组是一组有序的指针的集合。指针数组的所有元素都必须是具有相同存储类型和指向相同数据类型的指针变量。
指针数组说明的一般形式为：
类型说明符*数组名[数组长度]
其中类型说明符为指针值所指向的变量的类型。
例如：
int *pa[3]
表示pa是一个指针数组，它有三个数组元素，每个元素值都是一个指针，指向整型变量。
例3：
通常可用一个指针数组来指向一个二维数组。指针数组中的每个元素被赋予二维数组每一行的首地址，因此也可理解为指向一个一维数组。
main（）{
int a[3][3]={1，2，3，4，5，6，7，8，9}；
int *pa[3]={a[0]，a[1]，a[2]}；
int *p=a[0]；
int i；
for（i=0；i<3；i++）
printf（"%d，%d，%dn"，a[i][2-i]，*a[i]，*（*（a+i）+i））；
for（i=0；i<3；i++）
printf（"%d，%d，%dn"，*pa[i]，p[i]，*（p+i））；
}
本例程序中，pa是一个指针数组，三个元素分别指向二维数组a的各行。然后用循环语句输出指定的数组元素。其中*a[i]表示i行0列元素值；*（*（a+i）+i）表示i行i列的元素值；*pa[i]表示i行0列元素值；由于p与a[0]相同，故p[i]表示0行i列的值；*（p+i）表示0行i列的值。
在C语言中，数组元素全为指针的数组成为指针数组。
一维指针数组的定义形式为：“类型名*数组标识符[数组长度]”。
例如，一个一维指针数组的定义：int *ptr_array[10]。
指针数组的含义：
指针数组中的每一个元素均为指针，即有诸形如“*ptr_array[i]”的指针。
由于数组名本身也是一个指针，因此指针数组中的元素亦可以表示为“*（*（ptr_ayyry+i））”。又因为“（）”的优先级较“*”高，且“*”是右结合的，因此可以写作**（ptr_array+i）。
五、结构数组
数组的元素也可以是结构类型的。因此可以构成结构型数组。结构数组的每一个元素都是具有相同结构类型的下标结构变量。在实际应用中，经常用结构数组来表示具有相同数据结构的一个群体。如一个班的学生档案，一个车间职工的工资表等。
方法和结构变量相似，只需说明它为数组类型即可。
例4：
struct stu
{
int num；
char *name；
char sex；
float score；
}boy[5]；
定义了一个结构数组boy，共有5个元素，boy[0]～boy[4]。每个数组元素都具有struct stu的结构形式。
例5：计算学生的平均成绩和不及格的人数。
struct stu
{
int num；
char *name；
char sex；
float score；
}boy[5]={
{101，"Li ping"，'M'，45}，
{102，"Zhang ping"，'M'，62.5}，
{103，"He fang"，'F'，92.5}，
{104，"Cheng ling"，'F'，87}，
{105，"Wang ming"，'M'，58}，
}；
main（）
{
int i，c=0；
float ave，s=0；
for（i=0；i<5；i++）
{
s+=boy[i].score；
if（boy[i].score<60） c+=1；
}
printf（"s=%fn"，s）；
ave=s/5；
printf（"average=%fncount=%dn"，ave，c）；
}
本例程序中定义了一个外部结构数组boy，共5个元素，并作了初始化赋值。在main函数中用for语句逐个累加各元素的score 成员值存于s之中，如score的值小于60（不及格）即计数器C加1，循环完毕后计算平均成绩，并输出全班总分，平均分及不及格人数。
六、总结
数组是程序设计中最常用的数据结构。数组可分为数值数组（整数组，实数组），字符数组以及指针数组和结构数组。数组可以是一维的，二维的或多维的。数组类型说明由类型说明符、数组名、数组长度（数组元素个数）三部分组成。要想将不同的数据用不同类型的数组存放，就需要深入了解每一种类型的数组及其特点，这样才能灵活运用，充分发挥每种数据类型的长处。
参考文献：
[1]谭浩强.C程序设计教程[M].北京:清华大学出版社,2007,7
[2]李岩.C语言程序设计基础与上机知道[M].北京:清华大学出版社,2006,3
[3]马秀丽等.C语言程序设计[M].北京:清华大学出版社,2008,3
[4]罗坚.C语言程序设计[M].北京:中国铁道出版社,2009,2
作者簡介：
张科星（1980-），女，山西太原人，研究生，太原大学外语师范学院，助教，研究方向：网络，计算机教育。
int func(const int a, const int b);
那么，此时声明的函数变量add的地址即为这个函数的地址，同时，add的值保存为这个函数的地址，这个特性与数组相似：数组变量与数组变量的地址均为数组的起始地址。而在这个函数声明中，函数类型为int (const int a, const int b)。使用该函数类型来定义一个函数型指针，其方式如下：
int (* fp)(const int a, const int b); /* 其中，参数列表的参数名a和b可省 */
上述语句将变量func定义为指向类型为int (const int a, const int b)的指针操作符和变量名两侧的小括号不可省，否则其含义大不相同。例如：
int * fp(const int a, const int b);
此时，指针操作符与数据类型int结合为int型指针类型，该语句只是声明了一个fp函数，而非定义一个函数指针。为该函数型指针赋值的方式如下：
fp = func;
被赋值的函数变量的类型必须与fp的类型完全一致，包括其返回类型和每一个形参的类型。否则程序将报错。
注意：函数型指针变量赋值时，左值与右值的类型必须完全一致。
使用函数型指针变量调用函数的方法与使用函数变量类似，得到函数地址后再带上参数列表即可。可以使用下面两种方式来调用函数：
fp(5, 6);
或
(*fp)(5, 6);
由于fp被赋值为函数变量func的地址，而func的值又等于其地址，所以*fp可以得到func函数的地址。因此，在调用方式上，可以粗略地将两者视为一致（实际上其后台的处理略有不同）。范例14-7演示了如何使用函数型指针来调用函数。
【范例14-7】使用函数型指针来调用函数，实现方法如示例代码14-7所示。
示例代码14-7
01 #include
02
03 int add(const int a, const int b) { /* 定义add函数 */
04 return a + b;
05 }
06
07 int main(void) {
08 int (*fp) (const int a, const int b); /* 定义函数指针 */
09
10 fp = add; /* 将其赋值为add */
11 printf(“3 + 4 = %d”, fp(3, 4)); /* 使用fp计算+ 4的值 */
12 printf(“3 + 4 = %d”, (*fp)(3, 4)); /* 使用*fp计算+ 4的值 */
13
14 printf(“%p”, add); /* 输出add的值 */
15 printf(“%p”, &add); /* 输出add的地址 */
16 printf(“%p”, fp); /* 输出fp的值 */
17 printf(“%p”, *fp); /* 输出fp指向的值 */
18
19 return 0;
20 }
【运行结果】程序运行后，
【代码解析】本程序定义了一个函数指针，并将其赋值为相应类型的函数变量add。
第11～12行分别使用fp和*fp的方式调用函数，从图14-12的第1～2行中可以看到它们的调用结果是一样的。
第14～17行输出了add的值和地址、fp的值和指向的值，从图14-12的第3～6行中可以看到它们的调用结果都是一样的。
1.输入元素的值：
inti,a [10];
for(i = 0;i < 9;i ++);
a[i] = i;
(1)正序排列：(2)倒序排列：
for(i =0;i < 10;i ++)for(i = 9;i >= 0;i--)printf(“%d”, a[i]);printf(“%d”, a[i]);
2.初始化元素的值：
（1）在定义时，将数组元素一次放在一对花括号里;
eg: int a[10]={1,2,3,4,5,6,7,8,9,0};
(2)可以只给一部分元素赋值:
eg: int a[10]={1,3};
(3)使数组全部元素为0：
eg: int a[10]={0,0,0,0,0,0,0,0,0,0};或者 int a[10]={0};
(4)在对全部元素赋初值的时候，由于元素数已经确定，因此，可以不指定数组长度。（注：数组长度与提供初值个数不相同时，则长度不可以省略。）
3.巧妙地将两个元素列在一个循环中输出：（用for循环处理fobonacci数列）； eg：int f[20]={1,1};
for(i=2;i<20;i++)
f[i]=f[i-1]+f[i-2];
4． 数列Fobonacci数列核心：
int f[20]={1,1};
for(i=2;i<20;i++)
f[i]=f[i-1]+f[i-2];
5.换行操作：
for(i=0;i<=20;i++)/*当然也可以在for循环中处理，直接将{if(i%5= =0)printf(“n”);if(i%5= =0)printf(“n”);插入换行*/Printf(“%12ld”,f[i]);
}
6.起泡法：
int a[10];
for(j=0;j<9;j++)/*进行n-1趟比较*/
for(i=0;i<9-j;i++)/*在j趟比较中，比较n-1次*/
if(a[i]>a[i+i])/*由小到大排列，if(a[i]
7.初始化二维数组：
分行给二维数组赋初值；
将所有的元素都写在一个花括号里；
对部分元素赋值：
1)int a[3][3]={{3},{5},{9}};只讲0列元素赋值
2)int a[3][3]={{1}, {0,6},{0,0,11}};对部分元素赋值，对非0元素少使用方便
3)int a[3][3]={{1}, {5,6}};只对几行元素赋值
4)int a[3][3]={{1}, {},{9}};对第二行元素赋值
对全部元素赋值可以省略一维长度：
对部分元素赋初值，在省略一位长度时，应分行赋值：
8.二维数组的输入输出：
输入：直接定义
输出：
for(i=0;i<=2;i++)
{for(j=0;j<=1;j++)
printf(“%5d”,b[i][j]);
printf(“n”);
}
9.二维数组的行列转换：
b[j][i]=a[i][j];
10.数组中求最大值并输出行列号：
Eg：inti,row=0,colum=0,max;
inta[3][4]={1,2,3,4,5,6，7,8,9,10,11,12};
max=a[0][0];
for(i=0;i<=2;i++)
for(j=0;j<=3;j++)
if(a[i][j]>max)
{max=a[i][j];
row=i;
colum=j;}
11.字符数组的初始化方法：
逐个字符初始化：
eg：char c[10]={„I‟, „‟, „a‟, „m‟, „‟, „h‟, „a‟, „p‟, „p‟, „y‟};
1)在定义字符数组时，不初始化，则数组中的各元素的之不可预料；
2)如果花括号中提供的初值个数（即字符个数）大于数组的长度，则按语法错误
处理；
3)如果花括号中提供的初值个数（即字符个数）小于数组的长度，其余元素自动
定为空字符即（„‟）;
如果提供的初值个数与数组长度相同，则在定义时可以省略数组长度； 也可以定义一个二维数组：
eg:char diamond[5][5]={{},{},{},{},{}}; 用字符串常量，使字符数组初始化：
eg： char c[ ]={“I am happy”};或char c[ ]= “I am happy”;
12.字符数组的输出：
一维：二维：
for(i=0;i<=11;i++)for(i=0;i<=11;i++)
printf(“%c”,c[i]);for(i=0;i<5;i++)
printf(“n”);printf(“%c”,diamond[i][j]);
13.字符数组输出最大值：
eg：if(strcmp(string,str[1]>0)
strcpy(string,str[0]>0);
else
strcpy(string,str[1]);
if(strcmp(str[2],string>0)
strcpy(string,str[2]);
指针的基本概念 在计算机中，所有的数据都是存放在存储器中的。 一般把存储器中的一个字节称为一个内存单元， 不同的数据类型所占用的内存单元数不等，如整型量占2个单元，字符量占1个单元等， 在第二章中已有详细的介绍。为了正确地访问这些内存单元， 必须为每个内存单元编上号。 根据一个内存单元的编号即可准确地找到该内存单元。内存单元的编号也叫做地址。 既然根据内存单元的编号或地址就可以找到所需的内存单元，所以通常也把这个地址称为指针。 内存单元的指针和内存单元的内容是两个不同的概念。 可以用一个通俗的例子来说明它们之间的关系。我们到银行去存取款时， 银行工作人员将根据我们的帐号去找我们的存款单， 找到之后在存单上写入存款、取款的金额。在这里，帐号就是存单的指针， 存款数是存单的内容。对于一个内存单元来说，单元的地址即为指针， 其中存放的数据才是该单元的内容。在C语言中， 允许用一个变量来存放指针，这种变量称为指针变量。因此， 一个指针变量的值就是某个内存单元的地址或称为某内存单元的指针。图中，设有字符变量C，其内容为“K”(ASCII码为十进制数 75)，C占用了011A号单元(地址用十六进数表示)。设有指针变量P，内容为011A， 这种情况我们称为P指向变量C，或说P是指向变量C的指针。 严格地说，一个指针是一个地址， 是一个常量。而一个指针变量却可以被赋予不同的指针值，是变。 但在常把指针变量简称为指针。为了避免混淆，我们中约定：“指针”是指地址， 是常量，“指针变量”是指取值为地址的变量。 定义指针的目的是为了通过指针去访问内存单元。
既然指针变量的值是一个地址， 那么这个地址不仅可以是变量的地址， 也可以是其它数据结构的地址。在一个指针变量中存放一
个数组或一个函数的首地址有何意义呢? 因为数组或函数都是连续存放的。通过访问指针变量取得了数组或函数的首地址， 也就找到了该数组或函数。这样一来， 凡是出现数组，函数的地方都可以用一个指针变量来表示， 只要该指针变量中赋予数组或函数的首地址即可。这样做， 将会使程序的概念十分清楚，程序本身也精练，高效。在C语言中， 一种数据类型或数据结构往往都占有一组连续的内存单元。 用“地址”这个概念并不能很好地描述一种数据类型或数据结构， 而“指针”虽然实际上也是一个地址，但它却是一个数据结构的首地址， 它是“指向”一个数据结构的，因而概念更为清楚，表示更为明确。 这也是引入“指针”概念的一个重要原因。
指针变量的类型说明
对指针变量的类型说明包括三个内容：
(1)指针类型说明，即定义变量为一个指针变量;
(2)指针变量名;
(3)变量值(指针)所指向的变量的数据类型，
其一般形式为： 类型说明符 *变量名;
其中，*表示这是一个指针变量，变量名即为定义的指针变量名，类型说明符表示本指针变量所指向的变量的数据类型。
例如： int *p1;表示p1是一个指针变量，它的值是某个整型变量的地址。 或者说p1指向一个整型变量。至于p1究竟指向哪一个整型变量， 应由向p1赋予的地址来决定。
再如：
staic int *p2; /*p2是指向静态整型变量的指针变量*/
float *p3; /*p3是指向浮点变量的指针变量*/
char *p4; /*p4是指向字符变量的指针变量*/ 应该注意的是，一个指针变量只能指向同类型的变量，如P3 只能指向浮点变量，不能时而指向一个浮点变量， 时而又指向一个字符变量。
指针变量的赋值
指针变量同普通变量一样，使用之前不仅要定义说明， 而且必须赋予具体的值。未经赋值的指针变量不能使用， 否则将造成系统混乱，甚至死机。指针变量的赋值只能赋予地址， 决不能赋予任何其它数据，否则将引起错误。在C语言中， 变量的地址是由编译系统分配的，对用户完全透明，用户不知道变量的具体地址。 C语言中提供了地址运算符&来表示变量的地址。其一般形式为： & 变量名; 如&a变示变量a的地址，&b表示变量b的地址。 变量本身必须预先说明。设有指向整型变量的指针变量p，如要把整型变量a 的地址赋予p可以有以下两种方式：
(1)指针变量初始化的方法 int a;
int *p=&a;
(2)赋值语句的方法 int a;
int *p;
p=&a;
不允许把一个数赋予指针变量，故下面的赋值是错误的： int *p;p=1000; 被赋值的指针变量前不能再加“*”说明符，如写为*p=&a 也是错误的
指针变量的运算
指针变量可以进行某些运算，但其运算的种类是有限的。 它只能进行赋值运算和部分算术运算及关系运算。
1.指针运算符
(1)取地址运算符&
取地址运算符&是单目运算符，其结合性为自右至左，其功能是取变量的地址。在scanf函数及前面介绍指针变量赋值中，我们已经了解并使用了&运算符。
(2)取内容运算符*
取内容运算符*是单目运算符，其结合性为自右至左，用来表示指针变量所指的变量。在*运算符之后跟的变量必须是指针变量。需要注意的是指针运算符*和指针变量说明中的指针说明符* 不是一回事。在指针变量说明中，“*”是类型说明符，表示其后的变量是指针类型。而表达式中出现的“*”则是一个运算符用以表示指针变量所指的变量。
main{
int a=5,*p=&a;
1 结合实例剖析指针和数组的特点
下面我们给出实例来剖析指针和数组的特点，在主函数中间填写一部分语句或使用单独的函数以实现以下功能，求出1到1000之内能被7或11整除但不能同时被7和11整除的所有整数并存放在数组aa中，并把满足条件的值存入OUT.DAT中(我们事先已经在相应的目录建好了一个空的记事本文件，文件名为OUT，扩展名改为.DAT格式)，同时输出到执行屏幕上，我们使用两种方式分别加以实现。
1.1 基于指针的实现方法
首先使用指针来实现该函数的功能。
1.2 基于数组的实现方法
以下是数组的实现方法。
数组实现相对较简单，也很容易理解和掌握。这种方法没有使用单独的函数，由于该函数简单，直接放到主程序当中来实现，当然也没有用到参数传递。避免了在参数使用和参数传递中的不必要的错误。
这两种方法，前一种方法使用参数传递，在参数传递和地址传递中，指针有其非常优越的特性，利用指针我们实现了相应功能。但在具体使用中，虽然语句较少，指针在理解和学习过程中相对复杂。如在函数中的参数传递过程中，对整型变量n的传递使用的是变量n的地址&n，而不是n本身;对数组aa[1000]在函数传递中使用整型指针a，而不是*a或&a。
2 结束语
目前很多已经成型的编程专家，在很多情况下都不使用指针，特别是在大型软件程序的开发中。因为指针非常灵活和方便，在具体使用中很容易出现引用错误和指向错误的问题，与此同时这些错误在调试和测试中又是很难被发现的。数组虽然没有指针灵活，但我们可以实现与指针相同的效果，例如很多国外的编程专家都不使用指针，而使用数组来替代它。这样就避免了很多不必要的麻烦。也不是说大家都不要学习指针了，都来学数组。如果你是软件开发的新手，建议少使用指针，当然如果你是多年的编程专家并且对C语言掌握的非常透彻，指针当然是较好的选择。
摘要：针对C语言中的两大重点内容,结合实例,探讨了指针和数组在解决某些问题上的等价性,对不同层次和不同类型的C语言开发人员中有一定的指导意义。
关键词：C语言,指针,数组
参考文献
[1]李明辉,丁海艳,万克星,等.全国计算机等级考试上机考试题库——三级网络技术[M].成都:电子科技大学出版社,2008.
[2]谭浩强.C语言程序设计教程[M].3版.北京:高等教育出版社,2006.
[3]徐磊.Linux系统下C程序开发详解[M].北京:电子工业出版社,2008.
1. 初始化指针作为函数参数
指针是包含了内存地址的变量, 这个地址是内存中某一个特定数据类型变量的位置, 即地址。将指针作为函数的形参, 是将指针指向的这个变量的位置传递给函数, 供函数内部模块的调用, 而作为实参的指针并没有参与函数的调用。例1演示了这一个过程。
例1
Myfunc函数调用前和调用时的各变量在内存中的分配如图1所示。
从图1中可以看出传递给Myfunc子函数的是实参指针str和ip的内容, 即str指向的字符串首地址, ip指向的整型变量低字节的地址。在子函数调用过程中str和ip的内容并不会发生改变, 但子函数会改写str指向的字符串单元中的内容。
2. 未初始化指针作为函数参数
在有些情况下, 只是在主函数中定义一个指针变量, 但不对其初始化, 即该指针指向无效位置的内存单元, 将其作为子函数的一个形参, 希望在子函数中将该指针指向有效位置的内存单元。在这种情况下子函数必须获得该指针的地址, 将其强制转换成一个指针, 通过修改该指针指向的指针所包含的地址, 实现上述功能。具体的使用方法如例2所示。
例2
程序运行后会显示:
Myfunc函数调用前后的各变量在内存中的分配如图2所示。
从图2中可以看出在Myfunc调用前str是空指针, Myfunc在调用时, 得到的是指针str的地址, 因此可以通过str[i] (i=1, 2, …) 的方式对str中的内容进行访问和修改, 在Myfunc调用后str被指向了Myfunc子函数中动态分配的内存单元, 因此能够正常显示出字符串的内容。
通过对上述两个例子的比较可以看出:未初始化的指针变量作为形参的使用比初始化的指针变量作为形参的使用要复杂。虽然例1和例2显示的内容是相同的, 但完成的工作是不相同的。
【c语言之指针数组函数】推荐阅读：
黑马程序员：IOS面试宝典之c语言07-20
指针式万用表使用手册06-21
c语言总结07-15
c语言概念题09-22
c语言排序算法总结06-25
C语言实验报告模版07-10
c语言实验报告总结07-13
c语言课程设计要求07-25
c语言编程心得07-22
c语言二级考试题库07-07
