¿Cuáles son algunos usos de #pragma
en C, con ejemplos?
¿Cuáles son algunos usos de #pragma
en C, con ejemplos?
Respuestas:
#pragma
es para las directivas del compilador que son específicas de la máquina o del sistema operativo, es decir, le dice al compilador que haga algo, establezca alguna opción, tome alguna acción, anule algunos valores predeterminados, etc.que pueden o no aplicarse a todas las máquinas y operaciones sistemas.
Consulte msdn para obtener más información.
#pragma
se utiliza para hacer algo específico de implementación en C, es decir, ser pragmático para el contexto actual en lugar de ideológicamente dogmático.
El que uso habitualmente es el #pragma pack(1)
que trato de sacar más provecho de mi espacio de memoria en soluciones integradas, con matrices de estructuras que, de otro modo, terminarían con una alineación de 8 bytes.
Lástima que no tengamos #dogma
todavía. Eso sería divertido ;)
pragma(1)
mejora realmente la velocidad también? Ver stackoverflow.com/questions/3318410/…
En general, trataría de evitar el uso de #pragmas si es posible, ya que son extremadamente dependientes del compilador y no portátiles. Si desea usarlos de manera portátil, tendrá que rodear cada pragma con un #if
/ #endif
pair. GCC desaconseja el uso de pragmas y, en realidad, solo admite algunos de ellos por compatibilidad con otros compiladores; GCC tiene otras formas de hacer las mismas cosas para las que otros compiladores usan pragmas.
Por ejemplo, así es como se aseguraría de que una estructura esté compactada (es decir, sin relleno entre 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 desea compilarlo con un compilador que no sea GCC, todo lo que tiene que hacer es
#define __attribute__(x)
Mientras que si desea portar el código MSVC, debe rodear cada pragma con un #if
/ #endif
pair. No es bonito.
struct __attribute__((__packed__)) PackedStructure
hack
cuando encuentra un pragma que no reconoce, como solía hacer hace mucho, mucho tiempo, ver #pragma
y GCC , etc.)
Ponerlo #pragma once
en la parte superior de su archivo de encabezado asegurará 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 compiladores modernos.
Una alternativa es usar protectores incluidos (p #ifndef MY_FILE #define MY_FILE ... #endif /* MY_FILE */
. Ej. )
lo que siento es #pragma
una directiva en la que, si desea que el código sea específico de la ubicación, diga una situación en la que desea que el contador del programa lea desde la dirección específica donde está escrito el ISR, entonces puede especificar el ISR en esa ubicación usando #pragma vector=ADC12_VECTOR
y seguido de interrumpir el nombre de rotines y su descripción
Mi mejor consejo es mirar la documentación de su compilador, porque los pragmas son, por definición, específicos de la implementación. Por ejemplo, en proyectos integrados los he usado para localizar código y datos en diferentes secciones, o declarar manejadores de interrupciones. es decir:
#pragma code BANK1
#pragma data BANK2
#pragma INT3 TimerHandler
Todas las respuestas anteriores son buenas explicaciones, #pragma
pero quería agregar un pequeño ejemplo
Solo quiero explicar un simple OpenMP example
que demuestra algunos usos de #pragma
para hacer su trabajo.
OpenMp
briefly
es una implementación para la programación paralela de memoria compartida multiplataforma (entonces podemos decir que esmachine-specific
ooperating-system-specific
)
vayamos al ejemplo
#include <stdio.h>
#include <omp.h>// 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 algún bloque de código en 4 subprocesos
esto es solo uno de many many applications
ustedes puede hacer con el pequeño#pragma
perdón por la muestra exterior OpenMP
Se trata de una directiva de preprocesador que se puede utilizar para activar o desactivar determinadas funciones.
Es de dos tipos #pragma startup
, #pragma exit
y #pragma warn
.
#pragma startup
nos permite especificar funciones llamadas al inicio del programa.
#pragma exit
nos permite especificar funciones llamadas al salir del programa.
#pragma warn
le dice a la computadora que elimine cualquier advertencia o no.
Se #pragma
pueden usar muchos otros estilos para controlar el compilador.
#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
corre antes main
y func2
corre después.
NOTA: Este código solo funciona en el compilador Turbo-C. Para lograr esta funcionalidad en GCC, puede declarar func1
y func2
así:
void __attribute__((constructor)) func1();
void __attribute__((destructor)) func2();
En resumen, #pragma
le dice al compilador que haga cosas. Aquí hay un par de formas en que lo uso:
#pragma
se puede utilizar para ignorar las advertencias del compilador. Por ejemplo, para hacer que GCC se calle sobre las declaraciones de funciones implícitas, puede escribir:
#pragma GCC diagnostic ignored "-Wimplicit-function-declaration"
Una versión anterior de libportable
hace esto 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. libportable
comprueba si hay pragma una vez compatible.
#pragma
directiva sobrevive a la etapa de preprocesamiento. A diferencia de#include
y#define
.