once - Uso de#pragma en C

pragma once

Question

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

Answer 1

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 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.

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

Answer 2

Mi mejor consejo es mirar la documentación de tu compilador, 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

Answer 3

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

• #pragma se puede usar para ignorar las advertencias del compilador. 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 portably .

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

Answer 4

Por lo general, intentaré evitar el uso de #pragmas si es posible, ya que son extremadamente dependientes del compilador 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 compiladores; GCC tiene otras formas de hacer las mismas cosas que otros compiladores 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 compilarlo con un compilador 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.

Answer 5

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 compiladores modernos.

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

Answer 6

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 programació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 <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 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

Answer 7

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 programa 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

Answer 8

#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 compilador Turbo-C. Para lograr esta funcionalidad en GCC, puede declarar func1 y func2 así:

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

Answer 9

#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 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.

Answer 10

#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 ;)