FILE I/O: two file pointes

Question

I'm new to FILE I/O Stream and I want to write a program, which converts chars (read from "texti.txt") like "ä,Ä,ü,Ü,ö,Ö" to "ae,Ae,ue,Ue,oe,Oe" and write them in a new file called "texto.txt".

First Question: Is it ok to have two file pointers (on to each file) at the same time like i do?

Second Question: What am I doing wrong with character compare in the switch statement? VS2015 is warning that cases 2 and 3 already exist (reference to case 1)

Thirt Question Does fpo (file pointer to output-file) increment itself automatically by writig a char?

Question four: VS2015 is warning:

C4996 'fopen': This function or variable may be unsafe. Consider using fopen_s instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. See online help for details.

Is there another function I should use?

int main()
{
    char c;
    FILE *fpi;
    FILE *fpo;
    fpi = fopen("texti.txt","r");
    fpo = fopen("texto.txt", "w");
    if (fpi == NULL)
        fprintf(stderr, "Fehler beim Lesen");
    while (!feof(fpi))
    {
        c = fgetc(fpi);
    switch (c)

{
    case 'ä'||'Ä':      
        fputc('a', fpo);
        fputc('e', fpo);
        break;

    case 'ö'||'Ö':
        fputc('o', fpo);
        fputc('e', fpo);
        break;

    case 'ü' || 'Ü':
        fputc('u', fpo);
        fputc('e', fpo);
        break;

    default:
        fputc((c), fpo);
    }
    fpi++;
}
fclose(fpi);
fclose(fpo);

}

Answer 1

There are really to many different questions there, you should concentrate on one at a time, and post different questions if they are distinct like yours.

I'll answer the second question, about the switch statement. And the answer is if you want to use multiple values in a single case, you can't. You can however rely on the fact that cases fall through down if there is no break statement, and then you can do e.g.

switch (c)
{
case 'ä':
case 'Ä':
    // Code for the ä or Ä case
    break;

...
}

You could also use tolower or toupper:

switch (tolower(c))
{
case 'ä':
    // Code for the ä or Ä case
    break;

...
}

---

A little explanation about what is wrong with case 'ä'||'Ä'.

What happens is that the compiler sees 'ä' || 'Ä' as a boolean expression, and in C everything non-zero is considered true. Also in C boolean true is considered to be equal to 1, which means that the expression in your cases are equal to 1 || 1 which is true and therefore 1, so all your cases are case 1.

Answer 2

You can have as many open file pointers as you wish (limited by the maximum amount of open files a process can have, but in most modern OSes this number runs into the thousands). You should remember to close them all, though.

As for "incrementing" file pointers, remember that, despite the type is called FILE *, this doesn't actually point to the contents of the file, it points to an internal management structure that <stdio.h> uses to handle files. Therefore, something like fpi ++ is not updating the internal file position pointer (which is what you want to do); it's simply making fpi point to some other FILE structure. While there are legitimate reasons to do this (e.g., pointers to arrays of FILE *), moving inside the file is not done this way.

If you actually need to move inside a file, there's a function called fseek() that does this. However, reads or writes (i.e., calls to fread(), fwrite(), fgets(), fprintf(), getc() (and its equivalent fgetc()), putc() (and its equivalent fputc()), and any other function you can imagine that performs I/O on files represented by FILE * values) already update the internal file pointer to point after the data that the operation handled. In other words, when you read or write a character, the internal file pointer will already point after that character. You don't need to, and you shouldn't, attempt to update it yourself, since it's already been done for you.

The character comparisons will probably fail due to encodings — while there is a pretty standard way of representing the usual ASCII characters (codepoints 32 to 126; basic letters, numbers, and so on), international characters don't have this luxury. You'll need to find out what encoding the file uses, and handle that encoding manually; probably by using the raw character numbers instead of character notation. There are also wide character functions to help you here, if you want to research into that. EDIT: I just noticed your 'C' || 'c' notation in the case labels. That simply evaluates to 1, as any constant expression in a case label is solved at compile time (and non-constant ones aren't allowed at all). You need multiple case labels to match multiple values; you cannot use expressions there.

Finally, the VS warning is spurious, as fopen() is a standard library call. Do remember to #include the appropriate file, though (in this case <stdio.h>).