CODEWITHSUNDEEP
cfwrite
Alex Foglia
Alex Foglia

Reputation: 31

fwrite() appends instead of write C

I have to write a program witch reads from a file received by line and then it overwrites it with the read words uppercased. This is my code

void toUpperCase(char* string) {
int i=0;
while(string[i])
{
    string[i]=toupper(string[i]);
    i++;
} }
int main(int argc, char** argv) {
if(argc==1)
{
    puts("Error: INSERT PATH");
    exit(0);
}
char* file=argv[1];
FILE* fd=fopen(file,"r+");
if(fd<0)
{
    perror("Error opening file: ");
    exit(0);
}
char buffer[30][30];
int i=0;
while(!feof(fd))
{
    fscanf(fd,"%s",buffer[i]);
    i++;
}
int j=0;
for(j=0; j<i; j++)
{
    toUpperCase(buffer[j]);
    fwrite(buffer[j],strlen(buffer[j]),1,fd);
}
fclose(fd);
return 0; }

but this program appends the words contained in buffer[][] instead of overwriting the file. If the file contain was something like pippo pluto foo then, after the execution is pippo pluto fooPIPPOPLUTOFOO instead of PIPPO PLUTO FOO. Where am i wrong? Thank you

Upvotes: 2

Views: 1928

Answers (4)

Petr Skocik
Petr Skocik

Reputation: 60163

If you want to do in-place translation that doesn't change lengths, you can open the source file in two streams and then do read-chunk, write-chunk in lockstep. That has the advantage of being super-easy to convert to a non-in-place version that will work with nonseekable files too (stdin/stdout, pipes, and sockets).

#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <ctype.h> //toupper

inline void upcaseStr(char* str){
  for(;*str;str++) { *str=toupper(*str); }
}
int upcaseStream(FILE* in, FILE* out){
  char buf[BUFSIZ]; //BUFSIZ is an implementation-defined constant for an optimal buffer size
  while(fgets(buf, BUFSIZ, in)){
    upcaseStr(buf);
    if(fputs(buf, out) == EOF){ return 1; } 
  }
  if(!feof){ return 1; }
  return 0;
}
int main(int argc, char **argv)
{
  //default in and out
  FILE* in = stdin;
  FILE* out = stdout;

  if(argc == 2) {
    in = fopen(argv[1], "r");     //for reading
    out = fopen(argv[1], "r+");   //for writing (and reading) starting at the beginning

    if(!(in && out)){
      fprintf(stderr, "Error opening file %s for reading and writing: %s\n", argv[1], strerror(errno));
    }
  }
  return upcaseStream(in, out);
}

If you do use the in-place version, then in the unlikely event that the if(fputs(buf, out) == EOF){ return 1; } line should return, you're screwed unless you have a backup copy of the file. :)

Note: You shouldn't name your FILE pointers fd because C people will tend to think you mean "file descriptor". FILE is a struct around a file descriptor. A file descriptor is just an int that you can use for FILE access with the raw system calls. FILE streams are an abstraction layer on top of file descriptors--they aren't file descriptors.

Upvotes: 2

Avilius
Avilius

Reputation: 25

Welcome to StackOverflow!

Reopening the stream with fopen with the "w" parameter:

fd=fopen(file, "w");

It opens the file and if there are any contents in the file, it clears them.

Upvotes: -2

this
this

Reputation: 5300

As you read from the file, its internal position indicator gets moved. Once you start writing, you start writing from that position on, which happens to be at the end of the file. So you effectively append the data to the file.

Rewind the handle to reset the position indicator before writing into the file:

rewind(fp);

On a side note, you are reading the file incorrectly:

while(!feof(fd))
{
    fscanf(fd,"%s",buffer[i]);
    i++;
}

When you reach the end of the file, fscanf will return an error and not read anything, yet you still increment variable i, as if the read was successful. And then you check feof() for end-of-file, but i was already incremented.

Check feof() and return of fscanf() immediately after calling fscanf():

while(1)
{
    int read = fscanf(fd,"%s",buffer[i]);
    if( read != 1 )
       //handle invalid read

    if( feof(fd) )
         break;
    i++;
}

Think about what happens if the string is longer than 29 characters and/or the file contains more than 30 strings. char buffer[30][30];

Upvotes: 0

fvu
fvu

Reputation: 32983

You have to reset the file position indicator using fseek, as fscanf will advance it. Something like

fseek(fd, length_of_read_string, SEEK_CUR);

This allows you to read the file in chunks, but it will be tricky to get right. Or of course reset it to the file start because you read everything in 1 go:

fseek(fd, 0L, SEEK_SET);

I strongly recommend writing the modified data into a new file, and then after the program has run, delete the initial file and rename the new one. That will also take care of another issue with your program, you are reading the entire file into memory before handling it.

Upvotes: 3

Related Questions