Directiva #pragma en C/C++ – Barcelona Geeks

Esta directiva es una directiva de propósito especial y se utiliza para activar o desactivar algunas características. Estos tipos de directivas son específicas del compilador, es decir, varían de un compilador a otro. Algunas de las directivas #pragma se analizan a continuación:

#pragma startup y #pragma exit : estas directivas nos ayudan a especificar las funciones que se necesitan ejecutar antes del inicio del programa (antes de que el control pase a main()) y justo antes de la salida del programa (justo antes de que el control regrese de main()) .

Nota : el programa a continuación no funcionará con los compiladores GCC.
Mira el siguiente programa:

#include<stdio.h> 
    
void func1(); 
void func2(); 
    
#pragma startup func1 
#pragma exit func2 
    
void func1() 
{ 
    printf("Inside func1()\n"); 
} 
    
void func2() 
{ 
    printf("Inside func2()\n");    
} 
    
int main() 
{ 
    printf("Inside main()\n"); 
        
    return 0; 
} 

Producción:

Inside func1()
Inside main()
Inside func2()

El código anterior producirá el resultado que se indica a continuación cuando se ejecute en compiladores GCC:

Inside main()

Esto sucede porque GCC no admite el inicio o la salida de #pragma . Sin embargo, puede usar el siguiente código para obtener un resultado similar en los compiladores GCC.

#include<stdio.h> 
    
void func1(); 
void func2(); 
    
void __attribute__((constructor)) func1(); 
void __attribute__((destructor)) func2(); 
    
void func1() 
{ 
    printf("Inside func1()\n"); 
} 
    
void func2() 
{ 
    printf("Inside func2()\n");  
} 
    
int main() 
{ 
    printf("Inside main()\n"); 
        
    return 0; 
} 

Producción:

Inside func1()
Inside main()
Inside func2()

Directiva #pragma warn : esta directiva se utiliza para ocultar los mensajes de advertencia que se muestran durante la compilación. Esto puede ser útil para nosotros cuando tenemos un programa grande y queremos resolver todos los errores antes de mirar las advertencias, luego al usarlo podemos enfocarnos en los errores ocultando todas las advertencias. podemos volver a dejar que las advertencias sean visibles haciendo ligeros cambios en la sintaxis.

Sintaxis :

#pragma warn +xxx (To show the warning)
#pragma warn -xxx (To hide the warning)
#pragma warn .xxx (To toggle between hide and show)

Podemos ocultar las advertencias como se muestra a continuación:

#pragma warn -rvl : esta directiva oculta las advertencias que se generan cuando una función que se supone que debe devolver un valor no devuelve un valor.
#pragma warn -par : esta directiva oculta las advertencias que se generan cuando una función no usa los parámetros que se le pasan.
#pragma warn -rch : esta directiva oculta las advertencias que se generan cuando no se puede acceder a un código. Por ejemplo: cualquier código escrito después de la declaración de retorno en una función es inalcanzable.

Ejemplo :

// Example to explain the working of 
// #pragma warn directive
// This program is compatible with C/C++ compiler 
  
#include<stdio.h>
  
#pragma warn -rvl /* return value */
#pragma warn -par /* parameter never used */
#pragma warn -rch /*unreachable code */
        
int show(int x)
{   
    // parameter x is never used in
    // the function
      
    printf("GEEKSFORGEEKS");
      
    // function does not have a
    // return statement
}
            
int main()
{
    show(10);
      
    return 0;
}

Producción:

GEEKSFORGEEKS

El programa anterior se compila con éxito sin ninguna advertencia para dar el resultado «GEEKSFORGEEKS».

#pragma GCC veneno : esta directiva es compatible con el compilador GCC y se utiliza para eliminar un identificador por completo del programa. Si queremos bloquear un identificador, podemos usar la directiva de veneno #pragma GCC .

Ejemplo :

// Program to illustrate the 
// #pragma GCC poison directive
  
#include<stdio.h>
  
#pragma GCC poison printf
  
int main()
{
    int a=10;
      
    if(a==10)
    {
        printf("GEEKSFORGEEKS");
    }
    else
        printf("bye");
  
    return 0;
}

El programa anterior dará el siguiente error:

prog.c: In function 'main':
prog.c:14:9: error: attempt to use poisoned "printf"
         printf("GEEKSFORGEEKS");
         ^
prog.c:17:9: error: attempt to use poisoned "printf"
         printf("bye");
         ^

Dependencia #pragma GCC : La dependencia #pragma GCC le permite verificar las fechas relativas del archivo actual y otro archivo. Si el otro archivo es más reciente que el archivo actual, se emite una advertencia. Esto es útil si el archivo actual se deriva de otro archivo y debe regenerarse.
Sintaxis :
```
#pragma GCC dependency "parse.y"
#pragma GCC dependency "/usr/include/time.h" rerun fixincludes
```
#pragma GCC system_header : este pragma no acepta argumentos. Hace que el resto del código del archivo actual se trate como si viniera de un encabezado del sistema.
#pragma once : La directiva #pragma once tiene un concepto muy simple. El archivo de encabezado que contiene esta directiva se incluye solo una vez, incluso si el programador lo incluye varias veces durante una compilación. Esto no está incluido en ningún estándar ISO C++. Esta directiva funciona de manera similar al modismo #include guard. El uso de #pragma una vez salva al programa de la optimización de inclusión múltiple.
Sintaxis:
```
#pragma once
```

Publicación traducida automáticamente

Artículo escrito por VineetKumar2 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta Cancelar la respuesta