I am working on a Caesar function, which given the input and the offset, returns the output. I'm not sure if I am doing it. What am I doing wrong here? Any help is appreciated. Also if someone could explain me how to work with unsigned chars.
void encrypt(unsigned char* message_input, char off, unsigned char* message_output) {
int m_inp;
while(*(message_input+ m_inp)!=EOF)
{
*(message_output+ m_inp) = (*((unsigned char*)input + m_inp) + offset )%256;
}
}
There are a number of correctness and stylistic issues with the code.
The loop variable, m_inp, is not initialized.
It is unlikely that an unsigned char can ever equal EOF. The value of EOF is -1. The loop will never finish (unless you are on a very strange architecture).
The traditional Caesar cipher operates alphabetically, rather than on the whole ASCII character set.
Using more "stylistically correct" C will make it easier for other programmers to read your code. These are subjective.
The name m_inp is a poor name for a loop variable in a short loop. Use i instead.
It is easier to read ptr[i] instead of *(ptr + i), even though they are exactly equivalent in C.
Marking the input as const unsigned char * makes it more obvious that it is not modified.
Use int instead of char for the offset.
Traditionally, function outputs go on the left, inputs go on the right. This is not important, however.
Here is a sample revision. It takes a NUL-terminated string, and writes the Caesar encoded / decoded version to an output buffer. This is how I would write the function, not necessarily how you would write it:
void caesar(char *output, const char *input, int shift)
{
int i;
for (i = 0; input[i]; i++) {
if (input[i] >= 'a' && input[i] <= 'z')
output[i] = (input[i] - 'a' + shift) % 26 + 'a';
else if (input[i] >= 'A' && input[i] <= 'Z')
output[i] = (input[i] - 'A' + shift) % 26 + 'A';
else
output[i] = input[i];
}
output[i] = '\0';
}
Note that Caesar encryption and decryption are actually the same operation, just with different shift values. So if you encrypt with a shift of 3, you can decrypt with a shift of -3 (or equivalently, 23).
Also note that you can replace unsigned char with char or vice versa and everything will work exactly the same (although you'd need to cast the inputs).
The code you have written has a lot of mistakes
1) You have not initialized m_inp , but you are deferencing (message_output + m_inp)
2) You are checking the input string for EOF , which makes no sense.
Please have a look at this code , it is a much better implementation of caesar cipher
#include <stdio.h>
void caesar (char cipher[], int shift);
int main () {
char cipher[50];
int shift;
printf("Enter text to be encrypted IN CAPITAL LETTERS ONLY: ");
scanf("%s", cipher);
printf("How many shifts do you prefer? 1-10 only: ");
scanf("%d", &shift);
caesar (cipher, shift);
return 0;
}
void caesar (char cipher[], int shift) {
int i = 0;
while (cipher[i] != '\0') {
if ((cipher[i] += shift) >= 65 && (cipher[i] + shift) <= 90) {
cipher[i] += (shift);
} else {
cipher[i] += (shift - 25);
}
i++;
}
printf("%s", cipher);
}
