Why is it important for C / C++ Code to be compilable on different compilers?

Question

I'm interested in different aspects of portability (as you can see when browsing my other questions), so I read a lot about it. Quite often, I read/hear that Code should be written in a way that makes it compilable on different compilers.

Without any real life experience with gcc / g++, it seems to me that it supports every major platform one can imagine, so Code that compiles on g++ can run on almost any system. So why would someone bother to have his code run on the MS Compiler, the Intel compiler and others?

I can think of some reasons, too. As the FAQ suggest, I'll try to post them as an answer, opposed to including them into my own question.

Edit: Conclusion

You people got me completely convinced that there are several good reasons to support multiple compilers. There are so many reasons that it was hard to choose an answer to be the accepted one. The most important reasons for me:

• Contributors are much more likely to work an my project or just use it if they can use the compiler of their choice
• Being compilable everywhere, being usable with future compilers and tools, and adhering to the standards are enforcing each other, so it's a good idea

On the other hand, I still believe that there are other things which are more important, and now I know that sometimes it isn't important at all.

And last of all, there was no single answer that could convince me not to choose GCC as the primary or default compiler for my project.

Answer 1

Some reasons from the top of my head:

1) To avoid being locked with a single compiler vendor (open source or not).

2) Compiling code with different compilers is likely to discover more errors: warnings are different and different compilers support the Standard to a different degree.

Answer 2

It is good to be compilable on MSVC, because some people may have projects that they build in MSVC that they want to link your code into, without having to set up an entirely different build system.

It is good to be compilable under the Intel compiler, because it frequently compiles faster code.

It is good to be compilable under Clang, because it can give better error messages and provide a better development experience, and it is an easier project to work on than GCC and so may gain additional benefits in the future.

In general, it is good to keep your options open, because there is no one compiler that fits all needs. GCC is a good compiler, and is great for most purposes, but you sometimes need something else.

And even if you're usually only going to be compiling under GCC, making sure your code compiles under other compilers is also likely to help find problems that could prevent your code from working with past and future versions of GCC, for instance, if there's something that GCC is less strict about now, but later adds checks for, another compiler may catch in advance, helping you keep your code cleaner. I've found this helpful in the reverse case, where GCC caught more potential problems with warnings than MSVC did (MSVC is the only compiler we needed to support, as we were only shipping on Windows, but we did a partial port to the Mac under GCC in our free time), which allowed me to produce cleaner code than I would have otherwise.