C语言 文件指针+链表 综合使用

已于 2023-10-17 20:48:57 修改
阅读量912 收藏 5
点赞数 1
分类专栏： C语言程序设计 文章标签： C语言 链表 文件操作 菜单管理 数据结构
于 2022-04-20 18:28:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56051805/article/details/124303972
版权

目录

源码分享，仅供学习使用

menu.c  [菜谱结构体及对应点菜功能 源文件]

CFile.h  [文件操作 头文件]

CFile.c  [文件操作 源文件]

CList.h  [链表操作 头文件]

CList.c  [链表操作 源文件]

main.c  [主入口测试]

源码分享，仅供学习使用

#ifndef MENU_H
#define MENU_H
 
typedef struct menu_t
{
	int menu_id;
	char name[20];
	double price;
	struct menu_t *pnext;//指针 指向下个结构体存储的地址
}MENU_T;
 
//初始化链表头
MENU_T *menuList_init();
 
//把结构体添加到链表的尾部
void menuList_add(MENU_T *head,MENU_T menu);
 
//统计链表的节点个数
int menuList_count(MENU_T *head);
 
/*
获取某个节点的数据
参数1：链表头 
参数2：第几个节点(不包括头)
返回值：找到节点的地址
1.遍历链表 指针域不为空计数
2.判断计数值与pos是否一样
如果一样 说明找到了 返回当前这个节点的地址
*/
MENU_T* getMenuInfoByPos(MENU_T *head,int pos);
 
/*
获取某个节点的数据
参数1：链表头 
参数2：第几个节点(不包括头)
返回值：找到节点的地址
1.遍历链表 指针域不为空计数
2.菜品名称跟name一样
如果一样 说明找到了 返回当前这个节点的地址
*/
MENU_T* getMenuInfoByName(MENU_T *head,char *name);
 
/*
获取某个节点的数据
参数1：链表头 
参数2：第几个节点(不包括头)
返回值：找到节点的地址
1.遍历链表 指针域不为空计数
2.菜品id跟传参的id一样
如果一样 说明找到了 返回当前这个节点的地址
*/
MENU_T* getMenuInfoById(MENU_T *head,int id);
 
//打印链表中节点的所有的数据--遍历
void MenuList_printInfo(MENU_T *head);
 
/*
在第几个节点的后面插入新节点，也就是菜品信息
1遍历整条链表，找到第几个节点
2找到之后插入
*/
void MenuList_InsertByPos(MENU_T *head,MENU_T menu,int pos);
 
/*  
删除第几个节点
在第几个节点的后面删除节点，也就是菜品信息
1遍历整条链表，找到第几个节点
2找到之后删除
*/
int MenuList_DeleteByPos(MENU_T *head,int pos);
 
//释放整条链表
void freeMenuList(MENU_T *head);
 
#endif

menu.c  [菜谱结构体及对应点菜功能 源文件]

#include"menu.h"
#include<stdlib.h>
 
//初始化链表头
MENU_T *menuList_init()
{
	//创建菜谱结构体指针变量
	MENU_T *head = NULL;
	//动态开空间
	head = (MENU_T *)malloc(sizeof(MENU_T));
	if(head == NULL)
	{
		printf("open fail\n");
		exit(0);
	}
 
	//初始化 数据域
	memset(head,'\0',sizeof(MENU_T));
	//初始化指针域
	head->pnext = NULL;
	return head;
}
 
//把结构体添加到链表的尾部
void menuList_add(MENU_T *head,MENU_T menu)
{
	MENU_T *tmp=head;
	MENU_T *pNewNode = NULL; //新节点
	//判断pnext是否为空  找到链表的尾部
	while(tmp->pnext!=NULL)
	{
		tmp=tmp->pnext;	
	}
	//动态开空间
	pNewNode = (MENU_T *)malloc(sizeof(MENU_T));
	if(pNewNode==NULL)
	{
		printf("open fail\n");
		exit(0);	
	}
 
	//初始化 数据域
	memset(pNewNode,'\0',sizeof(MENU_T));
	//数据域赋值
	memcpy(pNewNode,&menu,sizeof(MENU_T));
 
	//新节点连接到上一个节点的指针域
	tmp->pnext = pNewNode;
}
 
//统计链表的节点个数
int menuList_count(MENU_T *head)
{
	//每一个节点找pnext 判断一下是否为空
	//不为空 +1
	int count =0;
	MENU_T *tmp=head;
	while(tmp->pnext!=NULL)
	{
		count++;
		tmp=tmp->pnext;
	}
    return count;
}
 
/*
获取某个节点的数据
参数1：链表头 
参数2：第几个节点(不包括头)
返回值：找到节点的地址
1.遍历链表 指针域不为空计数
2.判断计数值与pos是否一样
如果一样 说明找到了 返回当前这个节点的地址
*/
MENU_T* getMenuInfoByPos(MENU_T *head,int pos)
{
	//每一个节点找pnext 判断下一个是否为空
	//不为空+1
	int count =0;
	MENU_T *tmp=head;
	while(tmp->pnext!=NULL)
	{
		count++;
		tmp=tmp->pnext;
		if(pos==count)  //是不是找到了
		{
			return tmp;		
		}	
	}
	return NULL;
}
 
/*
获取某个节点的数据
参数1：链表头 
参数2：第几个节点(不包括头)
返回值：找到节点的地址
1.遍历链表 指针域不为空计数
2.菜品名称跟name一样
如果一样 说明找到了 返回当前这个节点的地址
*/
MENU_T* getMenuInfoByName(MENU_T *head,char *name)
{
	//每一个节点找pnext 判断下一个是否为空
	//不为空+1
	int count =0;
	MENU_T *tmp=head;
	while(tmp->pnext!=NULL)
	{
		count++;
		tmp=tmp->pnext;
		if(strcmp(name,tmp->name)==0)  //是不是找到了
		{
			return tmp;		
		}	
	}
	return NULL;
}
 
/*
获取某个节点的数据
参数1：链表头 
参数2：第几个节点(不包括头)
返回值：找到节点的地址
1.遍历链表 指针域不为空计数
2.菜品id跟传参的id一样
如果一样 说明找到了 返回当前这个节点的地址
*/
MENU_T* getMenuInfoById(MENU_T *head,int id)
{
	//每一个节点找pnext 判断下一个是否为空
	//不为空+1
	int count =0;
	MENU_T *tmp=head;
	while(tmp->pnext!=NULL)
	{
		count++;
		tmp=tmp->pnext;
		if(id==tmp->menu_id)  //是不是找到了
		{
			return tmp;		
		}	
	}
	return NULL;
}
 
//打印链表中节点的所有的数据--遍历
void MenuList_printInfo(MENU_T *head)
{
	int count =0;
	MENU_T *tmp=head;
	while(tmp->pnext!=NULL)
	{
		tmp=tmp->pnext;
		printf("%d\t%s\t%.1f\n",tmp->menu_id,tmp->name,tmp->price);
	}
}
 
/*
在第几个节点的后面插入新节点，也就是菜品信息
1遍历整条链表，找到第几个节点
2找到之后插入
*/
void MenuList_InsertByPos(MENU_T *head,MENU_T menu,int pos)
{
	//每一个节点找pnext判断一下是否为空
	//不为空+1
	int count =0;
	MENU_T *tmp=head;
	MENU_T *newNode =NULL;
	while(tmp->pnext!=NULL)
	{
		count++;
		tmp=tmp->pnext;
		if(pos==count)  //是不是找到了
		{
			//newNode开空间初始化，数据域内存copy
			newNode=(MENU_T *)malloc(sizeof(MENU_T));
			memset(newNode,'\0',sizeof(MENU_T));
			memcpy(newNode,&menu,sizeof(MENU_T));  //数据域
	
			//newNode pnext指向 当前的下一个
			newNode->pnext=tmp->pnext;
            //当前的下一个指向 新节点
			tmp->pnext=newNode;
			break;		
		}	
	}
}
 
//删除第几个节点
int MenuList_DeleteByPos(MENU_T *head,int pos)
{
	int count =0;
	MENU_T *tmp=head->pnext,*pre = head; //pre 记住上一个节点
	while(tmp!=NULL)
	{
		count++;
		if(count==pos)
		{
			//上个节点的pnext=tmp->pnext
			pre->pnext=tmp->pnext;
			free(tmp);
			return 1;//删除成功		
		}
		pre=pre->pnext;
		tmp=tmp->pnext;
	}
	return -1;//没找到
}
 
//释放整条链表
void freeMenuList(MENU_T *head)
{
	MENU_T *tmp=head;
	while(tmp->pnext!=NULL)
	{
		head = head->pnext;
		free(tmp);
		tmp=head;	
	}
	free(tmp);
}

CFile.h  [文件操作 头文件]

#ifndef CFILE_H
#define CFILE_H
#include<stdio.h> // 用到FILE结构体
#include"CList.h"

//保证打开一个文件  
FILE *f_open(char *name);

/*
函数名：  File_write(FILE *fp,LIST_T *head,int size)
函数作用：链表写入文件
函数参数： 
参数1：FILE *fp 操作的文件指针
参数2：LIST_T *head 链表头
参数3：写入数据的实际大小
返回：
*/
void File_write(FILE *fp,LIST_T *head,int size);

/*
函数名：  File_read(FILE *fp,LIST_T *head,int size)
函数作用：链表读取文件
函数参数： 
参数1：FILE *fp 操作的文件指针
参数2：LIST_T *head 链表头
参数3：读取数据的实际大小
返回：
*/
void File_read(FILE *fp,LIST_T *head,int size);

/*
函数名：  File_update(FILE *fp,void *data,int size,int index)
函数作用：链表更新文件
函数参数： 
参数1：FILE *fp 操作的文件指针
参数2：void *data 写入数据
参数3：int size 写入数据的实际大小
参数4：int index 第几个节点
返回：
*/
void File_update(FILE *fp,void *data,int size,int index);

/*
函数名：  File_add(FILE *fp,void *data,int size)
函数作用：文件追加数据
函数参数： 
参数1：FILE *fp 操作的文件指针
参数2：void *data 写入数据
参数3：int size 写入数据的实际大小
返回：
*/
void File_add(FILE *fp,void *data,int size);

#endif

CFile.c  [文件操作 源文件]

#include"CFile.h"
#include<stdlib.h>//malloc
#include<string.h>//memset

//保证打开一个文件  
FILE *f_open(char *name)
{
	FILE *fp = NULL;
	fp = fopen(name,"r+");
	if(fp==NULL)  //不存在
	{
		fp = fopen(name,"w+"); //就创建			
	}
	return fp;
}

/*
函数名：   File_write(FILE *fp,LIST_T *head,int size)
函数作用： 链表写入文件
函数参数： 参数1：FILE *fp 操作的文件指针
           参数2：LIST_T *head 链表头
		   参数3：写入数据的实际大小
返回：
*/
void File_write(FILE *fp,LIST_T *head,int size)
{
    LIST_T *tmp = head;
	// 链表 直接写入文件
	// 1. 遍历链表
	// 2. 获取数据域
	// 3. fwrite 写入位置  偏移量位置

	rewind(fp);
	while(tmp->pnext!=NULL)
	{
		tmp = tmp->pnext;
		fwrite(tmp->pdata,size,1,fp);
		fflush(fp);
	}
}

/*
函数名：   File_read(FILE *fp,LIST_T *head,int size)
函数作用： 链表读取文件
函数参数： 参数1：FILE *fp 操作的文件指针
           参数2：LIST_T *head 链表头
		   参数3：读取数据的实际大小
返回：
*/
void File_read(FILE *fp,LIST_T *head,int size)
{
	/*
	1.文件指示器 开头 rewind fseek(fp,0,SEEK_SET)
	2.循环读取 
	3.读取的内容放在节点
	4.节点添加到链表
	*/
	void *data=NULL;
	data = malloc(size);
	memset(data,0,size);
	rewind(fp);
	while(fread(data,size,1,fp)>0)
	{
		List_add(head,data);
		//重复开空间
	    data = malloc(size);
	    memset(data,0,size);
	}
}

/*
函数名：   File_update(FILE *fp,void *data,int size,int index)
函数作用： 链表更新文件
函数参数： 参数1：FILE *fp 操作的文件指针
           参数2：void *data 写入数据
		   参数3：int size 写入数据的实际大小
		   参数4：int index 第几个节点
返回：
*/
void File_update(FILE *fp,void *data,int size,int index)
{
	//修改文件
	//1 定位 （第几个节点-1）*size
	//2 写入数据
	//3 刷新缓存区
	fseek(fp,(index-1)*size,SEEK_SET);
	fwrite(data,size,1,fp);
	fflush(fp);
}

/*
函数名：   File_add(FILE *fp,void *data,int size)
函数作用： 文件追加数据
函数参数： 参数1：FILE *fp 操作的文件指针
           参数2：void *data 写入数据
		   参数3：int size 写入数据的实际大小
返回：
*/
void File_add(FILE *fp,void *data,int size)
{
	/*
	1 文件指示器到文件末尾 fseek(fp,0,SEEK_END)
	2 写入数据 fwrite
	3 刷新文件缓存区  fflush
	*/
	fseek(fp,0,SEEK_END);
	fwrite(data,size,1,fp);
	fflush(fp);
}

CList.h  [链表操作 头文件]

#ifndef CLIST_H
#define CLIST_H

//通用链表的结构体
typedef struct list_t
{
	void *pdata;          //(int或结构体)数据的地址 任意类型的指针
	struct list_t*pnext;  //存储下一个结构体的地址
}LIST_T;

//初始化链表头
LIST_T * List_init();

//把数据地址添加到链表的尾部
void List_add(LIST_T *head,void *node);

//统计链表的节点个数
int List_count(LIST_T *head);

//根据位置获取节点数据
void* List_getNode(LIST_T *head,int pos);

//根据位置插入节点
int List_insertByPos(LIST_T *head,int pos,void *data);

//根据位置删除节点
int List_deleteByPos(LIST_T *head,int pos);

//释放整条链表
void freeList(LIST_T *head);

#endif

CList.c  [链表操作 源文件]

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

//初始化链表头
LIST_T * List_init()
{
	//创建菜谱结构体指针变量
	LIST_T *head = NULL;
	//动态开空间
	head = (LIST_T *)malloc(sizeof(LIST_T));
	if(head == NULL)
	{
		printf("open fail\n");
		exit(0);
	}

	//初始化 数据域
	memset(head,'\0',sizeof(LIST_T));
	//初始化数据域
	head->pdata=NULL;

	//初始化指针域
	head->pnext = NULL;
	return head;
}

//把数据地址添加到链表的尾部
void List_add(LIST_T *head,void *node)
{
	LIST_T *tmp=head;
	LIST_T *pNewNode = NULL; //新节点
	//判断pnext是否为空  找到链表的尾部
	while(tmp->pnext!=NULL)
	{
		tmp=tmp->pnext;	
	}
	//动态开空间
	pNewNode = (LIST_T *)malloc(sizeof(LIST_T));
	if(pNewNode==NULL)
	{
		printf("open fail\n");
		exit(0);	
	}

	//初始化 数据域
	memset(pNewNode,'\0',sizeof(LIST_T));
	//数据域赋值
    pNewNode->pdata = node;

	//指针域赋值
	pNewNode->pnext=NULL;
	//新节点连接到上一个节点的指针域
	tmp->pnext = pNewNode;
}

//统计链表的节点个数
int List_count(LIST_T *head)
{
	LIST_T *tmp=head;
	int count =0;
	while(tmp->pnext!=NULL)
	{
		count++;
	    tmp=tmp->pnext;
	}
	return count;
}

//根据位置获取节点数据
void* List_getNode(LIST_T *head,int pos)
{
	int count=0;  //计算数字
	LIST_T* tmp=head;
	while(tmp->pnext!=NULL)
	{
		count++;
		tmp=tmp->pnext;
		if(pos == count)
		{
			//返回数据域 存储节点的地址
			return tmp->pdata;		
		}	
	}
       return NULL;
}

//根据位置插入节点  
//返回 1--成功 0--失败
int List_insertByPos(LIST_T *head,int pos,void *data)
{
	int count=0;
	LIST_T *tmp=head;
	LIST_T *newNode = NULL;//新节点
	while(tmp->pnext!=NULL)
	{
		count++;
		tmp=tmp->pnext;
		if(pos==count)//找到
		{
			newNode=(LIST_T*)malloc(sizeof(LIST_T));
			memset(newNode,'\0',sizeof(LIST_T));
			//数据域赋值
			newNode->pdata=data;

			//指针域赋值
			newNode->pnext=tmp->pnext;
			tmp->pnext=newNode;
			return 1;
		}	
	}
    return 0;
}

//根据位置删除节点
int List_deleteByPos(LIST_T *head,int pos)
{
	int count = 0;
	LIST_T *tmp=head->pnext,*pre=head;
	while(tmp!=NULL)
	{
		count++;
		if(count==pos)
		{
			pre->pnext=tmp->pnext;
			free(tmp);
			return 1;		
		}
		pre=pre->pnext;
		tmp=tmp->pnext;	
	}
	return -1;
}

//释放整条链表
void freeList(LIST_T *head)
{
	LIST_T *tmp=head;
	while(tmp!=NULL)
	{
		head=head->pnext;
		free(tmp);  // 释放节点
		tmp=head;	
	}
}

main.c  [主入口测试]

main.c  文件的读取[函数封装] 调用接口测试

#include<stdio.h>
#include<windows.h>  //exit(0)
#include<stdlib.h>//malloc
#include<string.h>//memset
#include"CFile.h"
#include"CList.h"

LIST_T *head = NULL;//全局变量
FILE *fp=NULL;//全局变量

typedef struct menu_t
{
	int id;
	char name[20];
	double price;
}MENU_T;

void menuAdd()
{
	MENU_T *pmenu=NULL;
	int count = 0;	
	pmenu = (MENU_T *)malloc(sizeof(MENU_T));
	if(pmenu==NULL)
	{
		printf("open fail\n");
		exit(0);	
	}
	memset(pmenu,'\0',sizeof(MENU_T));
	printf("请输入添加id:");
	scanf("%d",&pmenu->id);
	printf("请输入添加name:");
	scanf("%s",pmenu->name);
	printf("请输入添加价格:");
	scanf("%lf",&pmenu->price);
	// printf("%d\t%s\t%.1lf\n",pmenu->id,pmenu->name,pmenu->price);
	List_add(head,pmenu);
	count= List_count(head);
	printf("节点个数%d\n",count);
}

void printMenuInfo()
{
	MENU_T *pmenu=NULL;
	int count =0,i=0;
	count = List_count(head);
	for(i=1;i<=count;i++)
	{
		pmenu = List_getNode(head,i);
		printf("%d\t%s\t%.1lf\n",pmenu->id,pmenu->name,pmenu->price);	
	}
}

int main()
{
	int i=0;
	/*
	目标文件+链表综合应用 菜品 增删改查
	1.读取文件数据 -> 链表
	2. 链表写入（存储）文件
	*/
	//添加菜品
	MENU_T *pmenu=NULL;
	int count = 0;	
	//打开文件
	fp = f_open("data/menu.txt");
		head = List_init();
	if(fp==NULL)
	{
		printf("open file fail\n");
		exit(0);	
	}
/*	for(i=0;i<3;i++)
	{
		menuAdd();
	} */

	//文件数据读取 -> 链表
	//1 文件指示器开头
	//2 循环读取
	//3 放置在链表中
/*	pmenu = (MENU_T *)malloc(sizeof(MENU_T));
	memset(pmenu,0,sizeof(MENU_T));
	rewind(fp);
	while(fread(pmenu,sizeof(MENU_T),1,fp)>0)
	{
		List_add(head,pmenu);
		pmenu = (MENU_T *)malloc(sizeof(MENU_T));
	    memset(pmenu,0,sizeof(MENU_T));
	}
*/ 
	File_read(fp,head,sizeof(MENU_T));
	printMenuInfo();
	fclose(fp);
	return 0;	
}

main.c  文件修改里面的信息[根据id修改名字] 

文件数据信息内容的修改[函数封装] 调用接口测试

#include<stdio.h>
#include<windows.h>  //exit(0)
#include<stdlib.h>//malloc
#include<string.h>//memset
#include"CFile.h"
#include"CList.h"

LIST_T *head = NULL;//全局变量
FILE *fp=NULL;//全局变量

typedef struct menu_t
{
	int id;
	char name[20];
	double price;
}MENU_T;

void menuAdd()
{
	MENU_T *pmenu=NULL;
	int count = 0;	
	pmenu = (MENU_T *)malloc(sizeof(MENU_T));
	if(pmenu==NULL)
	{
		printf("open fail\n");
		exit(0);
	}
	memset(pmenu,'\0',sizeof(MENU_T));
	printf("请输入添加id:");
	scanf("%d",&pmenu->id);
	printf("请输入添加name:");
	scanf("%s",pmenu->name);
	printf("请输入添加价格:");
	scanf("%lf",&pmenu->price);
	// printf("%d\t%s\t%.1lf\n",pmenu->id,pmenu->name,pmenu->price);
	List_add(head,pmenu);
	count= List_count(head);
	printf("节点个数%d\n",count);
}

void printMenuInfo()
{
	MENU_T *pmenu=NULL;
	int count =0,i=0;
	count = List_count(head);
	for(i=1;i<=count;i++)
	{
		pmenu = List_getNode(head,i);
		printf("%d\t%s\t%.1lf\n",pmenu->id,pmenu->name,pmenu->price);	
	}
}

int main()
{
	int i=0;
	/*
	目标文件+链表综合应用 菜品 增删改查
	1.读取文件数据 -> 链表
	2. 链表写入（存储）文件
	*/
	//添加菜品
	MENU_T *pmenu=NULL;
	int count = 0,id=0;	
	char name[10]={0};
	//打开文件
	fp = f_open("data/menu.txt");
		head = List_init();
	if(fp==NULL)
	{
		printf("open file fail\n");
		exit(0);	
	}
/*	for(i=0;i<3;i++)
	{
		menuAdd();
	} */

	File_read(fp,head,sizeof(MENU_T));//修改之前需要读取
	//修改 ：链表修改 更新文件
	printf("请输入要修改的菜品的id:");
	scanf("%d",&id);
	printf("请输入要修改的菜品的name:");
	scanf("%s",name);
	printf("%d\t %s\n",id,name);
	// 1.通过id 找 count
	for(i=1;i<=List_count(head);i++)
	{
		pmenu=List_getNode(head,i);
		if(id == pmenu->id)
		{
			//修改name
			strcpy(pmenu->name,name);
			/*修改文件  1001 0*sizeof(MENU_T)  偏移量
			            1002 1*sizeof(MENU_T) 
			            1003 2*sizeof(MENU_T)
			*/ 
             File_update(fp,pmenu,sizeof(MENU_T),i);
			 break;		
		}	
	}	
	printMenuInfo();
	fclose(fp);
	return 0;	
}

main.c  追加数据信息到文件中

数据信息内容追加写入至文件中[函数封装] 调用接口测试

#include<stdio.h>
#include<windows.h>  //exit(0)
#include<stdlib.h>//malloc
#include<string.h>//memset
#include"CFile.h"
#include"CList.h"

LIST_T *head = NULL;//全局变量
FILE *fp=NULL;//全局变量

typedef struct menu_t
{
	int id;
	char name[20];
	double price;
}MENU_T;

void menuAdd()
{
	MENU_T *pmenu=NULL;
	int count = 0;	
	pmenu = (MENU_T *)malloc(sizeof(MENU_T));
	if(pmenu==NULL)
	{
		printf("open fail\n");
		exit(0);	
	}
	memset(pmenu,'\0',sizeof(MENU_T));
	printf("请输入添加id:");
	scanf("%d",&pmenu->id);
	printf("请输入添加name:");
	scanf("%s",pmenu->name);
	printf("请输入添加价格:");
	scanf("%lf",&pmenu->price);
	// printf("%d\t%s\t%.1lf\n",pmenu->id,pmenu->name,pmenu->price);
	List_add(head,pmenu);
	count= List_count(head);
	printf("节点个数%d\n",count);
}

void printMenuInfo()
{
	MENU_T *pmenu=NULL;
	int count =0,i=0;
	count = List_count(head);
	for(i=1;i<=count;i++)
	{
		pmenu = List_getNode(head,i);
		printf("%d\t%s\t%.1lf\n",pmenu->id,pmenu->name,pmenu->price);	
	}
}

int main()
{
	int i=0;
	/*
	目标文件+链表综合应用 菜品 增删改查
	1.读取文件数据 -> 链表
	2. 链表写入（存储）文件
	*/
	//添加菜品

	MENU_T *pmenu=NULL;
	int count = 0,id=0;	
	char name[10]={0};
	//打开文件
	fp = f_open("data/menu.txt");
		head = List_init();
	if(fp==NULL)
	{
		printf("open file fail\n");
		exit(0);	
	}
	pmenu = (MENU_T *)malloc(sizeof(MENU_T));
	if(pmenu==NULL)
	{
		printf("open fail\n");
		exit(0);
	}
	memset(pmenu,'\0',sizeof(MENU_T));
/*	for(i=0;i<3;i++)
	{
		menuAdd();
	} */

	File_read(fp,head,sizeof(MENU_T));//追加前先读取数据
	
  //链表添加节点 文件追加写入即可	
	printf("请输入添加id:");
	scanf("%d",&pmenu->id);
	printf("请输入添加name:");
	scanf("%s",pmenu->name);
	printf("请输入添加价格:");
	scanf("%lf",&pmenu->price);
	printf("%d\t%s\t%.1lf\n",pmenu->id,pmenu->name,pmenu->price);
	List_add(head,pmenu);
/*	fseek(fp,0,SEEK_END);
	fwrite(pmenu,sizeof(MENU_T),1,fp);
	fflush(fp);*/
	 File_add(fp,pmenu,sizeof(MENU_T));	
	printMenuInfo();
	fclose(fp);
	return 0;
}

chenruhan_QAQ_
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C语言的通用链表
西风世界
04-11 4700
在操作系统编程中， 往往是使用C语言， 但C使用起来极为痛苦， 不像C++有方便的STL模板库使用。linux内核中，有一套非常神奇的通用链表结构，能够方便的使用，管理各种类型的数据，我们今天就来研究一下，内核中的C数据结构。
【C语言】C语言通用链表的设计与实现（附详细讲解、图示和源码）
科技改变人类，技术成就未来
02-25 1229
C语言通用链表的设计与实现
C语言 链表的简单使用
m0_56051805的博客
04-19 489
C语言 链表的简单使用，链表的增删改查
链表详解（附有C语言详细代码）
Weirdo的博客
06-06 2361
在C语言中，可以使用结构体来定义链表节点。每个节点包含一个数据域（data）和一个指针域（next），其中指针域指向下一个节点。int data;// 数据域// 指针域} Node;链表作为一种重要的数据结构，具有动态分配、插入和删除操作方便等特点。通过定义节点结构、链表初始化、插入节点、删除节点和遍历链表等基本操作，可以实现链表的基本功能。此外，链表还有查找节点、反转链表、链表排序等扩展操作。链表在实际应用中具有广泛的应用场景，如文件存储、网络路由、哈希表冲突解决和LRU缓存淘汰策略等。
C语言—通用链表
别呀的博客
03-28 1692
思考：当一个项目里要使用多种结构体类型的链表，例如点菜系统里有人员、菜谱两种结构体，若要对这两种链表操作，就需要编写2套链表操作代码，对链表的操作有链表创建、添加节点、删除节点、获取链表节点个数、获取链表结点数据、释放链表等，这就会花费我们大量的时间。对于这2种业务，对链表的操作是相同的，那能不能编写一套通用的链表操作函数，这2种应用只要调用相应的操作函数即可？面临这样的问题，所以有了通用链表。 这里写目录标题通用链表设计通用链表基本操作通用链表示例 通用链表设计 通用链表结构体： struct lis.
通用链表-C语言
QiiizzZ的博客
07-16 120
list.h #ifndef LIST_H #define LIST_H #include <stdbool.h> // 类型重定义函数指针 typedef int (*Compar)(const void*,const void*); // 链表节点 typedef struct Node { void* ptr; //数据域 struct Node* prev; struct Node* next; }Node; // 通用链表结构 typedef struct List {
C语言指针练习+答案+讲解.docx
11-15
"C语言指针练习+答案+讲解" C语言指针是一种重要的数据类型，它允许程序员直接访问和操作计算机的内存。通过指针，可以实现高效的内存管理和数据处理。下面是关于C语言指针的一些重要知识点： 1. 指针的定义：在...
c语言指针和结构体链表详解ppt课件.ppt
11-20
C 语言指针和结构体链表详解 本资源主要讲解了 C 语言中的指针和结构体链表的概念和应用。结构体链表是一种重要的动态数据结构，具有动态性和灵活性，能够根据需要增加或减少元素个数，并且元素的位置可以变化。...
c语言，链表，文件，指针，表
07-06
c语言，链表，文件，指针，表
使用c语言实现指针和链表实现学成绩管理系统.doc
07-12
《使用C语言实现指针和链表实现学生成绩管理系统》 在计算机科学中，C语言因其高效、灵活和对底层内存操作的控制而被广泛用于系统编程和数据结构实现。本篇文档介绍如何利用C语言中的指针和链表数据结构来构建一个...
链表HuffmanTree-c语言文件读写
最新发布
06-26
在C语言中，我们可以使用链表来实现优先队列，通过比较节点的权值来决定节点的顺序。 构建哈夫曼树的基本步骤如下： 1. 初始化一个空的优先队列。 2. 将所有待编码字符及其频率（权值）添加到队列中。 3. 取出两个...
C语言通用链表
01-04
C语言通用链表
c语言通用链表库
02-02
本代码提供采用c语言编写链表的使用源码，有创建、初始化、删除、插入、查找等等功能
纯C语言实现的通用链表（类）源代码
01-14
纯C语言实现的通用链表（类）源代码，可以供学习参考，内附代码，可执行
c语言:通用链表
yeye924的博客
09-22 327
在以后的代码生涯中肯定不会缺少链表的使用，为了使用方便，可以制作一个通用链表。 typedef int (*CMP)(const void*,const void*); typedef void (*SHOW)(const void*); typedef struct Node { void* data; struct Node* prev; struct Node* next; }Node; Node* create_node(void* data) { Node* node = malloc
通用链表（C语言实现）
weixin_43504629的博客
07-13 753
#include <stdio.h> #include <stdlib.h> #include <stdbool.h> #include "list.h" //设计链表节点 typedef struct Node { void* ptr; //指向数据的首地址 struct Node* next; // 元素的下一个位置 }Node; /...
纯c语言通用链表
一个人的旅行的博客
05-08 1628
纯c语言通用链表 概述 c语言标准库不存在链表, 所以为了数据的简单操作自己写了一份链表 代码 ############               general_list.h             ############## #ifndef __GENERAL_LIST_H__ #define __GENERAL_LIST_H__
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

chenruhan_QAQ_

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

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

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

打赏作者

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

抵扣说明：

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

余额充值