【开发细节】用C语言基础写学生管理系统（三）

已于 2023-01-24 14:42:47 修改
阅读量1k 收藏 5
点赞数 2
分类专栏： 项目集 文章标签： c语言 开发语言 后端 算法
于 2022-01-26 21:20:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46231858/article/details/122705561
版权

前情回顾

  1. 自定义preconf.h头文件。作用：被核心头文件所包含，从而调用相关已定义的数据
  2. 定义Boolean、Status两种返回值类型，本质上是int类型
  3. 定义SqList、ElemType了两个结构体，实则属于独立结构的Struct嵌套
  4. 定义并初始化SysConfig结构体

一、本次目标

根据学生管理系统的功能特性与线性表的ADT描述，确定并编写相关的基本操作，便于后续的文件调用。

图片名称 GitHub：https://github.com/ITchujian/StudentManagementSystem_2022_C

注：为方便分享本次开发的经历，我把分析过程以及代码书写过程，以文字、图片形式合计放于开发记录中，但是一些非常基础的行为动作我将不会讲解或者阐述。
当前位置：【开发细节】用C语言基础写学生管理系统（三）
可跳转：

二、开发记录

步骤1

ADT——Abstract Data Type，意为抽象数据类型，我的理解：

描述数据结构的数学模型，以及该模型所能做出的操作

请注意，我们所使用的是线性表的顺序存储结构，而非链式结构，这一点已经在1.1文章的代码中有所体现。
因此，对于学生管理系统的线性表ADT如下：

  • 数据对象：D={学生1，学生2，……，学生n}，n>=0
  • 数据关系：R={相邻学生之间存在先后关系}
  • 基本操作表：
序号函数名操作结果
1InitList初始化，构造空的线性表
2DestroyList销毁线性表
3ClearList清空线性表
4ListEmpty判断空的线性表
5ListLength返回线性表长度
6GetElem获取线性表的数据元素
7LocateElem返回满足一定条件的数据元素的位序
8SearchElem通过数据项搜索线性表
9ListInsert向线性表插入元素
10ListDelete向线性表删除元素
11ListTraverse遍历线性表的数据元素，执行同类型操作
12SwapElem交换两个数据元素的位置
13ListSort排序整个线性表
以上表格中，绝大部分的操作我们都将可能用到，拭目以待吧。

步骤2

创建kernel_list.h（代表这是一个与表相关的核心文件，后续的其他文件都需要调用该头文件中的操作）
在这里插入图片描述
此时VS2022已经给我们的头文件顶行加上了如下代码：

#pragma once

看来微软官方的IDE也比较推荐我们使用这种😂

步骤3

引入自定义的头文件preconf.h。

#include "preconf.h"

步骤4

这一步，我们将实现基本操作表中的所有操作，函数的命名和表中呈现一样，使用大驼峰命名法（根据开发规范，此为核心文件，函数命名即为如此）。
初始化，构造空的线性表
通过malloc函数申请一片内存，然后判断内存是否分配成功；
赋予SqList结构体中的length初始值0，即现在0个学生；
初始分配空间值为128，单位为sizeof(ElemType)。

Status InitList(SqList* L)
{
	L->elem = (ElemType*)malloc(LIST_INIT_SIZE * sizeof(ElemType));
	if (!(L->elem))
		exit(OVERFLOWED);
	L->length = 0;
	L->list_size = LIST_INIT_SIZE;
	return OK;
}

销毁线性表
释放动态内存；
长度为0；
分配空间也为0；

Status DestroyList(SqList* L)
{
	free(L->elem);
	L->elem = NULL;
	L->length = 0;
	L->list_size = 0;
	return OK;
}

清空线性表

Status ClearList(SqList* L)
{
	L->length = 0;
	return OK;
}

判断空的线性表

Boolean ListEmpty(SqList* L)
{
	if (L->length == 0)
		return TRUE;
	else
		return FALSE;
}

返回线性表长度
这里可能我们会用不到，因为涉及长度的话，我们直接引用L->length就行了，但是写写也无妨，强迫症作祟🤣

int ListLength(SqList* L)
{
	return L->length;
}

获取线性表的数据元素
将第i个数据元素的值传给同类型的e，如果i不合法，退出并返回ERROR。

Status GetElem(SqList* L, int i, ElemType* e)
{
	if (i < 1 || i > ListLength(L))
		exit(ERROR);
	*e = *((L->elem) + i - 1);
	return OK;
}

返回满足一定条件的数据元素的位序
我记得在上一章中写了，C++在兼容C的有些地方是有差异的，在学习Python、Java的同时，也比较浅显的了解了部分的C++语法。其中比较有意思的是，在C中，如果这样写

int Test(float(*tt)())
{
	return 0;
}

你是否会认为参数中的函数是无参数的函数呢？
其实并不是的，如果无参数，那其实我们应该这样写

int Test(float(*tt)(void))
{
	return 0;
}

加上void，才是函数无参的最好证明，而为我们在C++中，这种做法是不可取的，我们的项目是基于C++的，尽管是C编写的，所以明白这一点，我们才能避免一些错误和大坑。
以下的函数指针Status(*compare)(ElemType, ElemType)表示一个返回类型是Status且拥有两个参数的函数，参数类型是ElemType。

int LocateElem(SqList* L, ElemType* e, Status(*compare)(ElemType, ElemType))
{
	ElemType* p;
	int i = 1;
	p = L->elem;
	while (i <= (L->length) && !(*compare)(*e, *(p++)))
		++i;
	if (i <= (L->length))
		return i;
	else
		return 0;
}

通过数据项搜索线性表
参数cur_e是搜索项，在之前的定义结构中，我注明了学号是所有学生表中的唯一值，它是不可重复的，因此，我们查询学生信息时，必须利用好这一点；
参数mode_manner表示搜索的偏差，如果为-1，即寻找某学号对应同学的前驱，0则为查询该同学本身，1则为查询某学号对应同学的后继。
最终将搜索出来的同学，传给参数e。

Status SearchElem(SqList* L, int cur_e, ElemType* e, int mode_manner)
{
	ElemType* r = L->elem;
	int i = 1;
	while (i <= L->length && r->num != cur_e)
	{
		i++;
		r++;
	}
	if (i > L->length)
		return INFEASIBLE;
	switch (mode_manner)
	{
	case -1:
		*e = *(--r);
		return OK;
	case 0:
		*e = *r;
		return OK;
	case 1:
		*e = *(++r);
		return OK;
	default:
		return ERROR;
	}
	return OK;
}

向线性表插入元素
在第i(i∈[1, n])个元素之前插入一个元素，需将i→n个元素向后移动一个位置。

Status ListInsert(SqList* L, int i, ElemType e)
{
	if (i < 1 || i >(L->length) + 1)
		return ERROR;
	if (L->length >= L->list_size)
	{
		ElemType* new_base = (ElemType*)realloc(L->elem, (L->length + LIST_INCREMENT) * sizeof(ElemType));
		if (!new_base)
			exit(OVERFLOWED);
		L->elem = new_base;
		L->list_size += LIST_INCREMENT;
	}
	ElemType* q = &(L->elem[i - 1]);
	ElemType* p = &(L->elem[(L->length) - 1]);
	for (p = &(L->elem[(L->length) - 1]); p >= q; --p) /* 插入位置及之后的元素右移 */
		*(p + 1) = *p;
	*q = e;
	++(L->length);
	return OK;
}

向线性表删除元素
删除第i(i∈[1, n])个元素，需将i+1→n个元素向前移动一个位置。

Status ListDelete(SqList* L, int i, ElemType* e)
{
	if (i < 1 || i > L->length)
		return ERROR;
	ElemType* p = L->elem + i - 1;
	*e = *p;
	ElemType* q = L->elem + L->length - 1;
	for (++p; p <= q; ++p)
		*(p - 1) = *p;
	--(L->length);
	return OK;
}

遍历线性表的数据元素，执行同类型操作

Status ListTraverse(SqList* L, void(*visit)(ElemType*))
{
	int i;
	ElemType* p = L->elem;
	for (i = 1; i <= L->length; ++i)
		visit(p);
	return OK;
}

交换两个数据元素的位置

Status SwapElem(ElemType* x, ElemType* y)
{
	ElemType* z = (ElemType*)malloc(sizeof(ElemType*)+1);
	if (z == NULL)
		return OVERFLOWED;
	*z = *x;
	*x = *y;
	*y = *z;
	return OK;
}

排序整个线性表
因为目前只学过冒泡排序，所以这里就用它吧
sort_manner≤0时，表示降序排序；
sort_manner>1时，表示升序排序；
key为排序的主键，根据项目情况，它只能排序的项有：

  • 语文 l
  • 数学 m
  • 英语 e
  • 平均分 a
  • 总分 s
  • 学号 n
Status ListSort(SqList* L, int sort_manner, char key)
{
	int i, j;
	Boolean flag = TRUE;
	for (i = 0; i < (L->length) - 1 && flag == TRUE; i++)
	{
		flag = FALSE;
		for (j = 0; j < (L->length) - i - 1; j++)
		{
			if (sort_manner <= 0)
			{
				switch (key)
				{
				case 'a':
					if ((L->elem)[j].average_score < (L->elem)[j + 1].average_score)
					{
						SwapElem(&((L->elem)[j]), &((L->elem)[j + 1]));
						flag = TRUE;
					}
					break;
				case 's':
					if ((L->elem)[j].sum_score < (L->elem)[j + 1].sum_score)
					{
						SwapElem(&((L->elem)[j]), &((L->elem)[j + 1]));
						flag = TRUE;
					}
					break;
				case 'l':
					if ((L->elem)[j].score_literature < (L->elem)[j + 1].score_literature)
					{
						SwapElem(&((L->elem)[j]), &((L->elem)[j + 1]));
						flag = TRUE;
					}
					break;
				case 'm':
					if ((L->elem)[j].score_math < (L->elem)[j + 1].score_math)
					{
						SwapElem(&((L->elem)[j]), &((L->elem)[j + 1]));
						flag = TRUE;
					}
					break;
				case 'e':
					if ((L->elem)[j].score_english < (L->elem)[j + 1].score_english)
					{
						SwapElem(&((L->elem)[j]), &((L->elem)[j + 1]));
						flag = TRUE;
					}
					break;
				case 'n':
					if ((L->elem)[j].num < (L->elem)[j + 1].num)
					{
						SwapElem(&((L->elem)[j]), &((L->elem)[j + 1]));
						flag = TRUE;
					}
					break;
				default:
					printf("该主键不支持排序\n");
					return ERROR;
				}
			}
			else
			{
				switch (key)
				{
				case 'a':
					if ((L->elem)[j].average_score > (L->elem)[j + 1].average_score)
					{
						SwapElem(&((L->elem)[j]), &((L->elem)[j + 1]));
						flag = TRUE;
					}
					break;
				case 's':
					if ((L->elem)[j].sum_score > (L->elem)[j + 1].sum_score)
					{
						SwapElem(&((L->elem)[j]), &((L->elem)[j + 1]));
						flag = TRUE;
					}
					break;
				case 'l':
					if ((L->elem)[j].score_literature > (L->elem)[j + 1].score_literature)
					{
						SwapElem(&((L->elem)[j]), &((L->elem)[j + 1]));
						flag = TRUE;
					}
					break;
				case 'm':
					if ((L->elem)[j].score_math > (L->elem)[j + 1].score_math)
					{
						SwapElem(&((L->elem)[j]), &((L->elem)[j + 1]));
						flag = TRUE;
					}
					break;
				case 'e':
					if ((L->elem)[j].score_english > (L->elem)[j + 1].score_english)
					{
						SwapElem(&((L->elem)[j]), &((L->elem)[j + 1]));
						flag = TRUE;
					}
					break;
				case 'n':
					if ((L->elem)[j].num > (L->elem)[j + 1].num)
					{
						SwapElem(&((L->elem)[j]), &((L->elem)[j + 1]));
						flag = TRUE;
					}
					break;
				default:
					printf("该主键不支持排序\n");
					return ERROR;
				}
			}
		}
	}
	return OK;
}

kernel_list.hの的完整代码：

#pragma once  // 解决宏名引发的各种奇怪问题/Solve various strange problems caused by macro names
/*********************************************************************
 * 转载请注明来源/Reprint please indicate the source
 * @FileName kernellist.h
 * @Description 核心线性表/core linear table
 * @History
 * version      author      data       introduction and operations
 *  1.0         初见     2022-01-23             Create
 *  ***         ***      ****-**-**             *******
 */

#include "preconf.h"
 /*********************************************************************
  * @chujian(cn) 引入自定义头文件
  * @chujian(en) Import custom header files
  */

Status InitList(SqList* L)
{
	L->elem = (ElemType*)malloc(LIST_INIT_SIZE * sizeof(ElemType));
	if (!(L->elem))
		exit(OVERFLOWED);
	L->length = 0;
	L->list_size = LIST_INIT_SIZE;
	return OK;
}
/*********************************************************************
 * @chujian(cn) 初始化
 * @chujian(en) Initialize
 */

Status DestroyList(SqList* L)
{
	free(L->elem);
	L->elem = NULL;
	L->length = 0;
	L->list_size = 0;
	return OK;
}
/*********************************************************************
 * @chujian(cn) 销毁
 * @chujian(en) Destroy
 */

Status ClearList(SqList* L)
{
	L->length = 0;
	return OK;
}
/*********************************************************************
 * @chujian(cn) 清空
 * @chujian(en) Reset
 */

Boolean ListEmpty(SqList* L)
{
	if (L->length == 0)
		return TRUE;
	else
		return FALSE;
}
/*********************************************************************
 * @chujian(cn) 判断空表
 * @chujian(en) Judge the empty table
 */

int ListLength(SqList* L)
{
	return L->length;
}
/*********************************************************************
 * @chujian(cn) 返回长度
 * @chujian(en) Retrun length of the table
 */

Status GetElem(SqList* L, int i, ElemType* e)
{
	if (i < 1 || i > ListLength(L))
		exit(ERROR);
	*e = *((L->elem) + i - 1);
	return OK;
}
/*********************************************************************
 * @chujian(cn) 获取第i个数据元素
 * @chujian(en) Get the i-th data element
 */

int LocateElem(SqList* L, ElemType* e, Status(*compare)(ElemType, ElemType))
{
	ElemType* p;
	int i = 1;
	p = L->elem;
	while (i <= (L->length) && !(*compare)(*e, *(p++)))
		++i;
	if (i <= (L->length))
		return i;
	else
		return 0;
}
/*********************************************************************
 * @chujian(cn) 返回满足特定关系的数据元素位序
 * @chujian(en) Returns the bit order of data elements that satisfy a specified relationship
 */

Status SearchElem(SqList* L, int cur_e, ElemType* e, int mode_manner)
{
	ElemType* r = L->elem;
	int i = 1;
	while (i <= L->length && r->num != cur_e)
	{
		i++;
		r++;
	}
	if (i > L->length)
		return INFEASIBLE;
	switch (mode_manner)
	{
	case -1:
		*e = *(--r);
		return OK;
	case 0:
		*e = *r;
		return OK;
	case 1:
		*e = *(++r);
		return OK;
	default:
		return ERROR;
	}
	return OK;
}
/*********************************************************************
 * @chujian(cn) 学号搜索引擎
 * @chujian(en) Student ID Search Engine
 */

Status ListInsert(SqList* L, int i, ElemType e)
{
	if (i < 1 || i >(L->length) + 1)
		return ERROR;
	if (L->length >= L->list_size)
	{
		ElemType* new_base = (ElemType*)realloc(L->elem, (L->length + LIST_INCREMENT) * sizeof(ElemType));
		if (!new_base)
			exit(OVERFLOWED);
		L->elem = new_base;
		L->list_size += LIST_INCREMENT;
	}
	ElemType* q = &(L->elem[i - 1]);
	ElemType* p = &(L->elem[(L->length) - 1]);
	for (p = &(L->elem[(L->length) - 1]); p >= q; --p) /* 插入位置及之后的元素右移 */
		*(p + 1) = *p;
	*q = e;
	++(L->length);
	return OK;
}
/*********************************************************************
 * @chujian(cn) 插入
 * @chujian(en) insert
 */

Status ListDelete(SqList* L, int i, ElemType* e)
{
	if (i < 1 || i > L->length)
		return ERROR;
	ElemType* p = L->elem + i - 1;
	*e = *p;
	ElemType* q = L->elem + L->length - 1;
	for (++p; p <= q; ++p)
		*(p - 1) = *p;
	--(L->length);
	return OK;
}
/*********************************************************************
 * @chujian(cn) 删除
 * @chujian(en) delete
 */

Status ListTraverse(SqList* L, void(*visit)(ElemType*))
{
	int i;
	ElemType* p = L->elem;
	for (i = 1; i <= L->length; ++i)
		visit(p);
	return OK;
}
/*********************************************************************
 * @chujian(cn) 遍历所有数据进行同等操作
 * @chujian(en) Iterate over all data for the same operation
 */

Status SwapElem(ElemType* x, ElemType* y)
{
	ElemType* z = (ElemType*)malloc(sizeof(ElemType*)+1);
	if (z == NULL)
		return OVERFLOWED;
	*z = *x;
	*x = *y;
	*y = *z;
	return OK;
}
/*********************************************************************
 * @chujian(cn) 交换两个数据元素的位置
 * @chujian(en) Swap the positions of two data elements
 */

Status ListSort(SqList* L, int sort_manner, char key)
{
	int i, j;
	Boolean flag = TRUE;
	for (i = 0; i < (L->length) - 1 && flag == TRUE; i++)
	{
		flag = FALSE;
		for (j = 0; j < (L->length) - i - 1; j++)
		{
			if (sort_manner <= 0)
			{
				switch (key)
				{
				case 'a':
					if ((L->elem)[j].average_score < (L->elem)[j + 1].average_score)
					{
						SwapElem(&((L->elem)[j]), &((L->elem)[j + 1]));
						flag = TRUE;
					}
					break;
				case 's':
					if ((L->elem)[j].sum_score < (L->elem)[j + 1].sum_score)
					{
						SwapElem(&((L->elem)[j]), &((L->elem)[j + 1]));
						flag = TRUE;
					}
					break;
				case 'l':
					if ((L->elem)[j].score_literature < (L->elem)[j + 1].score_literature)
					{
						SwapElem(&((L->elem)[j]), &((L->elem)[j + 1]));
						flag = TRUE;
					}
					break;
				case 'm':
					if ((L->elem)[j].score_math < (L->elem)[j + 1].score_math)
					{
						SwapElem(&((L->elem)[j]), &((L->elem)[j + 1]));
						flag = TRUE;
					}
					break;
				case 'e':
					if ((L->elem)[j].score_english < (L->elem)[j + 1].score_english)
					{
						SwapElem(&((L->elem)[j]), &((L->elem)[j + 1]));
						flag = TRUE;
					}
					break;
				case 'n':
					if ((L->elem)[j].num < (L->elem)[j + 1].num)
					{
						SwapElem(&((L->elem)[j]), &((L->elem)[j + 1]));
						flag = TRUE;
					}
					break;
				default:
					printf("该主键不支持排序\n");
					return ERROR;
				}
			}
			else
			{
				switch (key)
				{
				case 'a':
					if ((L->elem)[j].average_score > (L->elem)[j + 1].average_score)
					{
						SwapElem(&((L->elem)[j]), &((L->elem)[j + 1]));
						flag = TRUE;
					}
					break;
				case 's':
					if ((L->elem)[j].sum_score > (L->elem)[j + 1].sum_score)
					{
						SwapElem(&((L->elem)[j]), &((L->elem)[j + 1]));
						flag = TRUE;
					}
					break;
				case 'l':
					if ((L->elem)[j].score_literature > (L->elem)[j + 1].score_literature)
					{
						SwapElem(&((L->elem)[j]), &((L->elem)[j + 1]));
						flag = TRUE;
					}
					break;
				case 'm':
					if ((L->elem)[j].score_math > (L->elem)[j + 1].score_math)
					{
						SwapElem(&((L->elem)[j]), &((L->elem)[j + 1]));
						flag = TRUE;
					}
					break;
				case 'e':
					if ((L->elem)[j].score_english > (L->elem)[j + 1].score_english)
					{
						SwapElem(&((L->elem)[j]), &((L->elem)[j + 1]));
						flag = TRUE;
					}
					break;
				case 'n':
					if ((L->elem)[j].num > (L->elem)[j + 1].num)
					{
						SwapElem(&((L->elem)[j]), &((L->elem)[j + 1]));
						flag = TRUE;
					}
					break;
				default:
					printf("该主键不支持排序\n");
					return ERROR;
				}
			}
		}
	}
	return OK;
}
/*********************************************************************
 * @chujian(cn) 冒泡排序(看起来比较繁琐，因为多个不同的排序项)
 * @chujian(en) Bubble Sor(Seems cumbersome here because of multiple different sort items)
 */
顾平安6
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
学生管理系统（C语言）
weixin_57620050的博客
04-22 642
大一写的一个学生管理系统，写得非常基础，可供初学者参考。
C语言学生信息管理系统报告
11-03
C语言学生信息管理系统报告是一本详细介绍了使用C语言开发学生信息管理系统的项目报告。报告内容包括项目背景、系统设计、功能模块设计、数据库设计、用户界面设计、系统实现等，全面展示了系统的开发过程和实现细节...
学生信息管理系统——C语言版
热门推荐
qq_63099085的博客
07-26 10万+
学生信息管理系统
C语言实现学生管理系统
sakura0908的博客
05-19 6955
学习完C语言之后，我们可以通过简单写一个学生管理系统来检验自己学的怎么样。很多计算机系大学生都会学到C语言，对于C语言课程的设计作业可能会感到困难，该篇博客的核心点就是带领读者单独完成学生管理系统，此篇博客附有整个学生管理系统的源码。
【C语言-学生管理系统】
a1379292747的博客
10-22 3万+
C语言，学生管理系统是比较基础的一个项目，涉及到了结构体、函数、数组、指针、文件读写等相关知识，可以通过完成一个学生管理系统来对我们所学的知识进行回顾，总结，并且也可以学习一些课外的知识，丰富我们自己。
用C语言实现——学生管理系统
qq_42562989的博客
04-18 364
这个简单的学生管理系统可以让您添加学生、查找学生和显示所有学生。这个代码仅包含基本功能，您可以根据需求添加其他功能，如更新学生信息、删除学生信息等。
基于MFC的多功能学生成绩管理系统.zip
06-19
然后，一些小细节我就不说了，相信开发学生成绩管理系统的你也已经大致了解了MFC的基本概念。有一个特殊的点，我希望大家做实验前可以注意：就是在属性那里把Unicode改成多字节，否则，你会在实验中遇到各种各样的令...
学生成绩管理系统 - C语言课程设计，Qt实现.zip
08-02
用c++/qt写的项目，项目都经测试过，能跑通，请放心下载使用。 Qt的优势: 1.跨平台，几乎支持所有的平台 2.接口简单，容易上手，学习QT框架对学习其他框架有参考意义 3.一定程度上简化了内存回收机制 (特定场景...
基于java的学生信息管理系统源码.zip
最新发布
02-12
通过分析和运行源码，你将深入了解各平台开发的技术细节和最佳实践，逐步培养起自己的项目开发和问题解决能力。此外，在求职或创业过程中，具备跨平台开发能力的大学生将更具竞争力。 其他说明： 为了确保源码资源...
基于Java的学生成绩管理系统源码.zip
02-12
通过分析和运行源码，你将深入了解各平台开发的技术细节和最佳实践，逐步培养起自己的项目开发和问题解决能力。此外，在求职或创业过程中，具备跨平台开发能力的大学生将更具竞争力。 其他说明： 为了确保源码资源...
C语言实现学生管理系统(完整代码在文末)
qq_68920288的博客
01-05 1692
通过本实验，我们成功设计并实现了一个简单的学生管理系统，包括了学生信息的增删改查、排序、输出不及格学生和各科目最高分等功能。：通过 Sort_list 函数，实现对学生信息的排序功能，可以选择按总分、平均分、语文成绩、数学成绩或英语成绩排序。本系统使用链表存储学生信息，结构体 data 表示学生的基本信息，结构体 Student 表示链表中的节点。通过 Delete_list 函数，实现删除学生信息的功能，可以选择删除全部或者指定学生。float math;short age;
c语言实现学生管理系统
bodyzsm的博客
12-10 825
c语言实现学生管理系统
C语言代码：编写简单的学生管理系统。（数组+结构体实现）
wanghongshuai1的博客
06-07 5606
用结构体和数组实现简单的学生管理系统。
C语言编写学生管理系统
weixin_46308934的博客
12-31 1万+
项目介绍 学生信息管理系统是一个基于C语言开发的系统，其中有用到冒泡排序、指针、结构体、二位数组等知识。通过模块化的方法编写各个函数，其中在主界面函数调用各个模块的函数的实现以下具体功能： 学生信息的增删改查 学生成绩的排序 统计学生人数 显示所有学生的信息。 对学生信息存档 总体设计 本实验通过在main函数打开保存数据结果的文档和调用主界面函数；在主界面函数welcom()中实现边框的绘制，以及显示各个功能及各个功能对应的函数实现方法。 录入信息函数addInfo()：...
函数指针
fighting123678的博客
10-10 111
https://blog.csdn.net/sunxiwang/article/details/78591557 1、函数指针的返回值类型必须相同 2、使用函数指针是为了调用不同函数 3、例题 Status Equal(ElemType a,ElemType b) { if(a==b) return TRUE; else return FALSE; } int LocateE...
数据结构知识点_重点期考总结复习
CK_0ff的博客
12-14 970
数据结构知识点总结
数据结构-ADT
ncu-wfb的博客
01-10 1716
数据结构小知识： 抽象数据类型（ADT）是指由用户定义的、表示应用问题的数学模型，以及定义在这个模型上的一组操作的名称 具体包括三个部分：数据对象，数据对象上关系的集合，以及对数据对象基本操作的集合 >ADT 抽象数据类型 { 数据对象： <数据对象的定义> 数据关系：<数据关系的定义> 基本操作：<基本操作的定义> } 也就是 数据的对象，关系，和操作 数据结构：数据，结构，算法（操作） >基本操作名(参数表)
数据结构_抽象数据类型（ADT）
mootun‘s技术笔记
02-18 849
抽象数据类型 1.定义 抽象数据类型（abstract data structure，ADT）是用户进行软件系统设计时从问题的数学模型中抽象出来的逻辑数据结构和逻辑数据结构的运算,而不考虑计算机的存储结构和运算的具体实现算法。 2.描述方法 用三元组描述。格式如下： ADT（D，R，P），其中 { D：数据对象的声明 R：数据关系的声明 P：基本运算的声明 } 3.实现 最终将ADT的逻辑结构实现...
数据结构实训之学生信息管理系统
PANCHUNYU123456789的博客
01-01 1800
/*    Copyright (c)2016,烟台大学计算机与控制工程学院    * All rights reserved.    * 文件名称：项目1.cpp    * 作    者：泮春宇 * 完成日期：2016年1月1日    * 版 本 号：v1.0    *问题描述：学生信息管理系统
用C语言写一个学生信息管理系统
09-06
C语言写学生信息管理系统的基本流程如下： 1. 定义学生信息的结构体，包括学生姓名、学号、年龄、性别等信息。 2. 定义相关函数，如录入学生信息、修改学生信息、删除学生信息、查询学生信息等。 3. 在主函数中...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

顾平安6

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值