学生管理系统

这是一个常见的基本的管理系统，是模拟学校的管理机制，
分为三个模块：管理员、老师、学生。
管理员负责对老师进行管理，老师负责对学生进行管理，
学生则是对自己的基本信息的一些查询。

主要的一些功能是用链表的方式来完成，所以封装了一个通用链表。

链表的封装

list.h的代码段

#ifndef LIST_H
#define LIST_H

#include<stdio.h>
#include<stdbool.h>

typedef struct Node
{
   
   
	void* ptr;
	struct Node* next;
}Node;
//封装通用链表

typedef struct List
{
   
   
	Node* head;
	Node* tail;
	size_t size;
}List;

//定义比较函数指针类型
typedef int (*Cmpfp)(void*,void*);

//创建节点
Node* create_node(void* ptr);
//创建链表
List* create_list(void);
//销毁链表
void destroy_list(List* list);
//头添加
void add_head_list(List* list,void* ptr);
//尾添加
void add_tail_list(List* list,void* ptr);
//头删除
bool del_head_list(List* list);
//尾删除
bool del_tail_list(List* list);
//表删除
bool del_list(List* list,void* ptr,Cmpfp func);
//修改
bool modify_list(List* list,void* old,void* ptr,Cmpfp func);
//查询
Node* find_list(List* list,void* ptr,Cmpfp func);
//遍历
void show_list(List* list,void(*func)(void* ptr));
//排序
void sort_list(List* list,Cmpfp func);

#endif  //LIST_H

list.c

#include<stdlib.h>
#include<string.h>
#include"list.h"

//创建节点
Node* create_node(void* ptr)
{
   
   
	Node* node = malloc(sizeof(Node));
	node->ptr = ptr;
	node->next = NULL;
	return node;
}

//创建链表
List* create_list(void)
{
   
   
	List* list = malloc(sizeof(List));
	list->head = NULL;
	list->tail = NULL;
	list->size = 0;
	return list;
}

//销毁链表
void destroy_list(List* list)
{
   
   
	if(NULL == list || NULL ==list->head) return;
	Node* prev = list->head;
	while(NULL !=prev->next)
	{
   
   
		Node* temp = prev;
		prev = prev->next;
		free(temp->ptr);
		free(temp);
	}
	free(prev->ptr);
	free(prev);
	free(list);
}

//头添加
void add_head_list(List* list,void* ptr)
{
   
   
	Node* node = create_node(ptr);
	if(NULL ==list->head)
	{
   
   
		list->head = node;
		list->tail = node;
	}
	else
	{
   
   
		node->next = list->head;
		list->head = node;
	}
	list->size++;
}
//尾添加
void add_tail_list(List* list,void* ptr)
{
   
   
	Node* node = create_node(ptr);
	if(NULL == list->tail)
	{
   
   
		list->head = node;
		list->tail = node;
	}
	else
	{
   
   
		list->tail->next = node;
		list->tail = node;
	}
	list->size++;
}

//头删除
bool del_head_list(List* list)
{
   
   
	if(NULL == list->head) return false;
	Node* node = list->head;
	list->head = node->next;
	list->size--;
	free(node->ptr);
	free(node);

	if(0 == list->size) list->tail = NULL;
	return true;
}

//尾删除
bool del_tail_list(List* list)
{
   
   
	if(NULL ==list->tail) return false;
	if(1==list->size) return del_tail_list(list);

	Node* prev = list->head;
	while(prev->next != list->tail) prev = prev->next;
	
	list->tail = prev;
	free(prev->next->ptr);
	free(prev->next);
	prev->next = NULL;
	list->size--;
	return true;
}


//表删除
bool del_list(List* list,void* ptr,Cmpfp func)
{
   
   
	if(0 == func(list->head->ptr,ptr)) return del_head_list(list);
	if(0 == func(list->tail->ptr,ptr)) return del_tail_list(list);

	Node* prev = list->head;
	while(NULL !=prev->next)
	{
   
   
		if(0 == func(prev->next->ptr,ptr))
		{
   
   
			Node* node = prev->next;
			prev->next = node->next;
			free(node->ptr);
			free(node);
			list->size--;
			return true;
		}
		prev = prev->next;
	}
	return false;

}

//修改
bool modify_list(List* list,void* old,void* ptr,Cmpfp func)
{
   
   
	for(Node* node =list->head;NULL !=node;node=node->next)
	{
   
   
		if(0 == func(node->ptr,old))
		{
   
   
			free(node->ptr);
			node->ptr = ptr;
			return true;
		}
	}
	return false;
	
}

//查询
Node* find_list(List* list,void* ptr,Cmpfp func)
{
   
   
	for(Node* node = list->head;NULL!=node;node=node->next)
	{
   
   
		if(0==func(node->ptr,ptr))
		{
   
   
			return node;
		}
	}
	return NULL;
}

//遍历
void show_list(List* list,void(*func)(void* ptr))
{
   
   
	for(Node* node = list->head;NULL!=node;node = node->next)
	{
   
   
		func(node->ptr);
	}
}

//排序
void sort_list(List* list,Cmpfp func)
{
   
   
	Node* max = list->tail;
	while(max !=list->head)
	{
   
   
		bool flag =true;
		Node* node = list->head;
		while(NULL !=node)
		{
   
   
			if(1==func(node->ptr,node->next->ptr))
			{
   
   
				void *temp = node->ptr;
				node->ptr = node->next->ptr;
				node->next->ptr=temp;
				flag = false;
			}
			if(node->next ==max)
			{
   
   
				max=node;
				break;
			}
			node=node->next;
		}
		if(flag) break;
	}
}

main函数代码

#include"sams.h"
int main()
{
   
   
	sams_init();
	sams_start();
}

文件读取

dao.h

#ifndef DAO_H
#define DAO_H
#include"list.h"

//文件加载数据到链表
void load_data(List* list,const char* file,size_t size);

//把链表中的数据保存到文件
void save_data(List* list