#include<stdio.h>
#include<malloc.h>
#include<string.h>
#include<ctype.h>
#include <stdlib.h>
#define max 16
#define maxmin 9
#define row1 30
#define row2 10
#define row3 5
#define row4 33
#define row5 6
#define row6 6
#define row7 8
/***********************存放每个零件一行的备注信息**********************/
struct BZNODE{ char beizhu[30];
struct BZNODE *next;
//***********************存放每个零件每行的信息**************************
struct LJNODE{ char minchen[20];
char sinhao[11]; //存储第二列零件信息
char shulian[3]; //存储第三列数量信息
struct BZNODE *nextbz;
struct LJNODE *nextlj;
//***********************存储零件的中文信息****************************
struct NODE{
char ch;
char *data; //已知零件种类的信息
char *china;
char feilei;
struct LJNODE *nextlj; //指向零件节点的指针
}zuonglei[max]={{’a’,“CD“,“电解电容 CD-“,’C’,NULL},
{’b’,“DZ“,“稳压二极管 “,’B’,NULL},
{’c’,“D“,“二极管 “,’B’,NULL},
{’d’,“IC“,“集成电路 “,’B’,NULL},
{’e’,“Q“,“三极管 “,’B’,NULL},
{’f’,“J“,“跳线 REX-“,’C’,NULL},
{’g’,“A“,“插座“,’C’,NULL},
{’h’,“OUT“,“输出接线柱 “,’C’,NULL},
{’i’,“QD“,“桥堆 “,NULL},
//***********下面是不能直接比较出类型的零件************************************
{’j’,““,“集成电容 “,’C’,NULL},
{’k’,““,“涤沦电容 CL-“,’C’,NULL},
{’l’,““,“金属膜电容 CL21-“,’C’,NULL},
{’m’,““,“瓷片电容 CC-“,’C’,NULL},
{’n’,““,“碳膜电阻 RT-“,’C’,NULL},
{’o’,““,“金膜电阻 RJ-“,’C’,NULL},
{’p’,““,““,’ ’,NULL}
void readfile(FILE *fpr); //读文件的函数申明
void xierufile(FILE *fpw); //写文件的函数申明
void quchu(struct zuonglei *zl,FILE fw); //取出节点信息并写入文件的函数申明
//*************************消除字符串开始部分指定字符***********************
void clearbegin (char str[],char ch )
char *p;
p=str;
if(*p==ch)
p++;
while(*p)
*str++=*p++;
*str=0;
//************************清除字符串结束时指定字符*******************************
void clearend(char str[],char ch)
{ char *p;
p=str;
while(*p++);
if(*(p-2)==ch)
*(p-2)=0;
//*****************************将字符串转化为浮点数****************************
float atoff(char *p)
{ char *p1;
float f=0,f2=0,f1;
long int lint=1;
int x,i=0,j=0,k;
i=strlen(p);
p1=strchr(p,’.’); //判断小数点的位置
if(p1) //如果为真，则表示该数是小数
j=p1-p; //两指针相减得到整数位数
else
j=i;
for(k=0;k<j;k++) //将字符串中浮点数中整数部分转化成整数
{ lint=1;
for(x=j-k-1;x>0;x--)
lint=lint*10;
f=f+((*(p+k)-48)*lint);
for(k=0;k<i-j-1;k++) //将小数部分转化出来
{ f1=1;
for(x=0;x<=k;x++)
f1=f1*0.1;
f2=f2+((*(p+j+k+1)-48)*f1);
f=f+f2;
return f;
//*******************************整数转化为字符串***************************************************
char * atoll(int i,char a[])
{ char ch[20];
int j,k=0;
char *p;
p=a;
for(j=0;j<20;j++)
ch[j]=0;
a[j]=0;
for(j=19;j>=0;j--)
{a[j]=i%10+48;
i=(i-i%10)/10;
if(i<10)
break;
a[--j]=i+48;
for(i=j;i<20;i++)
a[k++]=a[i];
return p;
//*******************************比较两字符串中浮点数的大小**************************
int strcmpp(char *word1,char *word2)
float f1,f2;
int i;
f1=atoff(word1);
f2=atoff(word2);
if(f1-f2>0.000001)
i=1;
else
i=0;
return i;
//********************削除字符串两端的空格并统计字符个数******************************
int wordlen(char word[])
{int i=0;
char *wp,*p,*p1;
wp=p1=word;
while(*wp&&(*wp==’ ’||*wp==10)) //将指针移到第一个非空格字符处
wp++;
p=wp;
while(*wp++); //将指针移到字符串尾再往回退一个字符
wp=wp-2;
while(p!=wp&&*wp==’ ’||*wp==10) //判断出那段是非空格字符
wp--;
wp++;
while(wp!=p&&*p) //将这段非空格字符复制到字符串中
*p1++=*p++;
*p1=NULL;
i= strlen(word);
return i;
//***************************当知道零件属于何种类型后，查找相应的数组下标*********
int findbianhao(char ch)
{ int i=0;
for(i=0;i<max;i++)
{ if(ch==zuonglei[i].ch)
return i;
return i;
//*********************************细分中文信息对应的数组下标************************
int findxb(char word1[],char word2[],char word4[])
{ char ch;
int i,j;
i=strlen(word1);
// printf(“%s\t“,word1);
ch=word1[i-1];
if (strstr(word2,“CD“))
j=findbianhao(’a’); //电解电容
return j;
if(strstr(word4,“C“)) //当第四列信息包含CC时，则说明是电容,下面继续判断是何种电容
if (strstr(word1,“CC“))
j=findbianhao(’m’); //瓷片电容
return j;
else if(strstr(word1,“L“)&&(ch==’J’))
j=findbianhao(’l’); //金属膜电容
return j;
else if(strstr(word1,“CL“)&&(ch==’S’))
j=findbianhao(’j’); //集成电容
return j;
else {
j=findbianhao(’k’); //涤纶电容
return j;
else if(strstr(word4,“R“)) //当第四列包含R时，说明是电阻，下面继续判断是何种电阻
if(strstr(word1, “J“)) //金膜电阻
j=findbianhao(’o’);
return j;
else {
j=findbianhao(’n’); //碳膜电阻
return j;
else
return max-1; //以上情况都不是时，说明不能转换此种零件信息
//*************************对第一列数据进行拆分************************************
void chaifei(char word[],char str1[],char str2[])
{ char *p;
char *pword;
char *pch1,*pch2;
char ch1[15],ch2[10];
pword=word;
pch1=ch1;
pch2=ch2;
p=strchr(word,’/’);
if(p!=NULL)
{ while(pword!=p)
*pch1++=*pword++;
*pch1=0;
strcpy(pch2,p+1);
strcpy(word,pch2);
strcat(word,str2);
strcat(word,ch1);
else { strcpy(ch1,str1);
strcat(ch1,str2);
strcat(ch1,word);
strcpy(word,ch1);
//**************************跳线专用函数*********************************************
void chaifei_f(char word[],char str1[],char str2[])
{ char *p;
char *pword;
char *pch1,*pch2;
char ch1[15],ch2[10];
pword=word;
pch1=ch1;
pch2=ch2;
p=strchr(word,’/’);
if(p!=NULL)
{ while(pword!=p)
*pch1++=*pword++;
*pch1=0;
strcpy(pch2,p+1);
strcpy(word,pch2);
strcat(word,“II“);
strcat(word,str2);
strcat(word,ch1);
else { strcpy(ch1,str1);
strcat(ch1,str2);
strcat(ch1,word);
strcpy(word,ch1);
//**********************针对具体那种类型零件，对相应的每列数据进行处理***************
void takedata(int i,char word1[],char word2[])
{ int lei=i;
char *p;
char ch; //根据CH的值来区分零件数组的下标
char str1[15]; //将第一列的数据拆分后临时存放在这两个数组里
ch=zuonglei[i].ch;
switch(ch)
case ’a’ : chaifei(word1,“16V“,“-“); //电解电容
strcat(word1,“±20%“);
break;
case ’b’ : chaifei(word1,“1/2W“,“-“); //稳压二极管
break;
case ’c’ : if(!(strstr(word1,“N“))) //二极管
{strcpy(str1,“1N“);
strcat(str1,word1);
strcpy(word1,str1);
break;
case ’d’ : strcpy(word2,“\0“); //集成电路
break;
case ’e’ : break; //三极管
case ’f’ : strcpy(word2,word1); //跳线
chaifei_f(word1,“0.6II“,“-“); //单独调用另外一个函数
p=strchr(word2,’/’);
if(p)
*p=0;
break;
case ’g’ : strcpy(word1,word2); //插座
strcpy(word2,“\0“);
strcat(word1,“(XH)“);
break;
case ’h’ : strcpy(word2,“\0“); //输出接线柱
break;
case ’i’ : break; //集成电容
case ’j’ : strcpy(word2,“\0“); //桥堆
break;
case ’k’ : clearbegin(word1,’C’);
clearbegin(word1,’L’);
chaifei(word1,“63V“,“-“); //涤纶电容
strcat(word1,“±20%“);
break;
case ’l’ : clearbegin(word1,’C’);
clearbegin(word1,’L’);
chaifei(word1,“5V“,“-“); //金属膜电容
break;
case ’m’ : clearbegin(word1,’C’);
clearbegin(word1,’C’);
chaifei(word1,“50V“,“-“); //瓷片电容
strcat(word1,“±20%“);
break;
case ’n’ : chaifei(word1,“1/4W“,“-“); //碳膜电容
strcat(word1,“Ω±5%“);
break;
case ’o’ : chaifei(word1,“1/4W“,“-“); //金膜电容
strcat(word1,“Ω±20%“);
break;
case ’p’ : break; //不能转化的零件
//****************查找第二列数据包含的种类所对应的中文信息所处的数组下标*************
int bijiao(char word1[],char word2[],char word4[])
int i,j;
for(i=1;i<maxmin;i++) //小于maxmin的数据可以直接处理
if(strstr(word4,zuonglei[i].data))
break;
if(i<maxmin)
j=i;
else
j=findxb(word1,word2,word4); //大于mxamin时，则要细分电阻和电容的种类
takedata(j,word1,word2); //针对具体的种类，将其第1列数据转换
return j;
//**************************将数据写进节点*****************************************
void jianlianbiao(struct LJNODE *lj,struct BZNODE *bz,char word1[],char word2[],char word3[])
{ strcpy(lj->minchen,word1);
strcpy(lj->shulian,word3);
strcpy(lj->sinhao,word2);
lj->nextbz=bz;
lj->nextlj=0;
//***************判断两节点是否完全相同*********************************************
int tote(struct LJNODE *lj, struct LJNODE *pp)
{ int i,k;
i=strcmp(lj->minchen,pp->minchen);
k=strcmp(lj->sinhao,pp->sinhao);
if(i==0&&k==0)
return 1;
else return 0;
return 0;
//***********************************合并节点*****************************************
void unite(struct LJNODE *lj, struct LJNODE *pp)
{ struct BZNODE *ljbz,*ppbz,*bz;
int i,j;
char ch[30];
ljbz=lj->nextbz;
ppbz=pp->nextbz;
while(ppbz)
bz=ppbz;
ppbz=ppbz->next;
strcat(bz->beizhu,“, “);
i=atol(lj->shulian);
j=atol(pp->shulian);
i=i+j;
atoll(i,ch);
clearbegin(ch,’0’);
clearbegin(ch,’0’);
strcpy(pp->shulian,ch);
bz->next=lj->nextbz;
free(lj);
// printf(“%s\n“,bz->next->beizhu);
i=strlen(bz->beizhu);
j=strlen(ljbz->beizhu);
i=i+j;
if(i<row4-3)
{printf(“%d\n“,i);
strcpy(ch,bz->beizhu);
strcat(ch,ljbz->beizhu);
strcpy(bz->beizhu,ch);
printf(“BZ=%s\t“,bz->beizhu);
printf(“lj=%s*********\n“,ljbz->beizhu);
// strcat(bz->beizhu,ljbz->beizhu);
// printf(“%s\n“,bz->beizhu);
// printf(“%s\n“,ch);
// bz->next=ljbz->next;
// free(ljbz);
/* else
ppbz=ljbz;
i=atol(lj->shulian);
j=atol(pp->shulian);
i=i+j;
atoll(i,ch);
clearbegin(ch,’0’);
clearbegin(ch,’0’);
strcpy(pp->shulian,ch);
// free(lj);
// printf(“%s\n“,bz->beizhu);
// getchar();
//**************************将节点排序***********************************************
int charu(struct LJNODE *lj,int row)
struct LJNODE * plj1,*plj2,*pp;
int i=0;
plj1=plj2=pp=zuonglei[row].nextlj;
if(pp)
{ i=tote(lj,pp); // 调用tote函数先判断这种类型零件有无相同节点
if(i==1)
unite(lj,pp); //如果有相同节点，则合并节点
return 1;
else
pp->nextlj;
pp=zuonglei[row].nextlj;
while(pp!=NULL&&(strcmpp(lj->sinhao,pp->sinhao))) //插入排序
{ plj1=pp;
pp=pp->nextlj;
//***********测试
if(pp==plj1)
{lj->nextlj=zuonglei[row].nextlj;
zuonglei[row].nextlj=lj;
else
{lj->nextlj=pp;
plj1->nextlj=lj;
return 0;
//****************************将第二列中的浮点数分离并换算************************
void fenjian(char word[],int len)
{char *p2,*p,*p1;
char word1[14];
double f;
int i;
p=word;
p=word;
p1=p2=word1;
if(word[0]==’0’)
return ;
while(*p&&!(isdigit(*p))) //遇到第一个数字时，终止循环
p++;
while(*p&&(isdigit(*p)||*p==’.’)) //从第一个数字开始取浮点数
*p1++=*p++;
*p1=0;
f=atoff(word1); //将字符串转化为浮点数
f=f*25.4; //换算成毫米脚距
f=f*100+5; //以下几条语句是四舍五入保留一位小数
f=f/10.0;
i=f;
f=i/10.0;
gcvt(f, 5, word); //将浮点数转化为字符串利于保存
//**************************读文件，并建立链表***********************************************
void readfile(FILE *fpr)
struct BZNODE *bz,*pbz;
struct LJNODE *lj,*plj=NULL;
char word1[23],word2[15],word3[9],word4[37];
char ch,*chp;
int i=0,k=0,row,Lie_1=0,Lie_2=0,Lie_3=0,Lie_4=0,j=0,flag;
ch=fgetc(fpr);
while(ch!=EOF&&i<5) //从第三行开始读取
ch=fgetc(fpr);
if(ch==10)
i++;
while(!feof(fpr))
//**************************处理第一列数据****************************************
fgets(word1,22,fpr); //读出第一列数据
chp=word1;
i=3;
while(*chp) //判断第一列数据是否有回车键，如果有，则这行数据无效
if(*chp++==10)
i=0;
if(i==0)
continue;
Lie_1=wordlen(word1);
//**************************处理第二列数据*****************************************
fgets(word2,14,fpr); //读出第二列数据
Lie_2=wordlen(word2); //判断第二列数据是否为空
//**************************处理第三列数据*****************************************
fgets(word3,8,fpr);
Lie_3=wordlen(word3);
//**************************处理第四列数据*****************************************
fgets(word4,36,fpr);
Lie_4=wordlen(word4);
bz=(struct BZNODE *)malloc(sizeof(struct BZNODE));
strcpy(bz->beizhu,word4);
bz->next=NULL;
if(Lie_1+Lie_2>0) //如果第一列和第二列数据不为空，说明这是新记录
row=bijiao(word1,word2,word4); //判断该行数据应该接入那个编号的结构体
if(row!=5)
fenjian(word2,Lie_2); //对第二列数据中的浮点数进行处理
lj=(struct LJNODE *)malloc(sizeof(struct LJNODE));
lj->nextlj=NULL;
jianlianbiao(lj,bz,word1,word2,word3);
pbz=lj->nextbz;
flag=charu(lj,row);
else { pbz->next=bz; //如果第一二列为空，直接将备注信息接入节点
pbz=bz;
//****************************取出节点信息，并写入文件*************************************
void quchu(struct NODE zl,FILE *fw)
int j;
static int xh=0;
struct LJNODE *plj1=zl.nextlj,*plj;
struct BZNODE *bz,*bz1;
char *p1,*p2,*p3,*p;
char chr=10;
char *ch;
char *pch,chp[20];
char chrr;
int i=0,row;
ch=zl.china;
while(plj1)
xh++;
pch=atoll(xh,chp);
p1=plj1->minchen;
p2=plj1->sinhao;
p3=plj1->shulian;
chrr=zl.feilei;
p=zl.china;
bz=plj1->nextbz;
while(bz)
fputs(“|“,fw);
fputs(pch,fw);
row=strlen(pch);
for(j=0;j<4-row;j++)
fputc(’ ’,fw);
fputc(’|’,fw);
fputs(p,fw);
fputs(p1,fw);
row=strlen(p)+strlen(p1);
for(j=0;j<row1-row;j++)
fputc(’ ’,fw);
fputc(’|’,fw);
fputs(p2,fw);
row=strlen(p2);
for(j=0;j<row2-row;j++)
fputc(’ ’,fw);
fputc(’|’,fw);
fputs(p3,fw);
row=strlen(p3);
for(j=0;j<row3-row;j++)
fputc(’ ’,fw);
fputc(’|’,fw);
fputs(bz->beizhu,fw);
row=strlen(bz->beizhu);
for(j=0;j<row4-row;j++)
fputc(’ ’,fw);
fputc(’|’,fw);
for(j=0;j<row5;j++)
fputc(’ ’,fw);
fputc(’|’,fw);
for(j=0;j<row6;j++)
fputc(’ ’,fw);
fputc(’|’,fw);
fputc(chrr,fw);
for(j=0;j<row7;j++)
fputc(’ ’,fw);
fputc(’|’,fw);
fputc(10,fw);
p1=“ “;
p2=“ “;
p3=“ “;
pch=“ “;
p=““;
chrr=’ ’;
bz1=bz; //为了删除节点
bz=bz->next;
free(bz1); //释放指针
fputs(“|“,fw);
for(j=0;j<4;j++)
fputc(’-’,fw);
fputc(’|’,fw);
for(j=0;j<row1;j++)
fputc(’-’,fw);
fputc(’|’,fw);
for(j=0;j<row2;j++)
fputc(45,fw);
fputc(’|’,fw);
for(j=0;j<row3;j++)
fputc(’-’,fw);
fputc(’|’,fw);
for(j=0;j<row4;j++)
fputc(’-’,fw);
fputc(’|’,fw);
for(j=0;j<row5;j++)
fputc(’-’,fw);
fputc(’|’,fw);
for(j=0;j<row6;j++)
fputc(’-’,fw);
fputc(’|’,fw);
for(j=0;j<row7+1;j++)
fputc(’-’,fw);
fputc(’|’,fw);
fputc(10,fw);
plj=plj1;
plj1=plj1->nextlj;
free(plj); // 释放指针
//***************************写入空数据*******************************************
void huabiao(FILE *fw)
{ int j;
fputs(“|“,fw);
for(j=0;j<4;j++)
fputc(’ ’,fw);
fputc(’|’,fw);
for(j=0;j<row1;j++)
fputc(’ ’,fw);
fputc(’|’,fw);
for(j=0;j<row2;j++)
fputc(’ ’,fw);
fputc(’|’,fw);
for(j=0;j<row3;j++)
fputc(’ ’,fw);
fputc(’|’,fw);
for(j=0;j<row4;j++)
fputc(’ ’,fw);
fputc(’|’,fw);
for(j=0;j<row5;j++)
fputc(’ ’,fw);
fputc(’|’,fw);
for(j=0;j<row6;j++)
fputc(’ ’,fw);
fputc(’|’,fw);
for(j=0;j<row7+1;j++)
fputc(’ ’,fw);
fputc(’|’,fw);
fputc(10,fw);
void huaxian_1(FILE *fw)
{ int j;
fputs(“|“,fw);
for(j=0;j<4;j++)
fputc(’_’,fw);
fputc(’|’,fw);
for(j=0;j<row1;j++)
fputc(’_’,fw);
fputc(’|’,fw);
for(j=0;j<row2;j++)
fputc(’_’,fw);
fputc(’|’,fw);
for(j=0;j<row3;j++)
fputc(’_’,fw);
fputc(’|’,fw);
for(j=0;j<row4;j++)
fputc(’_’,fw);
fputc(’|’,fw);
for(j=0;j<row5;j++)
fputc(’_’,fw);
fputc(’|’,fw);
for(j=0;j<row6;j++)
fputc(’_’,fw);
fputc(’|’,fw);
for(j=0;j<row7+1;j++)
fputc(’_’,fw);
fputc(’|’,fw);
fputc(10,fw);
//*****************************画横线***********************************************
void huaxian(FILE *fw)
{ int j;
fputs(“|“,fw);
for(j=0;j<4;j++)
fputc(’-’,fw);
fputc(’|’,fw);
for(j=0;j<row1;j++)
fputc(’-’,fw);
fputc(’|’,fw);
for(j=0;j<row2;j++)
fputc(45,fw);
fputc(’|’,fw);
for(j=0;j<row3;j++)
fputc(’-’,fw);
fputc(’|’,fw);
for(j=0;j<row4;j++)
fputc(’-’,fw);
fputc(’|’,fw);
for(j=0;j<row5;j++)
fputc(’-’,fw);
fputc(’|’,fw);
for(j=0;j<row6;j++)
fputc(’-’,fw);
fputc(’|’,fw);
for(j=0;j<row7+1;j++)
fputc(’-’,fw);
fputc(’|’,fw);
fputc(10,fw);
//*******************************开始写入文件************************************
void xierufile(FILE *fw)
{ int i=0,j;
int len;
char *p;
for(i=0;i<55;i++)
fputc(’ ’,fw);
fputs(“零件明细表“,fw);
fputc(10,fw);
fputs(“ “,fw);
for(i=0;i<row1+row2+row3+row4+row5+row6+row7+12;i++)
fputc(’_’,fw);
fputc(10,fw);
p=“|序号|“;
fputs(p,fw);
fputs(“ 名称 “,fw);
fputs(“ | 宽度(mm) |“,fw);
fputs(“ 数量|“,fw);
fputs(“ 备注 |“,fw);
p=“制造商“;
len=strlen(p);
fputs(p,fw);
for(i=0;i<row5-len;i++)
fputc(’ ’,fw);
fputc(’|’,fw);
p=“供应商“;
len=strlen(p);
fputs(p,fw);
for(i=0;i<row6-len;i++)
fputc(’ ’,fw);
fputc(’|’,fw);
p=“物料分类“;
len=strlen(p);
fputs(p,fw);
for(i=0;i<row7-len+1;i++)
fputc(’ ’,fw);
fputc(’|’,fw);
fputc(10,fw);
// fputs(“ |----|------------------|----------|-----|-----------------------------------|“,fw);
fputs(“|“,fw);
for(j=0;j<4;j++)
fputc(’-’,fw);
fputc(’|’,fw);
for(j=0;j<row1;j++)
fputc(’-’,fw);
fputc(’|’,fw);
for(j=0;j<row2;j++)
fputc(45,fw);
fputc(’|’,fw);
for(j=0;j<row3;j++)
fputc(’-’,fw);
fputc(’|’,fw);
for(j=0;j<row4;j++)
fputc(’-’,fw);
fputc(’|’,fw);
for(j=0;j<row5;j++)
fputc(’-’,fw);
fputc(’|’,fw);
for(j=0;j<row6;j++)
fputc(’-’,fw);
fputc(’|’,fw);
for(j=0;j<row7+1;j++)
fputc(’-’,fw);
fputc(’|’,fw);
fputc(10,fw);
for(i=0;i<max;i++)
if(zuonglei[i].nextlj!=NULL)
quchu(zuonglei[i],fw) ;
for(i=0;i<row6;i++)
{huabiao(fw); //画最后几栏空表格
if(i<row6-1)
huaxian(fw);
else
huaxian_1(fw);
//*******************************主函数**********************************************
void main()
FILE *fpr,*fpw;
char filer[30],filew[30];
// printf(“请输入要读取文件的路径\n“);
// scanf(“%s“,filer);
// printf(“请输入要写入的文件路径\n“);
// scanf(“%s“,filew);
if ((fpr=fopen(“f:\a.txt“,“r“))==NULL)
{ printf(“要读取的文件路径输入有误\n“);
return ;
if ((fpw=fopen(“f:\newfile“,“w“))==NULL)
{ printf(“要写入的文件路径输入有误\n“);
return;
readfile(fpr);
fclose(fpr);
//********************************读文件结束，链表建完,开始写文件*************************
xierufile(fpw);
fclose(fpw);
// printf(“文件转换完毕\n“);
// getchar();
