Good practice on porting C++ code from GCC to MSVC? [closed] - c++

Question

Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
We don’t allow questions seeking recommendations for books, tools, software libraries, and more. You can edit the question so it can be answered with facts and citations.
Closed 4 years ago.
Improve this question
I am a student and I am currently taking a compiler construction course. I develop my compiler in C++ on Ubuntu, using GCC and CMake. While everything works fine on my development machine, the code broke horribly when compiled against MSVC or Visual Studio 2017 on the school test. As I tracked down the error messages thrown by MSVC, I noticed there are several issues causing these failures:
GCC's headers give you more stuffs than MSVC does.
Some other weird errors that I can't explain (Sorry but I can find a better word).
To ground the discussion, see the following examples,
which work for GCC but break on MSVC.
#include <iostream>
int main() {
std::string S;
std::getline(std::cin, S);
}
MSVC requires #include <string> to work.
#include <unordered_map>
int main() {
std::min(1, 2);
}
MSVC requires #include <algorithm> to work.
These issues are not hard to fix once they break out: I can just #include the required headers. However, it is too expensive to let them break out. It takes away my scores and hurt me.
I have no interest in discussing which compiler is more standard-compliant. I simply want to catch any portability issue before they catch me. But I am not well-informed of all those tricky differences between these compilers. That's why I am asking for tools to catch these issues. I want to update my tool chains to write more portable code.
Edit: Besides tools, I will humbly learn any code disciplines, good practices and known issues in writing portable code.
Edit: Sorry folks. I am not meant to make the second example wrong (just deleted). I just have no access to a MSVC to reproduce the problems.
Edit for Clarification: What this post is not for:
How to fix certain issues when porting code from GCC to MSVC.
How to write standard-compliant C++ code that universally compiles.
In fact, this post is asking for practical actions one can take to port code from GCC to MSVC or better, to write code without portability issues from the beginning. The examples in this post are used to make discussion concrete or to show the actual difficulty, but not comprehensive. I don't think there is a single truth about this question, but I'd like to try out some good ones.

Answer 1

Compile against multiple compilers
When comes to portability there are two approaches. One charming, idealistic but non-practical: where you wish to write code that is absolutely portable: i.e. to work as expected on any compiler, real or imaginary, present and future. You might be tempted to say: hey that's just standard C++ code. Unfortunately compilers are software and as any complex software they have bugs. Moreover, the standard has bugs (where defect-reports are applied retroactively). The more you write complex code the more you will encounter these bugs.
The other approach is a practical one. Instead of aiming for 100% portable code, you aim for portability on a set of versions of compilers on a set of architectures. For instance you can aim for your code to work on x64 linux and windows, gcc clang and msvc, latest version , or from version x upwards and ignore everything else. (icc be damned). To achieve this there is really just one way: test your code on all these platforms. For this at minimum you need to create unit tests for your code and then compile and run these tests on all the architectures and compilers. You can do this manually or automate the process (e.g. CI).
Running your code on multiple compilers you will find that you need to modify the code to be more standard compliant or write different code for different compilers and versions to go around bugs or limitations. SO is full with compliant code that doesn't work on some major compiler (version) or another.
Compile with appropriate switches
Compilers have custom extensions (some enabled by default). You should disable them. It's compiler specific. For gcc and clang for example you need -pedantic. I don't know for msvc. But even these are not enough:
Some users try to use -Wpedantic to check programs for strict ISO C
conformance. They soon find that it does not do quite what they want:
it finds some non-ISO practices, but not all—only those for which ISO
C requires a diagnostic, and some others for which diagnostics have
been
Use tools complementary to compilers
Use static analyzer tools. These tools analyze your code and catch some cases of bugs, illegal or Undefined Behavior code.
Also take a look over clang sanitizers.
Don't forget about the standard
You say you are not interested in a discussion about which one is more standard compliant, but you should at least be interested in standard compliant code. For instance in your first example even if it happens to work on your version of gcc the code is illegal because including <string> and <algorithm> is mandated by the standard here.
When you encounter code that works differently on different compilers you definitely should investigate and see what is standard compliant.