c++ - sharp - referencia de c# microsoft
¿Qué preprocesador de plataforma cruzada define?(__WIN32__ o__WIN32 o WIN32)? (5)
Depende de lo que estés tratando de hacer. Puede verificar el compilador si su programa quiere hacer uso de algunas funciones específicas (por ejemplo, de la cadena de herramientas gcc). Puede verificar el sistema operativo (_WINDOWS, __unix__) si desea usar algunas funciones específicas del sistema operativo (independientemente del compilador, por ejemplo, CreateProcess en Windows y fork en unix).
Debe verificar la documentación de cada compilador para poder detectar las diferencias al compilar. Recuerdo que gnu toolchain (gcc) tiene algunas funciones en la biblioteca C ( libc ) que no están en otras cadenas de herramientas (como Visual C por ejemplo). De esta manera, si desea usar esas funciones fuera del producto, debe detectar que está usando GCC, por lo que el código que debe usar sería el siguiente:
#ifdef __GNUC__
// do my gcc specific stuff
#else
// ... handle this for other compilers
#endif
A menudo veo __WIN32 , WIN32 o __WIN32__ . Supongo que esto depende del preprocesador utilizado (ya sea de Visual Studio o GCC), etc.
¿Tengo que verificar primero el sistema operativo y luego el compilador usado? Estamos utilizando aquí G ++ 4.4.x, Visual Studio 2008 y Xcode (que asumo que es un gcc de nuevo) y ATM estamos usando solo __WIN32__ , __APPLE__ y __LINUX__ .
Este artículo responde a su pregunta:
- Consejo de C / C ++: cómo detectar el tipo de sistema operativo utilizando macros predefinidas del compilador (más el enlace de archive.org en caso de que desaparezca).
El artículo es bastante largo e incluye tablas que son difíciles de reproducir, pero aquí está la esencia:
Puedes detectar el estilo de Unix con:
#if !defined(_WIN32) && (defined(__unix__) || defined(__unix) || (defined(__APPLE__) && defined(__MACH__)))
/* UNIX-style OS. ------------------------------------------- */
#endif
Una vez que sepa que es Unix, puede encontrar si es POSIX y la versión POSIX con:
#include <unistd.h>
#if defined(_POSIX_VERSION)
/* POSIX compliant */
#endif
Puede verificar los sistemas derivados de BSD con:
#if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
#include <sys/param.h>
#if defined(BSD)
/* BSD (DragonFly BSD, FreeBSD, OpenBSD, NetBSD). ----------- */
#endif
#endif
y Linux con:
#if defined(__linux__)
/* Linux */
#endif
y los sistemas operativos de Apple con
#if defined(__APPLE__) && defined(__MACH__)
/* Apple OSX and iOS (Darwin) */
#include <TargetConditionals.h>
#if TARGET_IPHONE_SIMULATOR == 1
/* iOS in Xcode simulator */
#elif TARGET_OS_IPHONE == 1
/* iOS on iPhone, iPad, etc. */
#elif TARGET_OS_MAC == 1
/* OS X */
#endif
#endif
Windows con Cygwin
#if defined(__CYGWIN__) && !defined(_WIN32)
/* Cygwin POSIX under Microsoft Windows. */
#endif
Y Windows no POSIX con:
#if defined(_WIN64)
/* Microsoft Windows (64-bit) */
#elif defined(_WIN32)
/* Microsoft Windows (32-bit) */
#endif
El artículo completo de los caracteres de los caracteres de los caracteres de los caracteres de los caracteres, así como los caracteres de los caracteres, y los sistemas de caracteres, y los sistemas de caracteres, y los sistemas de caracteres, y los sistemas de caracteres, y los sistemas de __OpenBSD__ , _POSIX_IPV6 , _POSIX_MAPPED_FILES , _POSIX_SEMAPHORES , _POSIX_THREADS , _POSIX_VERSION , sun , __sun , __SunOS , __sun__ , __SVR4 , __svr4__ , TARGET_IPHONE_SIMULATOR , TARGET_OS_EMBEDDED , TARGET_OS_IPHONE , TARGET_OS_MAC , UNIX , unix , __unix , __unix__ , WIN32 , _WIN32 , __WIN32 , __WIN32__ , WIN64 , _WIN64 , __WIN64 , __WIN64__ , WINNT , __WINNT , __WINNT__ .
Un artículo relacionado ( enlace archive.org ) cubre la detección de compiladores y versiones del compilador. En él se enumeran los siguientes símbolos: __clang__ , __GNUC__ , __GNUG__ , __HP_aCC , __HP_cc , __IBMCPP__ , __IBMC__ , __ICC , __INTEL_COMPILER , _MSC_VER , __PGI , __SUNPRO_C , __SUNPRO_CC para detectar compiladores, y __clang_major__ , __clang_minor__ , __clang_patchlevel__ , __clang_version__ , __GNUC_MINOR__ , __GNUC_PATCHLEVEL__ , __GNUC__ , __GNUG__ , __HP_aCC , __HP_cc , __IBMCPP__ , __IBMC__ , __ICC , __INTEL_COMPILER , __INTEL_COMPILER_BUILD_DATE , _MSC_BUILD , _MSC_FULL_VER , _MSC_VER , __PGIC_MINOR__ , __PGIC_PATCHLEVEL__ , __PGIC__ , __SUNPRO_C , __SUNPRO_CC , __VERSION__ , __xlC_ver__ , __xlC__ , __xlc__ para detectar versiones de compilador.
He reconstruido mi respuesta ... Maldición, editando berserk: P:
Usted no necesita usar partical uno. Y probablemente para MacOSX, Linux y otros Me gusta de Unix, no necesita usar ninguno en absoluto.
El más popular es (en la medida en que Google dice la verdad) es _WIN32 .
Nunca lo definas "a mano" en tu código fuente. Se define de una de estas formas:
como una marca de preprocesador / compilador de línea de comandos (como g++ -D _WIN32 )
o está predefinido por el compilador en sí mismo (la mayoría de los compiladores de Windows predefinen _WIN32 , y algunas veces otros como WIN32 o _WIN32_ . Entonces, no necesita preocuparse por definirlo, el compilador hace todo el trabajo.
Y mi vieja respuesta:
Usted no ''tiene que'' nada. Es solo por compatibilidad multiplataforma. A menudo, la versión del código para todos los Me gusta de Unix (incluidos Linux, MacOSX, BSD, Solaris ...) y otras plataformas POSIX serán completamente iguales y debe haber algunos cambios para Windows. Entonces, la gente escribe su código generalmente para Me gusta de Unix y coloca algunas partes solo de Windows (por ejemplo, instrucciones de DirectX, rutas de archivo de Windows ...) entre #ifdef _WIN32 y #endif .
Si tienes algunas partes por ejemplo. Solo en el sistema X-Window, o solo en MacOS, haces algo similar con #ifdef X_WINDOW o #ifdef MACOS . Luego, necesita establecer una definición de preprocesador adecuada al compilar (con gcc utilizando el indicador -D, como por ejemplo, gcc -D _WIN32 ).
Si no escribe ningún código dependiente de la plataforma, entonces no necesita ocuparse de tales #ifdef, #else, #endif . Y la mayoría de los compiladores / preprocesadores de Windows AFAIK han predefinido algunos símbolos como _WIN32 (el más popular, en lo que Google dice la verdad), WIN32 , _WIN32_ , etc. simplemente compilando
No veo por qué tienes que hacerlo. Es posible que deba recordar especificar la definición manualmente en la línea de comandos de su compilador, pero eso es todo. Para el registro, la definición de Visual Studio es _WIN32 (con un guión bajo) en lugar de __WIN32 . Si no está definido, entonces no está definido, y no importará.
Suspiro: no confíe en nada en el compilador, especifique qué plataforma está creando en su Makefile. En pocas palabras, cualquier cosa que comience con _ depende de la implementación y no es portátil.
Probé su método una vez, en un proyecto muy grande, y entre los movimientos de Sun-C ++ y GCC, decidimos utilizar el control Makefile en lugar de intentar deducir lo que iban a hacer los compiladores.