C程序设计（谭浩强）随书代码验证-第八章 善于利用指针

C程序设计（谭浩强）随书代码验证-第八章 善于利用指针

源码

源码: github.

知识点：

• 指针
  通过地址找到所需的变量单元，将地址形象化地称为“指针”
  一个变量的地址称为该变量的“ 指针”
• 直接访问
  直接通过变量名访问
• 间接访问
  将变量 i 的地址存放在另一变量中，然后通过该变量找到 i 的地址，从而访问 i 变量
• 指针变量
  一个专门用来存放另一变量的地址（即指针），则称之为“指针变量”，即地址变量
  指针变量包含两方面内容：

1. 存储单元编号表示的地址
2. 指向存储单元的数据类型（例：int char float）

• 指针变量定义
  形式：类型名 * 指针变量名
  int * pointer_1, pointer_2
  int 为 基类型 ，用于指定此 指针变量 指向的 变量 的 类型，如例的指针变量的指向是整形，但不能指向浮点型变量
  Note：不能直接将一个整数赋值给指针变量

8-1 通过指针变量访问整形变量

#include 
int main()
{ 
	int a=100,b=10;                            // 定义整型变量a,b，并初始化
  	int *pointer_1, *pointer_2;                // 定义指向整型数据的指针变量pointer_1, pointer_2
  	
	pointer_1=&a;                              // 把变量a的地址赋给指针变量pointer_1
  	pointer_2=&b;                              // 把变量b的地址赋给指针变量pointer_2 
  	printf("a=%d,b=%d\n",a,b);                 // 输出变量a和b的值
  	printf("*pointer_1=%d,*pointer_2=%d\n",*pointer_1,*pointer_2);     //
  	return 0;
}

8-2 引用指针变量

#include 
int main()
 { int *p1,*p2,*p,a,b;
   printf("please enter two integer numbers:");
   scanf("%d,%d",&a,&b);                   // 输入两个整数
   p1=&a;                                  // 使p1指向变量a
   p2=&b;                                  // 使p2指向变量b 
   if(a<b)                                 // 如果a
     {p=p1;p1=p2;p2=p;}                    // 使p1与p2的值互换
   printf("a=%d,b=%d\n",a,b);              // 输出a,b
   printf("max=%d,min=%d\n",*p1,*p2);      // 输出p1和p2所指向的变量的值
   return 0;
}

Note：第9行可以改为p1 = &b; p2 = &a;

8-3指针变量作为函数的参数

#include 
int main()
{
	void swap(int *p1,int *p2);
  	int a,b;
  	int*pointer_1,*pointer_2;
  	
  	printf("please enter a and b:");
  	scanf("%d,%d",&a,&b);
  	
  	pointer_1=&a;
  	pointer_2=&b;
  	
  	if(a<b) swap(pointer_1,pointer_2);
  	
  	printf("max=%d,min=%d\n",a,b);
  	
  return 0;
 }    

void swap(int *p1,int *p2)
{	
	int temp;
  	temp=*p1;
  	*p1=*p2;
  	*p2=temp;
}

Note：交换时，直接对地址所对应的空间进行变量值交换
如下方式有风险

temp 是temp所指向的变量。由于temp并未赋值，其指向的单元不可预知，当对temp赋值 就是向未知单元赋值，此未知单元可能存放着有用的数据，因此有可能破坏系统的正常工作。
故应该使用与 *p1 *p2 相同类型的变量，int temp；

Note：上图函数不能用于函数值交换，应该使用其指针进行交换操作

8-4 指针形参的改变不能改变实参的值

#include 
int main()
{
	void swap(int *p1,int *p2);
  	int a,b;
  	int*pointer_1,*pointer_2;
  	
	printf("please enter two integer numbers:");
	scanf("%d,%d",&a,&b);
	
	pointer_1=&a;
	pointer_2=&b;
	
	if(a<b) 
		swap(pointer_1,pointer_2);
		
	printf("max=%d,min=%d\n",a,b);
	
	return 0;
 }    

void swap(int *p1,int *p2)
{
	int *p;
	
	p=p1;
	p1=p2;
	p2=p;
}

point：实参变量和形参变量之间的数值传递是单向的“值传递”
Note:通过改变指针形参并没有改变实参，数据并没有被交换

8-5 输入三个整数，并大小排序

#include 
int main()
{
	void exchange(int *q1, int *q2, int *q3);    // 函数声明  
	
	int a,b,c,*p1,*p2,*p3;
	
	printf("please enter three numbers:");
	scanf("%d,%d,%d",&a,&b,&c);
	
	p1=&a;p2=&b;p3=&c;
	
	exchange(p1,p2,p3);
	
	printf("The order is:%d,%d,%d\n",a,b,c);
	
	return 0;
}

void exchange(int *q1, int *q2, int *q3)       // 定义将3个变量的值交换的函数   
{ 
	void swap(int *pt1, int *pt2);               // 函数声明  
	
	if(*q1<*q2) swap(q1,q2);                     // 如果a
	if(*q1<*q3) swap(q1,q3);                     // 如果a
	if(*q2<*q3) swap(q2,q3);                     // 如果b
}        

void swap(int *pt1, int *pt2)                  // 定义交换2个变量的值的函数      
{ 
	int temp;
	
	temp=*pt1;                                   // 换*pt1和*pt2变量的值  
	*pt1=*pt2;
	*pt2=temp;
}  

8-6通过指针引用数组

• Tips：引用数组的方法

1. 下标法，如a[i]
2. 指针法，如*（a+i）或 *(p+i)。 a是数组名，p是指向数组元素的指针变量，其初值 p = a

1.下标法

#include 
int main()
{
	int a[10];
  	int i;
  	
  	printf("please enter 10 integer numbers:");
  	for(i=0;i<10;i++)
    	scanf("%d",&a[i]);
    	
  	for(i=0;i<10;i++)
    	printf("%d ",a[i]);
    	
  	printf("%\n");
  	return 0;
 }

2.数组名计算数组元素地址

#include 
int main()
{
	int a[10];
	int i;
	
	printf("please enter 10 integer numbers:");
	for(i=0;i<10;i++)
		scanf("%d",&a[i]);
	
	for(i=0;i<10;i++)
		printf("%d ",*(a+i));       //通过故数组名和元素序号计算元素地址，再找到该元素
	
	printf("\n");
	
	return 0;
}

3.用指针变量指向数组元素

#include 
int main()
{
	int a[10];
	int *p,i;
	
	printf("please enter 10 integer numbers:");
	for(i=0;i<10;i++)
		scanf("%d",&a[i]);
		
	for(p=a;p<(a+10);p++)
		printf("%d ",*p);                             // 用指针指向当前的数组元素
	
	printf("\n");

	return 0;
}

Note：8,9行可以改为以下

#include 
int main()
{
	int a[10];
	int *p;
	
	printf("please enter 10 integer numbers:");
	for(p=a;p<(a+10);p++)
		scanf("%d",p);
		
	for(p=a;p<(a+10);p++)
		printf("%d ",*p);                             // 用指针指向当前的数组元素
	printf("\n");
	
	return 0;
}

比较：

方法	优缺点
1.下标法	与2. 方法执行效率相同 ，编译器会将其转化至2,形式处理
2.数组名计算数组元素地址	同1.
3.用指针变量指向数组元素	不用每次重新计算地址，大大提高执行效率

• Note
  p ++ 是可以使用的，但是a ++ 不能使用，因为a 代表数组元素首地址，是一个指针型常亮

8-7注意指针变量的当前值

#include 
int  main()
{ 
	int *p,i,a[10];
	p=a;
	
	printf("please enter 10 numbers:");
	for(i=0;i<10;i++)
		scanf("%d",p++);
	
	for(i=0;i<10;i++,p++)
		printf("%d ",*p);
	
	printf("\n");
	
	return 0;
}

原因
执行第一个循环后，指针p已经指向数组的末尾了
应该在执行第二个循环之前，重新将数组的首元素传递给p

#include 
int main()
{ 
	int i,a[10],*p=a;
	
	printf("please enter 10 integer numbers:");
	for(i=0;i<10;i++)
		scanf("%d",p++);
	
	p=a;  //重新将数组的首元素传递给p
	
	for(i=0;i<10;i++,p++)
		printf("%d ",*p);
	
	printf("\n");
	
	return 0;
}

指针的使用技巧 小结

• Tips1.
  
• Tips2.
  
  
• Tips3
  
• Tips4
  
• Tips5
  

8-8 用数组名作函数参数

1 数组名作形参

#include 
int main()
{
	void inv(int x[ ],int n);
	int i,a[10]={3,7,9,11,0,6,7,5,4,2};
	
	printf("The original array:\n");
	for(i=0;i<10;i++)
		printf("%d ",a[i]);                   // 输出未交换时数组各元素的值
	printf("\n");
	
	inv(a,10);                               // 调用inv函数，进行交换

	printf("The array has been inverted:\n");
	for(i=0;i<10;i++)
		printf("%d ",a[i]);                    //  输出交换后数组各元素的值
	printf("\n");
	
	return 0;
}

void inv(int x[ ],int n)                  // 形参x是蚊数组名
{
	int temp,i,j,m=(n-1)/2;
	for(i=0;i<=m;i++)
	{
		j=n-1-i;
		
	 	temp=x[i];
		x[i]=x[j];
		x[j]=temp;       // 把x[i]和x[j]交换
	}
	return;
}

2 指针变量作形参

#include 
int main()
{
	void inv(int *x,int n);
	int i,a[10]={3,7,9,11,0,6,7,5,4,2};
	
	printf("The original array:\n");
	for(i=0;i<10;i++)
		printf("%d ",a[i]);
	printf("\n");
	
	inv(a,10);
	
	printf("The array has been inverted:\n");

	for(i=0;i<10;i++)
		printf("%d ",a[i]);
	printf("\n");
	
	return 0;
}

void inv(int *x,int n)                   //形参x是指针变量       
{
	int temp,*i,*j;
	
	i=x;
	j=x+n-1;
	
	for(;i<=j;i++,j--)
	{temp=*i;*i=*j;*j=temp;}               //*i与*j交换
	return;
}

8-9 8-10 省略

8- 11 通过指针引用多维数组

1. 多维数组元素地址

#include 
int main()
{ 
	int a[3][4]={1,3,5,7,9,11,13,15,17,19,21,23};
	
	printf("%d,%d\n",a,*a);                      // 0行首地址和0行0列元素地址
	
	printf("%d,%d\n",a[0],*(a+0));               // 0行0列元素地址
	
	printf("%d,%d\n",&a[0],&a[0][0]);            // 0行首地址和0行0列元素地址

	printf("%d,%d\n",a[1],a+1);                  // 1行0列元素地址和1行首地址

	printf("%d,%d\n",&a[1][0],*(a+1)+0);         // 1行0列元素地址

	printf("%d,%d\n",a[2],*(a+2));               // 2行0列元素地址

	printf("%d,%d\n",&a[2],a+2);                 // 2行首地址

	printf("%d,%d\n",a[1][0],*(*(a+1)+0));       // 1行0列元素的值

	printf("%d,%d\n",*a[2],*(*(a+2)+0));         // 2行0列元素的值

	return 0;
}

2.指向多维数组元素的指针变量

#include 
int main()
{
	int a[3][4]={1,3,5,7,9,11,13,15,17,19,21,23};
	int *p;
	
	for(p=a[0];p<a[0]+12;p++)
	{
		if((p-a[0])%4==0)
			printf("\n");
			
	 	printf("%4d",*p);
	}
	
	printf("\n");
	
	return 0;
} 

#include 
int main()
{
	int a[3][4]={1,3,5,7,9,11,13,15,17,19,21,23};
	int (*p)[4],i,j;                           // 指针变量p指向包含4个整型元素的一维数组
	p=a;                                       // p指向二维数组的0行
	
	printf("please enter row and colum:");
	scanf("%d,%d",&i,&j); 
	                     // 指定元素的行列
	printf("a[%d,%d]=%d\n",i,j,*(*(p+i)+j));   // 输出a[i][j]的值
	
	return 0;
}

指针数组 VS 数组指针

3.用指向数组的指针作函数参数

#include 
int main()
{
	void average(float *p,int n);
  	void search(float (*p)[4],int n);
  	
  	float score[3][4]={{65,67,70,60},{80,87,90,81},{90,99,100,98}};
  	
  	average(*score,12); //jl:注意此处实参  
	           
  	search(score,2);	//jl:注意此处实参 
	   
 	return 0;
}

void average(float *p,int n)	//jl:注意此处形参 
{
	float *p_end;
	float sum=0,aver;
	p_end=p+n-1;
	
	for(;p<=p_end;p++)
		sum=sum+(*p);
		
	aver=sum/n;
	
	printf("average=%5.2f\n",aver);
}

void search(float (*p)[4],int n)	//jl:注意此处形参 
{
	int i;
	
	printf("The score of No.%d are:\n",n);
	
	for(i=0;i<4;i++)
	printf("%5.2f ",*(*(p+n)+i));
	
	printf("\n");
}

#include 
int main()
{
	void search(float (*p)[4],int n); 
	    
	float score[3][4]={{65,57,70,60},{58,87,90,81},{90,99,100,98}};
	
	search(score,3);
	
	return 0;
}

void search(float (*p)[4],int n)
{
	int i,j,flag;
	for(j=0;j<n;j++)
	{
		flag=0;
		
		for(i=0;i<4;i++)
		if(*(*(p+j)+i)<60) 
			flag=1;
			
		if(flag==1)
		{ 
			printf("No.%d fails,his scores are:\n",j+1);
			
			for(i=0;i<4;i++)
			printf("%5.1f ",*(*(p+j)+i));
			
			printf("\n");
		}
	}
} 

通过指针引用字符串

8-16 (1)用字符数组存放一个字符串,可以通过数组名和下标引用字符串中一个字符,也可以通过数组名和格式声明“%s“输出该字符串。

#include 
#include 
int main()
{
	char string[]="I love China!"; 
	
	//string[13] = 'W';       
	
	printf("%s\n",string);                    // 用%s输出string，可以输出整个字符串
	
	printf("sizeof(string) = %d\n",sizeof(string)); 	//14
	printf("strlen(string) = %d\n",strlen(string));   	//13
		
	printf("%c\n",string[7]);
	
	//printf(" string[14] = %c\n",string[14]);
	
	return 0;
}

8-17(2)用字符指针变量指向一个字符串常量,通过字符指针变量引用字符串常量。

#include 
int main()
{
	//char *string="I love China!";  //right
	
	
	char *string ="I love China!";	//right
	string="I love China!"; 		//right
	
	
	//*string="I love China!";    //error
	
	printf("%s\n",string);
	return 0;
}

8-18 对字符串中字符的存取,可以用下标方法,也可以用指针方法。

#include 
int main()
{
	char a[ ]="I am a student.",b[20];
	int i;
	
	for(i=0;*(a+i)!='\0';i++)
		*(b+i)=*(a+i);                  //将a[i]的值赋给b[i]
	*(b+i)='\0';                       //在b数组的有效字符之后加'\n'
	
	printf("string a is:%s\n",a);      //输出a数组中全部字符
	printf("string b is:");
	for(i=0;b[i]!='\0';i++)
		printf("%c",b[i]);               //逐个输出b数组中全部字符
	printf("\n");
	
	return 0;
}

8-19 用指针方法

#include 
int main()
{
	char a[]="I am a boy.",b[20],*p1,*p2;
	p1=a;p2=b;                                   // p1,p2分别指向a数组和b数组中的第一个元素
	
	for(;*p1!='\0';p1++,p2++)
		*p2=*p1;                                  // 将p1所指向的元素的值赋给p2所指向的元素
	
	*p2='\0';                                    // 在复制完全部有效字符后加'\0'
	printf("string a is:%s\n",a);                // 输出a数组中的字符
	printf("string b is:%s\n",b);                // 输出b数组中的字符
	return 0;
}

字符指针作函数参数

1. 字符数组名 作 函数参数

#include 
int main()
{
	void copy_string(char from[], char to[]);
	char a[]="I am a teacher.";
	char b[]="you are a student.";
	
	printf("string a=%s\nstring b=%s\n\n",a,b);
	printf("copy string a to string b:\n");
	
	copy_string(a,b);
	
	printf("\nstring a=%s\nstring b=%s\n",a,b);  
	return 0;
}

void copy_string(char from[], char to[])
{ 
	int i=0;
	while(from[i]!='\0')
	{
		to[i]=from[i];
		i++;
	}
	
	to[i]='\0';
}        

2.字符 指针变量 作 函数参数

#include 
int main()
{
	void copy_string(char from[], char to[]);
	char a[]="I am a teacher.";
	char b[]="you are a student.";
	char *from=a,*to=b;
	
	printf("string a=%s\nstring b=%s\n",a,b);
	printf("\ncopy string a to string b:\n\n");
	
	copy_string(from,to);
	
	printf("string a=%s\nstring b=%s\n",a,b);  
	return 0;
}

void copy_string(char from[], char to[])
{ 
	int i=0;
	while(from[i]!='\0')
	{
		to[i]=from[i];
		i++;
	}
	to[i]='\0';
}        

3.字符 指针变量 作 函数形参&实参

#include 
int main()
{
	void copy_string(char *from, char *to);
	
	char *a="I am a teacher.";
	char b[]="You are a student.";
	char *p=b;                                             // 使指针变量p指向b数组首元素
	
	printf("string a=%s\nstring b=%s\n",a,b);              // 输出a串和b串
	printf("\ncopy string a to string b:\n\n");
	
	copy_string(a,p);                                      // 调用copy_string函数，实现复制
	
	printf("string a=%s\nstring b=%s\n",a,b);  
	return 0;
}

void copy_string(char *from, char *to)                  // 定义函数，形参为字符指针变量
{  
	for(;*from!='\0';from++,to++)
	{
		*to=*from;
	}
	*to='\0';
}        

使用字符指针变量 和 字符数组比较

（1）字符数组：
字符数组由若干个元素组成，每个元素放一个字符
字符指针变量存放的是地址(字符串第一个字符的地址)
（2）赋值方式
可以对 字符指针变量 赋值，但是不能对 数组名 赋值


（3）初始化的含义

（4）存储单元的内容


(5)指针变量的值可以改变，数组名代表一个固定值（数组元素首地址） ，不能改变


(6)字符数组各元素的值是可以被改变的，（可进行再赋值），但字符指针指向的字符串常量中的内容是不可以被取代的（不能对它们再赋值）

#include 
int main()
{
	char *a="I love China!";
	//a=a+7;
	
	//*( a + 2 ) = 'w';	//error:不能修改字符串常量 
	//a[1] = 'A';			//error:不能修改字符串常量 
	
	printf("%s\n",a);
	return 0;
}

（7）

（8）

8.5指向函数的指针

函数指针定义
如果在程序中定义了一个函数，在编译时，编译系统为函数代码分配一段存储空间，这段存储空间的起始地址（又称 入口地址）称为这个函数的指针

8-22用函数指针变量调用函数

#include 
int main()
{
	int max(int,int);
	int (*p)(int,int);                           // 定义指向函数的指针变量p
	int a,b,c;
	
	p=max;                                       // 使p指向max函数
	printf("please enter a and b:");
	scanf("%d,%d",&a,&b);
	
	c=(*p)(a,b);                                 // 通过指针变量调用max函数
	
	printf("a=%d\nb=%d\nmax=%d\n",a,b,c);
	return 0;
}

int max(int x,int y)                            // 定义max函数
{
	int z;
	if(x>y)  
		z=x;
	else     
		z=y;
		
	return(z);
}

函数指针变量的 定义 和 使用

形式： 类型名（* 指针变量名）（函数参数列表）
此为指向函数的指针

对比：类型名 * 指针变量名（函数参数列表）
此为返回值为整形指针的函数

8-23用函数指针变量调用函数

#include 
int main()
{
	int max(int,int);                     // 函数声明
	int min(int x,int y);                 // 函数声明      
	int (*p)(int,int);                    // 定义指向函数的指针变量
	int a,b,c,n;
	
	printf("please enter a and b:");
	scanf("%d,%d",&a,&b);
	
	printf("please choose 1 or 2:");
	scanf("%d",&n);                       	// 输入1戓2
	
	if (n==1) 
		p=max;                      		// 如输入1，使p指向max函数          
	else if (n==2) 
		p=min;                 				// 如输入2，使p指向min函数   
	
	c=(*p)(a,b);                          	// 调用p指向的函数
	
	printf("a=%d,b=%d\n",a,b);
	if (n==1) 
		printf("max=%d\n",c);
	else  
		printf("min=%d\n",c);
	return 0;
}

int max(int x,int y)
{
	int z;
	if(x>y)  z=x;
	else     z=y;
	return(z);
}

int min(int x,int y)
{
	int z;
	if(x<y)  z=x;
	else     z=y;
	return(z);
}

8-24用指向函数的指针作函数参数

指向函数的指针变量的一个重要用途是把函数的地址作为参数传递到其他函数

#include 
int main()
{
	int max(int,int); 
	int min(int,int);
	int add(int,int);
	void fun(int x,int y, int (*p)(int,int));
	int a=34,b=-21,n;
	
	printf("please choose 1,2 or 3:");
	scanf("%d",&n);
	
	if (n==1) 
		fun(a,b,max);
	else if (n==2) 
		fun(a,b,min);
	else if (n==3) 
		fun(a,b,add);
	return 0;
}

void fun(int x,int y,int (*p)(int,int))
{
	int resout; 
	resout=(*p)(x,y);
	printf("%d\n",resout);
}

int max(int x,int y)
{
	int z;
	if(x>y)
		z=x;
	else 
		z=y;
	printf("max=" );
	return(z);
}

int min(int x,int y)
{ 
	int z;
	if(x<y)
		z=x;
	else 
		z=y;
	printf("min=");
	return(z);
}

int add(int x,int y)
{ 
	int z;
	z=x+y;
	printf("sum=");
	return(z);
}

8-25 返回指针值的函数

形式:
类型名 * 函数名（参数列表）

#include 
int main()
{
	float score[ ][4]={{60,70,80,90},{56,89,67,88},{34,78,90,66}};   //定义数组，存放成绩
	float  *search(float (*pointer)[4],int n);                       // 函数声明
	float  *p;
	int i,k;
	
	printf("enter the number of student:");
	scanf("%d",&k);                                                  // 输入要找的学生的序号
	
	printf("The scores of No.%d are:\n",k);
	p=search(score,k);                                    //调用search函数，返回score[k][0]的地址
	
	for(i=0;i<4;i++)
		printf("%5.2f\t",*(p+i));                           // 输出score[k][0]到score[k][3]的值
	printf("\n");
	return 0;
}

float *search(float (*pointer)[4],int n)               // 定义函数，形参pointer是指向一维数组的指针变量
{
	float *pt;
	pt=*(pointer+n);                                    // pt的值是&score[k][0]
	return(pt);
}

8-26 返回指针值的函数

#include 
int main()
{
	float score[ ][4]={{60,70,80,90},{56,89,67,88},{34,78,90,66}};   //定义数组，存放成绩
	float  *search(float (*pointer)[4]);                      // 函数声明
	float  *p;
	int i,j;
	for(i=0;i<3;i++)
	{
		p=search(score+i);                                    //调用search函数,如有不及格返回score[i][0]的地址，否则返回NULL，
	  	if(p==*(score+i))                                     //如果返回的是score[i][0]的地址
	    {
			printf("No.%d score:",i);
		 	for(j=0;j<4;j++)
	        	printf("%5.2f  ",*(p+j));                       // 输出score[i][0]到score[i][3]的值
	     	printf("\n");
	    } 
	 }
	return 0;
}

float *search(float (*pointer)[4])                            // 定义函数，形参pointer是指向一维数组的指针变量
{
	int i=0;
	float *pt;
	pt=NULL;                                                   // 先使pt的值为NULL
	for(;i<4;i++)
	 	if(*(*pointer+i)<60) 
		pt=*pointer;                        // 如果有不及格课程，使pt指向score[i][0] 
	return(pt);
}

指针数组 和 多重指针

一个数组，其元素均为指针类型数据，称为指针数组

形式：
类型名 * 数组名[数组长度]

使用背景
指向若干个字符串，使字符串处理更加灵活

8-27指针数组

#include 
#include 
int main()
{
	void sort(char *name[ ],int n);
	void print(char *name[ ],int n);
	
	char *name[ ]={"Follow me","BASIC","Great Wall","FORTRAN","Computer design"};
	int n=5;
	
	sort(name,n);
	print(name,n);
	
	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]);
}

8-28指向 指针数据 的 指针

#include 
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);
	}
}

8-29指向整型数据 的 指针数组

#include 
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++;
	}
	printf("\n");
	return 0;
}

指针数组作函数的形参

动态内存分配 与 指向它的指针变量

概述
静态存储区
动态存储区（栈区）：非静态局部变量存储区
内存动态分配区域（堆区）：可以随时开辟，随时释放
由于未在声明部分定义他们为变量或数组，因此不能通过变量名和数组名来引用，只能通过指针来引用

内存动态分配的建立
malloc
calloc
realloc
free

1.malloc
函数原型：
void * malloc(unsigned int size);

作用：
在内存的动态存储区分配一个长度为 size 的连续空间。

如果函数未能成功执行（例如内存空间不足），则返回空指针。

2.calloc
函数原型：
void * calloc(unsigned int n, unsigned int size);

作用：
在动态存储区中分配n个长度为size的连续空间，这个空间一般比较大，足以保存一个数组

calloc函数可以为一维数组开辟动态存储空间，n为数组元素的个数，每个元素长度为size。

如果分配不成功，返回NULL

3.free
函数原型：
void free （void * p）;

作用：释放指针变量p所指向的动态空间，是这部分空间能重新被其他变量使用。

p 应是最近一次调用calloc 或 malloc函数得到的返回值

4.realloc
函数原型：
void * realloc（void *p ,unsigned int size）;

作用：
如果已经通过malloc函数 或 calloc函数获得了动态空间，想改变其大小，则可用realloc函数重新分配。

void指针类型

C99允许使用基类型为void 的指针类型，（void * 型变量），它不指向任何类型的数据

请注意：
不要把“指向void 类型”理解为能指向“任何的数据类型”的数据，而应该理解为指向“空类型”或“不指向确定的类型”的数据。在将它的值赋给另一指针变量时，由系统对它进行类型转换，使之适合于被赋值的数据类型

#include  

int main()
{
	void * void_p;
	
	char ch= 'A';
	
	void_p = &ch;
	
	printf("%c",*void_p);
}

8-30 malloc

有关指针的小结

1. 弄清指针的含义：指针就是地址。
   区别 指针和指针变量
   指针：就是地址本身；
   指针变量：用来存放地址的变量

2. “指向”
   地址意味着指向，因为通过地址找到具有该地址的对象
   只有与指针变量 基类型相同的数据的地址才能存放在相应的指针变量中。

3. 掌握在数组的操作中正确地使用指针
   一维数组代表数组首元素的地址

4. 有关指针变量的归纳比较
   
   

5. 指针运算
   5.1指针变量加减一个整数
   
   5.2指针变量赋值
   
   5.3两个指针变量可以相减
   
   5.4两个指针变量比较
   

6. 指针变量可以有空值，即指针变量不指向任何变量