DAY31

#include<myhead.h>

//定义结构体
struct Data
{
    const char *srcfile;
	const char *dstfile;
	int start;
	int length;
};

/**************************定义求文件长度函数****************************************/
int getlen(const char *srcfile,const char *dstfile)
{
	//定义两个文件描述符
	int fd1,fd2;

	//以只读的形式打开源文件
	if((fd1=open(srcfile,O_RDONLY))==-1)
	{
		perror("srcfile open error");
		return -1;
	}

	//以只写的形式打开源文件
	if((fd2=open(dstfile,O_WRONLY|O_CREAT|O_TRUNC,0664))==-1)
	{
		perror("dstfile open error");
		return -1;
	}

	//求源文件的长度
	int len=lseek(fd1,0,SEEK_END);
	
	//关闭文件
	close(fd1);
	close(fd2);

	return len;
}

/************************定义文件拷贝函数*********************************************/
void copy_file(const char *srcfile,const char *dstfile,int start,int len)
{
	//定义两个文件描述符
	int fd1,fd2;

	//以只读的形式打开源文件
	if((fd1=open(srcfile,O_RDONLY))==-1)
	{
		perror("srcfile open error");
	}

	//以只写的形式打开源文件
	if((fd2=open(dstfile,O_WRONLY))==-1)
	{
		perror("dstfile open error");
	}

	//将光标定位在开始拷贝的位置
	lseek(fd1,start,SEEK_SET);
	lseek(fd2,start,SEEK_SET);

	//开始进行拷贝工作
	char buf[128]="";         //数据搬运工
	int sum=0;              //记录搬运的总个数

	while(1)
	{
		//从源文件中读取数据
		int ret=read(fd1,buf,sizeof(buf));
		sum+=ret;             //记录每次搬运的个数

		if(ret==0||sum>len)
		{
			write(fd2,buf,ret-(sum-len));     //将最后一次不满128的数据拷贝到新文件中
			break;
		}

		//将数据写入目标文件
		write(fd2,buf,ret);
	}

	printf("拷贝成功\n");
}

/***********************定义线程体函数***********************************************/
void *task1(void *arg)
{
	//将数据进行解压出来
	struct Data data=*(struct Data*)arg;

	//调用文件拷贝函数
	copy_file(data.srcfile,data.dstfile,data.start,data.length);

	//退出当前线程
	pthread_exit(NULL);
}

/************************主程序*******************************************************/
int main(int argc, const char *argv[])
{
	//判断是否传入两个文件
	if(argc!=3)
	{
		printf("input file error\n");
		printf("usage:./a.out srcfile dstfile\n");
		return -1;
	}

	//求文件的长度
	int len=getlen(argv[1],argv[2]);

	//定义数据结构体变量
	struct Data data={argv[1],argv[2],len/2,len-len/2};

	//定义线程号
	pthread_t tid;

	//创建线程
	if(pthread_create(&tid,NULL,task1,&data))
	{
		printf("线程创建失败\n");
		return -1;
	}

	//调用文件拷贝函数
	copy_file(argv[1],argv[2],0,len/2);

	//阻塞回收线程的资源
	pthread_join(tid,NULL);

	return 0;
}

#include<th.h>


struct txt
{
	FILE * fp1;
	FILE * fp2;
};

int getlen(FILE *fp)
{
	if((fp = fopen("th.txt","r")) == NULL)
	{
		perror("fopen error\n");
		return -1;
	}

	fseek(fp,0,SEEK_END);
	int len = ftell(fp);

	fclose(fp);

	return len;
}




void * task1(void * arg)
{
	struct txt file = *(struct txt *)arg;
	if((file.fp1 = fopen("th.txt","r")) == NULL)
	{
		perror("fopen error\n");
		return NULL;
	}
	

	if((file.fp2 = fopen("ah.txt","w")) == NULL)
	{
		perror("fopen error\n");
		return NULL;
	}
	int len = getlen(file.fp1);
	printf("%d\n",len);
	fwrite(file.fp1,len / 2,1,file.fp2);
	
	fclose(file.fp1);
	fclose(file.fp2);
	pthread_exit(NULL);
}

void * task2(void * arg)
{

	sleep(1);
	struct txt file = *(struct txt *)arg;

	int len = getlen(file.fp1);
	if((file.fp1 = fopen("th.txt","r")) == NULL)
	{
		perror("fopen error\n");
		return NULL;
	}
	if((file.fp2 = fopen("ah.txt","a")) == NULL)
	{
		perror("fopen error\n");
		return NULL;
	}
	
	fseek(file.fp1,len / 2,SEEK_SET);
	fwrite(file.fp1,len - len / 2,1,file.fp2);

	fclose(file.fp1);
	fclose(file.fp2);
	pthread_exit(NULL);
}


int main(int argc, const char *argv[])
{
	FILE * fp1;
	FILE * fp2;
	struct txt file = {fp1,fp2};

	pthread_t tid1;
	if(pthread_create(&tid1,NULL,task1,&file))
	{
		printf("error\n");
		return -1;
	}

	pthread_t tid2;
	if(pthread_create(&tid2,NULL,task2,&file))
	{
		printf("error\n");
		return -1;
	}
	
	pthread_join(tid1,NULL);
	pthread_join(tid2,NULL);
	return 0;
}