Uso de #pragma en C

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

#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 #dogmatodavía. Eso sería divertido ;)

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/ #endifpair. 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/ #endifpair. No es bonito.

Ponerlo #pragma onceen la parte superior de su archivo de encabezado asegurará que solo se incluya una vez. Tenga en cuenta que #pragma onceno 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 #pragmauna 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_VECTORy 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, #pragmapero quería agregar un pequeño ejemplo

Solo quiero explicar un simple OpenMP exampleque demuestra algunos usos de #pragmapara hacer su trabajo.

OpenMp brieflyes una implementación para la programación paralela de memoria compartida multiplataforma (entonces podemos decir que es machine-specifico operating-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 #pragmahizo ...

le dice al sistema operativo que ejecute algún bloque de código en 4 subprocesos

esto es solo uno de many many applicationsustedes 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 exity #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 #pragmapueden 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í, func1corre antes mainy func2corre después.

NOTA: Este código solo funciona en el compilador Turbo-C. Para lograr esta funcionalidad en GCC, puede declarar func1y func2así:

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

En resumen, #pragmale dice al compilador que haga cosas. Aquí hay un par de formas en que lo uso:

• #pragmase 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 libportablehace 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.