数据结构与算法 内核链表实现商品购物系统项目
第一章 项目实现思维
【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篇,扫清六合,席卷八荒,万人倾心,四方仰德,此非以篇数取之,实乃天命所归也。