Uso de #pragma en C

¿Cuáles son algunos usos de #pragma en C, con ejemplos?

#pragma es para las directivas del comstackdor que son específicas de la máquina o del sistema operativo, es decir, le dice al comstackdor que haga algo, establezca alguna opción, tome alguna medida, anule algunas predeterminadas, etc. que pueden aplicarse o no a todas las máquinas y sistemas operativos.

Ver msdn para más información.

#pragma se utiliza para hacer algo específico de la implementación en C, es decir, ser pragmático para el contexto actual en lugar de ideológicamente dogmático.

El que utilizo regularmente es #pragma pack(1) donde trato de exprimir más espacio de mi memoria en soluciones integradas, con arreglos de estructuras que de otra manera terminarían con una alineación de 8 bytes.

Es una lástima que todavía no tengamos un #dogma . Eso sería divertido 😉

Por lo general, intentaré evitar el uso de #pragmas si es posible, ya que son extremadamente dependientes del comstackdor y no portátiles. Si desea usarlos de forma portátil, deberá rodear cada pragma con un par # if / # endif. GCC desalienta el uso de pragmas, y realmente solo admite algunos de ellos para la compatibilidad con otros comstackdores; GCC tiene otras formas de hacer las mismas cosas que otros comstackdores usan pragmas.

Por ejemplo, así es cómo se aseguraría de que una estructura esté bien empaquetada (es decir, sin relleno entre los miembros) en MSVC:

 #pragma pack(push, 1) struct PackedStructure { char a; int b; short c; }; #pragma pack(pop) // sizeof(PackedStructure) == 7 

Así es como harías lo mismo en GCC:

 struct PackedStructure __attribute__((__packed__)) { char a; int b; short c; }; // sizeof(PackedStructure == 7) 

El código GCC es más portátil, porque si quieres comstackrlo con un comstackdor no GCC, todo lo que tienes que hacer es

#define __attribute__(x)

Mientras que si desea portar el código MSVC, debe rodear cada pragma con un par # if / # endif. No es bonito.

Si coloca #pragma once en la parte superior del archivo de encabezado, se asegurará de que solo se incluya una vez. Tenga en cuenta que #pragma once no es C99 estándar, pero es compatible con la mayoría de los comstackdores modernos.

Una alternativa es usar guardias (ej. #ifndef MY_FILE #define MY_FILE ... #endif /* MY_FILE */ )

lo que siento es que #pragma es una directiva en la que si quieres que el código sea específico de la ubicación. digamos una situación donde quieres que el contador del progtwig lea de la dirección específica donde está escrito el ISR, entonces puedes especificar ISR en esa ubicación usando #pragma vector=ADC12_VECTOR y seguido por el nombre de rotines de interrupción y su descripción

Mi mejor consejo es mirar la documentación de tu comstackdor, porque los pragmas son, por definición, específicos de la implementación. Por ejemplo, en proyectos integrados, los he usado para ubicar códigos y datos en diferentes secciones, o declaro manejadores de interrupciones. es decir:

 #pragma code BANK1 #pragma data BANK2 #pragma INT3 TimerHandler 

Esta es una directiva de preprocesador que se puede usar para activar o desactivar ciertas funciones.

Es de dos tipos: #pragma startup , #pragma exit y #pragma warn .

#pragma startup nos permite especificar las funciones requeridas al inicio del progtwig.

#pragma exit nos permite especificar funciones llamadas al salir del progtwig.

#pragma warn le dice a la computadora que elimine cualquier advertencia o no.

Muchos otros estilos #pragma se pueden usar para controlar el comstackdor.

#pragma startup es una directiva que se utiliza para llamar a una función antes de la función principal y para llamar a otra función después de la función principal, por ejemplo

 #pragma startup func1 #pragma exit func2 

Aquí, func1 ejecuta antes de funcionamientos main y func2 después.

NOTA: Este código funciona solo en el comstackdor Turbo-C. Para lograr esta funcionalidad en GCC, puede declarar func1 y func2 así:

 void __attribute__((constructor)) func1(); void __attribute__((destructor)) func2(); 

Todas las respuestas anteriores dan buenas explicaciones para #pragma pero quería agregar un pequeño ejemplo

Solo quiero explicar un simple OpenMP example que demuestre algunos usos de #pragma para hacer su trabajo

OpenMp briefly es una implementación para la progtwigción paralela de memoria compartida multiplataforma (entonces podemos decir que es machine-specific la machine-specific o machine-specific operating-system-specific )

vamos al ejemplo

 #include  #include // compile with: /openmp int main() { #pragma omp parallel num_threads(4) { int i = omp_get_thread_num(); printf_s("Hello from thread %d\n", i); } } 

la salida es

 Hello from thread 0 Hello from thread 1 Hello from thread 2 Hello from thread 3 Note that the order of output can vary on different machines. 

ahora déjame decirte lo que #pragma hizo …

le dice al sistema operativo que ejecute el bloque de código en 4 subprocesos

esta es solo una de las many many applications que puedes hacer con el pequeño #pragma

lo siento por la muestra exterior OpenMP

Para resumir, #pragma le dice al comstackdor que haga cosas. Aquí hay un par de formas en que lo uso:

  • #pragma se puede usar para ignorar las advertencias del comstackdor. Por ejemplo, para hacer que GCC se calle acerca de las declaraciones de funciones implícitas, puede escribir:

     #pragma GCC diagnostic ignored "-Wimplicit-function-declaration" 

    Una versión anterior de libportable hace de forma portátil .

  • #pragma once , cuando se escribe en la parte superior de un archivo de encabezado, hará que dicho archivo de encabezado se incluya una vez. comprobaciones libportable para pragma una vez compatible.