¿Hay alguna macro para determinar si mi código se comstack en Windows?

Me gustaría detectar si el sistema operativo en el que estoy comstackndo es Windows. ¿Hay alguna macro simple que pueda verificar para verificar eso?

[Editar: supongo que quieres usar macros en tiempo de comstackción para determinar en qué entorno estás. Tal vez quiera determinar si está ejecutando Wine bajo Linux o algo en lugar de Windows, pero, en general, su comstackdor se dirige a un entorno específico, y es Windows (DOS) o no, pero rara vez (nunca ?) ambos.]

Algunos comstackdores ofrecen macros para indicar un entorno de comstackción de Windows. Pero estos varían de comstackdor a comstackdor, e incluso en el mismo comstackdor en Windows si el entorno de destino no es exclusivamente Windows. Usualmente es __WIN32__ , pero no siempre.

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

A veces puede ser _WIN32 , __CYGWIN32__ , o posiblemente solo el indicador del comstackdor ( _MSC_VER ).

Si conoce el entorno que va a construir (a partir del archivo MAKE), generalmente puede pasar el #define en la línea de comando, como ” g++ -D __WIN32__ yourfile.c “.

Un poco más de información aquí

Hay varias formas diferentes de detectar entornos de comstackción, host y runtime. Todo depende exactamente de lo que quieres saber. Hay tres tipos de entornos amplios:

  • Build : este es el entorno en el que se comstack el progtwig.
  • Host : este es el entorno en el que se ejecuta el progtwig.
  • Objetivo : en el caso de las herramientas de generación de código (como los comstackdores), aquí es donde se ejecutará el código generado.

Si realiza una comstackción cruzada , el entorno de creación y host puede ser completamente diferente (esto es común cuando se crean aplicaciones incrustadas, pero no es muy común cuando se crean aplicaciones de escritorio / servidor), y normalmente no se puede ejecutar el binario comstackdo en el sistema utilizado para comstackrlo De lo contrario, el entorno de host debe ser compatible con el entorno de comstackción: por ejemplo, crear una aplicación en XP que se ejecutará en Vista.

Las macros de preprocesador C no se pueden usar para informarle los detalles del sistema host (es decir, en qué se está ejecutando); solo le pueden decir para qué se compiló el código. En el caso de Windows, las dos macros más importantes son:

  • _WIN32 significa que la API de Win32 está disponible. No te dice qué comstackdor estás usando, de hecho _WIN32 se define tanto al usar el GCC de Cygwin como el GCC de MinGW. Por lo tanto, no use _WIN32 para averiguar si está comstackdo con Visual Studio.
  • _MSC_VER le informa que el progtwig se está comstackndo con Microsoft Visual C / C ++. Bueno, casi. _MSC_VER también se define cuando se utiliza el comstackdor C ++ de Intel, que pretende ser un reemplazo _MSC_VER para Visual C ++.

Hay un montón de otras macros descritas en la documentación de Visual Studio.

Si desea saber qué versión exacta de Windows está utilizando, tendrá que usar funciones de tiempo de ejecución como GetVersion () (como se describe en otras respuestas).

Es posible que obtenga respuestas más específicas si nos indicó exactamente qué desea verificar.

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

Hará un buen trabajo al enumerar todas las macros (# define’s) automágicamente definidas para usted por su comstackdor g ++ [específico de la máquina].

Puede haber algo similar para los comstackdores de Microsoft …

Estas tres líneas lo ayudarán con la detección, primero nosotros o la mayoría de las ventanas predefinidas apuntan juntas en una definición de macro OS_WIN:

 # si está definido (_WIN32) ||  definido (WIN32) ||  definido (__ CYGWIN__) ||  definido (__ MINGW32__) ||  definido (__ BORLANDC__)
 #define OS_WIN
 #terminara si

Luego puede verificarlo usando el preprocesador ifdef:

 #ifdef OS_WIN
 // Cosas específicas de Windows
 #más
 // Cosas normales
 #terminara si

Si está ejecutando el código de destino de MS Windows, puede llamar a GetVersion () o GetVersionEx () para obtener más información e identificar la variante de Windows en la que se está ejecutando.

Para obtener más información, consulte la información de MSDN.

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

Esto funciona en Visual Studio 2012 y en el comstackdor g ++ de otros cgwin. Cortar y pegar, pero esto es generalmente tan delgado como se puede. Todo lo que hace es detectar sistemas operativos de Windows. Solo aplique la cuantificación: Si no gana, entonces * inux: D disfrute

 #include  #include  #include  #include  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; } 

Los enlaces mencionados hasta ahora indican información en tiempo de comstackción. Puede establecer indicadores dentro de esos segmentos de código en tiempo de comstackción.

Sin embargo, creo que lo que estás preguntando es más como “¿En qué versión de Windows me estoy ejecutando?”, No “¿Estoy comstackdo para ejecutarlo en Windows?” Espero que sea una suposición correcta.

En C #, es relativamente simple. Puede hacer referencia a System.Environment.OSVersion y luego buscar en “Platform”.

Sin embargo, preguntas sobre C ++. Qué comstackdor estas usando? Esto marca una gran diferencia en cuanto a la forma de verificar una versión del sistema operativo, ya que no hay un estándar único para obtener esta información (que he encontrado).

En Visual C ++, use Google para buscar información en GetVersion / GetVersionEx. Ambos le proporcionarán estructuras que contienen información sobre la versión actual de Windows con la que se ejecuta el progtwig.

El comstackdor MSVC ++ (no windows.h ) define _WIN32 para todas las comstackciones, por lo que es una macro más segura de verificar. El comstackdor MinGW gcc también lo hace. Cualquier entorno de comstackción cruzada que tenga como objective Win32 debería establecer esto también.

En realidad, me gustaría ir con el medio ambiente. getenv () es una función de biblioteca estándar y probablemente es la única forma potencialmente portátil de hacerlo. El truco está en descubrir qué variables son únicas para todos los sistemas operativos. Windows tiene ComSpec, appdata, Windir, systemroot y systemdrive que deben configurarse. También podría strstr la variable de ruta para WINDOWS o WINNT, pero eso podría no ser preciso. No soy experto en Linux shell / Solaris / MacOS para que alguien más pueda decirle qué variables de entorno “estándar” existen en esos sistemas operativos. CygWin puede causarle algunos problemas, también.

Probablemente dependa del comstackdor que está utilizando, pero intente:

 #ifdef WIN32 ... #endif 

Las macros como las enumeradas arriba le dirán si el progtwig fue comstackdo en una máquina con Windows, no si se está ejecutando en una máquina con Windows.

Si escribe algo que es completamente independiente de la plataforma (es decir, solo maneja las secuencias de archivos de apertura / lectura / procesamiento / escritura), tendrá que hacer algunas pruebas, como abrir un archivo que debería existir si la computadora ejecuta Windows. Si su progtwig usa stdio estándar, matemática, etc., este será el caso.

De lo contrario, si su código contiene llamadas al sistema específicas de Windows, simplemente no se ejecutará en ninguna otra plataforma.

Podrías escribir algunas macro como:

 #define RUNNING_ON_WINDOWS ( ... some test ) 

Simplemente no lo use para la comstackción condicional, es decir:

 if (RUNNING_ON_WINDOWS) { ... } else printf("Windows Required\n");