C语言指针学习（5）

                                                        指针数组和多重指针

1.什么是指针数组

一个数组，若其元素均为指针类型数据，称为指针数组。下面定义一个指针数组：

          int *p[4]; 

由于【】比*优先级高，因此p先与【】结合，为数组形式，然后再与前面的*结合，表示此数组是指针类型的，每个数组元素都可以指向一个整型变量。注意不要写成：

        int(*p)[4];                                             //这是指向一维数组的指针变量

【例题】将若干个字符串按字母顺序输出。

#include<stdio.h>
#include<string.h>
void sort(char *name[],int n);
void print(char *name[],int n);
int main()
{
	char *name[]={"Follow me","BASIC","Great Wall","FORTRAN","computer design"};
	int n=5;
	sort(name,n);                                 //调用sort函数，对name进行排序
	print(name,n);                                //调用print函数，输出字符串 
	return 0;
 } 
void sort(char *name[],int n)
{
	char *temp;
	int i,j,k;
	for(i=0;i<n-1;i++){
		k=i;
		for(j=i+1;j<n;j++){
			if(strcmp(name[k],name[j])>0){
				k=j;
			}
		}
		if(k!=i){
			temp=name[i];
			name[i]=name[k];
			name[k]=temp;
		}
	}
}
void print(char *name[],int n)
{
	int i;
	for(i=0;i<n;i++){
		printf("%s\n",name[i]);
	}
}

运行结果：

strcmp是系统提供的字符串比较函数，name【j】和 name【k】是第j个和第k个字符串首字符地址。strcmp（name【k】，name【j】）的值为。如果name【k】所指的字符串大于name【j】所指的字符串，则为正数，如果小于则为负数，等于就为0.

print函数也可以改写成以下形式：

void print(char *name[],int n)
{
	int i=0;
	char *p;
	p=name[0];
	while(i<n){
		p=*(name+i++);
		printf("%s\n",p);
	}
}

其中，*（name+i++）表示先求*（name+i）的值，即name【i】（它是一个地址），然后i加1。在输出时，按字符串形式输出从p地址开始的字符串。

2.指向指针数据的指针变量

在了解了指针数组的基础上，需要了解指向指针数据的指针变量，简称为指向指针的指针。下面定义一个指向指针数据的指针变量：char **p;

**p相当于*（*p），*p是指针变量的定义形式，前面又有一个*代表指向指针数据的指针变量。

【例题】使用指向指针数据的指针变量

#include<stdio.h>
int main()
{
	char *name[]={"Follow me","BASIC","Great Wall","FORTRAN","computer design"};
	char **p;
	int i;
	for(i=0;i<5;i++){
		p=name+i;
		printf("%s\n",*p);
	}
	return 0;
 } 

运行结果：

【例题】有一个指针数组，其元素分别指向一个整型数组的元素，用指向指针数据的指针变量，输出整型数组各元素的值。

#include<stdio.h>
int main()
{
	int a[5]={1,3,5,7,9};
	int *num[5]={&a[0],&a[1],&a[2],&a[3],&a[4]};
	int **p,i;
	p=num;
	for(i=0;i<5;i++){
		printf("%d ",**p);
		p++;
	}
	return 0;
}

 运行结果：

3.指针数组作main函数的形参

 指针数组的一个重要的应用是作为main函数的形参。在以往的过程中，main函数的第一行一般写为int main（）或者int main（void）括号中是空或者void表示main函数没有参数，调用main函数时不必给出实参，这是一般程序采用的形式，在某些情况下，main函数可以有参数，即：

int main(int argc,char *argv[])

其中，argc和argv就是函数的实参，他们是程序的“命令行参数”，argc（argument count的缩写，意思是参数个数），argv（argument vector缩写，意思是参数向量），它是一个*char指针数组，数组中的每一个元素指向命令行中的一个字符串的首字母。

通常main函数和其他函数组成一个文件模块，有一个文件名，对这个文件进行编译和连接，得到可执行文件（后缀为.exe）。用户执行这个可执行文件操作系统就调用main函数，然后由main函数调用其他函数，从而完成程序的功能。
什么情况下 main 函数需要参数？main 兩数的形参是从哪里传递给它们的呢？

显然形参的值不可能在程序中得到。main 函数是操作系统调用的,实参只能由操作系统给出。在操作命令状态下,实参是和执行文件的命令一起给出的。例如在 DOS,UNIX 或Linux等系统的操作命令状态下,在命令行中包括了命令名和需要传给 main 函数的参数。命令行的一般形式为
命令名参数 1 参数 2…参数 n
命令名和各参数之间用空格分隔。命令名是可执行文件名(此文件包含 main 函数),假设可执行文件名为 filel. exe,今想将两个字符串"China","Beijing"作为传送给 main 函数的参数。命令行可以写成以下形式：
filel China Beijing
filel 为可执行文件名,China 和 Beijing 是调用 main 函数时的实参。实际上,文件名应包括盘符,路径,今为简化起见,用 filel 来代表。请注意以上参数与 main 函数中形参的关系。main 函数中形参 argc 是指命令行中参数的个数(注意,文件名也作为一个参数。例如,本例中“filel”也算一个参数),现在,argc 的值等于 3（有 3 个命令行参数：file1,China, Beijing)。 main 函数的第 2 个形参 argv 是一个指向字符串的指针数组,也就是说,带参数的 main 函数原型是:
int main(int argc,char * argv[ ]);
命令行参数必须都是字符串(例如,上面命令行中的"filel","China","Beijing"都是字符串),这些字符串首地址构成一个指针数组,见图 8.41。指针数组 argv 中的元素 argv[O]指向字符串"file1"的首字符(或者说 argv[o]的值是字符串"file1”的首地址),argv[I]指向字符串"China"的首字符,argv[2]指向字符串"Beijing"的首字母。

如果有一个名为 fiel 的文件,它包言以下的 min 函数。

#include<stdio.h>
int main(int argc,char *argv[])
{
	while(argc>1){
		++argv;
		printf("%s\n",*argv);
		--argc;
	}
	return 0;
}

在 Visual C++ 环境下对程序编译和连接后,选择“工程”—>“设置”—>“调试”—>“程序查量"命令,输入"China Beijing”,再运行程序,将会输出以下信息,
China
Being
上面 main 函数可以改写为

int main(in arge.char eargx[ ]){
(while(arge-->1)
print("%s\n",·++argv);
}

其中,“*十十argv”是先进行十十argv的运算,使 arBv 指向下一个元素,然后进行。的运算.找到 argv 当前指向的字符串,输出该字符串。在开始时,argv 指向字符串"filea!"，++argv使之指向"China",所以第1次输出的是"China",第 2次输出"Beining”。各字符串)在同一行上输出。实现“参数回送”的C程序(文件名为 echo.e)如下，

#include<stdio.h>
int main(int argc,char *argv[])
{
	while(--argc>0){
		printf("%s%c",*++argv,(argc>1)?'':'\n');
		--argc;
	}
	return 0;
}

其实，main函数中的形参不一定命名为argc和argv，可以是任意的名字，只是人们习惯用argc和argv而已。

利用指针数组作main函数的形参，可以向程序传送命令行参数（这些参数是字符串），这些字符串的长度事先并1不知道，而且各参数字符串的长度也不一定相同，命令行参数的数目也可以是任意的。用指针数组能够较好的满足上述要求。

3.动态内存分配与指向它的指针变量
1.什么是内存的动态分配
我们已近了解过全局变量和局部变量，全局变量是分配在内存中的静态存储区的，非静态的局部变量(包括形参)是分配在内存中的动态存储区的,这个存储区是一个称为栈(stack)的区域。除此以外,C语言还允许建立内存动态分配区域,以存放一些临时用的数据,这些数据不必在程序的声明部分定义,也不必等到函数结束时才释放,而是需要时随时开辟,不需要时随时释放。这些数据是临时存放在一个特别的自由存储区,称为堆(heap)区。可以根据需要,向系统申请所需大小的空间。由于未在声明部分定义它们为变量或数组,因此不能通过变量名或数组名去引用这些数据,只能通过指针来引用。
2 怎样建立内存的动态分配
对内存的动态分配是通过系统提供的库函数来实现的,主要有 malloc, calloc, fre,
ealloc 这 4 个函数。
1.用 malloc 函数开辟动态存储区
其函数原型为：

void *malloc(unsigned int size);

其作用是在内存的动态存储区中分配一个长度为 size 的连续空间。形参 size的类型定为无符号整型（不允许为负数）。此函数的值，是所分配区域的第一个字节的地址，或者说,此函数是一个指针型函数,返回的指针指向该分配域的第一个字节。如：

malloe(100)；            //开辟 100 字节的临时分配域,函数值为其第1个字节的地址

注意指针的基类型为 void,即不指向任何类型的数据,只提供一个纯地址。如果此函数未能成功地执行(例如内存空间不足),则返回空指针(NULL)。
2.用 calloc 函数开辟动态存储区
其函数原型为：

void * calloc( unsigned n,unsigned size);

其作用是在内存的动态存储区中分配n个长度为 size的连续空间,这个空间一般比较大,足以保存一个数组。
用 calloc 函数可以为一维数组开辟动态存储空间,n 为数组元素个数,每个元素长度为size。这就是动态数组。函数返回指向所分配域的第一个字节的指针;如果分配不成功,返回NULL。如：

p=calloc(50,4)；          //开辟 50×4 个字节的临时分配域,把首地址赋给指针变量；

3.用 realloc 函数重新分配动态存储区
其函数原型为

void * realloc(void * p,unsigned int size);

如果已经通过 malloc 函数或 calloc 函数获得了动态空间,想改变其大小,可以用 recalloc 函
数重新分配。
用 realloc 函数将 p 所指向的动态空间的大小改变为 size。p 的值不变。如果重分配不
成功,返回 NULL。如

realloc(p,50)；  //将 p所指向的已分配的动态空间改为 50 字节

4.用 free 函数释放动态存储区
其函数原型为：

void free(void * p);

作用是释放指针变量p所指向的动态空间,使这部分空间能重新被其他变量使用。P应是最近一次调用 calloc 或 malloc 函数时得到的函数返回值。如：

free(p)；    //释放指针变量 p 所指向的已分配的动态空间

free函数无返回值。
以上4 个函数的声明在 stdlib. h 头文件中,在用到这些函数时，应当用“#include<stdlib.h>”指令把头文件包含到程序文件中。

3.void指针类型

C 99 允许使用基类型为 void 的指针类型。可以定义一个基类型为 void 的指针变量(即void *型变量),它不指向任何类型的数据。请注意：不要把“指向 void 类型”理解为能指向“任何的类型”的数据,而应理解为“指向空类型”或“不指向确定的类型”的数据。在将它的值赋给另一指针变量时由系统对它进行类型转换,使之适合于被赋值的变量的类型。例如：

int a=3；                         //定义a为整型变量 
int *pl=&a；                      //p1指向int型变量 
char * p2;                        //p2指向char型变量 
void * p3;                        //p3为无类型指针变量（基类型为void型） 
p3=(void *)pl；                   //将p1的值转换为void*类型，然后赋值给p3 
p2=(char*)p3；                    //将p3的值转换为char*类型，然后赋值给p2 
printf("%d",* pl);                //合法，输出整型变量a的值 
p3=&a; printf("%d",* p3)；        //错误，p3是无指向的，不能指向a 

【例题】建立动态数组，输入5个学生成绩，另外用一个函数检查有没有不及格的并输出

#include<stdio.h>
#include<stdlib.h>
void check(int *);
int main(int argc,char *argv[])
{
	int p1,i;                           //p1是int型指针
	p1=(int *)malloc(5*sizef(int));     //开辟动态内存区，将地址转化为int*型，然后放在p1中
	for(i=0;i<5;i++){
		scanf("%d",p1+i);               //输入五个学生的成绩 
	} 
	check(p1);                          //调用函数 
	return 0;
}
void check(int *p){
	int i;
	printf("They are fail:");
	for(i=0;i<5;i++){
		if(p[i]<60){
			printf("%d ",p[i]);
		}
	}
	printf("\n");
}