| 网站首页 | 业界新闻 | 小组 | 威客 | 人才 | 下载频道 | 博客 | 代码贴 | 在线编程 | 编程论坛 | 
登录
注册
用户控制面板
搜索
道具
风格
短消息
论坛展区
帮助
编程论坛 → 开发语言 → 『 C语言论坛 』 → 零件库存管理系统
我的收件箱(0)
欢迎加入我们，一同切磋技术
用户名：   
 
密　码：  
共有 2135 人关注过本帖
标题：零件库存管理系统
取消只看楼主 加入收藏
renkejun1942
Rank: 14Rank: 14Rank: 14Rank: 14
来　自：不是这样
等　级：贵宾
威　望：33
帖　子：1645
专家分：5297
注　册：2016-12-1
结帖率：95.65%
楼主
收藏
 问题点数：0 回复次数：8 
零件库存管理系统
终于……终于……让输入变的安全了。

历时3天，第一版本不到400行。
昨天的第二版本，650行左右。
今天的修改，估计快700行了。
一共10个文件，又一次体会到模块化的好处，修改起来太方便了。

整个人都要崩了。也许唯一值得高兴的是，又多了2个以后可以重用的函数。NICE。

实际上还有一个BUG，但完全不知道怎么重现，也完全不知道是怎么产生的。我就重现了一次，之后就再也不能。
悲剧。

程序代码：
#include "DataType.h"
#include "DataOperation.h"
#include "FileOperation.h"
#include "Function.h"
#include "getstring.h"
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#define __SYSTEM__H__ 1
#if defined(__SYSTEM__H__)
#define CLRSCR system("cls")
#else
#define CLRSCR system("clear")
#endif

void
Number( int *Num );


int
main( int avgc, char **avgr )
{
    Node *Root;
    Node InNode;
    int number;
    int value;
    char *str;

    Root = NULL;
    InNode.Type = Head;
    InNode.Ption.HeadInformation.MaxNumber = 0;
    InNode.Ption.HeadInformation.DeleteionNumber = 0;
    InNode.Ption.HeadInformation.Total = 0;

    if( 2 == avgc )
        str = *++avgr;
    else
    {
        printf("输入要打开的文件:");
        str = getword( stdin );
    }

    FileRead( &Root, &InNode, str );

    CLRSCR;
    while( 1 )
    {
        FunCtion();
        getint( &value );
        
        switch( value )
        {
            case 1:
                CLRSCR;
                NewData( &Root, &InNode, str );
                break;
            case 2:
                CLRSCR;
                Number( &number );
                BuyData( Root, number, str );
                break;
            case 3:
                CLRSCR;
                Number( &number );
                Sell( Root, number, str );
                break;
            case 4:
                CLRSCR;
                Number( &number );
                Delete( &Root, number, str );
                break;
            case 5:
                CLRSCR;
                Number( &number );
                Print( Root, number, str );
                break;
            case 6:
                CLRSCR;
                PrintAll( Root );
                break;
            case 7:
                CLRSCR;
                PrintTotal( Root );
                break;
            case 8:
                CLRSCR;
                End( Root, str );
                if( 2 == avgc )
                    free( str );
                printf( "Bye!\n" );
                return 0;
            default:
                break;

        }
    }

    return 0;
}

void
Number( int *Num )
{
    
    while( printf( "请输入编号：" ), 1 != scanf("%d",Num) )
    {
        int ch;
        while( '\n' != ( ch = getchar() ) )
            printf("%c ",ch);
        printf("错误的输入。\n");
    }
    getchar();
}


程序代码：
#ifndef DATATYPE_H
#define DATATYPE_H
struct Head {
    int MaxNumber;//最大编号
    int DeleteionNumber;//缺失的编号
    double Total;//所有零件的总价
}; 

struct Component {
    char Description[ 21 ];//描述信息
    int PartNumber;//编号
    int Quantity;//数量
    double ComponentTotal;//该零件的总价值
};

typedef struct NODE {
    union {
        struct Head HeadInformation;
        struct Component ComponentInformation;
    }Ption;
    enum { Head, Component }Type;
    struct NODE *Next;
}Node;

#endif



程序代码：
#ifndef FUNCTION_H
#define FUNCTION_H
void
FunCtion( void );
void
NewData( Node **Root, Node *InNode, char *str );
void
BuyData( Node *Root, int Number, char *str );
void
Sell( Node *Root, int Number, char *str );
void
Delete( Node **Root, int Number, char *str );
void
Print( Node *Root, int Number, char *str );
void
PrintAll( Node *Root );
void
PrintTotal( Node *Root );
void
End( Node *Root,char *str );
#endif


程序代码：
#include "DataType.h"
#include "DataOperation.h"
#include "FileOperation.h"
#include "Function.h"
#include "getstring.h"
#include <stdio.h>

static char *Prompt[] = { "请输入新零件的描述信息：", "请输入新零件的数量：",
           "请输入新零件的单价：" };
static char *PromptBuy[] = { "请输入要增加的数量：", "请输入购入该零件的单价：" };
static char *PromptSell[] = { "请输入要减少的数量：", "请输入每个零件的出售价格：" };
int
FindNumber( Node *Root );


void
FunCtion( void )
{
    printf("1.New\n2.Buy\n3.Sell\n4.Delete\n5.Print\n6.PrintAll\n7.PrintTotal\n8.end\n"
            "输入你要进行操作的编号:");
}
void
NewData( Node **Root, Node *InNode, char *str )
{
    double price;
    Node *This;

    This = *Root;
    This->Ption.HeadInformation.DeleteionNumber = FindNumber( This );

    printf( "%s", Prompt[ 0 ] );
    getname( InNode->, 21 );
        

    while( printf( "%s", Prompt[ 1 ] ) )
    {
        getint( &InNode-> );
        if( 0 < InNode-> )
            break;
    }

    while( printf( "%s", Prompt[ 2 ] ) )
    {
        getdouble( &price ); 
        if( 0 < price )
            break;
    }

    InNode-> = 
        InNode-> * price;

    if( (*Root)->Ption.HeadInformation.DeleteionNumber )
    {
        InNode-> = 
            ( *Root )->Ption.HeadInformation.DeleteionNumber;
    }
    else
    {
        InNode-> = 
            ++(*Root)->Ption.HeadInformation.MaxNumber;
    }

    ( *Root )->Ption.HeadInformation.Total += 
        InNode-> InNode->Type = Component;

    InsertNode( Root, InNode );

    FileWrite( This, str );

}

void
BuyData( Node *Root, int Number, char *str )
{
    int quantity;
    double cost_each;
    Node *This;

    This = FindNode( Root, Number );
    if( NULL == This )
        return;

    while( printf( "%s", PromptBuy[ 0 ] ) )
    {
        getint( &quantity );
        if( 0 < quantity )
            break;
    }

    while( printf( "%s", PromptBuy[ 1 ] ) )
    {
        getdouble( &cost_each );
        if( 0 < cost_each )
            break;
    }

    This-> += quantity;
    This-> += quantity * cost_each;
    Root->Ption.HeadInformation.Total += quantity * cost_each;

    FileWrite( Root, str );
}

void
Sell( Node *Root, int Number, char *str )
{
    double price_each;
    double now_price_each;
    int quantity;
    Node *This;

    This = FindNode( Root, Number );
    if( NULL == This )
        return;

    while( printf( "%s",PromptSell[ 0 ] ) )
    {
        getint( &quantity ) ;
        if( 0 < quantity )
            break;
    }
    while( printf( "%s",PromptSell[ 1 ] ) )
    {
        getdouble( &price_each );
        if( 0 < price_each )
            break;
    }

    if( This-> - quantity < 0 )
    {
        printf("库存中没有足够的数量，你确定没有输入错误？\n");
        return;
    }

    now_price_each = This-> /
        This-> This-> -= now_price_each * quantity;
    This-> -= quantity;
    Root->Ption.HeadInformation.Total -= now_price_each * quantity;

    printf("共盈利：%.2lf\n" , quantity * ( price_each - now_price_each ) );

    FileWrite( Root, str );

}

void
Delete( Node **Root, int Number, char *str )
{
    Node *This;

    This = *Root;
    DeleteNode( Root, Number );
    FileWrite( This, str );
}

void
Print( Node *Root, int Number, char *str )
{
    PrintNode( Root, Number );
}


void
PrintAll( Node *Root )
{
    PrintList( Root );
}
void
PrintTotal( Node *Root )
{
    printf("%8s %8s %10s\n","最大编号","缺失编号","总价值");
    printf("%8d %8d %10.2lf\n",Root->Ption.HeadInformation.MaxNumber,
            Root->Ption.HeadInformation.DeleteionNumber,
            Root->Ption.HeadInformation.Total);
}
void
End( Node *Root, char *str )
{
    FileWrite( Root, str );
}

int
FindNumber( Node *Root )
{
    Node *Next;
    int NextNum, ThisNum;
    

    Next = Root->Next;
    for( NextNum = 1; NULL != Next; Next = Next->Next )
    {
        ThisNum = Next->if( NextNum != ThisNum )
            return NextNum;
        NextNum++;
    }

    return 0;
}



程序代码：
#ifndef FILEOPERATION_H
#define FILEOPERATION_H
void
FileRead( Node **Root, Node *InNode, char *str );
void
FileWrite( Node *Root, char *str );
#endif

程序代码：
#include <stdio.h>
#include <stdlib.h>
#include "DataType.h"
#include "FileOperation.h"
#include "DataOperation.h"


void
FileRead( Node **Root, Node *InNode, char *str )
{
    FILE *fp;

    if( NULL == ( fp = fopen( str, "a+b" ) ) )
    {
        perror( str );
        exit( EXIT_FAILURE );
    }
    fseek( fp, 0, SEEK_END);
    if( 0 == ftell( fp )  )
    {
        InsertNode( Root, InNode );
        fclose( fp );
        return;
    }
    else
    {
        fseek( fp, 0, SEEK_SET );
        while( 1 == fread( InNode, sizeof( Node ), 1, fp ) )
            InsertNode( Root, InNode );
        fclose( fp );
    }
}

void
FileWrite( Node *Root, char *str )
{
    FILE *fp;
    Node *Current;

    if( NULL == ( fp = fopen( str, "w+b" ) ) )
    {
        perror( str );
        exit( EXIT_FAILURE );
    }
    for( Current = Root; NULL != Current; Current = Current->Next )
    {
        fwrite( Current, sizeof( Node ), 1, fp );
    }
    fclose( fp );
}


程序代码：
#ifndef DATAOPERATION_H
#define DATAOPERATION_H
void
InsertNode( Node **Root, Node *InNode );
Node*
FindNode( Node *Root, int Number );
void
PrintNode( Node *Root, int Number );
void
PrintList( Node *Root );
void
DeleteNode( Node **Root, int Number );
#endif


程序代码：
#include "DataType.h"
#include "DataOperation.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void
InsertNode( Node **Root, Node *InNode )
{
    Node *Next;
    Node *NewCell;

    while( NULL != ( Next = *Root ) && 
            InNode-> > 
            Next-> )
        Root = &Next->Next;

    if( NULL == ( NewCell = ( Node* )malloc( sizeof( Node ) ) ) )
    {
        perror( "InsertNode" );
        exit( EXIT_FAILURE );
    }

    NewCell->Next = Next;
    *Root = NewCell;

    if( InNode->Type == Head )
    {
        NewCell->Type = Head;

        NewCell->Ption.HeadInformation.MaxNumber = 
            InNode->Ption.HeadInformation.MaxNumber;

        NewCell->Ption.HeadInformation.DeleteionNumber = 
            InNode->Ption.HeadInformation.DeleteionNumber;

        NewCell->Ption.HeadInformation.Total = 
            InNode->Ption.HeadInformation.Total;
    }
    else
    {
        NewCell->Type = Component;

        strcpy( NewCell->,
                InNode-> );

        NewCell-> = 
            InNode-> = 
            InNode-> = 
            InNode-> }
}


Node *
FindNode( Node *Root, int Number )
{
    Node *This;

    This = Root->Next;
    while( NULL != This && This-> != Number )
        This = This->Next;

    return This;
}

void
DeleteNode( Node **Root, int Number )
{
    Node *This,*Next;

    This = *Root;
    for( Next = *Root;
                   NULL != Next && Next-> != Number;
                  Next = *Root )
          Root = &Next->Next;

    if( NULL == Next )
        return;
    else
    {
        This->Ption.HeadInformation.DeleteionNumber = 
            Next-> -= 
            Next->if( Next == This->Next && NULL == Next->Next )
            This->Ption.HeadInformation.MaxNumber = 0;
        else if( This->Ption.HeadInformation.MaxNumber == 
                Next-> )
            This->Ption.HeadInformation.MaxNumber -= 1;

        *Root = Next->Next;
        free( Next );
    }
}

static void
Print( Node *Current );

void
PrintNode( Node *Root, int Number )
{
    Node *This;

    This = FindNode( Root, Number );
    if( NULL == This )
        return;
    else
        Print( This );
}

void
PrintList( Node *Root )
{
    Node *This;

    This = Root->Next;

    printf("%-20s %6s %6s %10s\n","描述","编号","数量","总额");
    while( NULL != This )
    {
        Print( This );
        This = This->Next;
    }
}


static void
Print( Node *Current )
{
    if( !Current->Type )
    {
        printf( "所有零件总价值：%6.2lf\n", Current->Ption.HeadInformation.Total );
    }
    else
    {
        printf("%-20s %6d %6d %10.2lf\n",Current->,
                Current->,
                Current->,
                Current->);
    }
}


程序代码：
#include <stdio.h>
#ifndef getstring_h
#define getstring_h
char *
getstring( FILE *FP );
char *
getword( FILE *FP );
void
getname( char *str, int size );
void
getint( int *value );
void
getdouble( double *value );
#endif


程序代码：
#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>
#include "getstring.h"
#define INITSIZE 124

char *
getstring( FILE *FP )
{
    char *Temp, *Str;
    int CurrentSize, lx;
    int ch;

    CurrentSize = INITSIZE;
    Temp = NULL;
    Str = ( char * )malloc( INITSIZE * sizeof( char ) );
    
    if( NULL != Str )
    {
        for( lx = 0; EOF != ( ch = getc(FP) ) && '\n' != ch; lx++ )
        {
            if( lx == CurrentSize - 1 )
            {
                CurrentSize += INITSIZE;
                Temp = ( char * )realloc( Str, CurrentSize * sizeof( char ) );
                if( NULL == Temp )
                {
                    Str[ lx ] = '\0';
                    return Str;
                }
                Str = Temp;
            }
            Str[ lx ] = ch;
        }

        if( '\n' == ch )
            Str[ lx++ ] = '\n';
        Str[ lx ] = '\0';

        if( 0 == lx )
        {
            free( Str );
            Str = NULL;
            return Str;
        }

        if( lx < CurrentSize )
        {
            Temp = ( char * )realloc( Str, ( lx + 1 ) * sizeof( char ) );
            if( NULL == Temp )
                return Str;
            Str = Temp;
        }
        return Str;
    }
    else
        return NULL;
}

char *
getword( FILE *FP )
{
    char *Word, *Temp;
    int ch;
    int lx, CurrentSize;

    CurrentSize = INITSIZE;
    Temp = NULL;
    Word = ( char * )malloc( CurrentSize * sizeof( char ) );

    while( !isalpha( ch = getc( FP ) ) && EOF != ch )
        ;
    if( NULL != Word )
    {
        for( lx = 0; EOF != ch  && !isspace( ch ); lx++, ch = getc( FP ) )
        {
            if( lx == CurrentSize - 1 )
            {
                CurrentSize += INITSIZE;
                Temp = ( char * )realloc( Word, CurrentSize * sizeof( char ) );
                if( NULL == Temp )
                {
                    Word[ lx ] = '\0';
                    return Word;
                }
                Word = Temp;
            }
            Word[ lx ] = ch;
        }
        if( 0 == lx )
        {
            free( Word );
            Word = NULL;
            return Word;
        }
        if( lx < CurrentSize )
        {
            Temp = ( char * )realloc( Word, ( lx + 1 ) * sizeof( char ) );
            if( NULL == Temp )
            {
                Word[ lx ] = '\0';
                return Word;
            }
            Word = Temp;
        }
        if( ispunct( Word[ lx - 1 ] ) )
        {
            Word[ --lx ] = '\0';
            return Word;
        }
        Word[ lx ] = '\0';
        return Word;
    }
    else
        return NULL;

}

void
getname( char *str, int size )
{
    int ch;
    int i;

    for(i = 0; i < size - 1 && EOF != ( ch = getchar() ) && '\n' != ch; i++ )
        str[ i ] = ch;
    if( '\n' == ch )
        ungetc( ch, stdin );
    while( getchar() != '\n' )
        ;
    str[ i ] = '\0';
}


void
getint( int *value )
{
    char *str;

    str = getstring( stdin );
    *value = atoi( str );
    free( str );
}

void
getdouble( double *value )
{
    char *str;

    str = getstring( stdin );
    *value = atof( str );
    free( str );
}


[此贴子已经被作者于2017-3-24 08:43编辑过]

搜索更多相关主题的帖子: 管理系统　左右　
2017-03-23 23:37
renkejun1942
Rank: 14Rank: 14Rank: 14Rank: 14
来　自：不是这样
等　级：贵宾
威　望：33
帖　子：1645
专家分：5297
注　册：2016-12-1
第 2 楼
收藏
 得分:0 
回复 2楼 wp231957
不知道了。
《C语言接口与实现》中链表一节的开头写了这么一句话，“几乎每个应用程序都会以某种形式使用链表。”

[此贴子已经被作者于2017-3-24 05:33编辑过]


09：30 05/21 种下琵琶种子，能种活么？等待中……
21：50 05/27 没有发芽。
20：51 05/28 没有发芽。
23：03 05/29 没有发芽。
23：30 06/09 我有预感，要发芽了。
2017-03-24 05:25
renkejun1942
Rank: 14Rank: 14Rank: 14Rank: 14
来　自：不是这样
等　级：贵宾
威　望：33
帖　子：1645
专家分：5297
注　册：2016-12-1
第 3 楼
收藏
 得分:0 
回复 4楼 ehszt
你再运行一次呢？重新读取那个文件。Tatol显示，第一次运行可能出问题，第二次就不会了。
但是第一次运行出显示错误，我遇到过一次，但不知道原因，而且后来也没办法再现。

而且你到底执行了什么操作啊。闹不明白。

如果你能告诉我，你读取的文件的后缀，以及执行的操作流程，我想我会更容易定位到错误。

在输入方面，应该不会出问题了。这个我自己测试过很多次。

[此贴子已经被作者于2017-3-24 07:55编辑过]


09：30 05/21 种下琵琶种子，能种活么？等待中……
21：50 05/27 没有发芽。
20：51 05/28 没有发芽。
23：03 05/29 没有发芽。
23：30 06/09 我有预感，要发芽了。
2017-03-24 07:48
renkejun1942
Rank: 14Rank: 14Rank: 14Rank: 14
来　自：不是这样
等　级：贵宾
威　望：33
帖　子：1645
专家分：5297
注　册：2016-12-1
第 4 楼
收藏
 得分:0 
回复 6楼 ehszt
二进制的打开，写法不同而已。以更新流打开二进制文件。
也就是文本模式w+的二进制版本。
当然这个有两种写法，效果是一样的。

09：30 05/21 种下琵琶种子，能种活么？等待中……
21：50 05/27 没有发芽。
20：51 05/28 没有发芽。
23：03 05/29 没有发芽。
23：30 06/09 我有预感，要发芽了。
2017-03-24 07:56
renkejun1942
Rank: 14Rank: 14Rank: 14Rank: 14
来　自：不是这样
等　级：贵宾
威　望：33
帖　子：1645
专家分：5297
注　册：2016-12-1
第 5 楼
收藏
 得分:0 
回复 8楼 wp231957
书上的题。5星难度。我就想试试，结果还挺好。
能学到不少东西，写的时候，模块化，功能化，以及安全性。

09：30 05/21 种下琵琶种子，能种活么？等待中……
21：50 05/27 没有发芽。
20：51 05/28 没有发芽。
23：03 05/29 没有发芽。
23：30 06/09 我有预感，要发芽了。
2017-03-24 07:58
renkejun1942
Rank: 14Rank: 14Rank: 14Rank: 14
来　自：不是这样
等　级：贵宾
威　望：33
帖　子：1645
专家分：5297
注　册：2016-12-1
第 6 楼
收藏
 得分:0 
回复 6楼 ehszt
顺带告诉我一下，你遇到的BUG还在吗？如果在的话，告诉我一下你的执行的操作的过程。我看看能不能把那个BUG揪出来。

09：30 05/21 种下琵琶种子，能种活么？等待中……
21：50 05/27 没有发芽。
20：51 05/28 没有发芽。
23：03 05/29 没有发芽。
23：30 06/09 我有预感，要发芽了。
2017-03-24 08:01
renkejun1942
Rank: 14Rank: 14Rank: 14Rank: 14
来　自：不是这样
等　级：贵宾
威　望：33
帖　子：1645
专家分：5297
注　册：2016-12-1
第 7 楼
收藏
 得分:0 
回复 11楼 ehszt
编号重复你怎么做到的？编号问题我花了很多时间修正。
告诉我过程。。

09：30 05/21 种下琵琶种子，能种活么？等待中……
21：50 05/27 没有发芽。
20：51 05/28 没有发芽。
23：03 05/29 没有发芽。
23：30 06/09 我有预感，要发芽了。
2017-03-24 08:12
renkejun1942
Rank: 14Rank: 14Rank: 14Rank: 14
来　自：不是这样
等　级：贵宾
威　望：33
帖　子：1645
专家分：5297
注　册：2016-12-1
第 8 楼
收藏
 得分:0 
回复 13楼 ehszt
嗯嗯，这BUG可以重现了，我找找先。
找到问题了，你在Function.c中，Newdata函数的最后一行的*Root，改成This。


[此贴子已经被作者于2017-3-24 08:39编辑过]


09：30 05/21 种下琵琶种子，能种活么？等待中……
21：50 05/27 没有发芽。
20：51 05/28 没有发芽。
23：03 05/29 没有发芽。
23：30 06/09 我有预感，要发芽了。
2017-03-24 08:18
renkejun1942
Rank: 14Rank: 14Rank: 14Rank: 14
来　自：不是这样
等　级：贵宾
威　望：33
帖　子：1645
专家分：5297
注　册：2016-12-1
第 9 楼
收藏
 得分:0 
回复 15楼 ehszt
有时间在试试吧。

牙疼，拔牙最好。智齿的话。

我估计你遇到的PrintTotal打印出现错误，应该也是同样的问题。我说我为什么没遇到过了，原来我一直尝试执行了别的操作，别的操作对文件写入了正确的信息。

只有NewData函数会对文件写入错误的信息。

[此贴子已经被作者于2017-3-24 08:29编辑过]


09：30 05/21 种下琵琶种子，能种活么？等待中……
21：50 05/27 没有发芽。
20：51 05/28 没有发芽。
23：03 05/29 没有发芽。
23：30 06/09 我有预感，要发芽了。
2017-03-24 08:26
快速回复：零件库存管理系统
数据加载中...
 
　　　



关于我们 | 广告合作 | 编程中国 | 清除Cookies | TOP | 手机版

编程中国 版权所有，并保留所有权利。
Powered by Discuz, Processed in 0.121044 second(s), 9 queries.
Copyright©2004-2024, BCCN.NET, All Rights Reserved