How do I check OS with a preprocessor directive?

C Operating System C Preprocessor Conditional Compilation

C Problem Overview

I need my code to do different things based on the operating system on which it gets compiled. I'm looking for something like this:

#ifdef OSisWindows
// do Windows-specific stuff
#else
// do Unix-specific stuff
#endif

Is there a way to do this? Is there a better way to do the same thing?

C Solutions

Solution 1 - C

The Predefined Macros for OS site has a very complete list of checks. Here are a few of them, with links to where they're found:

Windows

_WIN32 Both 32 bit and 64 bit
_WIN64 64 bit only
__CYGWIN__

Unix (Linux, *BSD, but not Mac OS X)

See this related question on some of the pitfalls of using this check.

unix
__unix
__unix__

Mac OS X

__APPLE__ Also used for classic
__MACH__

Both are defined; checking for either should work.

Linux

__linux__
linux Obsolete (not POSIX compliant)
__linux Obsolete (not POSIX compliant)

Android

__ANDROID__

Solution 2 - C

show GCC defines on Windows:

gcc -dM -E - <NUL:

on Linux:

gcc -dM -E - </dev/null

Predefined macros in MinGW:

WIN32 _WIN32 __WIN32 __WIN32__ __MINGW32__ WINNT __WINNT __WINNT__ _X86_ i386 __i386

on UNIXes:

unix __unix__ __unix

Solution 3 - C

Based on nadeausoftware and Lambda Fairy's answer.

#include <stdio.h>

/**
 * Determination a platform of an operation system
 * Fully supported supported only GNU GCC/G++, partially on Clang/LLVM
 */

#if defined(_WIN32)
    #define PLATFORM_NAME "windows" // Windows
#elif defined(_WIN64)
    #define PLATFORM_NAME "windows" // Windows
#elif defined(__CYGWIN__) && !defined(_WIN32)
    #define PLATFORM_NAME "windows" // Windows (Cygwin POSIX under Microsoft Window)
#elif defined(__ANDROID__)
    #define PLATFORM_NAME "android" // Android (implies Linux, so it must come first)
#elif defined(__linux__)
    #define PLATFORM_NAME "linux" // Debian, Ubuntu, Gentoo, Fedora, openSUSE, RedHat, Centos and other
#elif defined(__unix__) || !defined(__APPLE__) && defined(__MACH__)
    #include <sys/param.h>
    #if defined(BSD)
        #define PLATFORM_NAME "bsd" // FreeBSD, NetBSD, OpenBSD, DragonFly BSD
    #endif
#elif defined(__hpux)
    #define PLATFORM_NAME "hp-ux" // HP-UX
#elif defined(_AIX)
    #define PLATFORM_NAME "aix" // IBM AIX
#elif defined(__APPLE__) && defined(__MACH__) // Apple OSX and iOS (Darwin)
    #include <TargetConditionals.h>
    #if TARGET_IPHONE_SIMULATOR == 1
        #define PLATFORM_NAME "ios" // Apple iOS
    #elif TARGET_OS_IPHONE == 1
        #define PLATFORM_NAME "ios" // Apple iOS
    #elif TARGET_OS_MAC == 1
        #define PLATFORM_NAME "osx" // Apple OSX
    #endif
#elif defined(__sun) && defined(__SVR4)
    #define PLATFORM_NAME "solaris" // Oracle Solaris, Open Indiana
#else
    #define PLATFORM_NAME NULL
#endif

// Return a name of platform, if determined, otherwise - an empty string
const char *get_platform_name() {
    return (PLATFORM_NAME == NULL) ? "" : PLATFORM_NAME;
}

int main(int argc, char *argv[]) {
    puts(get_platform_name());
    return 0;
}

Tested with GCC and clang on:

Debian 8
Windows (MinGW)
Windows (Cygwin)

Solution 4 - C

In most cases it is better to check whether a given functionality is present or not. For example: if the function pipe() exists or not.

Solution 5 - C

Microsoft C/C++ compiler (MSVC) Predefined Macros can be found here

I think you are looking for:

> - _WIN32 - Defined as 1 when the compilation target is 32-bit ARM, 64-bit ARM, x86, or x64. Otherwise, undefined > - _WIN64 - Defined as 1 when the compilation target is 64-bit ARM or x64. Otherwise, undefined.

gcc compiler PreDefined MAcros can be found here

I think you are looking for:

> - __GNUC__ > - __GNUC_MINOR__ > - __GNUC_PATCHLEVEL__

Do a google for your appropriate compilers pre-defined.

Solution 6 - C

#ifdef _WIN32
// do something for windows like include <windows.h>
#elif defined __unix__
// do something for unix like include <unistd.h>
#elif defined __APPLE__
// do something for mac
#endif

Solution 7 - C

On MinGW, the _WIN32 define check isn't working. Here's a solution:

#if defined(_WIN32) || defined(__CYGWIN__)
    // Windows (x86 or x64)
    // ...
#elif defined(__linux__)
    // Linux
    // ...
#elif defined(__APPLE__) && defined(__MACH__)
    // Mac OS
    // ...
#elif defined(unix) || defined(__unix__) || defined(__unix)
    // Unix like OS
    // ...
#else
    #error Unknown environment!
#endif

For more information please look: https://sourceforge.net/p/predef/wiki/OperatingSystems/

Solution 8 - C

There is no standard macro that is set according to C standard. Some C compilers will set one on some platforms (e.g. Apple's patched GCC sets a macro to indicate that it is compiling on an Apple system and for the Darwin platform). Your platform and/or your C compiler might set something as well, but there is no general way.

Like hayalci said, it's best to have these macros set in your build process somehow. It is easy to define a macro with most compilers without modifying the code. You can simply pass -D MACRO to GCC, i.e.

gcc -D Windows
gcc -D UNIX

And in your code:

#if defined(Windows)
// do some cool Windows stuff
#elif defined(UNIX)
// do some cool Unix stuff
#else
#    error Unsupported operating system
#endif

Solution 9 - C

Sorry for the external reference, but I think it is suited to your question:

C/C++ tip: How to detect the operating system type using compiler predefined macros

Solution 10 - C

You can use Boost.Predef which contains various predefined macros for the target platform including the OS (BOOST_OS_*). Yes boost is often thought as a C++ library, but this one is a preprocessor header that works with C as well!

> This library defines a set of compiler, architecture, operating system, library, and other version numbers from the information it can gather of C, C++, Objective C, and Objective C++ predefined macros or those defined in generally available headers. The idea for this library grew out of a proposal to extend the Boost Config library to provide more, and consistent, information than the feature definitions it supports. What follows is an edited version of that brief proposal.

For example

#include <boost/predef.h>

#if defined(BOOST_OS_WINDOWS)
#elif defined(BOOST_OS_ANDROID)
#elif defined(BOOST_OS_LINUX)
#elif defined(BOOST_OS_BSD)
#elif defined(BOOST_OS_AIX)
#elif defined(BOOST_OS_HAIKU)
...
#endif

The full list can be found in BOOST_OS operating system macros

Solution 11 - C

Use #define OSsymbol and #ifdef OSsymbol where OSsymbol is a #define'able symbol identifying your target OS.

Typically you would include a central header file defining the selected OS symbol and use OS-specific include and library directories to compile and build.

You did not specify your development environment, but I'm pretty sure your compiler provides global defines for common platforms and OSes.

Solution 12 - C

Just to sum it all up, here are a bunch of helpful links.

Solution 13 - C

I did not find [Haiku][1] definition here. To be complete, Haiku-os definition is simple __HAIKU__

[1]: https://www.haiku-os.org "Haiku"

Solution 14 - C

Some compilers will generate #defines that can help you with this. Read the compiler documentation to determine what they are. MSVC defines one that's __WIN32__, GCC has some you can see with touch foo.h; gcc -dM foo.h

Solution 15 - C

You can use pre-processor directives as warning or error to check at compile time you don't need to run this program at all just simply compile it .

#if defined(_WIN32) || defined(_WIN64) || defined(__WINDOWS__)
    #error Windows_OS
#elif defined(__linux__)
	#error Linux_OS
#elif defined(__APPLE__) && defined(__MACH__)
    #error Mach_OS
#elif defined(unix) || defined(__unix__) || defined(__unix)
    #error Unix_OS
#else
    #error Unknown_OS
#endif

#include <stdio.h>
int main(void)
{
	return 0;
}

Solution 16 - C

I wrote an small library to get the operating system you are on, it can be installed using clib (The C package manager), so it is really simple to use it as a dependency for your projects.

Install

$ clib install abranhe/os.c

Usage

#include <stdio.h>
#include "os.h"

int main()
{
    printf("%s\n", operating_system());
	// macOS
    return 0;
}

It returns a string (char*) with the name of the operating system you are using, for further information about this project check it out the documentation on Github.

Content Type	Original Author	Original Content on Stackoverflow
Question	perimosocordiae	View Question on Stackoverflow
Solution 1 - C	Lambda Fairy	View Answer on Stackoverflow
Solution 2 - C	qwer	View Answer on Stackoverflow
Solution 3 - C	PADYMKO	View Answer on Stackoverflow
Solution 4 - C	quinmars	View Answer on Stackoverflow
Solution 5 - C	Martin York	View Answer on Stackoverflow
Solution 6 - C	Arjun Sreedharan	View Answer on Stackoverflow
Solution 7 - C	anakod	View Answer on Stackoverflow
Solution 8 - C	Mecki	View Answer on Stackoverflow
Solution 9 - C	Konstantin Burlachenko	View Answer on Stackoverflow
Solution 10 - C	phuclv	View Answer on Stackoverflow
Solution 11 - C	devio	View Answer on Stackoverflow
Solution 12 - C	MD XF	View Answer on Stackoverflow
Solution 13 - C	TadejP	View Answer on Stackoverflow
Solution 14 - C	davenpcj	View Answer on Stackoverflow
Solution 15 - C	HaseeB Mir	View Answer on Stackoverflow
Solution 16 - C	abranhe	View Answer on Stackoverflow