Are there any macros to determine if my code is being compiled to Windows?

Question

I would like to detect whether the OS I'm compiling on is Windows. Is there a simple macro I can check to verify that?

Solution 1

[Edit: I assume you want to use compile-time macros to determine which environment you're on. Maybe you want to determine if you're running on Wine under Linux or something instead of Windows, but in general, your compiler targets a specific environment, and that is either Windows (DOS) or it isn't, but it's rarely (never?) both.]

Some compilers offer macros to indicate a Windows build environment. But these will vary from compiler to compiler, and even on the same compiler on Windows if the target environment is not exclusively windows. Usually it's __WIN32__, but not always.

#if defined (__WIN32__)
  // Windows stuff
#endif

Sometimes it can be _WIN32, __CYGWIN32__, or possibly just the compiler indicator (_MSC_VER).

If you know the environment you'll be building in (from the makefile) then you can usually pass in the #define on the command line, like "g++ -D __WIN32__ yourfile.c".

A little more info here

Solution 2

There are a number of different ways to detect compilation, host, and runtime environments. All depending on exactly what you want to know. There are three broad types of environments:

• Build: This is the environment in which the program is compiled.
• Host: This is the environment in which the program is being run.
• Target: In case of code-generation tools (such as compilers), this is where the generated code will run.

If you are cross-compiling, the build and host environment can be completely different (this is common when building embedded applications, but not very common when building desktop/server apps), and you typically cannot run the compiled binary on the system used to compile it. Otherwise, the host environment must be compatible with the build environment: for example, building an application on XP which will run on Vista.

C preprocessor macros can not be used to tell you the details of the host system (i.e. what you are running on); they can only tell you what the code was compiled for. In the windows case, the two most important macros are:

• _WIN32 signifies that the Win32 API is available. It does not tell you which compiler you are using, in fact _WIN32 is defined both when using Cygwin's GCC and MinGW's GCC. So, do not use _WIN32 to figure out if you're being compiled with Visual Studio.
• _MSC_VER tells you that you the the program is being compiled with Microsoft Visual C/C++. Well, almost. _MSC_VER is also defined when using Intel's C++ compiler which is intended to be a drop-in replacement for Visual C++.

There are a bunch of other macros described in the Visual Studio documentation.

If you want to know which exact version of Windows you are using, you'll have to use runtime functions such as GetVersion() (as described in other answers).

You might get more specific answers if you told us exactly what you want to check for.

Solution 3

% touch foo.C ; g++ -dM -E foo.C

Will do a nice job of listing all the macros (#define's) automagically defined for you by your [machine specific] g++ compiler.

There might be something similar for Microsoft's compilers...

Solution 4

This thing works in visual studio 2012, and other cgwin's g++ compiler. Cut and paste it around but this is generally as thin as it gets All it does is detect windows op systems. Just apply quantification: If not win Then *inux :D enjoy

#include <string>
#include <iostream>
#include <fstream>
#include <cstdlib>
Using namespace std;


int main(){    
    char chCap;    int i = 0;
    const int MAX_BUFFER = 70; 
    char buffer[MAX_BUFFER];

    string cmd="ver";   
    FILE *stream = _popen(cmd.c_str(), "r");

    if (0 != stream){
        while (!feof(stream)){  
            //One way is here
            //chCap = fgetc(stream);
            //cout << chCap;
            //buffer[i++] = chCap;

            //This one seams better
            fgets(buffer, MAX_BUFFER, stream);      
        }
        _pclose(stream);
    }       
    cout << endl;
    cout << buffer << endl;

    //The op sys detection starts here
    string opSys(buffer);   //char array to string
    if("Microsoft" == opSys.substr(0,9)){
        cout << "You are in a Microsoft envornment " << endl;
    }
    system("pause");
    return 0;    
}

Solution 5

If you're running MS Windows targeted code you can call GetVersion() or GetVersionEx() for more info, and to identify the variant of Windows you are running on.

For more info scope out the MSDN info.

http://msdn.microsoft.com/en-us/library/ms724451(VS.85).aspx

View more solutions

Comments

[Ankit Roy]

The preprocessor constants can be trusted. Even if you cross-compile from e.g. gcc on a Linux machine, the cross-compilation environment will supply preprocessor constants indicating the intended runtime environment.

[rubenvb]

Cygwin GCC only defines _WIN32 when compiling a Win32 application (which is not a Cygwin app), which effectively makes it act as a MinGW compiler, so that makes _WIN32 a nice OS check.

[Adam Rosenfield]

Or just gcc -E -xc -dM /dev/null' if you don't want to leave a temp file behind (replace -xc` with -xc++ for macros used with C++ instead of C).

[MSalters]

That's overkill. All the stuff after _popen is not needed. If _popen compiles, it's a Microsoft platform, else it's not.

[user877329]

@Mat-e If it used the popen and pclose, which works on MinGW, you may get a false positive from a user command ver.

[Davislor]

Additionally, clang defines _MSC_VER and _MSC_FULL_VER in MSVC compatibility mode and provides a -fms-compatibility-version= option to enable the features of different versions of MSVC, and set the feature-test macros accordingly.