精华内容
下载资源
问答
  • 超市管理系统

    2021-03-14 22:00:02
     退出管理系统 在这里主要是名称和编号唯一相当于一个人的姓名和身份证,身份证肯定是唯一的,所以整体用编号来查询。其实也可以用姓名加编号双关键字相等来查找会更严谨,但是项目要求是编号。在保证

    提示:大一第一次写的项目


    项目要求:利用二分查找法对排序好的超市物品编号实现快速查找,并按其他关键字的查找可以采用最简单的顺序查找方法进行。(主要关键字是编号)

     主菜单主界面与功能一览
     按超市物品编号查询功能
     按超市物品名称查询功能
     按照进货时间查询功能
     货架管理功能
     进货功能
     出货功能
     退出管理系统
    在这里主要是名称和编号唯一相当于一个人的姓名和身份证,身份证肯定是唯一的,所以整体用编号来查询。其实也可以用姓名加编号双关键字相等来查找会更严谨,但是项目要求是编号。在保证这两个关键字唯一的情况下,下面代码经过三四天的更改并且不断测试是基本上没有BUG的。抵住了今天的的答辩加面试


    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <malloc.h>
    #include <windows.h>//包含Sleep、system、message(MB_ICONQUESTION)
    typedef struct
    {
    
        char name[20];//商品名称
        char num[20];//商品编号
        int item;//商品件数
        char time[30]; //商品日期
        double  price;//商品单价
    
    } goods; //物品
    typedef struct node
    {
        goods data;
        struct node *lnext,*rnext;
    } Node;
    Node *head=NULL;//初始头指针
    Node *search(goods x,Node **p)  //搜索:循环两个参数,一个是物品,一个用二级指针来保存p的地址
    {
      Node *T;
       T=head;
       *p=NULL;
       while(T&&strcmp(x.num,T->data.num)!=0)
       {
           *p=T;
            if(strcmp(x.num,T->data.num)<0)
                 T=T->lnext;
               else T=T->rnext;
       }
    
    return T;
    }
    int searchname(goods x,Node *rootnode,int *flag)  //搜索名称:递归参数,一个是物品,一个是根节点,flag表示是否查询到
    {
        if(rootnode==NULL)
            return 0;
        if(strcmp(x.name,rootnode->data.name)==0)   //前序遍历,检查当前节点的名称是否匹配,否则查找左右子树
        {
            printf("          o商品名称:%s\n ",rootnode->data.name);
            printf("         o商品编号:%s \n",rootnode->data.num);
            printf("          o商品件数: %d\n",rootnode->data.item);
            printf("          o商品价格: %.2lf\n",rootnode->data.price);
            printf("          o商品录入日期:%s \n\n\n",rootnode->data.time);
            *flag=1;
        }
        searchname(x,rootnode->lnext,flag);
        searchname(x,rootnode->rnext,flag);
    }
    int searchtime(goods x,Node *rootnode,int* flag)  //搜索:递归参数,一个是物品,一个是根节点,,flag表示是否查询到
    {
    
        if(rootnode==NULL)
            return 0;
        if(strcmp(x.time,rootnode->data.time)==0) //前序遍历,检查当前节点的日期是否匹配否则查找左右子树
        {
            printf("%-8s\t%-8s\t%-8d\t%s\t%-8.2lf\n",rootnode->data.name,rootnode->data.num,rootnode->data.item,rootnode->data.time,rootnode->data.price);
            *flag=1;
        }
        searchtime(x,rootnode->lnext,flag);
        searchtime(x,rootnode->rnext,flag);
    
    }
    void insert(goods x)//插入节点,要判断当前节点是否存在
    {
        Node *p,*flag,*t;
        if(head==NULL)
        {
            head=(Node *)malloc(sizeof(Node));
            head->data=x;
            head->lnext=head->rnext=NULL;
            return ;
        }
        else
        {
            flag=search(x,&p);
                                //P二级指针     //插入的时候先查找当前数据是否存在
            if(flag!=NULL)
            {
                flag->data.item+=x.item;
            }
            else
            {
                t=(Node *)malloc(sizeof(Node));
                t->data=x;
                t->lnext=t->rnext=NULL;
                if(strcmp(x.num,p->data.num)<0)
                    p->lnext=t;
                else
                    p->rnext=t;
    
            }
        }
        return ;
    
    }
    
    void input()//商品录入
    {
        Node *p;
        goods x;
        int n;
        char ch;
        printf("   \t\t\t*******************************************\n\n");
        printf("   \t\t\t**         欢迎进入超市商品录入界面      **\n\n");
        printf("   \t\t\t*******************************************\n\n\n");
    
        printf("     请输入需要录入商品的种类\n\n");
        scanf("%d",&n);
        printf("\t 录入的商品有%d种",n);
    
        for(int i=1; i<=n; i++)
        {
            printf("     第%d种商品的录入\n",i);
            printf("     -----------------------------\n");
            printf("          o商品名称: ");
    
            scanf("%s",x.name);
            printf("          o商品编号: ");
            scanf("%s",x.num);
            printf("          o商品件数: ");
            scanf("%d",&x.item);
    
            printf("          o商品价格: ");
            scanf("%lf",&x.price);
            printf("          o商品录入日期: ");
            scanf("%s",x.time);
            printf("     -----------------------------\n\n");
            insert(x);      //商品录入创建节点
        }
        printf("\n\n录入完成,请按任意键返回主目录\n\n");
    
    }
    void getthing()//商品进货
    {
        printf("   \t\t\t*******************************************\n\n");
        printf("   \t\t\t**         欢迎进入超市商品进货界面      **\n\n");
        printf("   \t\t\t*******************************************\n\n\n");
        Node *p;
        char ch;
        goods thing;
        printf("请分别输入您需进货商品的名称、编号、件数、日期、单价:\n");
    
        printf("     -----------------------------\n\n");
        printf("          o商品名称: ");
    
        scanf("%s",thing.name);
        printf("          o商品编号: ");
        scanf("%s",thing.num);
        printf("          o商品件数: ");
        scanf("%d",&thing.item);
        printf("          o录入日期: ");
        scanf("%s",thing.time);
        printf("          o商品价格: ");
        scanf("%lf",&thing.price);
        printf("     -----------------------------\n\n");
        printf("该商品已经存入\n\n");
    
        insert(thing);       //商品进货直接插入
        printf("该商品已经进货完成,请按任意键返回目录\n");
        return ;
    }
    
    void putthing()//商品出货
    {
        printf("   \t\t\t*******************************************\n\n");
        printf("   \t\t\t**         欢迎进入超市商品出货界面      **\n\n");
        printf("   \t\t\t*******************************************\n\n\n");
        goods thing;
        Node *p,*flag;
        char ch;
        if(head==NULL)
        {
            printf("仓库目前没有商品,可按任意键返回目录。。。。\n");
            system("pause");
            return ;
        }
    
    
        printf("     -----------------------------\n\n");
        printf("          o商品名称: ");
    
        scanf("%s",thing.name);
        printf("          o商品编号: ");
        scanf("%s",thing.num);
        printf("          o商品件数: ");
        scanf("%d",&thing.item);
        printf("          o录入日期: ");
        scanf("%s",thing.time);
        printf("          o商品价格: ");
        scanf("%lf",&thing.price);
    
        printf("     -----------------------------\n\n");
        p=(Node*)malloc(sizeof(Node));
        p->data=thing;
        flag=search(thing,&p);  //出货要search一遍看它存不存在
        if(flag)                  //进行查找当前节点如果未查到记录它的父节点,查到了记录当前节点
        {
            if(flag->data.item>=thing.item)  //如果当前货物大于所出货的就能出货
            {
                flag->data.item-=thing.item;
                printf("已成功出货,请按任意键返回主目录");
            }
            else                               //提示无法出货
            {
                printf("目前该物品库存为:%d   库存不够,无法出货\n",flag->data.item);
                printf("请按任意键返回目录\n");
            }
        }
        else
        {
            printf("数据错误,当前仓库没有此物品\n");
            printf("请按任意键返回目录\n");
        }
    }
    void Makemenu()//界面--菜单
    {
        system("color e3");
        printf("\n\n");
        printf("  \t\t\t\t*******************************************\n\n");
        printf("  \t\t\t\t**         欢迎进入超市管理系统          **\n\n");
        printf("  \t\t\t\t*******************************************\n\n\n");
        printf("        \t\t\t-----------------------------------------\n");
        printf("  \t    \t\t\t \t1.商品进货    \t\t\t\n");
        printf("  \t    \t\t\t \t2.商品出货    \t\t\t\n");
        printf("  \t    \t\t\t \t3.商品录入    \t\t\t\n");
        printf("  \t    \t\t\t \t4.按照超市物品编号查询 \t\t\n");
        printf("  \t    \t\t\t \t5.按照超市物品名称查询 \t\t\n");
        printf("  \t    \t\t\t \t6.按照超市物品进货时间查询   \t\n");
        printf("  \t    \t\t\t \t7.浏览商品   \t\t\t\n");
        printf("  \t    \t\t\t \t8.保存/不保存并退出\t\t\t\n");
        printf("        \t\t\t-----------------------------------------\n");
        printf("  ->请输入您的选择:");
    }
    void print(Node *p)
    {
        if(p==NULL)
            return ;
        print(p->lnext);
        printf("%-8s\t%-8s\t%-8d\t%-8s\t%-8.2lf\n",p->data.name,p->data.num,p->data.item,p->data.time,p->data.price);
        print(p->rnext);
    }
    void lookthrough(Node *head)  //商品浏览
    {
        printf("   \t\t\t*******************************************\n\n");
        printf("   \t\t\t**         欢迎进入超市商品浏览界面      **\n\n");
        printf("   \t\t\t*******************************************\n\n\n");
    
        Node *p;
        p=head;
        if(p==NULL)
        {
    
            printf("还未录入数据,请录入数据后再进行浏览,按任意键键返回主目录\n");
            printf("—————————————————————————————————————————————————————————\n");
            return;
        }
        printf("\n------------------------------商品信息表------------------------------\n\n");
        printf("商品名称\t商品编号\t商品件数\t商品日期\t商品单价\n");
        print(p->lnext);
        printf("%-8s\t%-8s\t%-8d\t%-8s\t%-8.2lf\n",p->data.name,p->data.num,p->data.item,p->data.time,p->data.price);
        print(p->rnext);
        printf("\n\n");
        printf("\n\n浏览完成,按任意键返回上一级\n\n");
    }
    void writeprint(Node *p,FILE *fp)//中序递归遍历写入文件
    {
        if(p==NULL)
            return ;
        writeprint(p->lnext,fp);
        fprintf(fp,"%s %s %d %s %.2lf\n",p->data.name,p->data.num,p->data.item,p->data.time,p->data.price);
        writeprint(p->rnext,fp);
    
    }
    void write(char *filename)//写入文件
    {
    
        FILE *fp;
        Node *p,*q;
        if(head==NULL)
            return ;
        p=head;
        if((fp=fopen(filename,"w"))!=NULL)       //采用中序遍历写入文件
        {
            writeprint(p->lnext,fp);
            fprintf(fp,"%s %s %d %s %.2lf\n",p->data.name,p->data.num,p->data.item,p->data.time,p->data.price);
            writeprint(p->rnext,fp);
        }
    
        fclose(fp);
    }
    void  read(char *filename)//从文件中将数据读入并创建排序树
    {
        FILE *fp;
        if((fp=fopen(filename,"r"))==NULL)  //系统运行的时候还没有创建文件
        {
    
            return ;
        }
        goods x;
        while(fscanf(fp,"%s %s %d %s %lf",x.name,x.num,&x.item,&x.time,&x.price)!=EOF)
        {
            insert(x);
    
        }
        fclose(fp);
    
    }
    int main()
    {
        int i;
        i=MessageBox(NULL,"是否进入管理系统","超市管理系统",MB_YESNO|MB_ICONQUESTION);
    
        if(i==IDYES)
            MessageBox(NULL,"已成功进入管理系统","超市管理系统",MB_OK|MB_ICONASTERISK);
        else
            exit(1);
        Node *p,*flag;
        goods x;//系统每次打开时都将头结点置空,不带头结点
        read("file.txt");//读取数据
        int choose;
        while(1)
        {
    
            Makemenu();
            scanf("%d",&choose);
            switch(choose)
            {
            case 1://单个商品进货功能
    
                i=MessageBox(NULL,"是否进入商品进货界面","超市管理系统",MB_YESNO|MB_ICONQUESTION);
                if(i==IDNO)
                {
                    MessageBox(NULL,"已返回主菜单","超市管理系统",MB_OK|MB_ICONWARNING);
                    system("cls");
                    break;
                }
    
                printf("\n您选择了商品进货功能!\n");
                printf("\t正在进入中请稍等。。。。。。。。\n");
                Sleep(2000);
                system("pause");
                system("cls");
                getthing();
                system("pause");
                system("cls");
    
                break;
            case 2://商品出货功能
                i=MessageBox(NULL,"是否进入商品出货界面","超市管理系统",MB_YESNO|MB_ICONQUESTION);
                if(i==IDNO)
                {
                    MessageBox(NULL,"已返回主菜单","超市管理系统",MB_OK|MB_ICONWARNING);
                    system("cls");
                    break;
                }
                printf("\n您选择了商品出货功能!\n\n");
                printf("\t正在进入中请稍等。。。。。。。。\n");
                Sleep(1000);
                system("pause");
                system("cls");
                putthing();
                system("pause");
                system("cls");
                break;
            case 3 ://是否进入商品录入功能
                i=MessageBox(NULL,"是否进入商品录入界面","超市管理系统",MB_YESNO|MB_ICONQUESTION);
                if(i==IDNO)
                {
                    MessageBox(NULL,"已返回主菜单","超市管理系统",MB_OK|MB_ICONWARNING);
                    system("cls");
                    break;
                }
                printf("\n您选择了商品录入功能!\n\n");
                printf("\t正在进入功能中请稍等。。。。。。。。\n");
                Sleep(2000);
                system("pause");
                system("cls");
                input();
                system("pause");
                system("cls");
    
                break;
            case 4://是否进入商品编号查询
                i=MessageBox(NULL,"是否进入商品编号查询界面","超市管理系统",MB_YESNO|MB_ICONQUESTION);
                if(i==IDNO)
                {
                    MessageBox(NULL,"已返回主菜单","超市管理系统",MB_OK|MB_ICONWARNING);
                    system("cls");
                    break;
                }
                printf("\n您选择了超市物品编号查询功能!\n");
                printf("\t正在进入中请稍等。。。。。。。。\n");
                Sleep(2000);
                system("pause");
                system("cls");
                printf("   *******************************************\n");
                printf("   **       欢迎进入超市商品编号查询界面  **\n");
                printf("   *******************************************\n\n\n");
                printf("请输入您需查找商品的编号:\n");
                printf("     -----------------------------\n");
                printf("          o商品编号: ");
                scanf("%s",x.num);
                printf("     -----------------------------\n\n");
                flag=search(x,&p);
                if(flag==NULL)
                    printf("查无此商品,按任意键返回主目录\n");
                else
                {
                    printf("          o商品名称:%s\n ",flag->data.name);
                    printf("         o商品编号:%s \n",flag->data.num);
                    printf("          o商品件数: %d\n",flag->data.item);
                    printf("          o商品价格: %.2lf\n",flag->data.price);
                    printf("          o商品录入日期:%s \n\n\n",flag->data.time);
                }
                printf("   ->可按任意热键返回\n\n");
                system("pause");
                system("cls");
                break;
            case 5:
                i=MessageBox(NULL,"是否进入超市物品名称查询界面","超市管理系统",MB_YESNO|MB_ICONQUESTION);
                if(i==IDNO)
                {
                    MessageBox(NULL,"已返回主菜单","超市管理系统",MB_OK|MB_ICONWARNING);
                    system("cls");
                    break;
                }
                printf("\n您选择了超市物品名称查询功能!\n");
                printf("\t正在进入中请稍等。。。。。。。。\n");
                Sleep(2000);
                system("pause");
                system("cls");
                printf("   *******************************************\n");
                printf("   **         欢迎进入超市商品名称查询界面      **\n");
                printf("   *******************************************\n\n\n");
                printf("请输入您需进货商品的名称:\n");
                printf("     -----------------------------\n");
                printf("          o商品名称:");
                scanf("%s",x.name);
                printf("     -----------------------------\n\n");
                int ans=0;
                searchname(x,head,&ans);
                if(ans==0)
                {
                    printf("查无此商品,请按任意键返回主界面\n");
    
                }
                printf("   ->可按任意热键进行返回\n");
                system("pause");
                system("cls");
                break;
            case 6:
                i=MessageBox(NULL,"是否进入超市物品时间查询界面","超市管理系统",MB_YESNO|MB_ICONQUESTION);
                if(i==IDNO)
                {
                    MessageBox(NULL,"已返回主菜单","超市管理系统",MB_OK|MB_ICONWARNING);
                    system("cls");
                    break;
                }
                printf("\n您选择了超市物品时间查询功能!\n");
                printf("\t正在进入中请稍等。。。。。。。。\n");
                Sleep(2000);
                system("pause");
                system("cls");
                printf("   *******************************************\n");
                printf("   **         欢迎进入超市商品时间查询界面      **\n");
                printf("   *******************************************\n\n\n");
                printf("请输入您需进货商品的日期(如xxxx/xx/xx):\n");
                printf("     -----------------------------\n");
                printf("          o商品日期: ");
    
                scanf("%s",x.time);
                printf("     -----------------------------\n\n");
                int ans1=0;
                searchtime(x,head,&ans1);
                if(ans1==0)
                {
                    printf("查无此商品,请按任意键返回主界面\n");
    
                }
                printf("   ->可按任意热键进行返回\n");
                system("pause");
                system("cls");
                break;
            case 7:
                i=MessageBox(NULL,"是否进入商品浏览界面","超市管理系统",MB_YESNO|MB_ICONQUESTION);
                if(i==IDNO)
                {
                    MessageBox(NULL,"已返回主菜单","超市管理系统",MB_OK|MB_ICONWARNING);
                    system("cls");
                    break;
                }
                printf("\n您选择了商品浏览功能!\n\n");
                printf("\t正在进入中请稍等。。。。。。。。\n");
                Sleep(2000);
                system("pause");
                system("cls");
    
                lookthrough(head);
                system("pause");
                system("cls");
                break;
            case 8:
    
    
                i=MessageBox(NULL,"是否确认退出超市管理系统","超市管理系统",MB_YESNO|MB_ICONQUESTION);
                if(i==IDYES)
                {
                    i=MessageBox(NULL,"是否保存当前数据","超市管理系统",MB_YESNO|MB_ICONQUESTION);
                    if(i==IDYES)
                    { write("file.txt");
                        i=MessageBox(NULL,"保存成功","超市管理系统",MB_OK|MB_ICONINFORMATION);
    
                    }
                    else MessageBox(NULL,"已取消保存","超市管理系统",MB_OK|MB_ICONWARNING);
                    exit(0);
                }
                else
                {
                    MessageBox(NULL,"保存取消退出","超市管理系统",MB_OK|MB_ICONWARNING);
                    system("cls");write("file.txt");
                    continue ;
                }
                printf("退出成功,谢谢使用\n");
    
                exit(0);
    
    
            default :
                MessageBox(NULL,"热键错误,请键入正确的功能","超市管理系统",MB_OK|MB_ICONHAND);
    
                 system("cls");
    
            }
        }
    }
    
    

    总结

    这里因为要用链表进行二分法,所以我的整体数据结构使用了二叉排序树,每次创建结点比它小的放在左子树,比它大的放在右子树,这样它就直接可以用一个中序遍历写入文件就能够保证是有序的,读取出来直接一个循环直接到文末符,还用了API的的MessageBox来实现简单的人机交互。

    展开全文
  • C语言课程设计超市信息管理系统PAGEPAGE 5中国海洋大学青岛学院C语言课程设计报告书题 目超市管理系统学生姓名指导教师学 院专业班级组内分工姓名主要模块占比列***商品入库,物品信息修改,浏览,删除,出售管理65%...

    C语言课程设计超市信息管理系统

    PAGE

    PAGE 5

    中国海洋大学

    青岛学院

    C语言课程设计报告书

    题 目

    超市管理系统

    学生姓名

    指导教师

    学 院

    专业班级

    组内分工

    姓名

    主要模块

    占比列

    ***

    商品入库,物品信息修改,浏览,删除,出售管理

    65%

    ***

    超市利润,商品价值总和,物品信息查询

    35%

    目 录

    TOC \o "1-3" \h \z \u HYPERLINK \l "_Toc276277733" 1 前言 PAGEREF _Toc276277733 \h 1

    HYPERLINK \l "_Toc276277734" 2 需求分析 PAGEREF _Toc276277734 \h 2

    HYPERLINK \l "_Toc276277735" 3 模块设计图及组内分工 PAGEREF _Toc276277735 \h 3

    HYPERLINK \l "_Toc276277736" 4 NS流程图清单 PAGEREF _Toc276277736 \h 4

    HYPERLINK \l "_Toc276277737" 5 存储结构及函数说明 PAGEREF _Toc276277737 \h 5

    HYPERLINK \l "_Toc276277738" 6 课程设计结果 PAGEREF _Toc276277738 \h 6

    HYPERLINK \l "_Toc276277739" 7 实践心得体会 PAGEREF _Toc276277739 \h 7

    1 前言

    该章主要描述课程设计的目的,以及对题目本身的理解。

    随着现代生活质量的提高,以及生活的需要,超市这种便利的服务开始走进我们的生活,同时随着超市涌入我们的生活,如何更便利的对超市进行系统和有序的操作,成为了我们需要考虑的问题,针对这一问题,我们小组本着界面化,人性化的目的编写了一个解决问题的程序。本程序运用C语言程序设计了一个超市管理系统。关于系统的的功能主要有新购物品入库、物品信息删除、物品信息修改、物品信息查询、物品信息浏览、物品出售、超市物品总价值查询功能,物品信息在相应的硬盘上面进行存盘以防止部分数据的丢失。为了使该程序在电脑中运行时节省内存,在入库函数中使用了链表功能。还在MENU选项中添加了系统颜色设置功能,使用户可以选择适合自己观看的界面。

    2 需求分析

    当今社会信息产业发展迅速,特别是在计算机行业,利用计算机解决日常生活中的问题,就像我们开发的超市管理软件,所以现在一些管理者都在想着怎样利用计算机的软件设计来解决管理问题,例如一些数据的存储,管理的功能,这样以来,软件的设计就因此而来,超市管理也不例外,一些管理者,因为对超市管理中的货物管理,以及物品的出售,还有物品的查询,浏览,感到很烦琐,因为人的大脑不可能将今天的进货全都记下来。所以就需要通过一个程序来代替他来完成这一任务。这就是 我们所说的市场需求。

    3 模块设计图

    根据第二章中对系统的需求分析,绘制模块图。

    4 NS流程图清单

    根据第三章的模块图,绘制每一个模块的NS流程图,如果在其中要用到某一特殊算法,如排序算法等,要详细说明。

    主菜单:

    物品的浏览:

    查询:

    入库:

    删除:

    修改:

    validateID函数:

    5 存储结构及函数说明

    在本章中主要描述系统中主要信息的存储结构,对于各模块中通用的信息尽量采用同一存储结构,并将共同的存储结构保存成头文件,以便于各模块调用。对于各模块出现的函数要加以详细说明,特别是函数功能,其中包括函数形参和返回值代表的含义。

    本程序一共包括十个模块:

    1入库函数。

    2修改函数。

    3浏览函数。

    4查询函数。

    5删除函数。

    6利润查询。

    7资金浏览。

    8程序退出。

    9颜色设置。

    10--物品出售。

    其中这十个函数中都用到了结构体来存储物品的信息,还用到了结构体指针。

    1:入库函数中主要是将物品信息保存到文件中,在入库函数中我们采用了链表的形式对物品信息入库到文件中,本程序中都没有采用形参只有在链表中用了形参,和返回值,形参是结构指针,返回值也是结构指针。

    2:修改函数中用到了数组,首先将文件打开,然后将文件中的内容读取到数组中,然后逐个浏览数组中的物品编号,当读到这一编号是将其修改,然后将数组中的内容读取到文件中。完成了修改功能。

    3:浏览功能中我们也用了数组,首先将文件的内容读取到数组中,然后将其中的物品信息逐一读取。

    4:查询函数中,先将文件中的内容读取到数组,然后利用循环将要查询的号码查询出来,然后读出来。显示到桌面。

    5:删除函数中,将文件中的数据读出来,然后用户输入要删除的编号,查询到编号的数据位置,在执行将文件信息读回去的时候,此条信息不读进文件中,这就完成了文件的删除功能。

    6:利润的查询是通过将文件中的数据读出来,然后依次

    展开全文
  • 文章目录前言一、超市货架管理系统1.题目说明2.功能要求及说明3.测试数据4.提示二、使用步骤1.引入库2.读入数据总结 前言 关于超市货架管理系统,具体使用语言C++,其中用到STL Stack 和Vector 以个人的想法编写而...


    前言

    关于超市货架管理系统,具体使用语言C++,其中用到STL Stack 和Vector
    以个人的想法编写而成代码,感觉使用stack和vector比较方便,就天马行空的写下代码✍,供自己学习,仅供参考。


    一、超市货架管理系统

    1.题目说明

    在商店中,每种商品用一个货架专门摆放。生产日期越近的越靠近货架底部,出货时从货架顶层取货。一天营业结束后,如果货架不满,则需要上货。如果直接将商品摆放到货架上,会使生产日期越近的商品越靠近货架顶层,这样就需要倒货架,使生产日期越近的越靠近货架底部。

    2.功能要求及说明

    设计一个算法实现商品货架的摆放管理,要求实现以下操作:
    (1)初始化商品货架。商品种类不少于10种,每种商品的货架容量为100。
    (2)每种商品至少包含商品名称,数量和生产日期3种属性,生产日期以年月日的形式存放。营业时间客户可以从货架取走商品,但取走商品的数量不能超过已有库存量;
    (3)当天营业结束后,对货架不满的商品进行上货操作时,保证每一次上货后生产日期越近的商品越靠近货架底部;
    (4)上货结束后,对每个商品按照从货架顶部到货架底部的顺序,打印出所有商品的数量和生产日期。
    (5)采用模块化设计,分别以函数形式描述上述各功能,程序界面清晰简洁。

    3.测试数据

    当天营业结束时,商品“牛奶”的货架上有生产日期分别为“2017-01-14”和“2017-04-22”的各20份,进行上货操作。
    新上牛奶的生产日期为“2017-05-13”。上货结束后打印该货架上的商品信息应为:
    牛奶:
    生产日期为“2017-01-14”的数量20;
    生产日期为“2017-04-22”的数量20,
    生产日期为“2017-05-13”的数量60。

    4.提示

    以栈结构实现商店货架。生产日期越近的越靠近栈底,出货时从栈顶取货。如果直接将商品摆放到货架上,会使生产日期越近的商品越靠近栈顶,这样就需要倒货架,使生产日期越近的越靠近栈底。

    5.个人分析

    • 每一种商品包含信息,书写商品类,类中写信息
    • 商品种类不少于10种,每种商品货架容量为100,不确定商品种类有多少,书写货架类 使用动态数组保存商品种类
    • 上货、出货和打印信息,有关数量和生产日期,在关于生产日期的地方使用到栈和排序算法
    • (根据4.提示) 生产日期近的为最近生产的,远的为生产有一段时间的,生产日期远的物品会先生产先进栈,导致生产日期近的物品在栈顶,由于需要先售卖生产日期远的,所以需要倒栈使得生产日期远的在栈顶。 (好像有那么一丝丝的绕🤔)
    • 以栈结构实现商品货架,为方便和速率,使用STL stack,装载不同数量和生产日期的商品
    • 货架装载商品,商品包含信息,货架使用动态数组保存商品种类,商品用栈装载每一次进货该商品的信息,即动态数组 数组元素为栈 栈中元素为商品类信息

    二、具体实现

    1.商品类

    商品类中信息包括名称、数量和日期:

     //商品类,商品信息
    class Commodit     
    {
    public:
        string name;      //商品名称
        int num;        //数量
        int year;       //年份
        int month;      //月份
        int day;        //日期
    };
    

    2.货架类

    货架类私有属性为商品类,即货架上放商品:

    class Shelves       
    {
    private:
        Commodit* data;             //商品信息
    public:
        void ComInit(stack<Commodit>&s, vector<stack<Commodit>>&v);//初始化
        void PutCom(stack<Commodit>&s, vector<stack<Commodit>>&v);//上货
        void OutCom(stack<Commodit>&s, vector<stack<Commodit>>&v);//出货
        void PrintCom(stack<Commodit>&s, vector<stack<Commodit>>&v);//显示货物的信息
    };
    

    这里使用了STL stack和vector 记得添加头文件

    #include<vector>
    #include<stack>
    

    3.main方法

     Shelves S;                              //货架
     Commodit *com;                          //商品信息
     com = new Commodit;
    stack<Commodit> s;                      //STL stack 
    vector<stack<Commodit>> v;               //动态数组vector
    

    菜单的话 就看自己设计啦

            switch (select)
            {
            case 1:                                 //1.初始化
                S.ComInit(s,v);
                break;
            case 2:                                 //2.营业时间售卖
                S.OutCom(s,v);
                break;
            case 3:                                 //3.营业结束上货
                S.PutCom(s,v);
                break;
            case 4:                                 //4.商品信息打印
                S.PrintCom(s,v);
                break;
            case 5:                                 //5.退出
                exit(0);
            default:
                break;
            }
    

    4.初始化

    初始化数据,这肯定是必不可少的😀

     cout << "请输入商品种类数量:" << endl;
        cin >> ComNUM;
        for (int i = 0; i <= ComNUM - 1; i++)
        {
            Commodit  C;                                        //商品类信息作为结点
            stack<Commodit> s;
            cout << "商品名称:" << endl;                       //商品名称
            cin >> C.name;                                      
            cout << "商品数量:" << endl;                       //商品数量
            cin >> C.num;
            if (C.num > 100)
            {
                C.num = 100;
            }
            cout << "商品的日期:(年--月--日):" << endl;     //商品日期
            cin >> C.year >> C.month >> C.day;
            cout << endl;
            s.push(C);                                          //商品信息作为结点进栈
            v.push_back(s);                                     //栈作为数组元素进数组
        }
    

    依次输入商品的名称和数量,因为容量最大为100,所以数量最多为100
    然后输入的商品信息入栈,栈又作为数组元素

    5.出货售卖

    到点出货售卖了😘
    首先肯定是要输入商品的名称和需要买的数量的

     string BuyName;                                         //输入需要购买的商品名称
        int BuyNum,count=0;
        cout << "输入需要购买的商品的名称:" << endl;
        cin >> BuyName;                                         //要购买的数量
        cout << "输入需要购买的数量:" << endl;
        cin >> BuyNum;
    

    但是好像没写如果不存在商品的时候的情况。

    然后开始进行判断

    for (int i = 0; i <= v.size() - 1; i++)
        {
            if (!v[i].empty())
            {
                v[i].top();
                if (v[i].top().name == BuyName && BuyNum > 0)   //找到名称对应的商品,并且要购买的数量要保证大于0
                {
                    stack<Commodit> temp;                       //临时的栈来储存
                    while (!v[i].empty())                       //先统计栈里面此类商品的总数Num
                    {
                        Commodit C;
                        count = v[i].top().num + count;         //计算栈里面商品总共的数量:count
                        C = v[i].top();
                        v[i].pop();
                        temp.push(C);                           //另一个栈保存至原本的栈为空
                    }
                    while (!temp.empty())                       //倒栈还回来至临时的栈为空
                    {
                        Commodit Temp;
                        Temp = temp.top();
                        temp.pop();
                        v[i].push(Temp);
                    }
                    if (count < BuyNum)                             //需要购买的数量大于库存,提示需要上货
                    {
                        cout << "商品数量不足,需要上货。" << endl;
                    }
                    if (count >= BuyNum)                            //库存大于购买量,够数量售卖
                    {
                        if (v[i].top().num == BuyNum)               //比较栈顶元素结点的num和需要购买的数量大小
                        {
                            v[i].pop();                             //栈顶元素与购买量相等,则直接出栈。  
                            if (v[i].empty())
                            {
                                cout << "此商品售至数量为0,货架上不存在这个商品,需要重新初始化。" << endl;      //数量为0时,货架上不存在这个东西,要重新初始化
                                break;                              //为什么不加break时,当唯一结点num正好买完时候,栈空会报错?
                            }
                            break;
                        }
                        if (v[i].top().num > BuyNum)                //栈顶元素的num比需要购买的大,则数量直接相减
                        {
                            v[i].top().num = v[i].top().num - BuyNum;
                            break;
                        }
                        if (v[i].top().num < BuyNum)                //若栈顶元素的num比需要购买的小,则先出栈后再取新的栈顶元素进行判断
                        {
                            BuyNum = BuyNum - v[i].top().num;
                            v[i].pop();
                            while (!v[i].empty())                   //往下新的栈顶元素进行判断比较
                            {
                                if (v[i].top().num == BuyNum)       //栈顶元素num等于购买量时,出栈
                                {
                                    v[i].pop();
                                    break;
                                }
                                if (v[i].top().num > BuyNum)                //num比购买量大,数量相减
                                {
                                    v[i].top().num = v[i].top().num - BuyNum;
                                    break;
                                }
                                if (v[i].top().num < BuyNum)            //仍然不足时,出栈再取新的栈顶元素再判断
                                {
                                    BuyNum = BuyNum - v[i].top().num;
                                    v[i].pop();
                                }
                            }
                        }
                    }
                }
            }
        }
    

    数量的判断就很麻烦,要考虑购买数量和已有数量的关系,还容易出现空指针的情况。
    太多判断条件了,其实感觉可以优化一下,而且还用倒栈,就感觉效率很低

    6.上货补货

    别看售卖这么复杂,其实补货更加复杂,不仅要保证售卖的时候先售卖生产日期远的,然后还有根据生产日期进行一个排序,如果生产日期相同,又因为数量的问题,需要相加等等操作

     string InName;	//上货商品名称
    for (int i = 0; i <= v.size() - 1; i++)
        {
            if (!v[i].empty())
            {
                v[i].top();
                if (v[i].top().name == InName)
                {
                    stack<Commodit> temp;                   //临时的栈储存
                    stack<Commodit> sort;                   //排序栈
                    while (!v[i].empty())
                    {
                        Commodit C;
                        count = v[i].top().num + count;         //统计原本的栈里面商品的总数
                        C = v[i].top();
                        v[i].pop();
                        temp.push(C);                       //倒栈,至原本的栈为空
                    }
                    if (count == 100)
                    {
                        cout << "货架上容量已满,不需要上货。" << endl;
                        break;
                    }   
                    Commodit Add;                                   //上货,作为新结点
                    Add.name = InName;
                    cout << "输入需要新上货的商品数量:" << endl;        //输入新上货商品的数量
                    cin >> Add.num;
                    if (count + Add.num > 100)                      //保证货架容量为100,修正数值
                    {
                        Add.num = 100 - count;
                    }
                    cout << "输入需要新上货的商品的日期:" << endl;       //输入新上货商品的日期
                    cin >> Add.year >> Add.month >> Add.day;
                    //进行排序,保证打印信息日期最近的在下面,年份的比较
                    if (Add.year < temp.top().year)                    
                    {
                        while (Add.year < temp.top().year)              
                        {
                            Commodit comsort;
                            comsort = temp.top();
                            temp.pop();                             //栈顶元素出栈
                            sort.push(comsort);                     //进行判断是否与新的栈顶元素日期相同
                            if (!temp.empty() && Add.year == temp.top().year && Add.month == temp.top().month && Add.day == temp.top().day)
                            {
                                Add.num = Add.num + temp.top().num;     //与新的栈顶元素日期相等,上货的数量修正加上原本在栈里的商品数量
                                temp.pop();                             //新的栈顶元素出栈
                                break;                                  //break 出while 让上货的结点进栈
                            }
                            if (temp.empty())
                            {
                                break;
                            }
                        }
                        temp.push(Add);                                 //排序完成进栈
                        while (!sort.empty())
                        {
                            Commodit backsort;
                            backsort = sort.top();
                            sort.pop();
                            temp.push(backsort);
                        }
                    }
                    //进行排序,保证打印信息日期最近的打印出来在下面,年份相等的情况下月份的比较
                    if (Add.year == temp.top().year && Add.month < temp.top().month)
                    {
                        while (Add.year == temp.top().year && Add.month < temp.top().month)
                        {
                            Commodit comsort;
                            comsort = temp.top();
                            temp.pop();                         //栈顶元素出栈
                            sort.push(comsort);                 //进行判断是否与新的栈顶元素日期相同
                            if (!temp.empty() && Add.year == temp.top().year && Add.month == temp.top().month && Add.day == temp.top().day)
                            {
                                Add.num = Add.num + temp.top().num;     //与新的栈顶元素日期相等,上货的数量修正加上原本在栈里的商品数量
                                temp.pop();                             //新的栈顶元素出栈
                                break;                                  //break 出while 让上货的结点进栈
                            }
                            if (temp.empty())
                            {
                                break;
                            }
                        }
                        temp.push(Add);                                     //排序完成进栈
                        while (!sort.empty())
                        {
                            Commodit backsort;
                            backsort = sort.top();
                            sort.pop();
                            temp.push(backsort);
                        }
                    }
                    //进行排序,保证打印信息日期最近的打印出来在下面,年份月份相等的情况下月份的比较
                    if (Add.year == temp.top().year && Add.month == temp.top().month && Add.day < temp.top().day)
                    {
                        while (Add.year == temp.top().year && Add.month == temp.top().month && Add.day < temp.top().day)
                        {
                            Commodit comsort;
                            comsort = temp.top();
                            temp.pop();                     //栈顶元素出栈
                            sort.push(comsort);             //进行判断是否与新的栈顶元素日期相同
                            if (!temp.empty()&& Add.year == temp.top().year && Add.month == temp.top().month && Add.day == temp.top().day)
                            {
                                Add.num = Add.num + temp.top().num;         //与新的栈顶元素日期相等,上货的数量修正加上原本在栈里的商品数量  
                                temp.pop();                                 //新的栈顶元素出栈       
                                break;                                      //break 出while 让上货的结点进栈
                            }
                            if (temp.empty())
                            {
                                break;
                            }
                        }
                        temp.push(Add);                                        //排序完成进栈
                        while (!sort.empty())
                        {
                            Commodit backsort;
                            backsort = sort.top();
                            sort.pop();
                            temp.push(backsort);
                        }
                    }
                    //日期相等的情况中,与栈顶元素日期相等的情况
                    if (Add.year == temp.top().year && Add.month == temp.top().month && Add.day == temp.top().day)
                    {
                        temp.top().num = Add.num + temp.top().num;
                    }
                    //新上货的日期为最近最新的,不需要排序,直接上货
                    if (Add.year > temp.top().year || (Add.year == temp.top().year && Add.month > temp.top().month)
                        || (Add.year == temp.top().year && Add.month == temp.top().month && Add.day > temp.top().day))
                    {
                        temp.push(Add);                                 //因为倒栈,商品在临时储存的栈里面
                    }        
                    while (!temp.empty() && count<100)             //倒栈回来,至临时的栈为空
                    {
                        Commodit Temp;
                        Temp = temp.top();
                        temp.pop();
                        v[i].push(Temp);                    
                    }
                }
            }
        }
    

    7.遍历打印信息

    一开始认为这个打印信息,这难道不是最好写的嘛,直接输出就好了
    等写到上货和出货,突然想起来,是不是打印信息也需要倒栈操作呢?

                                                    //打印商品所有信息
    void Shelves::PrintCom(stack<Commodit>&s, vector<stack<Commodit>>&v)       
    {
        string Secondname;                                                          
        cout << "输入需要打印的商品的名称:" << endl;
        cin >> Secondname;
        for (int i=0;i<=v.size()-1;i++)        //遍历动态数组vector
        {
            if(!v[i].empty())
            {
                v[i].top();
                if (v[i].top().name == Secondname)
                {
                    stack<Commodit> temp;                       //临时的一个栈储存
                    while (!v[i].empty())
                    {
                        Commodit C;
                        C = v[i].top();                           
                        cout << "商品名称为:" << v[i].top().name << endl;                  //打印信息
                        cout << "商品数量为:" << v[i].top().num << endl;
                        cout << "商品的生产日期为:" << v[i].top().year << "-" << v[i].top().month << "-" << v[i].top().day << endl;
                        v[i].pop();
                        temp.push(C);                      
                    }
                    while (!temp.empty())                    //倒栈回来,至原本栈为空
                    {
                         Commodit Temp;
                         Temp = temp.top();
                         temp.pop();
                         v[i].push(Temp);
                    }
                }
            }
        }
    }
    

    感觉倒栈操作,还是蛮复杂的,不知道是不是使用stack的问题呢,或许还有方法可以优化呢


    总结

    这就是自己所设想的超市货架管理系统了,其实还是有很多可以优化的地方的,而且好像还会有空指针的情况出现,代码中还有很多书写不规范的地方,当时写的时候没有在意命名规则 emmmm 以后改进 一开始拿到题目的时候,感觉都想用类来写,但是发现关于数量的问题就很难表示

    最后用到stack 和 vector 感觉还是很方便的,这也是c++强大的地方吧
    不得不说STL stack和 vector真的真的真的很方便
    个人学艺不精代码,如果写的不当之出,可以指出,共同学习🙃

    展开全文
  • 超市库存管理系统

    千次阅读 2020-01-13 20:35:15
    模拟真实的库存管理逻辑,完成超市管理系统的日常功能实现,见下图 二、案例需求分析 根据案例介绍,我们进行分析,首先需要一个功能菜单,然后输入功能序号后,调用序号对应的功能方法,实现想要的操作。分析...

    一、案例介绍

    模拟真实的库存管理逻辑,完成超市管理系统的日常功能实现,见下图

    二、案例需求分析

    根据案例介绍,我们进行分析,首先需要一个功能菜单,然后输入功能序号后,调用序号对应的功能方法,实现想要的操作。分析步骤如下

    1.完成超市商品初始化。创建商品,将商品添加到集合

    2.显示来到超市能做的操作,也就是显示主菜单

    3.根据接收到的功能选项,执行对应的功能

         3.1.库存货物查询

         3.2.添加新货物 

         3.3.删除货物

         3.4.修改货物

         3.5.退出系统,结束main方法的运行

    4.循环,回到 2.显示主菜单

     

    三、实现代码步骤

    每种库存商品都拥有多项商品信息,为了方便管理每种商品的信息,我们对商品信息进行封装,编写FruitItem.java文件

    public class FruitItem {

        int  ID;        //商品编号

        String  name;       //商品名称

        double  price;      //商品单价

        double  number;     //商品数量

        double  money;      //商品金额

    }

    上述代码中,对商品信息(编号、名称、单价、数量、金额)进行了封装。这样做的好处在于以后只要找到这个商品,就能够知道该商品的每项信息了。

    编写FruitStore.java,完成如下功能:

    编写main主方法

        public static void main(String[] args) {

            //定义数组,记录每个商品信息

            ArrayList<FruitItem> list = new ArrayList<FruitItem>();

            /*

             * 1.超市商品初始化

             */

            init(list);      

            while(true){

                /*

                 * 2.显示主菜单

                 */

                mainMenu();

                /*

                 * 3.根据接收到的功能选项,执行对应的功能

                 */

                chooseFunction(list);

            }

        }

        上述代码中,通过while(true)循环,完成用户调用不同功能。实现重复功能选择操作。

    1.超市商品初始化。创建商品,将商品添加到集合

        public static void init(ArrayList<FruitItem> list) {

            FruitItem item = new FruitItem();

            item.name = "少林寺酥饼核桃";

            item.ID = 9001;

            item.price = 120;

           

            FruitItem item2 = new FruitItem();

            item2.name = "尚康杂粮牡丹饼";

            item2.ID = 9002;

            item2.price = 20;

           

            FruitItem item3 = new FruitItem();

            item3.name = "新疆原产哈密瓜";

            item3.ID = 3;

            item3.price = 9007;

           

            list.add(item);

            list.add(item2);

            list.add(item3);

        }

       上述代码中,完成商品集合的初始化操作,添加了3件商品。

     

    2.显示来到超市能做的操作,也就是显示主菜单

        public static void mainMenu() {

             System.out.println("=========================欢迎光临itcast超市=========================");

             System.out.println("1:查询货物  2:添加新货物 3:删除货物 4:修改货物");

             System.out.println("5:退出系统");

        }

    上述代码,用来完成用户操作界面的显示。

     

    3.根据接收到的功能选项,执行对应的功能

        public static void chooseFunction(ArrayList<FruitItem> list) {

            System.out.println("请您输入要操作的功能序号:");

            Scanner sc = new Scanner(System.in);//键盘输入对象

            String choose = sc.next();

            //根据接收到的选择,执行对应的功能

            switch (choose) {

            case "1": //3.1.库存货物查询

                showFruitList(list);

                break;

            case "2": //3.2.添加新货物

                addFruitItem(list);

                break;

            case "3": //3.3.删除货物

                delFruitItem(list);

                break;

            case "4": //3.4.修改货物

                updateFruitItem(list);

                break;

            case "5": //3.5.退出系统,退出JVM

                System.out.println("退出系统");

                return;

            default:

                System.out.println("对不起,没有您输入的功能,请重新选择");

                break;

            }

        }

    上述代码中,参数list为库存商品集合。当键盘输入功能序号后,通过switch语句匹配后,调用对应的方法完成对应功能的实现。

     

    3.1.库存货物查询

        public static void showFruitList(ArrayList<FruitItem> list) {

            System.out.println("=======================商品库存清单=======================");

            System.out.println("商品编号\t商品名称\t\t商品单价");

            //查询每种库存商品信息

            for (int i = 0; i < list.size(); i++) {

                FruitItem item = list.get(i);

                System.out.println(item.ID + "\t" + item.name + "\t" + item.price);

            }

        }

             上述代码中,用来查询所有库存商品信息。

     

    3.2.添加新货物 

        public static void addFruitItem(ArrayList<FruitItem> list) { 

            //创建新获取对象

            FruitItem newItem = new FruitItem();

            Scanner sc = new Scanner(System.in);//键盘输入对象

            //提示输入信息

            System.out.print("请输入新水果的名称:");

            newItem.name = sc.next();

            System.out.print("请输入新水果的编号:");

            newItem.ID = sc.nextInt();

            System.out.print("请输入新水果单价:");

            newItem.price = sc.nextDouble();

           

            //向货物集合中添加新的物品项

            list.add(newItem);

        }

    上述代码中,通过键盘录入,将录入的商品信息存储到库存商品集合中。

     

    3.3.删除货物

        public static void delFruitItem(ArrayList<FruitItem> list) {

            System.out.print("请输入您要删除的水果编号:");

            Scanner sc = new Scanner(System.in);//键盘输入对象

            int fruitID = sc.nextInt();

            //删除集合元素

            for (int i = 0; i < list.size(); i++) {

                FruitItem thisItem = list.get(i);

                if(thisItem.ID == fruitID) {

                    list.remove(thisItem);

                    System.out.println("水果信息删除完毕!");

                    return;

                }

            }

            System.out.println("对不起,没有这个编号的水果!");

        }

    上述代码中,通过键盘录入,在库存集合中查找对应的商品编号,如果找到该商品,将该商品删除,否则,提示没有这个编号的商品。

     

    3.4.修改货物

        public static void updateFruitItem(ArrayList<FruitItem> list) {     

            System.out.println();

            System.out.print("请输入您要修改信息的水果编号:");

           

            Scanner sc = new Scanner(System.in);//键盘输入对象

            int fruitID = sc.nextInt();

           

            //更新集合元素

            for (int i = 0; i < list.size(); i++) {       

                FruitItem thisItem = list.get(i);

                if(thisItem.ID == fruitID) {

                    System.out.print("请输入新的水果ID:");

                    thisItem.ID = sc.nextInt();

                    System.out.print("请输入新的水果名称:");

                    thisItem.name = sc.next();

                    System.out.print("请输入新的水果单价:");

                    thisItem.price = sc.nextDouble();

                    System.out.println("水果信息更新完毕!");

                    return;

                }

            }

            System.out.println("对不起,没有这个编号的水果!");

        }

    上述代码中,通过键盘录入,在库存集合中查找对应的商品编号,如果找到该商品,则键盘录入修改商品信息,否则,提示没有这个编号的商品。

     

    展开全文
  • 超市订单管理系统

    2021-03-07 22:37:22
    超市订单管理系统是一个专为连锁店、超市等商业场所提供订单管理平台的系统。该系统的目标是建立一个订单管理平台,为需要合理规划超市供应链、供应商以及工作人员提供的便捷的平台。该系统的主要业务需求包括记录并...
  • C语言-超市仓库管理系统的设计与实现

    千次阅读 多人点赞 2020-11-02 23:54:58
    C语言-超市仓库管理系统的设计与实现 第一个博客~ 超市仓库管理系统的设计与实现 问题描述:实现一个小型仓库管理系统,完成商品的入库,出库,查询等功能。 物品信息说明:物品代码,物品名称,物品总量,商品价格...
  • 数据库《小型超市管理系统

    热门讨论 2011-01-21 13:17:36
    超市管理系统是市场上最流行的超市上常用的系统之一,它主要包含以下几个模块:系统权限的设定、原始数据录入、数据的汇总及查询等。从而,实现对进货、销售及员工信息等实现全面、动态、及时的管理。 2.1 功能及...
  • Python基础项目:超市商品销售管理系统

    万次阅读 多人点赞 2019-04-18 12:01:54
    在前几章的案例中,主要以项目为中心介绍了相关知识点,通过手机通讯录管理系统和学生信息管理系统案例的学习,应该掌握了Python当中的基础语法,变量语句函数以及常见数据结构列表与字典的基本操作,通过世界杯查询...
  • 基于java超市管理系统设计

    万次阅读 多人点赞 2019-04-15 22:33:47
    摘 要 获取项目源文件,学习交流联系Q:1415736481,可...同时J2EE平台的产品几乎能够在任何操作系统和硬件配置上运行,因此文中设计了一个基于J2EE 架构的超市综合管理信息系统。根据J2EE 架构的多层应用程序方案和...
  • 同时J2EE平台的产品几乎能够在任何操作系统和硬件配置上运行,因此文中设计了一个基于J2EE 架构的超市综合管理信息系统。根据J2EE 架构的多层应用程序方案和超市管理信息系统的特点,系统采用以Web 为中心的应用程序...
  • 用Python实现简易超市售货系统

    千次阅读 2021-02-03 15:25:14
    今天来实现一个简单的超市售货系统数据存储形式为json的数据首先是读取数据,这里用到的Python的json库,用于处理json类型的数据```pythondef load(): # 数据读取j = open('goods.txt', 'r', encoding='utf-8')# ...
  • JSP超市管理系统的设计与实现PAGEPAGE I摘 ...通过超市管理管理系统这个平台,可以实现超市管理管理的信息化、网络化、系统化、规范化,使工作人员从繁杂的数据查询和统计中解脱出来,减少工作量。系统的主要功能包...
  • JavaWeb开发技术之商品货物物品管理系统 一. 项目概述 随着时代的发展和科技的不断更新换代,人们也渐渐习惯了运用计算机等科技产品进行代替传统的行为已达到节省空间,时间,财力,物力等目的。 20世纪90年代后期,...
  • C语言程序设计——超市信息管理系统

    千次阅读 多人点赞 2020-06-15 10:03:45
    因此,我们小组设计的“超市信息管理程序”旨在解决货物的信息和购买商品信息的储存问题以及实现建立库存信息,对购物车添加商品、结算并修改库存等操作,同时也能实现对库存信息的读取和显示。 我们设计的程序要...
  • 基于JAVA超市自助购物系统的设计与实现

    千次阅读 多人点赞 2021-08-03 20:34:06
    基于RFID的自动识别技术,通过无线射频方式实时获得磁卡对超市物品的电子标签进行读取,然后将数据通过网络传输至服务器,在应用层开发一个管理系统,对超市物品信息、店内消费等各种行为进行管理和显示。...
  • 后台-服务器项目,但是只有简单的项目模型,今天使用完善的前端页面,自己写Servlet后台来完成一个超市管理系统的简单项目,主要有登录,注册,管理员查看会员信息,编辑会员信息,查看超市剩余物品,显示同时在线...
  • JAVA实现商品信息管理系统

    万次阅读 多人点赞 2019-10-14 20:43:56
    超市商品管理系统 题目要求 超市中商品分为四类,分别是食品、化妆品、日用品和饮料。每种商品都包含商品名称、价格、库存量和生产厂家、品牌等信息。 主要完成对商品的销售、统计和简单管理。 这个题目相对简单...
  • 使用C语言链表实现商品管理系统

    万次阅读 多人点赞 2018-06-06 15:11:24
    printf("\n\t**********************商品信息管理系统**********************");  printf("\n\t************************后台登录界面************************"); printf("\n\n\t请输入您的账号:"); // 获取...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,007
精华内容 402
关键字:

数据结构超市物品管理系统

数据结构 订阅