Shifting chars in C? - c

Question

My program's goal is to receive from the standard input a text, and a 'number', and to return to the screen the text after shifting of the letters 'number' times (for shift 3, 'a' becomes 'd', 'e' becomes 'g'). It should only shift the lower case letter and should be cyclic (letter 'y' in a shift of 3 should become 'a' again).
I have some bugs, though. If I shift 't' 11 times, it'll come to 'e', but if I shift 't' 12 times, I get space (" "). Why? Here's my code:
3 int main(int argc, char *argv[]) {
4 if (argc != 2) {
5 printf ("Wrong input\n");
6 return 1;
7 }
8 int shift = atoi (argv[1]);
9 int c;
10 while ((c = getchar()) != EOF) {
11 if (c >= 'a' && c <= 'z') {
12 char newch = c + shift;
13 if (newch > 'z') {
14 newch = 'a' + (newch - 'z' - 1);
15 }
16 if (newch < 'a') {
17 newch = 'z' - ('a' - newch - 1);
18 }
19 putchar (newch);
20 }
21 else
22 putchar(c);
23 }
24 return 0;
25 }
Also, when compiling I receive those warnings:
shift_chars.c: In function `main':
shift_chars.c:8: warning: implicit declaration of function `atoi'
shift_chars.c:8: warning: ISO C90 forbids mixed declarations and code
What do those mean?

Answer 1

The first warning means you did not include <stdlib.h>, which is where atoi() is declared.
The second warning means that you declared variables (shift etc) after you had some executable code. C++ allows that; C99 allows that; ISO C 90 (ANSI C 89) did not allow that. In older C, all variables in a block had to be defined before any executable statements.
Also, if you are shifting 3 and translate 'y' to 'a' you have a bug -- it should be 'b' ('z', 'a', 'b').
One of your problems is that the code for 'z' is 122, and adding 11 to 122 wraps you to a negative value if your characters (char type) are signed; you do not have this problem if char is unsigned. You'd probably do best to use an int instead of char while computing the new character value.
You might find it easier to manage if you calculate:
int newch = ((c - 'a') + shift) % 26 + 'a';
The c - 'a' gives you an index into the alphabet: a = 0, b = 1, ... z = 25. Add the shift; take the result modulo 26 to get the offset into the alphabet again; then add the result to 'a' to get the correct letter. Since c - 'a' generates an integer (because all char values are promoted to int), this avoid any overflows in char.
Indeed, you could avoid newch altogether and simply compute:
a = (c - 'a' + shift) % 26 + 'a';
You can then omit the putchar() at line 19, and drop the else, leaving the putchar(c); to output both transformed and untransformed characters.

Answer 2

I would shift the chars this way:
if(c >= 'a' && c <= 'z') {
newchar = (c - 'a' + shift) % 26 + 'a';
}
As for warnings - guys perfectly explained them.

Answer 3

If you look at the ascii table, 't' has the value 116. A char is likely signed on your platform.
So you get 116 + 12 = 128 , however that will be represented using a signed 8 bit value, so the value will be -128. Then you end up calculating newch = 'z' - ('a' - newch - 1);
If you use int newch = c + shift; , you'll not have that problem (until the addition wraps past 2147483648).
shift_chars.c:8: warning: implicit declaration of function 'atoi' says that the compiler has not seen a declaration for the atoi() function. You should #include <stdlib.h> to use atoi

Answer 4

Instead of lines 12 through 18, just do
char newch = (c - 'a' + shift) % 26 + 'a';

Answer 5

try to change
char newch = c + shift;
to
int newch = c + shift;
or, alternatively to unsigned char

Answer 6

My answer include explanation, plus solution:
Your newch has a char datatype. Most machines interpretes char as 1 byte.
That would mean the maximum decimal value for your newch variable is:
11111111 (in binary) == 128 in decimal. That's 0-127.
Now, in your code, when you pressed 't', getchar get this as 116 in decimal. If you add it with 12 (your shift), then the result will be 116+12=128. 128 overflows from the 0-127 range.
The solution? Make your newch datatype able to accept greater range, like:
unsigned char newch = c + shift;
or
int newch = c + shift;
Here's the complete code:
#include <stdio.h>
int main(int argc, char *argv[]) {
if (argc != 2) {
printf ("Wrong input\n");
return 1;
}
int shift = atoi (argv[1]);
int c;
while ((c = getchar()) != EOF) {
if (c >= 'a' && c <= 'z') {
unsigned char newch = c + shift;
if (newch > 'z') {
newch = 'a' + (newch - 'z' - 1);
}
if (newch < 'a') {
newch = 'z' - ('a' - newch - 1);
}
putchar (newch);
}
else
putchar(c);
}
return 0;
}