Conditional compilation in C++ based on operating

Question

I would like to write a cross-platform function in C++ that contains system calls. What conditional compilation flags can I check to determine which operating system the code is being compiled for? I'm interested mostly in Windows and Linux, using Visual Studio and GCC.

I think it should look something like this:

void SomeClass::SomeFunction()
{
    // Other code

#ifdef LINUX
    LinuxSystemCall();
#endif

#ifdef WINDOWS
    WindowsSystemCall();
#endif

    // Other code
}

Answer 1

Here's what I use. It works under Visual Studio 2008, and MinGW:

#ifdef __GNUC__
  #define LINUX
#else
  #define WINDOWS
#endif

#ifdef WINDOWS
  #include "stdafx.h"
#else
  #include <stdlib.h>
  #include <string.h>
  #include <stdio.h>
  #include <ctype.h>
  #include <assert.h>
  #include <malloc.h>
#endif  

Answer 2

My gcc (4.3.3) defines the following Linux-related predefined macros:

$ gcc -dM -E - < /dev/null | grep -i linux
#define __linux 1
#define __linux__ 1
#define __gnu_linux__ 1
#define linux 1

Under VC++ (and many other Win32 compilers) there are also a couple of predefined macros identifying the platform, most notably _WIN32. Further details: http://msdn.microsoft.com/en-us/library/b0084kay(VS.80).aspx

Answer 3

I always try to keep the platform specifics out of the main code by doing it this way

platform.h:

#if BUILD_PLATFORM == WINDOWS_BUILD
#include "windows_platform.h"
#elif BUILD_PLATFORM == LINUX_BUILD
#include "linux_platform.h"
#else
#error UNSUPPORTED PLATFORM
#endif

someclass.c:

void SomeClass::SomeFunction()
{
   system_related_type t;
   // Other code
   platform_SystemCall(&t);
   // Other code
}

Now in windows_platform.h and linux_platform.h you typedef system_related_type to the native type, and either #define platform_SystemCall as the native call, or create a small wrapper function, if the argument set from one platform to the other is too different.

If the system APIs for a particular task are wildly different between platforms, you may need to create your own version API that splits the difference. But for the most part, there are fairly direct mappings between the various APIs on Windows and Linux.

Rather than relying on some particular compiler #define to select platform, I #define BUILD_PLATFORM xxx in the project file or makefile, since those have to be unique by platform anyway.

Answer 4

There is no standard way to do this. It may be possible to key off certain macros that are defined per platform. For instance, _WIN32 will be defined on Windows and almost certainly not Linux. However I don't know of any corresponding Linux macro.

Because you are using separate compilers, it follows that you have separate build environments. Why not just add the macro yourself? Both Visual Studio and GCC support defining macros from the command line so just define them.