Accessing files.

I've got the following code:

Code:

---

#include <stdio.h>
#include <stdlib.h>
FILE * fptr;
int main()
{
 char letter;
 int i;
 fptr = fopen("C:\\abc.txt", "r+");
 printf("Enter: ");
 scanf("% d", &i);
 fseek(fptr, (i-1), SEEK_SET);
 fputc('*', fptr);
 fseek(fptr, 0, SEEK_SET);
 printf("The file looks like this: \n");
 for (i = 0; i < 26; i++)
    {
      letter = fgetc(fptr);
      printf("The next letter is %c\n",letter);
    }
 fclose(fptr);
 getchar();
 getchar();
 getchar();

  return 0;
}

---

The thing is that I I'd like to replace a letter, only the asterisk is placed somewhere completely different. Could anyone explain on how to make it work?

Thanks.

Are you counting correctly, as in counting newline as two characters?

--
Mats

FILE * fptr;
should be local inside main

char letter;
should be int letter because fgetc returns int

"% d"

should ne "%d"

Code:

---

for (i = 0; i < 26; i++)
    {
      letter = fgetc(fptr);
      printf("The next letter is %c\n",letter);
    }

---

loop should look like

Code:

---

while((letter = fgetc(fptr)) != EOF)
{
      printf("The next letter is %c\n",(unsigned char)letter);
}

---

Well the file I use to modify looks like this:
ABCDEFGHIJKLMNOPQRSTUVWXYZ

Code:

---

fseek(fptr, (i-1), SEEK_SET);

---

Will move the 'cursor' i bytes

So to check how much space 1 character takes up I tried:

Code:

---

#include <stdio.h>

int main()
{
  char b = 'A';
  printf(" &#37;d", sizeof(b));
  getchar();
  return 0;
}

---

The output was 1 . So to move the 'cursor' 1 character I would have to enter 1 I thought. It doesn't work though.

Vart would you mind explaining please?

Quote:

---

Originally Posted by omnificient

Well the file I use to modify looks like this:
ABCDEFGHIJKLMNOPQRSTUVWXYZ


So to check how much space 1 character takes up I tried:

The output was 1 . So to move the 'cursor' 1 character I would have to enter 1 I thought. It doesn't work though.

---

problem is not the size - the scanf

sizeof (char ) is always 1

and it is how much space the char takes in memory, not in file

Quote:

---

Originally Posted by omnificient

Vart would you mind explaining please?

---

Which of 4 items?

All except the one about "% d", that was a typo.

Well, you measured incorrectly. Here's what a part of the man page says about fseek:

Code:

---

SYNOPSIS
      #include<stdio.h>

      int fseek(FILE*stream,long offset,int whence);
[ ... ]
DESCRIPTION
      The  fseek  function  sets  the  file position indicator for the stream
      pointed to by stream.  The new position, measured in bytes, is obtained
      by  adding offset bytes to the position specified by whence.  If whence
      is set to SEEK_SET, SEEK_CUR, or SEEK_END, the offset  is  relative  to
      the  start of the file, the current position indicator, or end-of-file,
      respectively.

---

An int is only used to represent a character in most I/O functions because of the possibility that it must return EOF as a status. EOF is defined by the standard to be a negative number. Nothing in the same standard says that it fits in a character, which can be implemented as signed or unsigned by default according to the compiler. Most compilers I worked with utilized signed char anyway, so maybe EOF could be represented in a character. But it is not good practice at all to rely on the compiler's implementation details.

So fix your offset, and you should be ok.

But I think a whole lot easier method would be to just read the file, and replace the asterisk, then write it back to the file. You're already working at "I/O speed" so I don't think hacking at the interface to peek at the file is going to give you much of a performance boost. Any marginal benefit comes at the cost of you not really understanding how you solved the problem.

I'm sorry but I think your answer is a bit too complicated for me. What is wrong with my offset exactly?

Quote:

---

Originally Posted by omnificient

All except the one about "% d", that was a typo.

---

Then show the real code - by using copy/paste

1. FILE* pointer is used only in main - so it should be declared local to this function. You should avoid globals - they complicate maintanence of the code in big projects, so good habbit is to make all variables as local as possible declaring them in the smallest possible scope.

2. getc returns int 0-255 values are for byte read from file and -1 (EOF0 is used to indicate end-of-file event
so in general usage of this function should be

Code:

---

int letter;
letter = fgetc(fp);
if(letter != EOF)
{
  unsigned char readLetter = (unsigned char)letter;
  /* use readLetter */
}

---

3. as a result the loop that reads all the file contents using this function should look like in the sample I have shown. You could read more in FAQ

Can you post your current code?

Also, perhaps you could post the result of your program, and the inputs you used to get there?

--
Mats

BTW:

Code:

---

fseek(fptr, 0, SEEK_SET);

---

That's the same as

Code:

---

rewind(fptr);

---

Code:

---

getchar();
 getchar();
 getchar();

---

The more, the merrier!

Why not just use something like this?

Code:

---

while(getchar() != '\n');

---

Quote:

---

2. getc returns int 0-255 values are for byte read from file and -1 (EOF0 is used to indicate end-of-file event
so in general usage of this function should be

Code:

---

int letter;
letter = fgetc(fp);
if(letter != EOF)
{
  unsigned char readLetter = (unsigned char)letter;
  /* use readLetter */
}

---

---

Not necessarily. Most of the time, you can probably just read the letter as an int and keep it as an int. (chars are automatically promoted to ints when they're passed to varargs functions like printf() anyway, and with prototyped functions the compiler should be able to handle things.)

Anyway -- it's strange that your code isn't working, because this overwrites the '5' correctly for me.

Code:

---

#include <stdio.h>

#define FILENAME "overwrite.txt"

int main() {
    int c;
    FILE *fp = fopen(FILENAME, "w");
    fputs("1234567890", fp);
    fclose(fp);
   
    fp = fopen(FILENAME, "r+");
    fseek(fp, 5-1, SEEK_SET);  /* overwrite the '5' */
    putc('*', fp);
    rewind(fp);
   
    while((c = getc(fp)) != EOF) putchar(c);
   
    getchar();
    return 0;
}

---

The only thing that I can think of is that rewind() flushes the file and fseek() does not -- because you need to flush the file (such as with fflush()) as you switch between reading and writing.

Again, though, I agree with citizen -- why not just read in a line, change that, and re-create the file? It's probably more efficient, actually -- less file manipulation.

Well I'm not really trying to program something useful, I'm just going through a book, an trying to figure out how things work. So I just want to learn how to use what's in the book rather than fix things another way.
I'm still using the original code:

Code:

---

#include <stdio.h>
#include <stdlib.h>
FILE * fptr;
int main()
{
 char letter;
 int i;
 fptr = fopen("C:\\abc.txt", "r+");
 printf("Enter: ");
 scanf("% d", &i);
 fseek(fptr, (i-1), SEEK_SET);
 fputc('*', fptr);
 fseek(fptr, 0, SEEK_SET);
 printf("The file looks like this: \n");
 for (i = 0; i < 26; i++)
    {
      letter = fgetc(fptr);
      printf("The next letter is %c\n",letter);
    }
 fclose(fptr);
 getchar();
 getchar();
 getchar();

  return 0;
}

---

I compiled the program, ran it and I entered 4. the d should have been changed into *, but it prints out * much later it turns out. Have a look at abc.txt.
Attachment 7895

you still have % d as a format
and still missing fflush between write/read operations

Ah, the "% d", was the problem. I really thought I had fixed that :eek:

But what does flushing do exactly? I thought you could just switch between read and write when you used "r+" or "w+" with the fopen function?

you could switch, but you have to flush the file inbetween

So like this?

Code:

---

#include <stdio.h>
#include <stdlib.h>
FILE * fptr;
int main()
{
 char letter;
 int i;
 fptr = fopen("C:\\abc.txt", "r+");
 printf("Enter: ");
 scanf("%d", &i);
 fseek(fptr, (i-1), SEEK_SET);
 fputc('*', fptr);
 fseek(fptr, 0, SEEK_SET);
 fflush(fptr);
 printf("The file looks like this: \n");
 for (i = 0; i < 26; i++)
    {
      letter = fgetc(fptr);
      printf("The next letter is %c\n",letter);
    }
 fclose(fptr);
 getchar();  // This should be changed someday.
 getchar();
 getchar();

  return 0;
}

---

Does it work?

Code:

---

// This should be changed someday.

---

Glad to see you're paying attention. :p

Like I think I said, these two calls

Code:

---

fseek(fptr, 0, SEEK_SET);
 fflush(fptr);

---

are exactly the same as a single call to rewind(fptr). Why not use that? :)

I think it works, but I don't notice a difference.

The reason is that I'd like to learn one thing at a time, besides: I now know that it is always necesary to flush the buffer before switching between reading and writing. ;)

And I took your advice:

Code:

---

do    {
        puts("Press enter to quit.");
        getchar();
        }
 while (getchar() != '\n');

---

Thanks :)

Have you tested your code?

Code:

---

#include <stdio.h>
int main()
{
        do    {
                puts("Press enter to quit.");
                getchar();
        }
        while (getchar() != '\n');
}

---

You actually need to press Enter twice to exit this program

Yes, I tested it. The user only has to press enter once.

Quote:

---

Originally Posted by omnificient

Yes, I tested it. The user only has to press enter once.

---

If that's the case, you probably had a left-over newline in the input buffer from a scanf() or some such - as it's quite clear that if there is NOTHING in the input buffer, the first getchar() will wait for a newline and consume it, the second one will have to wait for ANOTHER newline.

Have you actually tested the code posted above by vart?

--
Mats

Well matsp, as I said: I indeed tested the code. I did realise, after vart pointed it out, that there is some \n left from another scanf() or something.

It works, so is there a problem with the loop I have used here?

Quote:

---

Originally Posted by omnificient

Well matsp, as I said: I indeed tested the code. I did realise, after vart pointed it out, that there is some \n left from another scanf() or something.

It works, so is there a problem with the loop I have used here?

---

You are relying on the input buffer being "exactly what you expect", and for that reason, I would suggest that you "eat" the previous newline left-over before the loop, then wait for another newline.

--
Mats

So that would mean using another getchar()? The problem that I then create is that the user now does have to press enter twice.

Maybe a while loop?

Quote:

---

Originally Posted by omnificient

So that would mean using another getchar()?

---

No, it means moving the gechar() from INSIDE the loop, to outside the loop.

Your current code expects the input to be '\n', '\n'. So your getchar() inside the loop "eats" the first newline, then the getchar() in the while-condition eats the final newline.

But consider that scanf() left an 'a' in the input buffer, as well as your expected two newlines. So your first getchar() eats the a, the while() one eats a newline and the user doesn't get to press enter before it exits. Other options exist.

--
Mats

So will the getchar() in the while statement is not only used to check if something is true, but it will actually be presented to the user?

Let me explain what is happening here:

Code:

---

do    {
        puts("Press enter to quit.");
        getchar();
        }
 while (getchar() != '\n');

---

Every time the loop executes, you:

1. Print a message.
2. Discard a single character from the input stream.
3. Get another character from the input.
4. Start executing the loop at the beginning again if this character is not a '\n'.

A few problems to note with this approach:

• Only every other character is checked against a newline.
• A message is printed every two characters.

So you might try to fix it by using this . . .

Code:

---

do    {
        puts("Press enter to quit.");
        }
 while (getchar() != '\n');

---

Right? Because now every character is checked against '\n'.

Not quite . . . what happens if the input stream contains "\nexit\n"? You'll get "Press enter to quit." printed six times!

So here's what you really want to do. You want to print the message once, and then eat as many characters as you need to until you get a '\n'. (Checking every character you read against '\n', of course.) In other words:

Code:

---

puts("Press enter to quit.");

do    {
        }
 while (getchar() != '\n');

---

Of course, that simplifies to:

Code:

---

puts("Press enter to quit.");
while(getchar() != '\n');

---

. . . which is what I had in the first place, I believe. :)

I see how it works now. Thanks for the explanation.