Char value higher then 255? - c

Question

Today I wrote simple program to encryption my .txt file. And I saw, I can set char value higher than 255.
This is the code:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(int argc, char** argv)
{
FILE* fp;
FILE* fp2;
char buffor = '\0';
int szyfr = 0;
if(argc < 4)
{
printf("Za malo argumentow (c/dc, sciezka, szyfr)!\n");
exit(0);
}
{
int i;
for(i = 0;i < strlen(argv[3]);++i)
{
szyfr *= 10;
szyfr += argv[3][i]-48;
}
}
if(!strncmp(argv[1], "c", 1))
{
fp = fopen(argv[2], "r");
fp2 = fopen("crypted.data", "w");
if(!fp)
{
printf("Cannot open file: %s!", argv[2]);
exit(0);
}
while(1)
{
buffor = fgetc(fp);
if(feof(fp) != 0) break;
fputc(buffor+szyfr, fp2);
}
fputc_unlocked(
fclose(fp);
fclose(fp2);
}
else if(!strncmp(argv[1], "dc", 2))
{
fp = fopen(argv[2], "r");
fp2 = fopen("uncrypted.txt", "w");
if(!fp)
{
printf("Cannot open file: %s!", argv[2]);
exit(0);
}
while(1)
{
buffor = fgetc(fp);
if(feof(fp) != 0) break;
fputc(buffor-szyfr, fp2);
}
fclose(fp);
fclose(fp2);
}
return 0;
}
Whatever you set in the szyfr value this will work, but chars in the .data file is very strange (for example for 666 szyfr it will be like " ×ýû¤")
Why this doesn't giving error about char memory or something like that?
PS: Sorry for some texts in code in Polish but I forgot about this

Answer 1

I saw, I can set char value higher than 255.
I guess you're talking about the first argument to fputc(), and maybe about the return value of fgetc(). These both have type int, but that doesn't mean what you seem to think it means. The behavior of both functions is defined in terms of type unsigned char:
fgetc():
the fgetc function obtains that character as an unsigned char converted to an int [...]
(C2011, 2.21.7.1/2; emphasis added)
fputc():
The fputc function writes the character specified by c (converted to an unsigned char) to the output stream pointed to by stream [...]
(C2011, 2.21.7.3/2; emphasis added)
So yes, inasmuch as the range of type int is, in practice, invariably larger than that of type unsigned char, you can pass a value larger than unsigned char can represent to fputc(). But no, that does not result in writing that value in a manner that can be read back. The conversion to unsigned char will result in the character actually written being in the range of unsigned char, which is almost certainly 0 - 255 for you.
Why this doesn't giving error about char memory or something like that?
There is no error in fputc() because the behavior is perfectly well defined for the arguments you are providing. Even if there were an error, however, your code would not tell you, because such an error would be communicated to your program via the return value of fputc(), which you do not check.
Regarding wide-character I/O
Note that wide-character I/O functions such as fgetwc() and fputwc() operate in larger units, but their underlying behavior is not fundamentally different. It involves casting analogous to that performed by fgetc() and fputc() -- thus affording the same possibility of data corruption -- and you might still see strange characters in your encrypted file, albeit probably different ones.
Regarding strange characters
As far as strange characters appearing in the encrypted file, this is pretty much to be expected, albeit somewhat dependent on what your editor or terminal (depending on how you display the file) supposes is the file's character encoding. Your encryption scheme effectively converts character data to binary data, so it's unreasonable to expect it to look like character data.

Answer 2

C is a low-level language that just does what you tell it, with no help or argument.
You declare a variable buffor to be a char, and then you call a function fgetc() that returns an int, and then you assign it. C says "Fine. You've asked me to put 16 gallons of water into an 8-gallon bucket, so I did." Now you've got a full 8 gallon bucket and a wet floor. C just chops off 8 bits and drops them, so for instance, you'll never be able to tell when fgetc() returns EOF, since that's a larger-than-8-bit value.
If you want to assure that 8-bit variables only get 8-bit values, you'll have to check them yourself before you assign them.