ex13.cpp

这里有大量的习题解答

		//		第13章      文     件


   // [例13.1] 格式转换处理一个结构变量
	#include<stdio.h>
    typedef struct  SData
    {      int		nLineset; float	 fAdjust;int nPoint;
	 	  float	     fXa;	float  fYa;	 float	fZa;	
	} CData;
	void OutputData(const  char *filename,const CData &d )
	{
       FILE *fp= fopen(filename, "w");
   	   fprintf(fp,"%d,%f,%d\n",d.nLineset,d.fAdjust,d.nPoint);//1
	   fprintf(fp,"%f,%f,%f\n", d.fXa,d.fYa,d.fZa);//2
	   fclose(fp);       
	}
    void InputData(const  char *filename,CData &d )
	{  FILE *fp = fopen(filename, "r");  
      fscanf(fp,"%d,%f,%d",&d.nLineset,&d.fAdjust,&d.nPoint);//1
	  fscanf(fp,"%f,%f,%f", &d.fXa,	&d.fYa,&d.fZa);//2
	  fclose(fp);       
    }	  	
	void main(void)
	{   CData s={1,2,3,4,5,6};   
        OutputData("c:\\sdata.out",s);
        CData d;              
        InputData("c:\\sdata.out",d);
        OutputData("c:\\cdata.out",d);       	  
	}
////[例13.2]fgetc.cpp
	 # include <stdio.h>    
	void main(void)
 	{	FILE* fpGet=fopen("fgetc.cpp","r");
	    if(fpGet==NULL) {printf("fopen failed\n");return;}         
		int i=0;
		char buffer[512];
		while(feof(fpGet)==0 && i<512) 
			buffer[i++]=fgetc(fpGet);           
		buffer[i]='\0';
		printf("%s\n",buffer); 
		//fclose(fpGet);
	}//    程序运行的结果显示fgetc.cpp在屏幕上。

///////////////[例13.3]fputc.cpp
	# include <stdio.h>    
	void main(void)
 	{	 FILE* fpGet=fopen("fputc.cpp","r");
	    if(fpGet==NULL) {printf("fopen failed\n");return;}  
		FILE* fpPut=fopen("fputc.xpp","w");
	    if(fpPut==NULL) {printf("fopen failed\n");return;}  
		while(!feof(fpGet)) //while(feof(fpGet)==0) 
				fputc(fgetc(fpGet),fpPut);           
		fclose(fpGet);			
		fclose(fpPut);
	}//程序运行之后即将上面的fputc.cpp源程序转存到fputc.xpp中。

  /////////////  [例13.4] fgets.cpp
	# include <stdio.h>    
	void main(void)
 	{   	FILE* fp=fopen("fgets.cpp","r");
	    if(fp==NULL) {printf("fopen failed\n");return;}  
		char sBuffer[128];
		for(int k=0;k<9;k++) 
		   if(fgets(sBuffer,128,fp)!=NULL) printf("%s",sBuffer); 
		fclose(fp);
	}//    程序运行的结果显示fgets.cpp在屏幕上。

 /////////////   [例13.5] fputs.cpp
    # include <stdio.h>                                
	void main(void)                                    
	{	FILE* fpRead=fopen("fputs.cpp","r");                  
   		if(fpRead==NULL) {printf("fopen r failed\n");return;} 
		FILE* fpWrite=fopen("fputsw.cpp","w");                  
   		if(fpWrite==NULL) {printf("fopen w failed\n");return;}  
		char s[81];                             
 		while(!feof(fpRead))       //while(feof(fpRead)==0)       
		if(fgets(s,81,fpRead)!=NULL) 
			{	fputs(s,fpWrite);	printf("%s",s);	} 
		fclose(fpWrite);                                    
	}
////////////	[例13.6]直接随机方式处理结构变量和数组
	#include<stdio.h>
    typedef struct  SData              //声明一个未含指针成员的结构类型
    {  int		nLineset; float	 fAdjust;int nPoint;
	  float	       fXa;	float  fYa;	 float	fZa;	
	} CData;                        //同时指定一个该类型的一个别名
	void WriteData(CData pSrc[],int n,FILE *fpDst)
	{  switch(n)                      //分支不是必要的仅只是阐明一些概念
		{ case 1:						//情形1常用于匹配一个简单的变量
   		fwrite(pSrc,sizeof(CData),1,fpDst); break;
		default:						//缺省情形着重数组的处理
         fwrite(pSrc,sizeof(CData),n,fpDst);//将内存数组pSrc[n]转存到fpDst定位的文件
	   }
	}
	inline  void ReadData(CData* pDst,int n,FILE *fpSrc )
	{   fread(pDst,sizeof(CData),n,fpSrc);	 } //从文件读数组fpSrc[n]到pDst定位的内存 	
	void PrintData(const CData &d )
	{	   printf("%4d,%4.1f,%4d,%4.1f,%4.1f,%4.1f\n",
		   d.nLineset,d.fAdjust,d.nPoint,d.fXa,d.fYa,d.fZa); 	         
	}
	void main(void)
	{   CData s  ={0,1,2,3,4,5};    	             //定义一个简单变量
        CData d[]={1,2,3,4,5,6,
		           2,3,4,5,6,7,
                   3,4,5,6,7,8};		             //定义一个结构数组	
        FILE* fpWrite=fopen("c:\\cdata.dat","w");  //打开文件的惯例操作是缺省文本方式
		if(fpWrite==NULL) {printf("fopen w failed\n");return;} 
	    WriteData(&s,1,fpWrite);                   //将结构变量s写入磁盘
        WriteData( d,3,fpWrite);                   //将结构数组d写入磁盘
		fclose(fpWrite);                          //及时地进行实际存盘运作
        FILE* fpRead=fopen("c:\\cdata.dat","r");    //以缺省方式打开上面刚生成的文件            
   		if(fpRead==NULL) {printf("fopen r failed\n");return;} 
		CData b[4];             //定义一个有4个元素的结构数组
        ReadData(b,3,fpRead);    //在文件中先读取3组结构数据直接送入b[0],b[1],b[2]
        ReadData(b+3,1,fpRead);  //在文件中随后位置再读取1组结构数据直接送入b[3]
		for(int k=0;k<4;k++)      //在屏幕上循环显示每一结构元素的成员值  
        PrintData(b[k]);          //二进制数据通过格式转换以文本输出
	}
/////[例13.7]ftell.cpp
     #include<stdio.h>	  	
	 void main(void)
	{   FILE * stream= fopen("ftell.cpp","rb");
        double a[20]; fread(a,sizeof(double),20,stream);
        printf("%d\n",ftell(stream));   //输出160	  
	}
//////////[例13.8] 一个简单的读写存盘程序
	#include <stdio.h>
	#include <stdlib.h>
	typedef struct student_tag
	{	int num;                    //成员num可以理解为学号
		char name[10];               //字符数组可以理解为姓名
		float s[3];                   //浮点数组具体意义可以灵活的理解
	}STudent;
	void Store(FILE*fpRead,int n)              //入口参数n用于动态构建结构数组
	{	FILE* fpWrite=fopen("STudent.txt","w");// fopen在heap空间建立流文件结构变量
		if(fpWrite==NULL)                 //打开文件的操作是缺省文本方式
         {printf("fopen w failed\n");return;} 
		rewind(fpRead);                          //反绕到文件的起始处
		STudent* ps=new STudent[n];               //定义动态的结构数组ps[n]
		while(!feof(fpRead))                      //一直读到文件见底EOF
		   fread(ps,sizeof(STudent),n,fpRead);       //在源中读取n*sizeof(STudent)到ps
		fprintf(fpWrite,"%-6s%-7s%-11s%-8s%-8s%-8s\n",
		   "order","number","name","math","c++","money"); //格式写的界面灵活多变
		for(int k=0;k<n;k++)                      //循环输出结构数组中元素的成员值
			fprintf(fpWrite,"%-6d%-6d%-11s%-8.2f%-8.2f%-8.2f\n",k,
			ps[k].num,ps[k].name,ps[k].s[0],ps[k].s[1],ps[k].s[2]);
		delete [] ps;                             //释放自行建立的结构数组空间
		fclose(fpWrite);                     //释放系统建立的结构变量,信息及时存盘
	}
	STudent* Produce(int &n)    //诞生一个静态结构数组
	{   static STudent s[]={3004,"commom",  70,80,234,
	      3001,"matchless",100,100,9999,	    3009,"prudish",  50,51,815,
	      3005,"critical",   60,60,60,		3007,"poor",     50,50,0	};
		n=sizeof(s)/sizeof(s[0]);              //静态结构数组的维数
		FILE* fpWrite=fopen("student.dat","w");//缺省方式写打开操作
		if(fpWrite==NULL)
           {printf("fopen w failed\n");exit(0);} 
		fwrite(s,sizeof(STudent),n,fpWrite);  //整齐归一的入口界面将s[n]送入fpWrite
		fclose(fpWrite);                  //及时关闭文件迅即执行存写操作
		return s;                        //返回一个局部静态数组的首地址
	}
	void Update(FILE*fp,int n)      //入口参数n用于指出磁盘空间结构数组的最大维数
	{   //更新流文件中相当于结构数组ps[n]中的元素ps[kth]的值
		printf("Enter the order num 0-%d to updade \n",n-1);
		int kth;
		scanf("%d",&kth);                    //屏幕交互实时地读入定位的尺数
        STudent s;                          //定义一个局部结构变量s
		fseek(fp,kth*sizeof(STudent),SEEK_SET);//定位于距起始位置kth*sizeof(STudent)处
		fread(&s,sizeof(STudent),1,fp);         //在新定的位置处读取一段数据到s
		Show(&s,kth);                       //显示刚读入的数据
		printf("Enter 4 values to updade for number,math,c++,money\n");
		scanf("%d,%f,%f,%f",&s.num,&s.s[0],&s.s[1],&s.s[2]);//键入四个结构成员值
		fseek(fp,kth*sizeof(STudent),SEEK_SET);//定位于结构数组ps[n]中的元素ps[kth]
		fwrite(&s,sizeof(STudent),1,fp);        //相当于写到元素ps[kth]中
		Show(&s,kth);                      //显示更新的数据
	}
	void Clear(FILE*fp,int n)
	{	printf("Enter the order num 0-%d to Clear \n",n-1);
		int kth;
		scanf("%d",&kth);                    //屏幕交互实时地读入定位的尺数
		fseek(fp,kth*sizeof(STudent),SEEK_SET);//定位于距起始位置kth*sizeof(STudent)处
		STudent s0={0,"",0,0,0};              //定义一个清0的结构变量s0
		fwrite(&s0,sizeof(STudent),1,fp);       //在新定的位置处存写s0
		fseek(fp,kth*sizeof(STudent),SEEK_SET);//复位于磁盘空间类似于至ps[kth]处
		STudent s;
		fread(&s,sizeof(STudent),1,fp);         //在最新的位置读数据到结构到变量s
		Show(&s,kth);                       //显示这个结构变量
	}
	void Show(STudent *ps,int k) //格式化显示ps所指的结构的成员值，形参k指出序号
	{	printf("%-6s%-7s%-11s%-8s%-8s%-8s\n",
				"order","number","name","math","c++","money");
		printf("%-6d%-7d%-11s%-8.2f%-8.2f%-8.2f\n",k,
			ps->num,ps->name,ps->s[0],ps->s[1],ps->s[2]);	
	}
	int MenuChoice(void) //菜单提示读取菜单选项值
	{	printf("\nEnter choice as bellow:\n"
				"1. store  a formatted file\n" 
				"2. update a record\n"
				"3. clear  a record\n" 
				"4. end program?\n");
		int k;
		scanf("%d",&k);
		return k;
	}
	int main()
	{	int n;
		STudent* ps=Produce(n);                   //产生一个磁盘文件student.dat
		for(int k=0;k<n;k++)                      //循环显示结果
           Show(ps+k,k); 
		FILE* fp=fopen("student.dat","r+");          //以读或写方式打开已存在的文件
		if(fp==NULL) 
         {printf("fopen r+ failed\n");return 1;} 
		int menu;
		while((menu=MenuChoice())!=4)            //选项4跳出循环
         {	switch(menu)
            {case 1:  //选向1用函数Store将格式化的结构数组存储到STudent.txt文件中
				Store(fp,n);	break;
			case 2:   //选向2用函数Update更新下一步选定的数组元素
				Update(fp,n);	break;
			case 3:   //选项3用函数Clear将下一步选定的数组元素清0
				Clear(fp,n);	break;		
			}	
		}
		fclose(fp);          //关闭流文件
		return 0;
	}