Why doesn't GCC produce a warning when assigning a signed literal to an unsigned type?
c, gcc, gcc-warning, unsigned
Solution
Use -Wconversion:
~/src> gcc -Wconversion -Werror -Wall -Wextra -pedantic -o signwarn signwarn.c
cc1: warnings being treated as errors
signwarn.c: In function 'main':
signwarn.c:5: error: negative integer implicitly converted to unsigned type
I guess the thing here is that gcc is actually pretty good at generating warnings, but it defaults to not doing so for (sometimes unexpected) cases. It's a good idea to browse through the available warnings and choose a set of options that generate those you feel would help. Or just all of them, and polish that code until it shines! :)
Problem
Several questions on this website reveal pitfalls when mixing signed and unsigned types and most compilers seem to do a good job about generating warnings of this type. However, GCC doesn't seem to care when assigning a signed constant to an unsigned type! Consider the following program: ``` /* foo.c */ #include <stdio.h> int main(void) { unsigned int x=20, y=-30; if (x > y) { printf("%d > %d\n", x, y); } else { printf("%d <= %d\n", x, y); } return 0; } ``` Compilation with GCC 4.2.1 as below produces no output on the console: ``` gcc -Werror -Wall -Wextra -pedantic foo.c -o foo ``` The resulting executable generates the following output: ``` $ ./foo 20 <= -30 ``` Is there some reason that GCC doesn't generate any warning or error message when assigning the signed value `-30` to the unsigned integer variable `y`?