c++ - sirve - pasos para crear una macro en excel
¿Hay macros para determinar si mi código se compila en Windows? (11)
Esta pregunta ya tiene una respuesta aquí:
Me gustaría detectar si el sistema operativo en el que estoy compilando es Windows. ¿Hay alguna macro simple que pueda verificar para verificar eso?
El compilador MSVC ++ (no windows.h ) define _WIN32 para todas las compilaciones, por lo que es una macro más segura de verificar. El compilador MinGW gcc también lo hace. Cualquier entorno de compilación cruzada que tenga como objetivo 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.
Hay varias formas diferentes de detectar entornos de compilació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 compila el programa.
- Host : este es el entorno en el que se ejecuta el programa.
- Objetivo : en el caso de las herramientas de generación de código (como los compiladores), aquí es donde se ejecutará el código generado.
Si realiza una compilació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 compilado en el sistema utilizado para compilarlo De lo contrario, el entorno de host debe ser compatible con el entorno de compilació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é compilador 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á compilado con Visual Studio.
-
_MSC_VERle informa que el programa se está compilando con Microsoft Visual C / C ++. Bueno, casi._MSC_VERtambién se define cuando se utiliza el compilador C ++ de Intel, que pretende ser un reemplazo_MSC_VERpara 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.
Las macros como las enumeradas arriba le dirán si el programa fue compilado 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 programa 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 compilación condicional, es decir:
if (RUNNING_ON_WINDOWS) {
...
} else
printf("Windows Required/n");
Los enlaces mencionados hasta ahora indican información en tiempo de compilación. Puede establecer indicadores dentro de esos segmentos de código en tiempo de compilació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 compilado 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é compilador 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 programa.
Probablemente dependa del compilador que está utilizando, pero intente:
#ifdef WIN32
...
#endif
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
[Editar: supongo que quieres usar macros en tiempo de compilació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 compilador se dirige a un entorno específico, y es Windows (DOS) o no, pero rara vez (nunca ?) ambos.]
Algunos compiladores ofrecen macros para indicar un entorno de compilación de Windows. Pero estos varían de compilador a compilador, e incluso en el mismo compilador 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 compilador ( _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 ".
% 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 compilador g ++ [específico de la máquina].
Puede haber algo similar para los compiladores 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:
#if defined(_WIN32) || defined(WIN32) || defined(__CYGWIN__) || defined(__MINGW32__) || defined(__BORLANDC__) #define OS_WIN #endif
Luego puede verificarlo usando el preprocesador ifdef:
#ifdef OS_WIN //Windows specific stuff #else //Normal stuff #endif
Esto funciona en Visual Studio 2012 y en el compilador 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 <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;
}