仓库管理系统

课程设计报告

学院

指导教师：孙暘 姓名：黄志浩

学院：计算机科学与工程班级：150407

需求分析

仓库管理系统应完成以下功能： （1）基础数据设定

主要包括仓库类型定义、仓库定义、仓库产品低储、高储、存储限量及存储期限、货位定义、货位存储能力、定义成本统计参数（包括总体系数、每种产品成本系数）、预警机制时间系数定义。 （2）仓库入库

包括原材料入库和成品入库

1.原材料入库：一种是本地的采购：首先由采购处编写请检单，经过质检部门质检合格后（质检部门记录质检结果，合格数、不合格数），仓库保管员将质检合格的原料入库（记录采购部门定义的当时单价）。系统自动产生入库单号（相当于入库批次号形式为年月日）。此时为仓库的假入库状态。办理入库后，由仓库管理员对入库单明细确认是否真入库。入库需要记录项目有：仓库、仓库货位、库管员、图号、型号、颜色、数量。若质检不合格，则对不合格原料进行挑选，把合格原料入库。

另一种是外地的采购：首先由库管员办理入库（放入待检区）。向采购部门和质检部门发消息。经过质检部门质检合格后方可入库（入库的操作同上）。不合格原料由仓库管理员办理手续进入相应的仓库，入库时应分货位存储（相应的仓库：如待检区的不合格区），系统自动产生入库单号（相当于批次号）。

2.成品入库：由生产车间经过质检部门质检合格后，由生产车间填写成品入库单提交到仓库管理员, 不合格的入到待处理库房。 （3）仓库出库

包括原材料出库、销售出库

1.原材料出库：由生产车间填写领料单（标注班组），仓库管理员办理出库确认约束条件：按照批次号先进先出的原则。车间填写领料单时可以是成品。提交仓库时，由仓库通过质部门提供的物资配料清单分解需要的零部件数量，根据现库存办理出库确认。

2.销售出库：销售出库由生产部门填写的销售出库单，办理出库。销售退库经质检部门合格后的成品入到成品库。 （4）仓库退库

包括原材料退库、成品退库、销售退库

1.原材料退库：生产车间将零部件或成品退回仓库。首先有生产车间填写退库单（相当于出库为负），由质检部门确认后方可由仓库确认。生产车间退库时，需要知道哪个批次的货物。

2.成品退库：成品退库，首先由质检部门同意将产品从生产车间退回库中。由车间填写退库单。经过仓库管理员确定后办理退库。

3.销售退库：由厂商将产品退回仓库，首先由质检部门质检，质检合格由仓 库管理员办理退库单。不合格的存放待处理成品区中。

（5）仓库库存查询：根据仓库一段时间内发生的入、出、退汇总数量、金额。 （6）统计分析：查询仓库产品数量分布情况。

（7）自动提醒预警信息：根据产品入出退库时间和系统参数定义，统计仓库目前的超量及库存已低于低储,存储期限超出查询。

（8）仓库台帐：及时反映仓库产品的入、出、退明细帐。

( 9) 仓库存储成本统计：根据产品成本系数和存储时间计算存储成本

公式：产品在仓库存储时间差*数量*单价*相应的总体系数*该产品自定义系数计算仓库存储成本

概要设计

源程序有7个文件：

main.cpp 程序入口，显示主菜单并跳转到工具类相应成员函数部分。

tools.cpp tools.hpp 工具类，程序由main.cpp跳转到工具类，有工具类具体跳转到相应部分。

product.cpp product.hpp 产品类，主要负责保存产品信息，即对象模型，同时还负责将对象保存的数据写入文件，或将文件中的数据经过链表类保存到对象中。

该文件中还有一个日志类WareLogs，继承自product，负责每次入、出、退库时需要记录的信息，如日期、产品型号、数量，还负责将对象保存的数据写入另外的日志文件，或将日志文件中的数据读取到对象中。同时日志类对象还有另外一个功能：将基础数据设定的数据写入单独的文件中。

linkList.cpp linkList.hpp 链表类，保存的是节点类对象，节点类对象的数据域为产品类对象。链表类的主要功能是将某文件中所有数据读取为链表，或在链表对象中搜索出某产品并对该产品进行相应更改之后再次将链表对象的数据域写入文件。

用来保存数据的文件有6个：

const string noQuilityProdCFileName = \"noQuilityProdCFile.txt\"; //成品不合格文件名

const string QuilityProdCFileName = \"QuilityProdCFile.txt\"; //成品合格文件名

const string noQuilityProdYFileName = \"noQuilityProdYFile.txt\"; //原材料不合格文件名

const string QuilityProdYFileName = \"QuilityProdYFile.txt\"; //原材料合格文件名

const string LogsToTheFile = \"logsFile.txt\"; //基础信息设定配置文件

const string ProductLogFileName = \"productLog.txt\"; //保存入出退日志信息

详细设计

产品类

数据成员部分：

货物型号／货物数量／货位号／单价／该产品的自定义成本系数／颜色／库管员／仓库名称／入出退库时间戳 成员方法：

int setInWareList(); //填写入库单，将数据保存在对象模型中 void setSaleWareList(); //填写销售出库单，将数据保存在对象模型中 void setReceiveList(); //填写领料单，将数据保存在对象模型中 void setOutWareList(); //填写退库单，将数据保存在对象模型中 int inToFile(string fileName); //根据入库单确认入库

void setProdModel(); //填写产品型号 供查询使用 int getDayByChrono(); //计算时间戳

时间戳的计算通过库函数来实现，需要包含头文件 chrono 和 ratio，每入出退库是都需要调用该函数记录时间日期，供查询使用。 int product::getDayByChrono(){ using namespace std::chrono;

typedef duration> days_type;

time_point today = time_point_cast(sys-tem_clock::now());

return today.time_since_epoch().count(); }

链表类：

将链表的头节点放在链表类中，节点类对象中含有数据域和指向下一个节点的指针域。

链表类的成员方法负责将链表的节点存储的产品类对象数据写入文件或将文件中的数据提取为链表。链表类的成员方法 //提取数据为链表

void getlinkListFromTheFile(string fileName);

//遍历链表找到节点

void forInLinkListForInAndOut(product *prod,string type);

//根据产品型号搜索出仓库名称/产品分布型号

void forInLinkListForLocation(product *prod,string type);

//根据基本数据设定信息查询高储低储 以及超出存储期限的产品 void forInLinkListForRemind(WareLogs *logs,string type);

//根据产品对象的型号和该产品成本系数以及日志文件中的基本数据设定信息 计算该产品的存储成本

void forInLinkListForCost(product *prod,WareLogs *logs,string type);

//将链表数据重新写入文件

void writeNodeToTheFile(string fileName);

调试分析

遇到过的问题：

1.计算仓库存储成本和预警存储期限时，需要知道产品入出退库的时间，这里采用库函数实现，可以获取当前的时间戳，产品每次入出退库时都需要将这个时间戳保存。用途如：通过当前的时间戳减去产品入库的时间戳就是产品在仓库的保存时间。

2.至于文件数据提取及修改，是通过链表实现的。对于链表的处理，C++和C 是有些不同的，在C++里，可以把节点类和链表类分别声明，将头节点作为链表类对象的成员属性，而每个节点的数据域保存了产品类对象，指针域指向下一个节点。

3.入库退库功能之外的查询工作，需要产品入出退库时间、基础数据设定等信息，这些信息保存在产品对象中不合适，而且这样使得产品对象过于庞大，但是又和产品对象的数据有密切关系，所以这里采用继承的方式，日志类继承产品类，需要完成的功能是将基础数据设定的数据和产品每次入出退库的时间写入文件。写入的时间需要和对应产品进行联系，所以需要获取对应产品的型号、数量、单价来计算总金额。

4.C++当自定义的头文件过多时，会有文件重复包含，即文件重复编译的情况出现。这里采用宏的方式处理：

#ifndef identifier #define identifier

#endif

5.入库时需要判断入库产品数量是否大于自定义的货位存储能力，同样出库时需要判断出库产品的数量是否大于仓库存储产品数量。为此在入库或出库时通过链表类对象提取文件中保存的对应型号产品的数量与将要入库或出库的产品数量做比较，不符合就要终止入库或退库。

用户使用说明

1.第一次使用时需要到基础数据设定模块中设定数据，这些数据在以后入出退库时都会默认调用。 2.入库时填写的入库单中产品的成本系数不能大于基本数据设定中自定义的总体成本系数。 3.当天入库的产品暂时不计存储成本(该产品存储天数为0 )。

4.牢记产品型号，仓库的查询功能除了“仓库库存分析查询”是通过时间段查询数据，其余都是通过产品型号来查询。

测试结果

1. 基础数据设定测试

2.入库测试

错误处理

3.出库测试

错误处理

4.退库测试

5.仓库库存查询测试

6.统计分析测试

7.提醒预警信息测试

8.仓库台账测试

错误处理

9.产品存储成本查询

当天入库的产品由于存储天数为0，无法计算存储成本。

为了测试改功能，将文件中该产品的入库时间

戳由16996修改为16990后(入库时间修改为前六天)，测试结果如下

附录

//

// main.cpp // 仓库管理系统 //

// Created by xiaoka on 16/7/4.

// Copyright © 2016年 黄志浩. All rights reserved. //

#include \"tools.hpp\" #include using namespace std;

void printToScreen(){ cout<cout<<\"---------------仓库管理系统---------------\"<<<\"-- 9-产品存储成本查询\"<int main(int argc, const char * argv[]) { printToScreen(); int menu = 0; while (1) { cin>>menu;

tools *t = new tools(); switch (menu) {

case 1: //基本数据设定 t->baseSetting(LogsToTheFile); break;

case 2: //仓库入库 t->addProduct(); break;

case 3: //仓库出库 t->outProduct(); break;

case 4: //仓库退库 t->againProduct(); break;

case 5: //仓库库存查询 t->wareStockAsk();

break;

case 6: //统计分析 t->allAnalyse(); break;

case 7: //提醒预警 t->remindWarning(); break;

case 8: //仓库台账 t->wareAccount(); break;

case 9: //仓库存储成本查询 t->productForCost(); break; case 0:

delete t; exit(0); break; default:

cout<<\"请正确输入菜单对应序号\"<delete t;

cout<<\"已返回主菜单\"<return 0; } //

// tools.hpp // 仓库管理系统 //

// Created by xiaoka on 16/7/4.

// Copyright © 2016年 黄志浩. All rights reserved. //

#include #include using namespace std;

class linkList;

class product; class WareLogs;

const string noQuilityProdCFileName = \"noQuilityProdCFile.txt\"; //成品不合格文件名

const string QuilityProdCFileName = \"QuilityProdCFile.txt\"; //成品合格文件名

const string noQuilityProdYFileName = \"noQuilityProdYFile.txt\"; //原材料不合格文件名

const string QuilityProdYFileName = \"QuilityProdYFile.txt\"; //原材料合格文件名

const string LogsToTheFile = \"logsFile.txt\"; //基础信息设定配置文件

const string ProductLogFileName = \"productLog.txt\"; //保存入出退日志信息

class tools{ public:

//设置基本信息

void baseSetting(string fileName);

//质检部门检验合格 string isQuilified();

//填写入库单 确认入库

void addProdToFile(string fileOKName,string fileNOName);

//仓库入库入口函数 void addProduct();

//填写领料单／销售出库单

void outProdFromFile(product *prodList,string fileName,string type);

//仓库出库入口函数 void outProduct();

//将退库的货物按合格与否分类

void OKOrNo(string fileOKName,string fileNoOKName);

//退库入口函数

void againProduct();

//仓库库存查询入口 void wareStockAsk();

//统计分析入口 void allAnalyse();

//提醒预警

void remindWarning();

//仓库台账

void wareAccount();

//产品存储成本查询 void productForCost(); }; //

// tools.cpp // 仓库管理系统 //

// Created by xiaoka on 16/7/4.

// Copyright © 2016年 黄志浩. All rights reserved. //

#include \"tools.hpp\" #include \"linkList.hpp\" #include \"product.hpp\" /**

* 仓库基础信息设定 将设定的信息写入文件 */

void tools::baseSetting(string fileName){

double maxStock,minStock,maxAbility,maxDate,costFactor; cout<<\"输入仓库高存储量 \"; cin>>maxStock;

cout<<\"输入仓库低存储量 \"; cin>>minStock;

cout<<\"输入货位存储能力 \"; cin>>maxAbility;

cout<<\"输入仓库最大存储期限 \"; cin>>maxDate;

cout<<\"输入仓库存储总体成本系数 \"; cin>>costFactor;

fstream fout(fileName,ios::out); if (!fout) {

cout<<\"打开\"<fout<* 质检部门确认合格与否 *

* @return \"y/Y\"合格 \"n/N不合格\" */

string tools::isQuilified(){ string is; while (1) {

cout<<\"质检部门确认合格?\"; cin>>is;

if (is==\"y\"||is==\"Y\") { return \"y\";

}else if (is==\"n\"||is==\"N\"){ return \"n\"; }

cout<<\"合格输入y/Y\"<* 填写入库单 将入库单数据(产品详尽信息)写入文件 *

* @param fileOKName 原材料/成品 合格库区 * @param fileNOName 原材料/成品 不合格库区 */

void tools::addProdToFile(string fileOKName,string fileNOName){ string is = isQuilified(); if (is==\"y\") {

product* q = new product();

int iss = q->setInWareList(); //填写入库单 if (iss==2) { return; }

q->inToFile(fileOKName); //根据入库单确认入库 WareLogs *log = new WareLogs();

log->wirteChangeToTheFile(q, ProductLogFileName, \"1\"); delete q;

} else if(is==\"n\"){

product* q = new product();

int iss = q->setInWareList(); //填写入库单 if (iss==2) { return; }

q->inToFile(fileNOName); //根据入库单放到不合格成品仓库 WareLogs *log = new WareLogs();

log->wirteChangeToTheFile(q, ProductLogFileName, \"1\"); delete q; } } /**

* 仓库入库 入口函数 */

void tools::addProduct(){ string t; while (1) {

cout<<\"1-成品入库\"<>t;

if (t==\"1\") {

addProdToFile(QuilityProdCFileName,noQuilityProdCFileName); break;

}else if (t==\"2\"){

addProdToFile(QuilityProdYFileName, noQuilityProdYFileName); break; }

cout<<\"请输入正确序号 \"<* 提取文件中数据为链表 根据出库单或领料单修改链表数据 并将数据重新写入文件 *

* @param prodList 出库单或领料单数据 * @param fileName 文件名

* @param type 2=出库 3=原材料退库／成品退库 */

void tools::outProdFromFile(product *prodList,string fileName,string type){ linkList *link = new linkList();

link->getlinkListFromTheFile(fileName);

if (link->head->next==NULL) { cout<<\"提取数据失败\"<link->forInLinkListForInAndOut(prodList,type); //遍历链表对链表相应节点进行修改 link->writeNodeToTheFile(fileName); //将链表数据写入文件 delete link; return; } /**

* 仓库出库 入口函数 */

void tools::outProduct(){ string is; while (1) {

cout<<\"1-原材料出库\"<>is;

if (is==\"1\") {

product *p = new product(); p->setReceiveList();

outProdFromFile(p, QuilityProdYFileName,\"2\"); break;

}else if (is==\"2\"){

product *p = new product(); p->setSaleWareList();

outProdFromFile(p, QuilityProdCFileName,\"2\"); break; }

cout<<\"输入正确序号\"<* 将退库的货物按合格与否分类 *

* @param fileOKName 合格产品存放 文件名 * @param fileNoOKName 不合格产品存放 文件名 */

void tools::OKOrNo(string fileOKName,string fileNoOKName){ string isOK;

isOK = isQuilified();

product *p = new product(); if (isOK==\"y\") {

p->setOutWareList(); //填写退库单

outProdFromFile(p, fileOKName,\"3\"); //提取文件中数据为链表 根据出库单或领料单修改链表数据 并将数据重新写入文件 }else{

cout<<\"填写入库单 存入原材料仓库不合格区\"<p->setInWareList(); //填写入库单

p->inToFile(fileNoOKName); } } /**

* 退库入口函数 */

void tools::againProduct(){ string is,isOK,fileName; while (1) {

cout<<\"1-原材料退库\"<>is;

if (is==\"1\") { //原材料退库 需要知道哪个批次的货物

OKOrNo(QuilityProdYFileName, noQuilityProdYFileName);

}else if (is==\"2\"){ //成品退库 需要输入：仓库名称、图号、型号、数量、车间、发生日期、仓库管理员、原因

OKOrNo(QuilityProdCFileName, noQuilityProdCFileName); }else if (is==\"3\"){ //销售退库 OKOrNo(QuilityProdCFileName, noQuilityProdCFileName); }else{

cout<<\"请输入正确序号 \"; }

break; } } /**

* 仓库库存分析查询入口 */

void tools::wareStockAsk(){ int day;

cout<<\"功能描述:根据输入的段时间查询仓库发生的入出退总数量／金额\"<>day;

WareLogs *log = new WareLogs();

log->readDateFromFile(day, ProductLogFileName, 1); delete log;

log = new WareLogs();

log->readDateFromFile(day, ProductLogFileName, 2); delete log;

log = new WareLogs();

log->readDateFromFile(day, ProductLogFileName, 3); delete log; } /**

* 统计分析入口 由产品型号搜索出产品分布情况(仓库名称／货位) 包括成品仓库和原材料仓库 */

void tools::allAnalyse(){

cout<<\"功能描述:由产品型号搜索出产品分布情况(仓库名称／货位) 包括成品仓库和原材料仓库\"<linkList *link = new linkList(); product *prod = new product(); prod->setProdModel();

link->getlinkListFromTheFile(QuilityProdCFileName); //将文件中的数据提取为链表 link->forInLinkListForLocation(prod,\"4\"); //查询成品仓库 delete link;

link = new linkList();

link->getlinkListFromTheFile(QuilityProdYFileName); //将文件中的数据提取为链表 link->forInLinkListForLocation(prod,\"5\"); //查询原材料仓库 delete prod; } /**

* 提醒预警信息入口 根据基本数据设定 输出仓库高储／低储／存储期限 */

void tools::remindWarning(){

cout<<\"功能描述:根据基本数据设定 输出仓库高储／低储／存储期限\"<int isOK = w->readBaseSettingFromTheFile(LogsToTheFile); if (isOK==2) { return; }

linkList *link = new linkList();

link->getlinkListFromTheFile(QuilityProdCFileName); link->forInLinkListForRemind(w,\"4\"); delete link;

link = new linkList();

link->getlinkListFromTheFile(QuilityProdYFileName); link->forInLinkListForRemind(w, \"5\"); delete link; } /**

* 仓库台账入口 */

void tools::wareAccount(){

cout<<\"功能描述:根据产品型号输出仓库产品的入、出、退明细帐\"<cout<<\"输入待查询产品型号 \"; cin>>model;

WareLogs *w = new WareLogs();

w->readFromFileToScreen(ProductLogFileName, model, 1); //1入库 2出库 3表示退库 需要填写原因 delete w;

w = new WareLogs();

w->readFromFileToScreen(ProductLogFileName, model, 2); delete w;

w = new WareLogs();

w->readFromFileToScreen(ProductLogFileName, model, 3); delete w; } /**

* 产品存储成本查询 */

void tools::productForCost(){

cout<<\"功能说明:根据产品型号计算该产品存储成本\"<WareLogs *logs = new WareLogs();

logs->readBaseSettingFromTheFile(LogsToTheFile); p->setProdModel();

linkList *link = new linkList();

link->getlinkListFromTheFile(QuilityProdCFileName); link->forInLinkListForCost(p, logs,\"4\"); delete link;

link = new linkList();

link->getlinkListFromTheFile(QuilityProdYFileName); link->forInLinkListForCost(p, logs,\"5\"); delete link; delete p; delete logs; }

//

// product.hpp // 仓库管理系统 //

// Created by xiaoka on 16/7/4.

// Copyright © 2016年 黄志浩. All rights reserved. //

#ifndef product_hpp #define product_hpp

#include #include using namespace std;

class product{ protected:

string prodModel; //货物型号 double prodNum; //货物存储数量 string location; //仓库货位序列号 double price; //产品单价 double costNum; //成本系数 string prodColor; //货物颜色 string peopleName; //货物库管员 string wareName; //仓库名称 int intoWareDay; //入库时间戳 int outFromWareDay; //出库时间戳 int againToWareDay; //退库时间戳 void print(); public:

product();

product(const product *p); friend class linkList; friend class wareHouse; friend class WareLogs; string getProdModel();

double getProdNum(); //数量 double getProdPrice(); //单价

int setInWareList(); //填写入库单

void setSaleWareList(); //填写销售出库单 void setReceiveList(); //填写领料单 void setOutWareList(); //填写退库单

int inToFile(string fileName); //根据入库单确认入库

void setProdModel(); //填写产品型号 供查询使用 int getDayByChrono(); //计算时间戳 };

#endif /* product_hpp */

class WareLogs:public product{ private:

double maxStock; //最大存储限量 double minStock; //最小存储限量 double maxAbility; //最大存储能力 double maxDate; //最大存储期限 double costFactor; //产品总体存储成本

string type; //1入库 2出库 3表示退库 需要填写原因 string changeModel; double changeNum;

double changeToatolMoney;

int intoWareDay; //入库时间戳 int outFromWareDay; //出库时间戳 int againToWareDay; //退库时间戳 string reason;

void initSomeValueWithProd(product *prod); public:

WareLogs();

friend class linkList; friend class product;

//从文件中读取基本数据设定

int readBaseSettingFromTheFile(string fileName);

//入出退库前调用 将数据保存到对象模型中 并在该方法中将数据写入文件 注意该方法要在prod的时间戳设置完毕后调用

void wirteChangeToTheFile(product *prod,string fileName,string type);

//仓库台账 根据产品型号输出入出退明细账 使用之前可以不用对数据成员设置 void readFromFileToScreen(string fileName,string model,int inOutAgainType);

//输出段时间内仓库发生的入出退明细账

void readDateFromFile(int day,string fileName,int inOutAgainType); };

//

// product.cpp // 仓库管理系统 //

// Created by xiaoka on 16/7/4.

// Copyright © 2016年 黄志浩. All rights reserved. //

#include \"product.hpp\" #include #include #include

product::product(){

prodModel = \" \"; //货物型号 prodNum = 0.00; //货物存储数量 location = \" \"; //仓库货位序列号 price = 0.00; //产品单价 costNum = 0.00; //成本系数 prodColor = \" \"; //货物颜色 peopleName = \" \"; //货物库管员 wareName = \" \"; //仓库名称 intoWareDay = 0; outFromWareDay = 0; againToWareDay = 0; } /**

* 拷贝构造函数 */

product::product(const product *p){ prodModel = p->prodModel; prodNum = p->prodNum; location = p->location; price = p->price; costNum = p->costNum; prodColor = p->prodColor; peopleName = p->peopleName; wareName = p->wareName;

intoWareDay = p->intoWareDay;

outFromWareDay = p->outFromWareDay; againToWareDay = p->againToWareDay; }

double product::getProdNum(){ return prodNum; }

double product::getProdPrice(){

return price; }

string product::getProdModel(){ return prodModel; }

int product::setInWareList(){

cout<<\"---------------填写入库单---------------\"<>prodModel;

cout<<\"输入存储数量 \"; cin>>prodNum;

prodNum = double(prodNum);

//存储数量不能大于货位的存储能力 WareLogs *log = new WareLogs();

log->readBaseSettingFromTheFile(\"logsFile.txt\"); if (log->maxAbilitycout<<\"该产品在货位\"<maxAbil-ity<cout<<\"文件写入失败\"<cout<<\"输入货位序列号 \"; cin>>location;

cout<<\"输入产品单价 \"; cin>>price;

price = double(price); cout<<\"输入成本系数 \"; cin>>costNum;

//成本系数不能大于基本数据设定中的总体成本系数 if (costNum>log->costFactor) {

cout<<\"该产品成本系数不能大于您在基础数据设定中设置的总体成本系数\"<costFactor<costNum = double(costNum); cout<<\"输入货物颜色 \"; cin>>prodColor;

cout<<\"输入库管员姓名 \"; cin>>peopleName;

cout<<\"输入仓库名称 \"; cin>>wareName;

intoWareDay = getDayByChrono(); delete log; return 0; }

void product::print(){

cout<<\"输入货物型号 \"; cin>>prodModel;

cout<<\"输入货物数量 \"; cin>>prodNum; } /**

* 填写产品型号供查询使用 */

void product::setProdModel(){ cout<<\"输入待查询产品型号 \"; cin>>prodModel; } /**

* 销售出库单 */

void product::setSaleWareList(){

cout<<\"----------------填写销售出库单---------------\"<outFromWareDay = getDayByChrono(); } /**

* 填写领料单 */

void product::setReceiveList(){

cout<<\"----------------填写领料单------------------\"<outFromWareDay = getDayByChrono(); } /**

* 填写退库单 */

void product::setOutWareList(){

cout<<\"---------------填写退库单---------------\"<againToWareDay = getDayByChrono(); } /**

* 确认入库 将对象所有属性写入文件 *

* @param fileName 文件名 */

int product::inToFile(string fileName){

fstream fout(fileName,ios::app|ios::out); if (!fout) {

cout<<\"打开\"<}

fout<* 计算调用该函数时的时间戳 *

* @return 返回整形数 单位:天 */

int product::getDayByChrono(){ using namespace std::chrono;

typedef duration> days_type;

time_point today = time_point_cast(sys-tem_clock::now());

return today.time_since_epoch().count(); }

/****************************************** wareLogs *******************************************/

WareLogs::WareLogs(){

maxStock = minStock = maxAbility = maxDate = costFactor = 0; type = \"0\";

changeModel = \" \"; changeNum = 0;

changeToatolMoney = 0; reason = \"nohave\"; intoWareDay = 0; outFromWareDay = 0; againToWareDay = 0; }

//从文件中读取基本数据设定

int WareLogs::readBaseSettingFromTheFile(string fileName){ fstream fin(fileName,ios::beg|ios::in); if (!fin) {

cout<<\"打开\"<fin>>maxStock>>minStock>>maxAbility>>maxDate>>costFactor;

if (maxStock == 0&&minStock == 0) { //说明没有设置基本数据 cout<<\"请首先返回主菜单设置基础信息\"<}

fin.close(); return 0; }

//根据prod初始化自己的changeModel changeNum changeToatolMoney void WareLogs::initSomeValueWithProd(product *prod){ changeModel = prod->getProdModel(); changeNum = prod->getProdNum();

changeToatolMoney = prod->getProdNum()*prod->getProdPrice(); intoWareDay = prod->intoWareDay;

outFromWareDay = prod->outFromWareDay; againToWareDay = prod->againToWareDay; }

//入出退库前调用的方法 记录仓库的变化的货物型号／数量／金额 //1入库 2出库 3表示退库需要填写原因

void WareLogs::wirteChangeToTheFile(product *prod,string fileName,string type){ initSomeValueWithProd(prod); if (type == \"3\") {

cout<<\"填写退库原因(不多于15字)\"<>reason; }

fstream fout(fileName,ios::app|ios::out); if (!fout) {

cout<<\"打开文件\"<fout<<* 因为不需要在日志文件中修改数据，为简便起见没有做链表 直接将文件中数据提取输出 *

* @param fileName 文件名 * @param model 产品型号 */

void WareLogs::readFromFileToScreen(string fileName,string model,int inOutAgainType){ fstream fin(fileName,ios::beg|ios::in); if (!fin) {

cout<<\"打开文件\"<string temp = \" \

int t = 0;

while (!fin.eof()) { fin>>temp;

if (temp==\" \"||temp==\"\") { break; }

type = temp;

fin>>changeModel>>changeNum>>changeToatolMoney>>intoWareDay>>outFromWare-Day>>againToWareDay>>reason; t = atoi(type.c_str());

if (changeModel==model&&t==inOutAgainType) { if (isHave==\"No\") { isHave = \"Yes\";

switch (inOutAgainType) { case 1:

cout<<\"以下是入库信息\"<cout<<\"产品型号 \"<<\"入库的数量 \"<<\" break; case 2:

cout<<\"以下是出库信息\"<cout<<\"产品型号 \"<<\"出库的数量 \"<<\" break; case 3:

cout<<\"以下是退库信息\"<cout<<\"产品型号 \"<<\"退库的数量 \"<<\"退库原因\"<break; default: break; } }

cout<cout<cout<temp = \" \"; }

if (isHave==\"No\") {

cout<<\"没有找到该产品\"; if (inOutAgainType==1) {

cout<<\"入库相关信息\"<cout<<\"退库相关信息\"<总金额 \"<fin.close(); } /**

* 输出段时间内仓库发生的入出退明细账 *

* @param day 段时间 * @param fileName 文件名

* @param inOutAgainType 入出退标识符 */

void WareLogs::readDateFromFile(int day,string fileName,int inOutAgainType){ fstream fin(fileName,ios::beg|ios::in); if (!fin) {

cout<<\"打开文件\"<string temp,isInHave = \"No\ int t = 0,today = 0;

product *p = new product();

today = p->getDayByChrono(); //调用此方法时的时间戳 while (!fin.eof()) { fin>>temp;

if (temp==\" \"||temp==\"\") { break; }

type = temp;

fin>>changeModel>>changeNum>>changeToatolMoney>>intoWareDay>>outFromWare-Day>>againToWareDay>>reason;

t = atoi(temp.c_str()); //将入出库标识符转换为int类型 if (t==inOutAgainType&&t==1) { //入库信息 if (isInHave==\"No\") { isInHave = \"Yes\";

cout<<\"以下是该时间段内仓库的入库信息\"<cout<<\"产品型号 \"<<\"入库的数量 \"<<\"总金额 \"<if ((today - intoWareDay) <= day) {

cout<if (t==inOutAgainType&&t==2) { //出库信息 if (isOutHave==\"No\") { isOutHave = \"Yes\";

cout<<\"以下是该时间段内仓库的出库信息\"<cout<<\"产品型号 \"<<\"出库的数量 \"<<\"总金额 \"<if ((today - outFromWareDay) <= day) {

cout<} }

if (t==inOutAgainType&&t==3) { //退库信息 if (isAgainHave==\"No\") { isAgainHave = \"Yes\";

cout<<\"以下是该时间段内仓库的退库信息\"<cout<<\"产品型号 \"<<\"退库的数量 \"<<\"总金额 \"<if ((today - againToWareDay) <= day) {

cout<temp = \" \"; }

if (isInHave==\"No\"&&inOutAgainType==1) {

cout<<\"没有找到该时间段内的入库信息\"<if (isOutHave==\"No\"&&inOutAgainType==2) {

cout<<\"没有找到该时间段内的出库信息\"<if (isAgainHave==\"No\"&&inOutAgainType==3) {

cout<<\"没有找到该时间段内的退库信息\"<fin.close(); }

//

// linkList.hpp // 仓库管理系统 //

// Created by xiaoka on 16/7/5.

// Copyright © 2016年 黄志浩. All rights reserved. //

#include using namespace std;

class product; class WareLogs;

class node{ private:

product *data; public:

node *next; node();

node(product *tempData);

friend void outProdFromFile(product *prodList,string fileName,string type); friend class linkList; };

class linkList{ private:

void addNodeFromProd(product *tempData); public:

node *head; linkList(); ~linkList();

friend void outProdFromFile(product *prodList,string fileName,string type); //提取数据为链表

void getlinkListFromTheFile(string fileName);

//遍历链表找到节点

void forInLinkListForInAndOut(product *prod,string type);

//根据产品型号搜索出仓库名称/产品分布型号

void forInLinkListForLocation(product *prod,string type);

//根据基本数据设定信息查询高储低储 以及超出存储期限的产品 void forInLinkListForRemind(WareLogs *logs,string type);

//根据产品对象的型号和该产品成本系数以及日志文件中的基本数据设定信息 计算该产品的存储成本

void forInLinkListForCost(product *prod,WareLogs *logs,string type);

//将链表数据重新写入文件

void writeNodeToTheFile(string fileName);

};

//

// linkList.cpp // 仓库管理系统 //

// Created by xiaoka on 16/7/5.

// Copyright © 2016年 黄志浩. All rights reserved. //

#include \"linkList.hpp\" #include \"product.hpp\"

node::node(){ data = NULL; next = NULL; }

node::node(product *tempData){ data = tempData; next = NULL; }

linkList::linkList(){ head = new node(); }

linkList::~linkList(){

if (head->next==NULL) { delete head; }else{

node *p = head,*q;

while (p->next!=NULL) { q = p->next; delete p; p = q; } } } /**

* 给链表增加节点 *

* @param tempData 节点数据 */

void linkList::addNodeFromProd(product *tempData){ node *p = new node(tempData); if (head->next==NULL) { head->next = p; }else{

node *q = head;

while (q->next!=NULL) { q = q->next;

}

q->next = p; } } /**

* 提取文件中的数据存储到模型对象中作为链表节点的数据域 *

* @param fileName 文件名 */

void linkList::getlinkListFromTheFile(string fileName){ fstream fin(fileName,ios::beg|ios::in); if (!fin) {

cout<<\"文件\"<string temp;

while (!fin.eof()) { fin>>temp;

if (temp==\" \"||temp==\"\") { break; }

product *n = new product(); n->prodModel = temp; fin>>n->prodNum >>n->location >>n->price >>n->costNum >>n->prodColor >>n->peopleName >>n->wareName >>n->intoWareDay >>n->outFromWareDay >>n->againToWareDay;

this->addNodeFromProd(n); temp = \" \"; }

fin.close(); return; } /**

* 遍历链表找到节点 并对该节点修改 *

* @param prod 出库单(领料单/销售出库单) */

void linkList::forInLinkListForInAndOut(product *prod,string type){ node *p; p = head;

if (p->next==NULL) {

cout<<\"链表为空\"<string isHaveORNo = \"No\"; while (p->next!=NULL) {

if (p->next->data->prodModel==prod->prodModel) { isHaveORNo = \"Yes\";

if (type==\"2\") { //出库

if (p->next->data->prodNumprodNum) {

cout<<\"销售出库单的货物数量大于库存数量\"<p->next->data->prodNum = p->next->data->prodNum - prod->prodNum; p->next->data->outFromWareDay = prod->outFromWareDay; //修改时间戳 //出库前将数据写入日志文件 WareLogs *w = new WareLogs();

w->wirteChangeToTheFile(p->next->data, \"productLog.txt\ delete w;

} else if(type==\"3\"){ //退库

p->next->data->prodNum = p->next->data->prodNum + prod->prodNum;

p->next->data->againToWareDay = prod->againToWareDay; //修改时间戳 //退库前将数据写入日志文件 WareLogs *w = new WareLogs();

w->wirteChangeToTheFile(p->next->data, \"productLog.txt\ delete w; } }

p = p->next; }

if (isHaveORNo == \"No\") {

cout<<\"没有找到\"<prodModel<<\" 请确认该型号和该产品入库单填写型号符合\"<* 根据产品型号搜索出仓库名称/产品分布情况 *

* @param prod 产品对象 * @param fileName 文件名 */

void linkList::forInLinkListForLocation(product *prod,string type){ if (type == \"4\") {

cout<<\"成品仓库查询结果如下\"<cout<<\"原材料仓库查询结果如下\"<node *p; p = head;

if (p->next==NULL) {

cout<<\"链表为空\"<return; }

string isHaveORNo = \"No\"; while (p->next!=NULL) {

if (p->next->data->prodModel==prod->prodModel) { if (isHaveORNo == \"No\") { isHaveORNo = \"Yes\";

cout<<\"产品型号 所在仓库 所在仓库货位 存储数量\"<cout<prodModel<<\" \"<next->data->wareName<<\" \"<next->data->location<<\" \"<next->data->prodNum<p = p->next; }

if (isHaveORNo == \"No\") { if (type == \"4\") {

cout<<\"没有在成品仓库中找到该型号产品\"<cout<<\"没有在原材料仓库中找到该型号产品\"<* 将链表数据写入文件 *

* @param fileName 文件名 */

void linkList::writeNodeToTheFile(string fileName){ fstream fout(fileName); node *p = head;

if (p->next==NULL) {

cout<<\"链表为空\"<while (p->next!=NULL) {

fout<next->data->prodModel<<\"\\n\" <next->data->prodNum<<\"\\n\" <next->data->location<<\"\\n\" <next->data->price<<\"\\n\" <next->data->costNum<<\"\\n\" <next->data->prodColor<<\"\\n\" <next->data->peopleName<<\"\\n\" <next->data->wareName<<\"\\n\" <next->data->intoWareDay<<\"\\n\" <next->data->outFromWareDay<<\"\\n\" <next->data->againToWareDay<<\"\\n\"; p = p->next; }

fout.close();

} /**

* 根据系统参数定义时间，提示仓库是否高储／低储 搜索出存储期限超出限定的产品 *

* @param type 符号标志 4=成品仓库 5=原材料仓库 */

void linkList::forInLinkListForRemind(WareLogs *logs,string type){ node *p;

double totoalNum = 0; //仓库总储货量 p = head;

if (p->next==NULL) {

cout<<\"链表为空\"<product *prod = new product();

int day = prod->getDayByChrono(); //获取当前时间戳 string dateOver = \"No\"; while (p->next!=NULL) {

totoalNum += p->next->data->prodNum;

if ((day - p->next->data->intoWareDay) >= logs->maxDate) { dateOver = \"Yes\";

cout<next->data->prodModel<<\"的存储时间超出最大存储期限 \"<p = p->next; }

if (dateOver == \"No\") {

type==\"4\" ? cout<<\"成品仓库\" : cout<<\"原材料仓库\" ; cout<<\"没有达到存储期限的货物\"<if (totoalNum >= logs->maxStock) {

type==\"4\" ? cout<<\"成品仓库\" : cout<<\"原材料仓库\" ;

cout<<\"库存已达高储\"<<\" 目前储货量为 \"<minStock){

type==\"4\" ? cout<<\"成品仓库\" : cout<<\"原材料仓库\" ;

cout<<\"库存已低于低储\"<<\" 目前仓库储货量为 \"<* 根据产品对象的型号和该产品成本系数以及日志文件中的基本数据设定信息 计算该产品的存储成本 *

* @param prod 产品类对象 取该产品成本系数 * @param logs 日志类对象 取总体成本系数 */

void linkList::forInLinkListForCost(product *prod, WareLogs *logs,string type){ cout<<\"以下是该产品在\";

type==\"4\" ? cout<<\"成品仓库\" : cout<<\"原材料仓库\"; cout<<\"的搜索结果\"<p = head;

if (p->next==NULL) {

cout<<\"链表为空\"<string isHaveORNo = \"No\"; while (p->next!=NULL) {

if (p->next->data->prodModel==prod->prodModel) { isHaveORNo = \"Yes\";

int day = prod->getDayByChrono();

if (day==p->next->data->intoWareDay) {

cout<<\"该货物今天入库,暂时不计存储成本\"<cout<getProdModel()<<\"的存储成本为\";

cout<next->data->costNum*logs->costFactor*p->next->data->getProd-Price()*p->next->data->getProdNum()*double(day-p->next->data->intoWareDay)<p = p->next; }

if (isHaveORNo == \"No\") { cout<<\"没有在\";

type==\"4\" ? cout<<\"成品仓库\" : cout<<\"原材料仓库\"; cout<<\"中找到\"<prodModel<