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

最新推荐文章于 2024-01-07 14:35:03 发布

jorgen7062

最新推荐文章于 2024-01-07 14:35:03 发布

阅读量274

点赞数 2

分类专栏： # 谭浩强《C程序设计》例程笔记 C语言

本文链接：https://blog.csdn.net/qq_28340229/article/details/104072717

版权

C语言同时被 2 个专栏收录

12 篇文章 1 订阅

订阅专栏

谭浩强《C程序设计》例程笔记

10 篇文章 1 订阅

订阅专栏

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

文章目录

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

源码

源码: github.

知识点：

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

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

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

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

在这里插入图片描述

#include <stdio.h>
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 <stdio.h>
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<b
     {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 <stdio.h>
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 <stdio.h>
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 <stdio.h>
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<b，交换a和b的值  
	if(*q1<*q3) swap(q1,q3);                     // 如果a<c，交换a和c的值  
	if(*q2<*q3) swap(q2,q3);                     // 如果b<c，交换b和c的值  
}        

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

在这里插入图片描述

8-6通过指针引用数组

Tips：引用数组的方法

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

1.下标法

#include <stdio.h>
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 <stdio.h>
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 <stdio.h>
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 <stdio.h>
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 <stdio.h>
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 <stdio.h>
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 <stdio.h>
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 <stdio.h>
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 <stdio.h>
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 <stdio.h>
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 <stdio.h>
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 <stdio.h>
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 <stdio.h>
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 <stdio.h>
#include <string.h>
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 <stdio.h>
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 <stdio.h>
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 <stdio.h>
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 <stdio.h>
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 <stdio.h>
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 <stdio.h>
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 <stdio.h>
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 <stdio.h>
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 <stdio.h>
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 <stdio.h>
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 <stdio.h>
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 <stdio.h>
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 <stdio.h>
#include <string.h>
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 <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);
	}
}

在这里插入图片描述

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

在这里插入图片描述

#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++;
	}
	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 <stdio.h> 

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

在这里插入图片描述

8-30 malloc

在这里插入图片描述

有关指针的小结

弄清指针的含义：指针就是地址。
区别指针和指针变量
指针：就是地址本身；
指针变量：用来存放地址的变量
“指向”
地址意味着指向，因为通过地址找到具有该地址的对象
只有与指针变量 基类型相同的数据的地址才能存放在相应的指针变量中。
掌握在数组的操作中正确地使用指针
一维数组代表数组首元素的地址
有关指针变量的归纳比较
指针运算
5.1指针变量加减一个整数

5.2指针变量赋值

5.3两个指针变量可以相减

5.4两个指针变量比较
指针变量可以有空值，即指针变量不指向任何变量

jorgen7062

关注

2
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
C程序设计（谭浩强）随书代码验证-第八章善于利用指针

C程序设计（谭浩强）随书代码验证-第八章善于利用指针知识点：指针通过地址找到所需的变量单元，将地址形象化地称为“指针”一个变量的地址称为该变量的“ 指针”直接访问直接通过变量名访问间接访问将变量 i 的地址存放在另一变量中，然后通过该变量找到 i 的地址，从而访问 i 变量指针变量一个专门用来存放另一变量的地址（即指针），则称之为“指针变量”，即地址变量指针变量定义形式...
复制链接

扫一扫