定义结构体，描述学生的姓名，年龄，三门成绩编写一子函数，实现两个结构体的交换编写一子函数，实现三门成绩的编写一子函数，实现结构体数组的输入编写一子函数，实现结构体数组的输出编写一

 定义结构体，描述学生的姓名，年龄，三门成绩

编写一子函数，实现两个结构体的交换

编写一子函数，实现三门成绩的

编写一子函数，实现结构体数组的输入

编写一子函数，实现结构体数组的输出

编写一子函数，求年龄最大人的首地址

编写一子函数，根据年龄进行排序

编写一子函数，根据姓名进行排序

编写一子函数，根据成绩总和进行排序
 

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

#define M 20
#define N 3
#define SIZE 5

//定义结构体，描述学生的姓名，年龄，三门成绩
typedef struct student
{
	char name[M];
	int age;
	float scores[M];
}Stu;
//编写一子函数，实现两个结构体的交换
//参数1：结构体1的首地址 Stu *pa 
//参数2：结构体2的首地址 Stu *pb
//返回值：void 
void swap(Stu *pa,Stu *pb)
{
	Stu temp = {0};
	temp = *pa;
	*pa = *pb;
	*pb = temp;
}
//编写一子函数，实现三门成绩的
//参数1：数组的首地址
//参数2：元素的个数
//返回值：求得的和
float sumScores(float b[],int count)
{
	int i;
	float sum = 0;
	for(i = 0; i < count; i++)
	{
		sum = sum + b[i];
	}
	return sum;
}
//编写一子函数，实现结构体数组的输入
//参数1：结构体的首地址STU *ps
//参数2：结构体的个数 int count
//返回值：void
void input(Stu *ps,int count)
{
	int i,j;
	for(i = 0;i < count; i++)
	{
		printf("请输入学生的姓名，年龄，三门成绩：\n");
		scanf("%s",ps->name);
		scanf("%d",&ps->age);
		for(j = 0;j < N; j++)
		{
			scanf("%f",&ps->scores[j]);
		}
		ps++;
	}
}
//编写一子函数，实现结构体数组的输出
//参数1：结构体的首地址
//参数2：结构体的个数
//返回值：void
void output(Stu *ps,int count)
{
	int i,j;
	for(i = 0;i < count; i++)
	{
		printf("%s ",ps->name);
		printf("%d ",ps->age);
		for(j =0;j < N; j++)
		{
			printf("%.1f ",ps->scores[j]);
		}
		printf("\n");
		ps++;
	}
}
//编写一子函数，求年龄最大人的首地址
//参数1：结构体的首地址
//参数2：结构体的个数
//返回值：年龄最大值的首地址 Stu *
Stu *calPmaxAge(Stu *ps,int count)
{
	int i;
	//定义一个结构体指针变量用来保存年龄最大人的首地址
	Stu *pMax = NULL;
	//假设第一个为最大
	pMax = ps;
	for(i = 1;i < count; i++)
	{
		if(pMax->age < (ps+i)->age)
		{
			pMax = (ps+i);
		}
	}
	return pMax;
}
//编写一子函数，根据年龄进行排序
//参数1：结构体的首地址
//参数2：元素的个数
//返回值：void
void sortByAge(Stu *ps,int count)
{
	int i,j;
	for(i = 0;i < count-1;i++)
	{
		for(j = 0;j < count-1-i; j++)
		{
			if((ps+j)->age > (ps+j+1)->age)
			{
				swap((ps+j),(ps+j+1));
			}
		}
	}
}
//编写一子函数，根据姓名进行排序
//参数1：结构体的首地址
//参数2：元素个数
//返回值：void
void sortByName(Stu *ps,int count)
{
	int i,j;
	for(i = 0; i < count-1; i++)
	{
		for(j = 0;j < count-1-i; j++)
		{
			if(strcmp((ps+j)->name,(ps+j+1)->name) > 0)
			{
				swap((ps+j),(ps+j+1));
			}
		}
	}
}
//编写一子函数，根据成绩总和进行排序
//参数1：结构体的首地址
//参数2：结构体的个数
//返回值:void
void sortBySumScores(Stu *ps,int count)
{
	int i,j;
	for(i = 0;i < count-1; i++)
	{
		for(j = 0;j < count-1-i;j++)
		{
			if(sumScores((ps+j)->scores,N) > sumScores((ps+j+1)->scores,N))
			{
				swap((ps+j),(ps+j+1));
			}
		}
	}
}

int save(Stu *p)
{
	fw = fopen("userinfo","w");
	if(NULL == fw)
	{
		perror("write file error");
		return 0;
	}
	if(fwrite(p,sizeof(Stu),3,fw) ==0)
		return 0;
	else
		fclose(fw);
	return 1;
}

int load(Stu *p)
{
	fr = fopen("userinfo","r");
	if(NULL == fr)
	{
		perror("open file error");
		return 0;
	}
	if(fread(p,sizeof(Stu),3,fr) == 0)
		return 0;
	else
		fclose(fr);
	return 1;
}

int main(void)
{
	int op;
	Stu *pMax = NULL;
	//申请SIZE个Stu那么大的空间
	//malloc
	//参数：要申请的空间的大小
	//返回值：成功返回申请到的空间的首地址，失败返回NULL
	//定义一个结构体指针变量用来接受malloc的返回值
	Stu *ps = NULL;
	ps = (Stu *)malloc(sizeof(Stu)*SIZE);
	if(NULL == ps)
	{
		perror("malloc error");
		return -1;
	}
	memset(ps,0,sizeof(Stu)*SIZE);
	while(1)
	{
		printf("请输入选项:\n");
		printf("1-----------input\n");
		printf("2-----------output\n");
		printf("3----------calPmaxAge\n");
		printf("4----------sortByAge\n");
		printf("5----------sortByName\n");
		printf("6----------sortBySumScores\n");
		printf("-1----------exit\n");
		scanf("%d",&op);
		if(-1 == op)
		{
			break;
		}
		switch(op)
		{
		case 1:
			input(ps,SIZE);
			break;
		case 2:
			output(ps,SIZE);
			break;
		case 3:
			pMax = calPmaxAge(ps,SIZE);
			printf("年龄最大人是%s首地址为：%p\n",pMax->name,pMax);
			break;
		case 4:
			sortByAge(ps,SIZE);
			break;
		case 5:
			sortByName(ps,SIZE);
			break;
		case 6:
			sortBySumScores(ps,SIZE);
			break;

		}

	}
	free(ps);
	ps = NULL;
	return 0;
}