Why should I always enable compiler warnings?

by

Why should I enable warnings?

C and C++ compilers are notoriously bad at reporting some common programmer mistakes by default, such as:

  • forgetting to initialise a variable
  • forgetting to return a value from a function
  • arguments in printf and scanf families not matching the format string
  • a function is used without being declared beforehand (C only)

These can be detected and reported, just usually not by default; this feature must be explicitly requested via compiler options.

How can I enable warnings?

This depends on your compiler.

Microsoft C and C++ compilers understand switches like /W1, /W2, /W3, /W4 and /Wall. Use at least /W3. /W4 and /Wall may emit spurious warnings for system header files, but if your project compiles cleanly with one of these options, go for it. These options are mutually exclusive.

Most other compilers understand options like -Wall, -Wpedantic and -Wextra. -Wall is essential and all the rest are recommended (note that, despite its name, -Wall only enables the most important warnings, not all of them). These options can be used separately or all together.

Your IDE may have a way to enable these from the user interface.

Why should I treat warnings as errors? They are just warnings!

A compiler warning signals a potentially serious problem in your code. The problems listed above are almost always fatal; others may or may not be, but you want compilation to fail even if it turns out to be a false alarm. Investigate each warning, find the root cause, and fix it. In the case of a false alarm, work around it — that is, use a different language feature or construct so that the warning is no longer triggered. If this proves to be very hard, disable that particular warning on a case by case basis.

You don’t want to just leave warnings as warnings even if all of them are false alarms. It could be OK for very small projects where the total number of warnings emitted is less than 7. Anything more, and it’s easy for a new warning to get lost in a flood of old familiar ones. Don’t allow that. Just cause all your project to compile cleanly.

Note this applies to program development. If you are releasing your project to the world in the source form, then it might be a good idea not to supply -Werror or equivalent in your released build script. People might try to build your project with a different version of the compiler, or with a different compiler altogether, which may have a different set of warnings enabled. You may want their build to succeed. It is still a good idea to keep the warnings enabled, so that people who see warning messages could send you bug reports or patches.

How can I treat warnings as errors?

This is again done with compiler switches. /WX is for Microsoft, most others use -Werror. In either case, the compilation will fail if there are any warnings produced.

Is this enough?

Probably not! As you crank up your optimisation level, the compiler starts looking at the code more and more closely, and this closer scrutiny may reveal more mistakes. Thus, do not be content with the warning switches by themselves, always use them when compiling with optimisations enabled (-O2 or -O3, or /O2 if using MSVC).

More Related Contents:

  1. How to turn on (literally) ALL of GCC’s warnings?
  2. Is using #pragma warning push/pop the right way to temporarily alter warning level?
  3. How can I turn on (literally) ALL of GCC’s warnings?
  4. Where and why do I have to put the “template” and “typename” keywords?
  5. What is this weird colon-member (” : “) syntax in the constructor?
  6. What are rvalues, lvalues, xvalues, glvalues, and prvalues?
  7. C++ delete – It deletes my objects but I can still access the data?
  8. How to stop C++ console application from exiting immediately?
  9. What is external linkage and internal linkage?
  10. Can a class member function template be virtual?
  11. Which kind of pointer do I use when?
  12. Why aren’t my include guards preventing recursive inclusion and multiple symbol definitions?
  13. Why is enum class preferred over plain enum?
  14. What are transparent comparators?
  15. What is the point of function pointers?
  16. Is the practice of returning a C++ reference variable evil?
  17. Lifetime of temporaries
  18. Why are C++ inline functions in the header?
  19. Flags to enable thorough and verbose g++ warnings
  20. What are template deduction guides and when should we use them?
  21. libpng warning: iCCP: known incorrect sRGB profile
  22. Why is ‘this’ a pointer and not a reference?
  23. Template specialization of particular members?
  24. What are the advantages of using nullptr?
  25. Why would one replace default new and delete operators?
  26. What’s the point of g++ -Wreorder?
  27. shared_from_this causing bad_weak_ptr
  28. Is it wise to ignore gcc/clang’s “-Wmissing-braces” warning?
  29. Conversion from Derived** to Base**
  30. Why should I initialize member variables in the order they’re declared in?

Leave a Comment