Control del comportamiento definido en la implementación

 

C

Lenguaje

Encabezados

Soporte de tipos

Utilidades del programa

Funciones variádicas

Gestión de errores

Gestión de memoria dinámica

Utilidades de fecha y hora

Biblioteca de cadenas de caracteres

Algoritmos

Números

Soporte de entrada/salida

Soporte de localización

Operaciones atómicas(C11)

Soporte de procesos(C11)

Especificaciones Técnicas

 

Lenguaje C

Conceptos básicos

Terminos clave

Preprocesador

Sentencias

Expresiones

Inicialización

Declaraciones

Funciones

Misceláneo:

Historia de C

Especificaciones Técnicas

 

Preprocesador

#if#ifdef#ifndef#else#elif#endif

#define#undef#,## operators

#include

#error

#pragma

#line

 

El comportamiento definido por la implementación está controlado por la directiva #pragma.

Sintaxis

#pragmapragma_parámetros	(1)
_Pragma(cadena-literal)	(2)	(desde C99)

1) Se comporta de una manera definida para la implementación (a menos que pragma_parametrizas sea uno de los pragmas estándar que se muestran a continuación.

2) Elimina el prefijo de codificación (si lo hay), las comillas externas, y los espacios en blanco iniciales y finales de la cadena-literal, reemplaza cada \" con " y cada \\ con \, luego tokeniza el resultado (como en la fase de traducción 3), y luego usa el resultado como si fuera una entrada a #pragma en (1).

Explicación

La directiva pragma controla el comportamiento específico de la implementación del compilador, como la desactivación de las advertencias del compilador o el cambio de los requisitos de alineación. Cualquier pragma que no sea reconocido es ignorado.

Pragmas estándar

Las siguientes tres pragmas están definidas por el estándar de lenguaje:

#pragma STDC FENV_ACCESS arg	(1)
#pragma STDC FP_CONTRACT arg	(2)
#pragma STDC CX_LIMITED_RANGE arg	(3)

dónde arg es bien ON o OFF o DEFAULT.

1) Si se establece en ON, informa al compilador de que el programa accederá o modificará el entorno de coma flotante, lo que significa que las optimizaciones que podrían subvertir las pruebas de flag y los cambios de modo (p. ej., eliminación de subexpresiones comunes globales, movimiento del código y plegado constante) están prohibidas. El valor por defecto es el definido en la implementación, normalmente OFF.

2) Permite la contratación de expresiones en coma flotante, es decir, optimizaciones que omiten errores de redondeo y excepciones en coma flotante que se observarían si la expresión se evaluara exactamente como está escrita. Por ejemplo, permite la implementación de (x*y)+ z con una única instrucción fusionada de CPU de múltiples adiciones. El valor por defecto es el definido para la implementación, normalmente ON.

3) Informa al compilador que la multiplicación, división y valor absoluto de números complejos puede usar fórmulas matemáticas simplificadas (x+iy)×(u+iv) = (xu-yv)+i(yu+xv), (x+iy)/(u+iv) = [(xu+yv)+i(yu-xv)]/(u2
+v2
), y |x+iy| = √x2
+y2
, a pesar de la posibilidad de un desbordamiento intermedio. En otras palabras, el programador garantiza que el rango de los valores que se pasarán a esa función es limitado. El valor por defecto es OFF

Nota: los compiladores que no soportan estas pragmas pueden proporcionar opciones de tiempo de compilación equivalentes, como las de gcc -fcx-limited-range y -ffp-contract.

Pragmas no estándar

#pragma once

#pragma once es un pragma no estándar que es soportado por la gran mayoría de los compiladores modernos. Si aparece en un fichero de cabecera, indica que sólo se debe analizar una vez, incluso si se incluye (directa o indirectamente) varias veces en el mismo fichero fuente.

El enfoque estándar para evitar la inclusión múltiple del mismo encabezado es el uso de protectores de inclusión:

#ifndef LIBRARY_FILENAME_H#define LIBRARY_FILENAME_H// contenido de la cabecera#endif /* LIBRARY_FILENAME_H */

De modo que se excluyen de la compilación todos los encabezados de cualquier unidad de traducción, excepto el primero. Todos los compiladores modernos registran el hecho de que un fichero de cabecera utiliza una protección de include y no vuelven a hacer un " reprocesado " del fichero si se encuentra de nuevo, siempre y cuando la protección siga estando definida. (ver p. ej. gcc)

Con #pragma once, el mismo encabezado aparece como

#pragma once// contenido de la cabecera

A diferencia de los protectores de cabecera, este pragma hace imposible usar erróneamente el mismo nombre de macro en más de un archivo. Por otro lado, dado que con #pragma once los archivos se excluyen en función de su identidad a nivel de sistema de archivos, esto no puede proteger contra la inclusión de un encabezado dos veces si existe en más de una ubicación en un proyecto.

Referencias

• Standard C11 (ISO/IEC 9899:2011):

• 6.10.9 Pragma operator (p: 178)

• Standard C99 (ISO/IEC 9899:1999):

• 6.10.6 Pragma directive (p: 159)

• Standard C89/C90 (ISO/IEC 9899:1990):

• 3.8.6 Pragma directive

Véase también

Documentación de C++ para Implementation defined behavior control

Enlaces externos

• C++ pragmas in Visual Studio 2010
• Pragmas accepted by GCC 4.9.2
• Individual pragma descriptions and Standard pragmas in IBM AIX XL C 13.1
• Appendix B. Pragmas in Sun Studio 11 C++ User's Guide
• Intel C++ compiler pragmas
• HP aCC compiler pragmas