• C语言实现学生管理系统（顺序表版）

    前言

    涉及知识


    使用语言：C语言


    数据结构类型：顺序表

    内容导图

    在这里插入图片描述

    效果展示

    在这里插入图片描述

    内容目录

    静态管理系统

    菜单的实现

    完成一个小项目，我们首先要明确它有那些功能，并且我们需要告诉明确的告诉用户这些功能。而菜单恰恰能够实现和用户的交互。但是，如果我们把菜单直接写在main函数里面就会显得非常的臃肿，所以我们可以把菜单封装成一个函数

    void menu()
{
	printf("********************************\n");
	printf("*******欢迎进入学生管理系统*****\n");
	printf("*********0.退出管理系统*********\n");
	printf("*********1.增加学生信息*********\n");
	printf("*********2.删除学生信息*********\n");
	printf("*********3.查找学生信息*********\n");
	printf("*********4.修改学生信息*********\n");
	printf("*********5.打印学生信息*********\n");
	printf("********************************\n");
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    选择功能实现

    有了菜单还不够，我们需要让菜单的每一个选项都有对应的功能。
    因为每个功能都还没用函数进行实现，所以我们可以先用其他东西代替测试。比如我需要添加一个学生的信息，因为我还没开始实现我的增加学生这个函数，我们可以先打印一句话来确定。选择功能的这个函数有没有出问题。
    写完选择功能，我们可以把他和菜单函数一起放在main函数中测试一下。

    int main()
{
	int input=0;

	do
	{
		menu();
		printf("请选择功能：");
		scanf("%d", &input);
		switch (input)
		{
		case 1:printf("增加\n"); break;
		case 2:printf("删除\n"); break;
		case 3:printf("查找\n"); break;
		case 4:printf("修改\n"); break;
		case 5:printf("排序\n"); break;
		case 6:printf("打印\n"); break;
		default:printf("选项输入有误！\n"); break;
		}
	} while (input);
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    在这里插入图片描述


    测试正常，选择功能并没有出错，所以我们接下来需要分类实现一个个实现对应功能的函数。

    静态开辟空间

    每一位学生都有很多信息，所以符合结构体的特性。我们可以定义一个结构体类型。

    typedef struct StudentInfo
{
	char name[NAME];//姓名
	char sex[SEX];//性别
	int id;//学号
	int age;//年纪
	int score;//分数
}Student;

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    接下来，继续开辟一个结构体，里面还要存放上面的结构体的数组

    //静态开辟100个数组
#define MAX 100
typedef struct ClassInfo
{
	Student data[MAX];
	size_t size;
}Class;

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    实现增删功能

    增加功能实现

    静态开辟空间的最大缺陷就是内存有限，不能随需而增加。
    所以我们在是实现该增加函数的时候，必须要先判断他的内存是不是已经满了。

    void ClassAdd(Class* psl)
{
	assert(psl);
	if (psl->size == MAX)
	{
		printf("该学生管理系统内存已满，请清理！\n");
		return;
	}
	printf("请输入学生姓名：");
	scanf("%s", &psl->data[psl->size].name);
	printf("请输入学生性别：");
	scanf("%s", &psl->data[psl->size].sex);
	printf("请输入学生年纪：");
	scanf("%d", &psl->data[psl->size].age);
	printf("请输入学生分数：");
	scanf("%d", &psl->data[psl->size].score);
	printf("请输入学生学号：");
	scanf("%d", &psl->data[psl->size].id);
	psl->size++;
	printf("添加信息成功！\n");
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21

    删除功能实现

    想删除一个数，那就必须得先找到这个数，找到某个数所在的位置，这个需求，在其他的功能的实现中也是被需要的。所以我们可以把它封装为一个函数，便于实现其他功能的时候可以使用。
    我们使用循环，遍历数组中的所有内容。找到了就返回下标，找不到就返回-1

    int Find_name(Class* psl, char name[])
{
	int i = 0;
	for (i = 0; i < psl->size; i++)
	{
		if (0 == strcmp(psl->data[i].name, name))
		{
			return i;
		}
	}
	return -1;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    有了查找位置的功能，再去实现删除函数就显得容易很多了。
    当然，值得注意的是，顺序表要保证数据的连续性，你删除某个数，并不是删除它所在位置的空间，而是用后面的数来覆盖掉它，并且删除掉最后面的一个空间。以此来保证数据的连续性。

    void ClassDel(Class* psl)
{
	assert(psl);
	char name[NAME];
	printf("请输入你要删除学生的姓名：");
	scanf("%s", &name);
	int ret = Find_name(psl, name);
	if (-1 == ret)
		printf("你输入的学生不存在！\n");
	else
	{
		for (int i = ret; i < psl->size - 1; i++)
		{
			psl->data[i] = psl->data[i + 1];
		}
		psl->size--;
		printf("成功删除指定联系人\n");
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

    实现查找功能

    这个功能就用到了上面我们实现的查找位置函数了。我们只要查找到需要被查找到的数的位置，并打印该位置的数，就可以了。

    void ClassSearch(Class* psl)
{
	assert(psl);
	char name[NAME];
	printf("请输入你要查找的学生的姓名：");
	scanf("%s", &name);
	int ret = Find_name(psl, name);
	if (-1 == ret)
		printf("你要查找的学生不存在！\n");
	else
	{
		printf("%-5s\t%-5s\t%-5s\t%-20s\t%-10s\n", "姓名", "性别", "年龄", "学号", "总分");
		printf("%-5s\t%-5s\t%-5d\t%-20d\t%-10d\n", psl->data[ret].name,
			psl->data[ret].sex,
			psl->data[ret].age,
			psl->data[ret].id,
			psl->data[ret].score);
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

    实现修改功能

    和查找功能一样，想修改一个数，我们必须要找到这个数的。

    void ClassModi(Class* psl)
{
	printf("请输入要修改人的名字:>");
	char name[NAME];
	scanf("%s", name);
	int ret = Find_name(psl, name);
	if (ret == -1)
		printf("要修改的人不存在\n");
	else
	{
		printf("请输入学生姓名：");
		scanf("%s", &psl->data[ret].name);
		printf("请输入学生性别：");
		scanf("%s", &psl->data[ret].sex);
		printf("请输入学生年纪：");
		scanf("%d", &psl->data[ret].age);
		printf("请输入学生分数：");
		scanf("%d", &psl->data[ret].score);
		printf("请输入学生学号：");
		scanf("%d", &psl->data[ret].id);
		printf("修改成功\n");
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23

    实现排序功能

    实现排序的方法有很多，这里我使用的是大家最常用的冒泡排序法。
    我这里以分数作为的排序标准。
    感兴趣的也可以以学号或者年纪作为排序标准。

    void Score_sqrt(Class* psl)
{
	Student tmp;
	for (int i = 0; i < psl->size; i++)
	{
		for (int j = 0; j < psl->size; j++)
		{
			if (psl->data[j].score < psl->data[j + 1].score)
			{
				tmp = psl->data[j];
				psl->data[j] = psl->data[j + 1];
				psl->data[j + 1] = tmp;
			}
		}
	}
	printf("排序完成！\n");
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    动态管理系统

    动态开辟空间

    静态的管理系统最大的缺点就是不能自主的扩容，很麻烦。
    所以这里我们可以使用动态的顺序表来修改开辟空间的这一个过程。
    当然其他功能还都可以用上述的函数实现，最后面我们会汇总代码。

    typedef struct ClassInof
{
	Student *data;
	size_t size; //现有数据
	size_t capacity;//最大容量
}Class;

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    动态的初始化

    void ClassInit(Class* psl)
{
	assert(psl);//断言防止其为空指针
	psl->data = NULL;//讲该指针置空
	psl->size = 0;//设置有效数据个数为0
	psl->capacity = 0;//设置空间容量为0
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    动态扩容函数

    我们可以通过realloc函数根据我们需要多少空间来进行动态开辟。

    void ClassAddcapacity(Class* psl)
{
	assert(psl);

	if (psl->size == psl->capacity)
	{
		int newCapacity = psl->capacity == 0 ? 4 : psl->capacity * 2;
		Student* tmp = (Student*)realloc(psl->data, newCapacity * sizeof(Student));
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}

		psl->data = tmp;
		psl->capacity = newCapacity;
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    动态增加函数

    这个增加数据的函数，就是和静态管理系统的其他功能唯一不一样的地方了。
    其他的功能的实现和静态版本的一模一样，无需修改。

    void ClassAdd(Class* psl)
{
	assert(psl);
	ClassAddcapacity( psl);
	printf("请输入学生姓名：");
	scanf("%s", &psl->data[psl->size].name);
	printf("请输入学生性别：");
	scanf("%s", &psl->data[psl->size].sex);
	printf("请输入学生年纪：");
	scanf("%d", &psl->data[psl->size].age);
	printf("请输入学生分数：");
	scanf("%d", &psl->data[psl->size].score);
	printf("请输入学生学号：");
	scanf("%d", &psl->data[psl->size].id);
	psl->size++;
	printf("添加信息成功！\n");
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    总代码汇总

    静态管理系统汇总

    头文件：student.h

    #include
#include
#include
#include
#define NAME 50
#define SEX 100
#define MAX 100
//学生信息结构
typedef struct StudentInfo
{
	char name[NAME];//姓名
	char sex[SEX];//性别
	int id;//学号
	int age;//年纪
	int score;//分数
}Student;
//静态开辟的数组
typedef struct ClassInfo
{
	Student data[MAX];
	size_t size;
}Class;
//菜单函数的声明
void menu();
//初始化函数的声明
void ClassInit(Class* psl);
//增加函数的声明
void ClassAdd(Class* psl);
//打印函数的声明
void ClassPrint(Class* psl);
//删除函数的声明
void ClassDel(Class* psl);
//查找函数的声明
void ClassSearch(Class* psl);
//修改函数的声明
void ClassModi(Class* psl);
//排序函数的声明
void Score_sqrt(Class* psl);


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39

    函数实现：student.c

    #include"Student.h"
void menu()
{
	printf("********************************\n");
	printf("*******欢迎进入学生管理系统*****\n");
	printf("*********0.退出管理系统*********\n");
	printf("*********1.增加学生信息*********\n");
	printf("*********2.删除学生信息*********\n");
	printf("*********3.查找学生信息*********\n");
	printf("*********4.修改学生信息*********\n");
	printf("*********5.成绩排序信息*********\n");
	printf("*********6.打印学生信息*********\n");
	printf("********************************\n");
}
//静态初始化
void ClassInit(Class* psl)
{
	assert(psl);
	psl->size = 0;
	memset(psl->data, 0, MAX * sizeof(Student));
}
//增加函数的实现
void ClassAdd(Class* psl)
{
	assert(psl);
	if (psl->size == MAX)
	{
		printf("该学生管理系统内存已满，请清理！\n");
		return;
	}
	printf("请输入学生姓名：");
	scanf("%s", &psl->data[psl->size].name);
	printf("请输入学生性别：");
	scanf("%s", &psl->data[psl->size].sex);
	printf("请输入学生年纪：");
	scanf("%d", &psl->data[psl->size].age);
	printf("请输入学生分数：");
	scanf("%d", &psl->data[psl->size].score);
	printf("请输入学生学号：");
	scanf("%d", &psl->data[psl->size].id);
	psl->size++;
	printf("添加信息成功！\n");
}
//打印函数的实现
void ClassPrint(Class* psl)
{
	int i = 0;
	printf("%-5s\t%-5s\t%-5s\t%-20s\t%-10s\n", "姓名", "性别", "年龄", "学号", "总分");
	for (i = 0; i < psl->size; i++)
	{
		printf("%-5s\t%-5s\t%-5d\t%-20d\t%-10d\n", psl->data[i].name,
			psl->data[i].sex,
			psl->data[i].age,
			psl->data[i].id,
			psl->data[i].score);
	}
}
//查找位置的函数
int Find_name(Class* psl, char name[])
{
	int i = 0;
	for (i = 0; i < psl->size; i++)
	{
		if (0 == strcmp(psl->data[i].name, name))
		{
			return i;
		}
	}
	return -1;
}
//删除函数的实现
void ClassDel(Class* psl)
{
	assert(psl);
	char name[NAME];
	printf("请输入你要删除学生的姓名：");
	scanf("%s", &name);
	int ret = Find_name(psl, name);
	if (-1 == ret)
		printf("你输入的学生不存在！\n");
	else
	{
		for (int i = ret; i < psl->size - 1; i++)
		{
			psl->data[i] = psl->data[i + 1];
		}
		psl->size--;
		printf("成功删除指定联系人\n");
	}
}
//查找学生函数的实现
void ClassSearch(Class* psl)
{
	assert(psl);
	char name[NAME];
	printf("请输入你要查找的学生的姓名：");
	scanf("%s", &name);
	int ret = Find_name(psl, name);
	if (-1 == ret)
		printf("你要查找的学生不存在！\n");
	else
	{
		printf("%-5s\t%-5s\t%-5s\t%-20s\t%-10s\n", "姓名", "性别", "年龄", "学号", "总分");
		printf("%-5s\t%-5s\t%-5d\t%-20d\t%-10d\n", psl->data[ret].name,
			psl->data[ret].sex,
			psl->data[ret].age,
			psl->data[ret].id,
			psl->data[ret].score);
	}
}
//修改函数的实现
void ClassModi(Class* psl)
{
	printf("请输入要修改人的名字:>");
	char name[NAME];
	scanf("%s", name);
	int ret = Find_name(psl, name);
	if (ret == -1)
		printf("要修改的人不存在\n");
	else
	{
		printf("请输入学生姓名：");
		scanf("%s", &psl->data[ret].name);
		printf("请输入学生性别：");
		scanf("%s", &psl->data[ret].sex);
		printf("请输入学生年纪：");
		scanf("%d", &psl->data[ret].age);
		printf("请输入学生分数：");
		scanf("%d", &psl->data[ret].score);
		printf("请输入学生学号：");
		scanf("%d", &psl->data[ret].id);
		printf("修改成功\n");
	}
}
//排序函数的实现(冒泡)
void Score_sqrt(Class* psl)
{
	Student tmp;
	for (int i = 0; i < psl->size; i++)
	{
		for (int j = 0; j < psl->size; j++)
		{
			if (psl->data[j].score < psl->data[j + 1].score)
			{
				tmp = psl->data[j];
				psl->data[j] = psl->data[j + 1];
				psl->data[j + 1] = tmp;
			}
		}
	}
	printf("排序完成！\n");
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139
    • 140
    • 141
    • 142
    • 143
    • 144
    • 145
    • 146
    • 147
    • 148
    • 149
    • 150
    • 151
    • 152
    • 153

    功能实现：test.c

    #include"Student.h"
int main()
{
	int input=0;
	Class class;
	ClassInit(&class);
	do
	{
		menu();
		printf("请选择功能：");
		scanf("%d", &input);
		switch (input)
		{
		case 1:ClassAdd(&class); break;
		case 2:ClassDel(&class); break;
		case 3:ClassSearch(&class); break;
		case 4:ClassModi(&class); break;
		case 5:Score_sqrt(&class); break;
		case 6:ClassPrint(&class); break;
		default:printf("选项输入有误！\n"); break;
		}
	} while (input);
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24

    动态管理系统汇总

    头文件：student.h

    #pragma once
#include
#include
#include
#include
#define NAME 100
#define SEX 50
//学生基本信息
typedef struct StudentInof
{
	char name[NAME];//姓名
	char sex[SEX];//性别
	int id;//学号
	int age;//年纪
	int score;//分数
}Student;
//动态顺序表
typedef struct ClassInof
{
	Student *data;
	size_t size; //现有数据
	size_t capacity;//最大容量
}Class;

void menu();
//初始化函数的声明
void ClassInit(Class* psl);
//增加容量声明
void ClassAddcapacity(Class* psl);
//增加函数的声明
void ClassAdd(Class* psl);
//打印函数的声明
void ClassPrint(Class* psl);
//删除函数的声明
void ClassDel(Class* psl);
//查找函数的声明
void ClassSearch(Class* psl);
//修改函数的声明
void ClassModi(Class* psl);
//排序函数的声明
void Score_sqrt(Class* psl);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41

    函数实现：stduent2.c

    #include"student.h"
//菜单的定义
void menu()
{
	printf("********************************\n");
	printf("*******欢迎进入学生管理系统*****\n");
	printf("*********0.退出管理系统*********\n");
	printf("*********1.增加学生信息*********\n");
	printf("*********2.删除学生信息*********\n");
	printf("*********3.查找学生信息*********\n");
	printf("*********4.修改学生信息*********\n");
	printf("*********5.成绩排序信息*********\n");
	printf("*********6.打印学生信息*********\n");
	printf("********************************\n");
}
//动态初始化
void ClassInit(Class* psl)
{
	assert(psl);//断言防止其为空指针
	psl->data = NULL;//讲该指针置空
	psl->size = 0;//设置有效数据个数为0
	psl->capacity = 0;//设置空间容量为0
}
//动态扩容
void ClassAddcapacity(Class* psl)
{
	assert(psl);

	if (psl->size == psl->capacity)
	{
		int newCapacity = psl->capacity == 0 ? 4 : psl->capacity * 2;
		Student* tmp = (Student*)realloc(psl->data, newCapacity * sizeof(Student));
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}

		psl->data = tmp;
		psl->capacity = newCapacity;
	}
}
//增加数据函数定义
void ClassAdd(Class* psl)
{
	assert(psl);
	ClassAddcapacity( psl);
	printf("请输入学生姓名：");
	scanf("%s", &psl->data[psl->size].name);
	printf("请输入学生性别：");
	scanf("%s", &psl->data[psl->size].sex);
	printf("请输入学生年纪：");
	scanf("%d", &psl->data[psl->size].age);
	printf("请输入学生分数：");
	scanf("%d", &psl->data[psl->size].score);
	printf("请输入学生学号：");
	scanf("%d", &psl->data[psl->size].id);
	psl->size++;
	printf("添加信息成功！\n");
}
//打印函数的定义
void ClassPrint(Class* psl)
{
	int i = 0;
	printf("%-5s\t%-5s\t%-5s\t%-20s\t%-10s\n", "姓名", "性别", "年龄", "学号", "总分");
	for (i = 0; i < psl->size; i++)
	{
		printf("%-5s\t%-5s\t%-5d\t%-20d\t%-10d\n", psl->data[i].name,
			psl->data[i].sex,
			psl->data[i].age,
			psl->data[i].id,
			psl->data[i].score);
	}
}
//查找位置的函数
int Find_name(Class* psl, char name[])
{
	int i = 0;
	for (i = 0; i < psl->size; i++)
	{
		if (0 == strcmp(psl->data[i].name, name))
		{
			return i;
		}
	}
	return -1;
}
//删除函数的实现
void ClassDel(Class* psl)
{
	assert(psl);
	char name[NAME];
	printf("请输入你要删除学生的姓名：");
	scanf("%s", &name);
	int ret = Find_name(psl, name);
	if (-1 == ret)
		printf("你输入的学生不存在！\n");
	else
	{
		for (int i = ret; i < psl->size - 1; i++)
		{
			psl->data[i] = psl->data[i + 1];
		}
		psl->size--;
		printf("成功删除指定联系人\n");
	}
}
//查找学生函数的实现
void ClassSearch(Class* psl)
{
	assert(psl);
	char name[NAME];
	printf("请输入你要查找的学生的姓名：");
	scanf("%s", &name);
	int ret = Find_name(psl, name);
	if (-1 == ret)
		printf("你要查找的学生不存在！\n");
	else
	{
		printf("%-5s\t%-5s\t%-5s\t%-20s\t%-10s\n", "姓名", "性别", "年龄", "学号", "总分");
		printf("%-5s\t%-5s\t%-5d\t%-20d\t%-10d\n", psl->data[ret].name,
			psl->data[ret].sex,
			psl->data[ret].age,
			psl->data[ret].id,
			psl->data[ret].score);
	}
}
//修改函数的实现
void ClassModi(Class* psl)
{
	printf("请输入要修改人的名字:>");
	char name[NAME];
	scanf("%s", name);
	int ret = Find_name(psl, name);
	if (ret == -1)
		printf("要修改的人不存在\n");
	else
	{
		printf("请输入学生姓名：");
		scanf("%s", &psl->data[ret].name);
		printf("请输入学生性别：");
		scanf("%s", &psl->data[ret].sex);
		printf("请输入学生年纪：");
		scanf("%d", &psl->data[ret].age);
		printf("请输入学生分数：");
		scanf("%d", &psl->data[ret].score);
		printf("请输入学生学号：");
		scanf("%d", &psl->data[ret].id);
		printf("修改成功\n");
	}
}
//排序函数的实现(冒泡)
void Score_sqrt(Class* psl)
{
	Student tmp;
	for (int i = 0; i < psl->size; i++)
	{
		for (int j = 0; j < psl->size; j++)
		{
			if (psl->data[j].score < psl->data[j + 1].score)
			{
				tmp = psl->data[j];
				psl->data[j] = psl->data[j + 1];
				psl->data[j + 1] = tmp;
			}
		}
	}
	printf("排序完成！\n");
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139
    • 140
    • 141
    • 142
    • 143
    • 144
    • 145
    • 146
    • 147
    • 148
    • 149
    • 150
    • 151
    • 152
    • 153
    • 154
    • 155
    • 156
    • 157
    • 158
    • 159
    • 160
    • 161
    • 162
    • 163
    • 164
    • 165
    • 166
    • 167
    • 168
    • 169

    功能的实现：test.c

    #include"student.h"
int main()
{
	int input = 0;
	Class class;
	ClassInit(&class);
	do
	{
		menu();
		printf("请选择功能：");
		scanf("%d", &input);
		switch (input)
		{
		case 1:ClassAdd(&class); break;
		case 2:ClassDel(&class); break;
		case 3:ClassSearch(&class); break;
		case 4:ClassModi(&class); break;
		case 5:Score_sqrt(&class); break;
		case 6:ClassPrint(&class); break;
		default:printf("选项输入有误！\n"); break;
		}
	} while (input);
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
  • 相关阅读:
    ES 两次group by,先按照每天的时间力度，在统计每天的指定字段的值出现的次数
    ILS解析漏洞复现
    bim翻模教程：如何控制revit中的填充图案和构件显示隐藏
    Hive的原理概述与安装
    基于PyTorch的flappy bird游戏
    兼具高效与易用，融云 IM 即时通讯长连接协议设计思路
    【2】c++11新特性（稳定性和兼容性）—＞超长整型 long long
    代码随想录训练营第42天|01背包问题、LeetCode 416. 分割等和子集
    抛硬币有连续x次正面的期望
    Vue脚手架学习笔记
  • 原文地址：https://blog.csdn.net/weixin_61084441/article/details/128174810