Ignoring compiler warnings does seem pretty irresponsible to me, no matter how superb your unit test coverage is. At the very least it will cause a degregation of the codebase over time.
Yes. The most trivial example is probably (C++):
Foo* foo = malloc( sizeof(Foo) ); // warning: void* to Foo*
The most annoying warning ever is probably:
while ( true ) // warning: conditional expression is constant
{
foo();
if ( bar() )
break;
baz();
}
It's silliness like this which has caused many people to kneejerk ignore every warning ever. But in doing so, they don't realize they're throwing away a lot of free data about their codebase, while also encouraging dangerous coding practices.
But check this out:
#define SOME_MACRO( foo, bar ) \
do \
{ \
foo(); \
bar(); \
} while (0) // warning: conditional expression
// is constant
Most insidiously, you can't wrap the macro with #pragma warning (push, disable, pop) because it's a macro. So the warning can only be suppressed where you call it, not where it's defined!
That's why I globally disable this warning in all my projects. I've never been saved by it, and it's sucked away enough of my life.
#include <stdio.h>
#define ADD(x, y, z) \
do { \
z = x + y; \
} while (0)
int main(int argc, char *argv[])
{
int z;
ADD(1, 3, z);
printf("z = %d\n", z);
return 0;
}
It was a poor design choice by Microsoft. All of their compilers emit the warning when using the highest warning level.
Thanks again --- if GCC never warns, then I feel much better about globally disabling it.
Changing main's signature to int main() eliminates all warnings at -Wextra.
I've used up enough of your time already, but if you feel like it...:
Do you know if gcc has the equivalent of #pragma warning( disable: N ) ? i.e. could you disable your argc and argv warning for just that source file, and no other?
If yes, then is there a way to "scope" that disable to be within a header file? (#pragma warning(push) and #pragma warning(pop))
#pragma GCC diagnostic ignored "-Wunused-parameter"
Unit tests prove a different level of semantics that these warnings cannot substitute (although possibly complement).
"My, you're looking testy today!" ...
burgerbrain points out something very important: Code bases with warnings tend to be degenerate.
Tend to. SQLite is not one of them. But I've seen several large codebases. The two which were beautiful also had zero warnings, and the ~dozen others ranged from "meh" all the way down to "lol, grab a snickers".
This is obviously not enough data to draw any meaningful statistical conclusions from --- but it would be silly to ignore it completely. Good C/C++ programmers tend to respect compiler warnings.
That, actually, is part of the point. Unit tests check for correct expression of the problem domain (and solution). Compiler warnings check for correct expression of language constructs. It's possible, though not usually likely, for incorrect language usage to mask incorrect implementations.