使用write（）在C中写入文件时出现的随机符号

我正在制作一个程序，它接收一个文件并创建一个新文件，该文件的内容与原始文件的内容顺序相反

我可以这样做，但每次我写入文件时，所有内容都是正确的，但在输出文件的开头有随机符号不断变化

我正试图从这个来源把文本颠倒过来

预期产量

iP ot denrut niaga eh dnA

.stnerap rehto gnitatimi yb deriuqca ylno dah ilisaV ecnirP
hcihw tub ,doohybab morf nerdlihc rieht dettep evah ohw stnerap ot
larutan ssenrednet lautibah fo enot sselerac eht htiw reh gnisserdda
dna rethguad sih ot yltnatsni gninrut ,deksa eh "?ayleL ,lleW"

虽然我有时会得到这样的输出，但大多数时候我都会得到这样的输出

����iP ot denrut niaga eh dnA

.stnerap rehto gnitatimi yb deriuqca ylno dah ilisaV ecnirP
hcihw tub ,doohybab morf nerdlihc rieht dettep evah ohw stnerap ot
larutan ssenrednet lautibah fo enot sselerac eht htiw reh gnisserdda
dna rethguad sih ot yltnatsni gninrut ,deksa eh "?ayleL ,lleW"

我不知道为什么我会得到这些特殊的字符，它们并不总是相同的，它们不断变化，有时它们根本不存在，并给出正确的输出

#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
#include <sys/stat.h>
#include <stdlib.h>
#include <string.h>

size_t getFilesize(const char* filename) {
    struct stat st;
    if(stat(filename, &st) != 0) {
        return 0;
    }
    return st.st_size;   
}
 void reverse(char s[])
 {
     int i, j;
     char c;

     for (i = 0, j = strlen(s)-1; i<j; i++, j--) {
         c = s[i];
         s[i] = s[j];
         s[j] = c;
     }
} 
 void itoa(int n, char s[])
 {
     int i, sign;

     if ((sign = n) < 0)  /* record sign */
         n = -n;          /* make n positive */
     i = 0;
     do {       /* generate digits in reverse order */
         s[i++] = n % 10 + '0';   /* get next digit */
     } while ((n /= 10) > 0);     /* delete it */
     if (sign < 0)
         s[i++] = '-';
     s[i] = '\0';
     reverse(s);
}  


int main( int argc , char *argv[] ){

    int sz,fd,fd2;
    int seekStatus;
    int writeStatus;
    int fileSize;
    char c[100000];
    fd = open(argv[1],O_RDONLY);

    if (fd < 0) {
    perror("input file missing");
    exit(1);
  }
    mkdir("Output", 0700);
    fd2 = open("Output/A.txt", O_WRONLY | O_CREAT | O_TRUNC, 0700);


    fileSize= getFilesize(argv[1]);

    int progress = 0;
    char strprogress[100];
    int chunk;
    chunk = 100000;
    int i = -1; 

    if (fileSize<chunk ){
        seekStatus=lseek(fd, -1, SEEK_END);
        while (seekStatus >= 0 ){
            sz=read(fd,c,1);
            writeStatus=write(fd2, c , 1);
         progress= ((-1.0 * i / fileSize)) * 100 ;


            itoa(progress,strprogress);

            write(1,"\r",1);
            write(1,strprogress, strlen(strprogress));

            i=i-1;
            seekStatus=lseek(fd, i, SEEK_END);
        }
    }
    else{

        int k = 1; // iterator 
        seekStatus=lseek(fd, -1*k*chunk, SEEK_END); 
        while (seekStatus >=0){
            sz = read(fd , c ,chunk);
            reverse(c);
            writeStatus=write(fd2, c , chunk);
            progress= ((-1.0 * chunk  * k / fileSize)) * 100 ;
            write(1,"\r",1);
            write(1,strprogress, strlen(strprogress));
            k=k+1;
            seekStatus=lseek(fd, -1*k*chunk, SEEK_END);
        }
        int remaining;
        remaining = fileSize - (k*chunk);
        if ( remaining != 0 ){
            seekStatus=lseek(fd, fileSize-remaining, SEEK_END);
            sz = read(fd , c ,remaining);
            write(fd2, c , remaining);
            write(1,"\r",1);
            write(1,"100",strlen("100"));
        }

    }


}

#包括
#包括
#包括
#包括
#包括
#包括
#包括
大小\u t getFilesize（常量字符*文件名）{
结构统计；
如果（stat（filename，&st）！=0）{
返回0；
}
返回st.st_大小；
}
无效反向（字符s[]）
{
int i，j；
字符c；
对于（i=0，j=strlen（s）-1；i0）；/*删除它*/
if（符号<0）
s[i++]='-'；
s[i]='\0'；
反面；
}  
int main（int argc，char*argv[]）{
int sz、fd、fd2；
int seekStatus；
内特莱特斯塔斯；
int文件大小；
charc[100000]；
fd=打开（argv[1]，仅限Ordu）；
如果（fd<0）{
perror（“输入文件丢失”）；
出口（1）；
}
mkdir（“输出”，0700）；
fd2=open（“Output/A.txt”，O_WRONLY | O|u CREAT | O|u TRUNC，0700）；
fileSize=getFilesize（argv[1]）；
int progress=0；
char strprogress[100]；
整块；
区块=100000；
int i=-1；
如果（文件大小=0）{
sz=读取（fd，c，1）；
writeStatus=write（fd2，c，1）；
进度=（-1.0*i/fileSize））*100；
itoa（进度、标准进度）；
写入（1，“\r”，1）；
写入（1，strprogress，strlen（strprogress））；
i=i-1；
seekStatus=lseek（fd，i，SEEK_END）；
}
}
否则{
int k=1；//迭代器
seekStatus=lseek（fd，-1*k*chunk，SEEK_END）；
而（seekStatus>=0）{
sz=读取（fd，c，chunk）；
反面（c）；
writeStatus=写入（fd2，c，块）；
进度=（-1.0*块*k/文件大小））*100；
写入（1，“\r”，1）；
写入（1，strprogress，strlen（strprogress））；
k=k+1；
seekStatus=lseek（fd，-1*k*chunk，SEEK_END）；
}
剩余整数；
剩余=文件大小-（k*块）；
如果（剩余！=0）{
seekStatus=lseek（fd，剩余文件大小，SEEK_END）；
sz=读取（fd、c、剩余）；
写入（fd2，c，剩余）；
写入（1，“\r”，1）；
写（1，“100”，strlen（“100”）；
}
}
}

---

基本上，我试图在我的程序中做的是，我一次读取1000字节的文件，当剩余的字节数不到1000字节时，我将其写入文件，我一次只写入一个字节。我还有一个写入屏幕的进度状态。

首先，这段代码是非常错误的

        sz = read(fd , c ,chunk);
        reverse(c);
        writeStatus=write(fd2, c , chunk);

read

读取任意数量的字节。我无法想象想要逆转任意数量，所以这可能不是你想要的。对于这个用例，我们似乎需要

readblock

和

writeblock

。你的图书馆里没有

ssize_t readblock(int fd, void *outptr, size_t len)
{
    void *ptr = outptr;
    int delta;
    while (len) {
        delta = read(fd, ptr, len);
        if (delta < 0) return -1;
        if (delta == 0) { return ptr - outptr; }
        ptr += delta;
        len -= delta;
    }
    return ptr - outptr;
}

ssize_t writeblock(int fd, const void *inptr, size_t len)
{
    const void *ptr = inptr;
    int delta;
    while (len) {
        delta = write(fd, ptr, len);
        if (delta < 0) return -1;
        if (delta == 0) { errno = ENOSPC; return -1; }
        ptr += delta;
        len -= delta;
    }
    return ptr - inptr;
}

让我们来处理相反的问题

void reverse(char s[], size_t sz)
  //...
  for (i = 0, j = sz-1; i<j; i++, j--) {
  //...

void reverse（字符s[]，大小sz）
//...
对于（i=0，j=sz-1；i
void reverse(char s[], size_t sz)
  //...
  for (i = 0, j = sz-1; i<j; i++, j--) {
  //...