数据结构与算法 内核链表实现商品购物系统项目
第一章 项目实现思维
【1】编译介绍
本次实现的项目叫做商品购物系统，使用C语言实现，编译使用VScode，或者Linux平台，编译指令使用Makefile实现。
VScode编译指令：gcc *.c -o main
意思是将所有.c文件编译成可执行文件main
设计商品购物系统的目的，是想大对之前的内容的一个回顾，学完能做什么，不做什么学了做什么，反正学完每个章节必须有个项目做代表，这个项目我记得当时我还写进简历了，因为项目设计还是可以的。
本次项目主要使用内核链表和文件IO的知识，我还是开始项目编写把，不然各位大佬给我一个大逼逗字，我可就熬呜呜。
【2】框架思维
当然对于嵌入式的所有操作，大家不要想的这么麻烦，首先，你要有一个容器，或者说是数据库，用来保存你的数据，而这样的容器诸如：
结构体||枚举||联合体||整形||浮点型||字符型||数组||数据库||宏定义||指针||
以上这些你能灵活运用，说明你已经是一个成熟的程序员了，有了容器之后，我们需要的就是函数，函数又有那些尼？
static静态函数||const只读函数||inline联合函数||递归函数||回调函数||extern外部函数||static const静态只读函数||
这些函数的作用，功能，场合怎么用，你知道多少？
局部变量
全局变量
静态局部变量
静态全局变量
变量的范围也是需要重点掌握的。
怎么实现一个比较大型的项目
主框架 :
int main(void)
{
printf("\n \033[31m 购物界面 \033[0m");
printf("\n____________________________________________________\n");
printf("\n\033[32m 输入1：管理员功能 \033[0m\n\n");
printf("\033[32m 输入2：普通用户商品购物功能 \033[0m\n\n");
printf("\033[32m 输入3：查看购物车历史 \033[0m\n\n");
printf("\033[32m 输入0：退出购物系统[销毁] \033[0m\n");
printf("\n____________________________________________________\n");
//次框架
}
次框架：
printf("\n\033[31m 输入1：录入商品\033[0m\n\n");
printf("\033[31m 输入2：[输入->][1:搜索商品 2:更改信息 3:显示 4:删商品]\033[0m\n\n");
printf("\033[31m 输入0：退出管理员菜单，回到主菜单\033[0m\n");
printf("\n____________________________________________________\n");
printf("\n输入[1：搜索 2：更改 3:显示商品信息 4:删除商品信息]: ");
printf("\n\033[35m 输入1:添加购物商品\033[0m\n\n");
printf("\033[35m 输入2：操作及查看购物车内容\033[0m\n\n");
printf("\033[35m 输入3：修改购物车信息\033[0m\n\n");
printf("\033[35m 输入0：退出购物车菜单\033[0m\n"); printf("____________________________________________________\n");
==实际项目是庞大的，我就举例以上框架，使用C语言编写项目，最不能少的就是：
while(1){break;}
for(;;){break||continue;}
if(1){}
else if(2){}
else if(3){}
else{}
switch(第x件事)
{
case 第一件事：
break;
case 第二件事：
break;
......................
case default:
break;
}
当你把以上都熟练掌握以后，就让我们正式进入项目
第二章 Makefile编写
$ 代表引用
$@ 表示目标文件
$^ 表示所有的依赖文件
$< 表示第一个依赖文件
$? 表示比目标还要新的依赖文件列表
all:于makefile只能有一个目标，所以可以构造一个没有规则的终极目标all，并以多个可执行文件作为依赖
CC = gcc //用CC代替gcc
all : make //all: =可能有多个可执行文件
make : make.o commodity.o shopping.o
$(CC) -o $@ $^ //-o 生成指定的文件
//$(CC)=gcc //$@ =make //$^=make.o commodity.o shopping.o
make.o : make.c program.h
$(CC) -c $<
//$<=make.o //-c 生成为指定的文件
commodity.o : commodity.c program.h
$(CC) -c $<
shopping.o : shopping.c program.h
$(CC) -c $<
.PHONY:clean //安全的写法
clean :
rm -rf *.o *.a make *~
//删除make,所有.o文件，.a文件 所有~
mkdir := C:\Users\newuser\Desktop\项目\鸿星尔克购物系统\苏介银项目
echo :
echo $(mkdir) //查看目录
#./make运行
第三章 代码编写实现
【1】favorite.txt文件
商品名字：加多宝 价格：4.5 剩余：11
商品名字：还魂丹 价格：100.2 剩余：13
商品名字：猪头饭 价格：20.50 剩余：14
商品名字：鸡腿饼 价格：4.5 剩余：15
商品名字：海带皮 价格：6.6 剩余：20
商品名字：面包粉 价格：3.5 剩余：17
商品名字：康师傅 价格：2.6 剩余：18
商品名字：棒棒糖 价格：2.5 剩余：25
商品名字：冰红茶 价格：3.5 剩余：20
【2】history.txt文件
【3】list.h表头
#ifndef __DLIST_H
#define __DLIST_H
//统计小个结构体距离大个结构体的偏移量是多少
#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
//获取大个结构体的地址，并不是很通用
#define container_of(ptr, type, member) ({ \
const typeof( ((type *)0)->member ) *__mptr = (ptr); \
(type *)( (char *)__mptr - offsetof(type,member) );})
//在内核当中的两个非法地址
#define LIST_POISON1 ((void *) 0x00100100)
#define LIST_POISON2 ((void *) 0x00200)
/*
内核链表小个结构体的声明
*/
struct list_head {
struct list_head *next, *prev;
};
//为了配合小个结构体的初始化，就是小个结构体变量的声明
#define LIST_HEAD_INIT(name) { &(name), &(name) }
//诞生一个小个结构体变量，并且让里面prev指针跟next都指向自己
#define LIST_HEAD(name) \
struct list_head name = LIST_HEAD_INIT(name)
/*
初始化头节点
*/
#define INIT_LIST_HEAD(ptr) do { \
(ptr)->next = (ptr); (ptr)->prev = (ptr); \
} while (0)
//插入节点,new是新节点，prev上一个节点是谁，next下一个节点是谁
static inline void __list_add(struct list_head *new,
struct list_head *prev,
struct list_head *next)
{
next->prev = new;
new->next = next;
new->prev = prev;
prev->next = new;
}
//插入new节点到head后面去
static inline void list_add(struct list_head *new, struct list_head *head)
{
__list_add(new, head, head->next);
}
//插入new节点到head前面去
static inline void list_add_tail(struct list_head *new, struct list_head *head)
{
__list_add(new, head->prev, head);
}
//移除prev跟next两个节点中间的节点
static inline void __list_del(struct list_head *prev, struct list_head *next)
{
next->prev = prev;
prev->next = next;
}
//将entry节点从链表当中移除，将entry节点里面的上下个指针指向NULL
static inline void list_del(struct list_head *entry)
{
__list_del(entry->prev, entry->next);
entry->next = (void *) 0;
entry->prev = (void *) 0;
}
//将entry节点从链表当中移除，将entry节点里面的上下个指针指向entry
static inline void list_del_init(struct list_head *entry)
{
__list_del(entry->prev, entry->next);
INIT_LIST_HEAD(entry);
}
//将链表中的list节点移动到head后面去
static inline void list_move(struct list_head *list,
struct list_head *head)
{
__list_del(list->prev, list->next);
list_add(list, head);
}
//将链表中的list节点移动到head前面去
static inline void list_move_tail(struct list_head *list,
struct list_head *head)
{
__list_del(list->prev, list->next);
list_add_tail(list, head);
}
/**
* list_empty – tests whether a list is empty
* @head: the list to test.
*/
//判断链表是否为空链表
static inline int list_empty(struct list_head *head)
{
return head->next == head;
}
//接合list跟head两条链表
static inline void __list_splice(struct list_head *list,
struct list_head *head)
{
struct list_head *first = list->next;
struct list_head *last = list->prev;
struct list_head *at = head->next;
first->prev = head;
head->next = first;
last->next = at;
at->prev = last;
}
/**
* list_splice – join two lists
* @list: the new list to add.
* @head: the place to add it in the first list.
*/
//将两条链表合并成为一条链表
static inline void list_splice(struct list_head *list, struct list_head *head)
{
if (!list_empty(list))
__list_splice(list, head);
}
//将两条链表合并成为一条链表，顺便将list这个头节点初始化成为指向自己的头节点
static inline void list_splice_init(struct list_head *list,
struct list_head *head)
{
if (!list_empty(list)) {
__list_splice(list, head);
INIT_LIST_HEAD(list);
}
}
//通过小个结构体地址获取大个结构体地址的方式
#define list_entry(ptr, type, member) \
((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member)))
//不安全遍历方式，向下遍历
#define list_for_each(pos, head) \
for (pos = (head)->next; pos != (head); \
pos = pos->next)
//不安全遍历方式，向上遍历
#define list_for_each_prev(pos, head) \
for (pos = (head)->prev; pos != (head); \
pos = pos->prev)
//安全的遍历方式
#define list_for_each_safe(pos, n, head) \
for (pos = (head)->next, n = pos->next; pos != (head); \
pos = n, n = pos->next)
//以不安全的形式遍历链表的每个元素，并且获取大个结构体放到pos里面
#define list_for_each_entry(pos, head, member) \
for (pos = list_entry((head)->next, typeof(*pos), member); \
&pos->member != (head); \
pos = list_entry(pos->member.next, typeof(*pos), member))
//以安全的形式遍历链表的每个元素，并且获取大个结构体放到pos里面
#define list_for_each_entry_safe(pos, n, head, member) \
for (pos = list_entry((head)->next, typeof(*pos), member), \
n = list_entry(pos->member.next, typeof(*pos), member); \
&pos->member != (head); \
pos = n, n = list_entry(n->member.next, typeof(*n), member))
#endif
【4】program.h商品头
商品头文件的编写，你会自己写头文件，并且声明相关变量和函数吗，来一起看看就知道。
使用extern声明函数，代表这个函数可以在其他.c文件使用
#ifndef _PROGRAM_H //如果没有定义就定义
#define _PROGRAM_H //定义
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <time.h>
#include "list.h"
#define SIZE 100
//商品结构体
typedef struct commodity_node
{
char name[SIZE]; //商品名字
float price; //价格
int Remaining; //剩余
struct list_head list; //内核链表小结构体变量定义
}com_node_t;
//购物车信息节点 (关联小结构体 和商品结构体)
typedef struct shopping_car
{
com_node_t* com_info; //商品信息结构体指针
unsigned int shopping_count; //存储购物数量
struct list_head list; //内核小结构体变量定义
}scar_node_t;
//资源管理结构体 （关联商品结构体 和 购物车结构体）
typedef struct resource_manage
{
//商品信息链表
com_node_t *com_info_list; //指向商品信息结构体
//购物车链表
scar_node_t *scar_info_list;//指向购物车结构体
//历史文件信息
char history_info[30]; //购物历史记录
}node_t;
//商品函数声明
//商品节点内存申请函数
extern com_node_t *request_commodity_list_node(void);
//商品插入节点函数【1】
extern void insert_commodity_node_to_list(com_node_t *refer_node, com_node_t *insert_node);
//插入注册的商品信息到链表【2】
extern void insert_com_list(com_node_t *refer_node, com_node_t *insert_node);
//查找商品的信息
extern com_node_t *find_com_link_node(com_node_t *list_com_head,const char *find_com_name);
//查找商品信息并且打印
extern com_node_t *find_com_info_data(com_node_t *list_com_head);
//删除商品
extern int remove_com_info(com_node_t *list_com_head);
//删除某件商品信息
extern int remove_com_list_node(com_node_t *rm_node);
//修改商品的相关信息
extern void alter_com_some_info(com_node_t *list_com_head);
//录入修改商品信息【暂未用】
extern void change_com_info(com_node_t *new_node);
//[1]
//文件信息 存入商品结构体 即加载进链表 insert to list
extern int init_commodity_list(com_node_t *list_com_head, const char* file_name);
//显示商品信息
extern void display_com_link_list(com_node_t *list_com_head);
//在购物车界面完成排序
extern void show_scar_to_com_sort_node(com_node_t *list_com_head);
//销毁商品信息结构体
extern void destroy_com_list(com_node_t *list_com_head);
//冒泡排序商品信息
extern void bubble_com_sort_node(com_node_t *com_head);
//购物车节点内存申请函数
extern scar_node_t *request_shopping_car_node(void);
//插入节点到购物车建立链表[1]
extern void insert_scar_to_list(scar_node_t *refer_node, scar_node_t *insert_node);
//插入节点，建立购物车节点链表[2]
extern void insert_scar_node_to_list(scar_node_t *list_scar_head,scar_node_t *new_scar_node);
//移除购物车
extern int remove_scar_list_node(scar_node_t * rm_car_node);
//销毁购物车
extern void destory_scar_list(scar_node_t *list_scar_head);
//显示购物车销毁内容
extern void destroy_scar_link_list(scar_node_t *list_scar_head);
//寻找购物车指点节点是否也存在商品指点节点
extern scar_node_t *find_scar_link_node(scar_node_t *list_scar_head,const char* find_car_node);
//注册购物车信息
extern int register_scar_info(scar_node_t *list_scar_head,com_node_t *com_info,node_t *list_head);
//在购物车查找商品信息
extern scar_node_t *find_scar_node_info(scar_node_t *list_scar_head);
// 购物车购买商品
extern scar_node_t* in_scar_get_com(scar_node_t * list_scar_head,node_t *list_head);
/找到商品节点后可以选择更改购买数量或删除购买内容 输入商品名字
extern void selete_scar_alter_node(scar_node_t *list_scar_head);
//显示购物车内容 //采用安全遍历
extern void display_scar_link_list(scar_node_t *list_scar_head);
//购物历史显示函数
extern int display_scar_all_info(node_t *list_head, const char* file_name);
#endif
【5】shopping.c商品
内容其实不多，而且整个逻辑也不复杂，如果是大佬看到，嘴下留情
#include "program.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
//购物车节点内存申请函数
scar_node_t *request_shopping_car_node(void)
{
scar_node_t *new_car_node;
new_car_node = (scar_node_t *)malloc(sizeof(scar_node_t));
if(new_car_node == NULL)
{
perror("申请节点出错");
return NULL;
}
INIT_LIST_HEAD(&new_car_node->list); //小结构体头初始化
return new_car_node;
}
//插入节点到购物车建立链表[1]
void insert_scar_to_list(scar_node_t *refer_node, scar_node_t *insert_node)
{
//也就是第一个存入的在头节点下一个【头-》new_node】
list_add_tail(&insert_node->list, &refer_node->list); //插入到尾部
}
//插入节点，建立购物车节点链表[2]
void insert_scar_node_to_list(scar_node_t *list_scar_head,scar_node_t *new_scar_node)
{
scar_node_t *pos;
list_for_each_entry(pos,&list_scar_head->list,list)
{
//以名字长度，作为对比，
if(strcmp(pos->com_info->name,new_scar_node->com_info->name) > 0)//第一个值大于第二个
{
break;
}
}
list_add_tail(&new_scar_node->list,&pos->list);
}
//移除购物车
int remove_scar_list_node(scar_node_t * rm_car_node)
{
list_del(&rm_car_node->list); //移除原本所在的链表
free(rm_car_node);
printf("移除购物车成功\n");
return 0;
}
//销毁购物车
void destory_scar_list(scar_node_t *list_scar_head)
{
scar_node_t *pos,*n;
//安全的遍历
list_for_each_entry_safe(pos, n, &list_scar_head->list, list)
{
printf("加入购物车的商品节点释放%s\n",pos->com_info->name);
free(pos);
}
free(list_scar_head);
}
//显示购物车销毁内容
void destroy_scar_link_list(scar_node_t *list_scar_head)
{
scar_node_t *pos,*n;
list_for_each_entry_safe(pos,n,&list_scar_head->list,list)
{
if(pos != NULL)
{
printf("free %s\n",pos->com_info->name);
free(pos);
}
else
{
printf("购物车暂无添加商品\n");
break;
}
}
free(list_scar_head);
}
//寻找购物车指点节点是否也存在商品指点节点
scar_node_t *find_scar_link_node(scar_node_t *list_scar_head,const char* find_car_node)
{
scar_node_t *pos;
list_for_each_entry(pos,&list_scar_head->list, list)
{
if(strcmp(pos->com_info->name,find_car_node)==0)
{
return pos;
}
}
return NULL;
}
//购物车 购买数量
void change_scar_num_info(scar_node_t *car_node ,node_t *list_head)
{
short yes;
if(car_node == NULL)
return;
printf("你确认添加以下这些商品到购物车吗？[1: 是]：");
scanf("%hd",&yes);
if(yes == 1 )
{
printf("请正确输入购买商品信息添加到购物车[商品名 价格 剩余]：\n");
while(scanf("%s%f%d",car_node->com_info->name, &car_node->com_info->price, &car_node->com_info->Remaining) !=EOF)
{
printf("请输入购买数量：");
scanf("%u",&car_node->shopping_count);//存入购物车结构体
printf("\033[34m成功添加到购物车\033[0m\n");
break;
} //把这些信息存在新的那个商品结构体节点
}
else
printf("\n添加失败,没有该商品信息！\n");
}
//注册购物车信息
int register_scar_info(scar_node_t *list_scar_head,com_node_t *com_info,node_t *list_head)
{
scar_node_t *new_car_node;
new_car_node = request_shopping_car_node();
com_info = request_commodity_list_node(); //新申请商品节点空间
if(new_car_node ==NULL&&com_info ==NULL)
{
perror("申请出错");
return -1;
}
new_car_node->com_info = com_info;//商品信息 加入购物车 购物车里面的com_info指针指向新申请的这个节点
change_scar_num_info(new_car_node,list_head);
insert_scar_node_to_list(list_scar_head,new_car_node); //建立购物车链表
return 0;
}
//在购物车查找商品信息
scar_node_t *find_scar_node_info(scar_node_t *list_scar_head)
{
char scar_name[20];
scar_node_t*find_scar_node;
printf("请输入已在购物车的商品名字\n");
scanf("%s",scar_name);
find_scar_node = find_scar_link_node(list_scar_head, scar_name);
if(find_scar_node != NULL)
{
printf("寻找到的\033[32m商品名字：%s 价格：%.2f 剩余：%d\033[0m\n",
find_scar_node->com_info->name,find_scar_node->com_info->price,
find_scar_node->com_info->Remaining);
}
else
{
printf("找不到该购物车商品信息\n");
}
return find_scar_node;
}
// 购物车购买商品
scar_node_t* in_scar_get_com(scar_node_t * list_scar_head,node_t *list_head)
{
char name[20];
char sure[10];
float give_money;
struct tm *tblock;
time_t timer;
timer = time(NULL);
tblock = localtime(&timer);
// asctime(tblock);
scar_node_t*find_scar_node;
printf("\n请输入你想在购物车购买的商品名：");
scanf("%s",name);
find_scar_node = find_scar_link_node(list_scar_head, name);
if (find_scar_node !=NULL )
{
printf("\n你确认购买该商品吗[yes]：");
scanf("%s",sure);
if(strcmp(sure,"yes") == 0)
{
sprintf(list_head->history_info,"%s %s %s %s\n","今天",asctime(tblock),"购买了",name);
give_money: printf("\n请支付%.2f元: ",find_scar_node->com_info->price);
scanf("%f",&give_money);
if(give_money == find_scar_node->com_info->price)
{
printf("\n\033[31m购买成功，快递将在4小时内发送\033[0m\n");
}
else
{
printf("输入金额不对，请重新输入\n");
goto give_money;
}
}
return find_scar_node;
}
else
{
printf("\n购物车不存在该商品\n");
return NULL;
}
}
/找到商品节点后可以选择更改购买数量或删除购买内容 输入商品名字
void selete_scar_alter_node(scar_node_t *list_scar_head)
{
char name[20];
char name1[5];
char yes[5]="yes";
int num;
scar_node_t*find_scar_node;
scar_node_t *pos, *n;
printf("购物车已有商品信息\n");
list_for_each_entry_safe(pos,n,&list_scar_head->list,list)
{
printf("\033[32m商品名字：%s\t 价格：%.2f\t 剩余：%d\033[0m\n",pos->com_info->name,pos->com_info->price,pos->com_info->Remaining);
}
printf("\n请输入你要执行操作的购物车商品名：");
scanf("%s",name);
find_scar_node = find_scar_link_node(list_scar_head, name);
if(find_scar_node != NULL)
{
printf("你要购买该商品吗[yes/no]：");
scanf("%s",name1);
if(strcmp(name1,yes) == 0)
{
printf("当前商品信息[名 剩余]：%s %d\n",find_scar_node->com_info->name,find_scar_node->com_info->Remaining);
printf("你要购买多少：");
scanf("%d",&num);
list_scar_head->shopping_count=num;
printf("已购买%d 剩余%u 没有购买\n",num,find_scar_node->com_info->Remaining - num);
}
else
printf("不买走人\n");
}
else
printf("购物车不存在该商品\n");
}
//显示购物车内容 //采用安全遍历
void display_scar_link_list(scar_node_t *list_scar_head)
{
scar_node_t *pos, *n;
printf("购物车已有商品信息\n");
list_for_each_entry_safe(pos,n,&list_scar_head->list,list)
{
printf("\033[32m商品名字：%s\t 价格：%.2f\t 剩余：%d\033[0m\n",pos->com_info->name,pos->com_info->price,pos->com_info->Remaining);
}
}
//购物历史显示函数
int display_scar_all_info(node_t *list_head, const char* file_name)
{
char*buffer;
void *ret_point;
FILE*fp1;
fp1 = fopen(file_name,"r");
if(fp1 == NULL)
{
perror("打开购物车历史信息文件失败");
goto open_order_file_err;
}
buffer = malloc(1000);
if(buffer == NULL)
{
perror("申请内存出错");
goto request_mem_error;
}
printf("购物历史如下：\n");
while (1)
{
//获得文件信息 存入buffer
ret_point = fgets(buffer, 1000, fp1); //目的：从文件获取信息 存入buffer 打印出来
if(ret_point == NULL) //一行一行的读直到为空
{
printf("\n->->->\033[42m文件已读完\033[0m<-<-<-\n");
break; //文件没有内容 退出
}
printf("\033[31m%s\033[0m",buffer);
}
free(buffer);
return fclose(fp1);
request_mem_error:
fclose(fp1);
open_order_file_err:
return -1;
}
第四章 完整实现商品购物系统编写
【1】时间函数
time_t timer;//time_t就是long int 类型
struct tm *tblock;
timer = time(NULL);
tblock = localtime(&timer);
【2】输出颜色
【3】main.c
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "program.h"
//注册资源管理器 (商品头结点 购物车头结点 管理器头节点 初始化)
extern node_t *register_resouse_manage(void)
{
//为管理结构体申请一块内存
node_t *new_manage_node;
new_manage_node = malloc(sizeof(node_t)); //存储商品信息或购物历史信息
if(new_manage_node == NULL)
{
free(new_manage_node);
return NULL;
}
//申请商品链表头结点 申请成功应该初始化 传入文件信息
new_manage_node->com_info_list = request_commodity_list_node();
printf("\n开始获取商品信息...\n");
//初始化商品结构体
init_commodity_list(new_manage_node->com_info_list,"favorite.txt"); //文件信息传入建立商品链表
printf("获取结束 并且显示");
display_com_link_list(new_manage_node->com_info_list); //显示商品信息
//申请购物车头节点
//new_manage_node->scar_info_list = request_shopping_car_node();
return new_manage_node;
}
///资源管理器到处跑函数
extern void resouce_manage_write_fp(node_t *list_head)
{
FILE *fp2;
time_t timer;//time_t就是long int 类型
struct tm *tblock;
timer = time(NULL);
tblock = localtime(&timer);
// asctime(tblock);
fp2 = fopen("history.txt","w+");
if(fp2 == NULL)
{
perror("文件打开错误");
exit(0);
}
fputs(list_head->history_info,fp2);
fprintf(fp2,"%s\n",list_head->history_info); //存入文件
fclose(fp2);
}
int main(int argc, char const *argv[])
{
int input_value,input_value1;
com_node_t *list_com_head;
int input_value2;
node_t *list_head;
int scanf_if;
int kk,dd,i;
char password[20];
scar_node_t* find_pp;
//资源管理器初始化
// register_resouse_manage();
scar_node_t *list_scar_head;
list_scar_head = request_shopping_car_node(); //申请购物车结构体空间
if(list_scar_head ==NULL)
{
perror("申请失败1");
exit(0);
}
list_com_head = request_commodity_list_node(); //申请商品结构体空间
if(list_com_head == NULL)
{
perror("申请失败2");
exit(0);
}
list_head = register_resouse_manage(); //申请管理结构体空间 并且显示商品信息
if(list_head ==NULL)
{
perror("申请失败3");
return -1;
}
while(1)
{
printf("\n \033[31m 购物界面 \033[0m");
printf("\n____________________________________________________\n");
printf("\n\033[32m 输入1：管理员功能 \033[0m\n\n");
printf("\033[32m 输入2：普通用户商品购物功能 \033[0m\n\n");
printf("\033[32m 输入3：查看购物车历史 \033[0m\n\n");
printf("\033[32m 输入0：退出购物系统[销毁] \033[0m\n");
printf("\n____________________________________________________\n");
printf("\n请输入指令[\033[35m1\033[0m或 \033[36m2\033[0m或 \033[32m0\033[0m]：");
scanf("%d",&input_value);
switch (input_value)
{
case 1:
printf("请输入管理员密码执行操作[12345]：");
scanf("%s",password);
if(strcmp(password,"12345") == 0)
{
printf("\n登录成功\n");
while(1)
{
to:
printf("\n\033[31m 输入1：录入商品\033[0m\n\n");
printf("\033[31m 输入2：[输入->][1:搜索商品 2:更改信息 3:显示 4:删商品]\033[0m\n\n");
printf("\033[31m 输入0：退出管理员菜单，回到主菜单\033[0m\n");
printf("\n____________________________________________________\n");
printf("\n请输入你想操作的功能:");
scanf("%d",&input_value1);
//录入商品
if(input_value1!=0)
{
switch (input_value1) //接收 1 2 0
{
case 1:
init_commodity_list(list_com_head,"favorite.txt");
display_com_link_list(list_com_head);
break;
case 2:
printf("\n输入[1：搜索 2：更改 3:显示商品信息 4:删除商品信息]: ");
scanf("%d",&scanf_if);
if(scanf_if == 1)
{
//查找商品信息并且显示 //查到到，并且修改，在显示
find_com_info_data(list_com_head);
}
else if(scanf_if == 2)
{
alter_com_some_info(list_com_head); //更改商品信息
}
else if(scanf_if == 3)
{
display_com_link_list(list_com_head); //显示商品信息
}
else if(scanf_if == 4)
{
remove_com_info(list_com_head); //删除指定商品信息
}
else
printf("输入指令错误\n");
break;
}
}
else
break; //退出case 1:
}
}
else
printf("\033[31m!密码错误!\033[0m\n");
break;
case 2:
//显示商品信息
display_com_link_list(list_com_head);
while(1)
{
printf("\n\033[35m 输入1:添加购物商品\033[0m\n\n");
printf("\033[35m 输入2：操作及查看购物车内容\033[0m\n\n");
printf("\033[35m 输入3：修改购物车信息\033[0m\n\n");
printf("\033[35m 输入0：退出购物车菜单\033[0m\n");
printf("____________________________________________________\n");
printf("\n请输入指令进行相关操作：");
scanf("%d",&input_value2); //1 2 0
if(input_value2!=0)
{
switch (input_value2)
{
case 1:
//添加到商品到购物车
register_scar_info(list_scar_head,list_com_head ,list_head);
break;
case 2:
printf("输入：[1:显示购物车内容 2：购买商品且清空购物车链表 0：退出购物车菜单[商品排序]]: ");
scanf("%d",&kk);
if(kk == 1)
{
//显示购物车内容
display_scar_link_list(list_scar_head);
}
else if(kk == 2)
{
//在购物车搜索想买的商品
find_pp = find_scar_node_info(list_scar_head);
if(find_pp != NULL)
{
//购买商品
printf("\n输入指令进行购买删除操作：\033[32m[1]\033[0m：买 \033[33m[2]\033[0m：删 \033[34m[3]\033[0m:删除购物车所有商品]：");
scanf("%d",&dd);
if(dd == 1)
{
//购买商品函数
in_scar_get_com(list_scar_head, list_head);
}
else if(dd ==2)
{
//清空购物车链表
remove_scar_list_node(find_pp);
}
else if(dd == 3)
{
//destory_scar_list(list_scar_head);
resouce_manage_write_fp(list_head);
//printf("购物车商品已全部清空\n");
}
else
printf("输入指令错误请重试\n");
}
}
else if(kk == 0)
{
//排序商品并且显示
bubble_com_sort_node(list_com_head);
//显示排序
show_scar_to_com_sort_node(list_com_head);
goto to;
}
//输入0 回到录入商品界面
break;
case 3:
//选择并且修改购物车商品信息 或者删除购买内容
printf("输入： 1：修改 2:啥也不做\n");
scanf("%d",&i);
if(i == 1)
selete_scar_alter_node(list_scar_head);
else
printf("BYBY\n");
break;
case 0:
break; //回到主界面
}
}
else
break; //退出购物车菜单 返回到主页
}
break;// 退出case :2 回到主界面
case 3:
resouce_manage_write_fp(list_head);
//查看购物车历史
display_scar_all_info(list_head,"history.txt");
break;
case 0:
//销毁购物车链表
printf("\n开始销毁购物车\n");
destory_scar_list(list_scar_head);
//销毁商品链表
printf("\n开始销毁商品链表\n");
destroy_com_list(list_com_head);
return -1; //退出购物系统
default:
break; //输入其他
}
}
return 0;
}
第五章 附议
吾自四月一来，日日更新，舟车劳顿，任不失创作之意，自创作之日起，文笔流畅，花样繁多，但粉不见势，使我不得开心颜呐。
久闻CSDN大名，今日有幸参与51创作，吾自知天命，识时务，何为51前来犯CSDN,天数有变，神器更易，而归有德之人，此乃自然之理。
自51以来，黄金猖獗，博文纷争，创作冷暖之危，内卷有倒悬之急，我博文100篇，扫清六合，席卷八荒，万人倾心，四方仰德，此非以篇数取之，实乃天命所归也。
567
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
