Skip to main content
 Web开发网 » office教程 » excel教程

[程序设计]PCB板元器件文档转换成中文的一个程序(包括排序和出表格)

#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();

评论列表暂无评论
发表评论
微信